gea-program 0.61.0__tar.gz → 0.62.0__tar.gz

{gea_program-0.61.0 → gea_program-0.62.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gea-program
-Version: 0.61.0
+Version: 0.62.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
@@ -689,7 +689,9 @@ Each casing string's burst, collapse and tension ratings by API TR 5C3,
 from its size, weight and grade, against the loads the hole can put on it
 - gas to the surface held by the shoe, an emptied string, the buoyed
 weight with overpull - with the smallest safety factor and where, and the
-gas kick each open hole below a shoe can take and still be shut in. `gea
+gas kick each open hole below a shoe can take and still be shut in - the
+gas a real gas at the well's pressure and temperature, with a swabbed
+kick beside each. `gea
 casing --example`; declared on the **Casing & kick tolerance** tab, with
 `gea casing --workspace C:\site --well SWD-1 --strings ...`, or in the
 declarations sheet. `gea help casing`.

{gea_program-0.61.0 → gea_program-0.62.0}/README.md

@@ -650,7 +650,9 @@ Each casing string's burst, collapse and tension ratings by API TR 5C3,
 from its size, weight and grade, against the loads the hole can put on it
 - gas to the surface held by the shoe, an emptied string, the buoyed
 weight with overpull - with the smallest safety factor and where, and the
-gas kick each open hole below a shoe can take and still be shut in. `gea
+gas kick each open hole below a shoe can take and still be shut in - the
+gas a real gas at the well's pressure and temperature, with a swabbed
+kick beside each. `gea
 casing --example`; declared on the **Casing & kick tolerance** tab, with
 `gea casing --workspace C:\site --well SWD-1 --strings ...`, or in the
 declarations sheet. `gea help casing`.

{gea_program-0.61.0 → gea_program-0.62.0}/gea/__init__.py

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

{gea_program-0.61.0 → gea_program-0.62.0}/gea/__main__.py

@@ -653,7 +653,9 @@ def main(argv=None) -> int:
     p_cs.add_argument("--strings", type=str, default=None, help="shallowest shoe first: 'surface:13-3/8:54.5:J55:0-1500:17.5:9.0; intermediate:9-5/8:47:N80:0-7000:12.25:9.8' (what:od:lb_ft:grade:top-shoe:hole_in:mud_ppg[:wall_in])")
     for k_, h_ in (("td", "the well's TD below the deepest string, ft MD"), ("td-hole", "the hole below the deepest string, in"), ("td-mw", "the mud below the deepest string, ppg"),
                    ("pp", "a pore pressure for the well when the Pore pressure tab has none, ppg"), ("fg", "a fracture gradient for the well when the Pore pressure tab has none, ppg"),
-                   ("kick", "kick intensity above the mud, ppg (0.5)"), ("gas", "gas gradient, psi/ft (0.1)"), ("backup", "burst backup gradient outside, psi/ft (0.465)"),
+                   ("kick", "kick intensity above the mud, ppg (0.5)"), ("gas", "a fixed gas gradient, psi/ft, in place of the real gas ('none' for the real gas again)"),
+                   ("gas-sg", "the gas's specific gravity, air 1 (0.65)"), ("surface-temp", "the temperature at the surface, F (70)"),
+                   ("geothermal", "the geothermal gradient, F per 100 ft (1.5)"), ("backup", "burst backup gradient outside, psi/ft (0.465)"),
                    ("evacuation", "how far the string is emptied for collapse, 0 to 1 (1: to the shoe)"), ("df-burst", "burst design factor (1.1)"),
                    ("df-collapse", "collapse design factor (1.125)"), ("df-tension", "tension design factor (1.6)"), ("overpull", "overpull, klbf (100)"),
                    ("bha-od", "BHA outside diameter, in"), ("bha-length", "BHA length, ft"), ("dp-od", "drill pipe outside diameter, in")):
@@ -2625,7 +2627,8 @@ def main(argv=None) -> int:
             ws = Workspace(a.workspace) if a.workspace else None
             scene = "example" if (a.example or ws is None) else "workspace"
             keys_ = {"td": "td_md_ft", "td_hole": "td_hole_in", "td_mw": "td_mw_ppg", "pp": "pp_ppg", "fg": "fg_ppg", "kick": "kick_intensity_ppg",
-                     "gas": "gas_gradient_psi_ft", "backup": "backup_gradient_psi_ft", "evacuation": "evacuation", "df_burst": "df_burst",
+                     "gas": "gas_gradient_psi_ft", "gas_sg": "gas_sg", "surface_temp": "surface_temp_f", "geothermal": "geothermal_f_100ft",
+                     "backup": "backup_gradient_psi_ft", "evacuation": "evacuation", "df_burst": "df_burst",
                      "df_collapse": "df_collapse", "df_tension": "df_tension", "overpull": "overpull_klbf", "bha_od": "bha_od_in",
                      "bha_length": "bha_length_ft", "dp_od": "dp_od_in"}
             vals_ = {v: getattr(a, k) for k, v in keys_.items() if getattr(a, k) is not None}

{gea_program-0.61.0 → gea_program-0.62.0}/gea/acceptance_tests.py

@@ -13378,7 +13378,8 @@ def section_dd_casing_design(tmp: str) -> None:
        "match its weight, a string that does not pass through the one above and a short line each answered" + (f" [failed: {', '.join(failed1)}]" if failed1 else ""))
 
     # -- DD2 the loads and the kick tolerance, by hand on the example -------------------------------------------------------------------
-    ex = CSG.example()
+    ex0 = CSG.example()                                           # worked by hand with the fixed 0.1 psi/ft gas of the textbook method (section DE: the real gas)
+    ex = CSG.analyse({**ex0["config"], "gas_gradient_psi_ft": 0.1}, lambda md: float(md), CSG.EXAMPLE_WINDOW)
     sv, iv_, pv = ex["strings"]
     win = CSG.EXAMPLE_WINDOW
 
@@ -13439,7 +13440,9 @@ def section_dd_casing_design(tmp: str) -> None:
     cols_d, cols_l = DC.TABLES["casing_design"]["cols"], DC.TABLES["casing_loads"]["cols"]
     rows = [["[casing_design]", *cols_d], ["", "HY-2", "surface", "13-3/8", "54.5", "J55", "0", "1500", "17.5", "9.0", "", "casing tally (test)"],
             ["", "HY-2", "intermediate", "9.625", "47", "N80", "0", "6000", "12.25", "10", "", "casing tally (test)"],
-            ["[casing_loads]", *cols_l], ["", "HY-2", "10000", "8.5", "11", "9.5", "14.5", "0.5", "", "", "", "", "", "", "", "6.75", "400", "5", "drilling program (test)"]]
+            ["[casing_loads]", *cols_l], [""] + [{"well": "HY-2", "td_md_ft": "10000", "td_hole_in": "8.5", "td_mw_ppg": "11", "pp_ppg": "9.5", "fg_ppg": "14.5",
+                                                  "kick_intensity_ppg": "0.5", "bha_od_in": "6.75", "bha_length_ft": "400", "dp_od_in": "5",
+                                                  "source": "drilling program (test)"}.get(c_, "") for c_ in cols_l]]
     import csv as _csv
     import io as _io
     buf = _io.StringIO(); _csv.writer(buf).writerows(rows); sheet.write_text(buf.getvalue(), encoding="utf-8")
@@ -13526,6 +13529,140 @@ def section_dd_casing_design(tmp: str) -> None:
        "RESOLVED and says how far it reaches" + (f" [failed: {', '.join(failed4)}]" if failed4 else ""))
 
 
+def section_de_real_gas(tmp: str) -> None:
+    """Section DE - the kick and the burst load on a real gas: Sutton's pseudocritical properties and Dranchuk and
+    Abou-Kassem's z against an independent implementation; the gas's density, and a column of it integrated up the well
+    along the geothermal temperature; the kick tolerance with the gas's gradient at the bubble's own pressure and
+    temperature and the volume carried between shoe and bottom by p V / z T, and a swabbed kick beside it; a fixed
+    gradient still taken when declared, and the real gas back with 'none'."""
+    import subprocess as _sp
+    from . import casing_design as CSG
+    from . import declarations as DC
+    from . import helplib as H
+    from .workspace import Workspace
+    pkg = Path(__file__).parent
+
+    # -- DE1 the gas's properties ------------------------------------------------------------------------------------------------
+    # reference values from pyrestoolbox 3.8.9 (gas_z / gas_den, zmethod DAK, cmethod SUT), an independent open-source implementation
+    ref = [(3000, 0.65, 200, 0.9048073771833917, 8.819352273478), (6000, 0.65, 250, 1.0923431854133714, 13.58107045798391),
+           (1000, 0.8, 120, 0.8335178869315637, 4.469708326242926), (10000, 0.7, 300, 1.3920860511301727, 17.868657631013313),
+           (500, 0.6, 80, 0.9330965197803314, 1.6082418312797764)]
+    got = [CSG.gas_state(p_ - CSG.ATM, f_, sg_) for p_, sg_, f_, _, _ in ref]
+    tpc, ppc = CSG.pseudo_critical(0.65)
+    tpc8, ppc8 = CSG.pseudo_critical(0.8)
+    low = CSG.z_factor(1.5, 0.01)
+    c1 = {
+        "sutton": abs(tpc - 365.11) < 0.01 and abs(ppc - 670.129) < 0.01 and abs(tpc8 - 401.44) < 0.01 and abs(ppc8 - 649.696) < 0.01,
+        "z": all(abs(g_["z"] - r_[3]) < 1e-5 for g_, r_ in zip(got, ref)),
+        "density": all(abs(g_["rho_lb_ft3"] - r_[4]) / r_[4] < 1e-5 for g_, r_ in zip(got, ref)),
+        "gradient": all(abs(g_["psi_ft"] - g_["rho_lb_ft3"] / 144.0) < 1e-12 for g_ in got),
+        "ideal_limit": abs(low - 1.0) < 0.005 and CSG.z_factor(1.5, 0.0) == 1.0,
+        "chart_shape": CSG.z_factor(1.5, 2.0) < CSG.z_factor(1.5, 1.0) < 1.0 and CSG.z_factor(1.5, 10.0) > 1.0 and CSG.z_factor(1.2, 2.0) < CSG.z_factor(2.0, 2.0),
+    }
+    failed1 = [k for k, v in c1.items() if not v]
+    ok(not failed1,
+       "DE1 the gas: Sutton's pseudocritical temperature and pressure (365.11 R and 670.13 psia for a 0.65 gas), Dranchuk and Abou-Kassem's z and "
+       "the density p M / z R T within 1e-5 of an independent implementation (pyrestoolbox) from 500 to 10,000 psia, 80 to 300 F, gravities 0.6 "
+       "to 0.8; z to 1 as the pressure falls, the Standing-Katz chart's dip and rise" + (f" [failed: {', '.join(failed1)}]" if failed1 else ""))
+
+    # -- DE2 a column of gas up the well ------------------------------------------------------------------------------------------
+    cfg = {**CSG.DEFAULTS}
+    p0 = 0.052 * 11.0 * 10000.0
+    top = CSG.gas_column(cfg, p0, 10000.0, 0.0)
+    p_, z_ = p0, 10000.0                                          # a fine Euler integration of the same gas, 1 ft at a time
+    while z_ > 0.0:
+        p_ -= CSG.gas_state(p_, CSG.temperature_f(cfg, z_ - 0.5), 0.65)["psi_ft"]
+        z_ -= 1.0
+    hot = CSG.gas_column({**cfg, "geothermal_f_100ft": 2.5}, p0, 10000.0, 0.0)
+    heavy = CSG.gas_column({**cfg, "gas_sg": 0.9}, p0, 10000.0, 0.0)
+    fixed = CSG.gas_column({**cfg, "gas_gradient_psi_ft": 0.1}, p0, 10000.0, 0.0)
+    c2 = {
+        "integrated": abs(top - p_) < 0.5 and abs(top - 4658.6) < 1.0,
+        "hotter_lighter": hot > top and heavy < top,
+        "fixed": abs(fixed - (p0 - 1000.0)) < 1e-9,
+        "temperature": CSG.temperature_f(cfg, 0.0) == 70.0 and abs(CSG.temperature_f(cfg, 10000.0) - 220.0) < 1e-9,
+    }
+    failed2 = [k for k, v in c2.items() if not v]
+    ok(not failed2,
+       "DE2 a column of real gas from 5,720 psi at 10,000 ft (an 11 ppg pore pressure) integrated to the surface along 70 F rising 1.5 F per 100 ft: "
+       "4,659 psi at the surface (an average 0.106 psi/ft), as a 1 ft step integration gives; a hotter well's gas lighter, a heavier gas heavier; a "
+       "declared 0.1 psi/ft taken as it is" + (f" [failed: {', '.join(failed2)}]" if failed2 else ""))
+
+    # -- DE3 the kick tolerance and the burst load on the real gas -----------------------------------------------------------------
+    ex = CSG.example()
+    exf = CSG.analyse({**ex["config"], "gas_gradient_psi_ft": 0.1}, lambda md: float(md), CSG.EXAMPLE_WINDOW)
+    k_, kf = ex["kicks"][1], exf["kicks"][1]
+    win = CSG.EXAMPLE_WINDOW
+    fg_s = float(np.interp(7000.0, win["tvd_ft"], win["fg_ppg"]))
+    p_frac, p_bot = 0.052 * fg_s * 7000.0, 0.052 * k_["kick_ppg"] * 10000.0
+    maasp, sidpp = 0.052 * (fg_s - 11.5) * 7000.0, 0.052 * (k_["kick_ppg"] - 11.5) * 10000.0
+    gm = 0.052 * 11.5
+    h_b = (maasp - sidpp) / (gm - k_["gas_gradient_bottom_psi_ft"])
+    st_b = CSG.gas_state(p_bot - k_["gas_gradient_bottom_psi_ft"] * h_b / 2, CSG.temperature_f(ex["config"], 10000.0 - h_b / 2), 0.65)
+    h_s = (maasp - sidpp) / (gm - k_["gas_gradient_shoe_psi_ft"])
+    st_s = CSG.gas_state(p_frac + k_["gas_gradient_shoe_psi_ft"] * h_s / 2, CSG.temperature_f(ex["config"], 7000.0 + h_s / 2), 0.65)
+    carried = k_["volume_at_shoe_bbl"] * (st_s["p_psia"] / (st_s["z"] * st_s["t_r"])) / (st_b["p_psia"] / (st_b["z"] * st_b["t_r"]))
+    sv = ex["strings"][0]
+    top_load = CSG.gas_column(ex["config"], 0.052 * float(np.interp(1500.0, win["tvd_ft"], win["fg_ppg"])) * 1500.0, 1500.0, 0.0)
+    c3 = {
+        "bubble_gradient": abs(k_["gas_gradient_bottom_psi_ft"] - st_b["psi_ft"]) < 1e-5 and abs(k_["gas_gradient_shoe_psi_ft"] - st_s["psi_ft"]) < 1e-5
+                           and k_["gas_gradient_bottom_psi_ft"] > k_["gas_gradient_shoe_psi_ft"],
+        "heights": abs(k_["height_ft"] - h_b) < 0.2 and abs(k_["height_shoe_ft"] - h_s) < 0.2,
+        "carried": abs(k_["volume_shoe_as_bottom_bbl"] - carried) < 0.15 and "real-gas law" in k_["carried_by"] and "Boyle" in kf["carried_by"],
+        "z_t": k_["z_bottom"] > 0 and abs(k_["temp_bottom_f"] - CSG.temperature_f(ex["config"], 10000.0 - h_b / 2)) < 0.1,
+        "swabbed": all(k["swabbed"]["kick_ppg"] == k["mw_ppg"] and k["swabbed"]["volume_bbl"] > k["volume_bbl"] for k in ex["kicks"]),
+        "burst_real": abs(sv["rows"][0]["burst_net_psi"] - top_load) <= 1.0 and sv["rows"][0]["burst_limited_by_shoe"]
+                      and "real gas" in sv["gas"] and "0.1 psi/ft" in exf["strings"][0]["gas"],
+    }
+    failed3 = [k for k, v in c3.items() if not v]
+    ok(not failed3,
+       "DE3 on the worked example: the gas's gradient in the bubble at its own middle's pressure and temperature, heavier on bottom than at the shoe; "
+       "the bubble's heights from them; the shoe's volume carried to the bottom by p V / z T (Boyle's law with a fixed gradient); a swabbed kick "
+       "(no underbalance) beside each, larger; the burst load at the top the real gas's column from the fracture pressure at the shoe"
+       + (f" [failed: {', '.join(failed3)}]" if failed3 else ""))
+
+    # -- DE4 declared --------------------------------------------------------------------------------------------------------------
+    d = Path(tmp, "realgas"); d.mkdir()
+    wsp = str(d / "ws"); ws = Workspace.create(wsp, "Pad 3", actor="tester")
+    wid = ws.add_well_catalog("volve_f12_f14_production_excerpt", "15/9-F-12", 10000.0, actor="tester")["id"]
+    prog = "surface:13-3/8:54.5:J55:0-1500:17.5:9.0; intermediate:9-5/8:47:N80:0-7000:12.25:9.8"
+    run = lambda *a: _sp.run([sys.executable, "-m", "gea", "casing", "--workspace", wsp, "--well", wid, *a], capture_output=True, text=True, cwd=str(pkg.parent))
+    r1 = run("--strings", prog, "--td", "10000", "--td-hole", "8.5", "--td-mw", "11.5", "--pp", "10", "--fg", "15", "--gas-sg", "0.7", "--surface-temp", "80",
+             "--geothermal", "1.2", "--bha-od", "6.5", "--bha-length", "600", "--dp-od", "5", "--source", "test")
+    c_a = CSG.well_config(ws, wid)
+    r2 = run("--gas", "0.1", "--source", "test")
+    c_b = CSG.well_config(ws, wid)
+    r3 = run("--gas", "none", "--source", "test")
+    c_c = CSG.well_config(ws, wid)
+    pr = run()
+    cols = DC.TABLES["casing_loads"]["cols"]
+    sheet = "\n".join([",".join(["[casing_loads]", *cols]), ",".join([""] + [{"well": wid, "gas_sg": "0.75", "surface_temp_f": "60", "geothermal_f_100ft": "1.8",
+                                                                          "source": "drilling program (test)"}.get(c_, "") for c_ in cols])])
+    ps = DC.apply(ws, sheet, "tester", str(d), write=True)
+    c_d = CSG.well_config(ws, wid)
+    try:
+        CSG.set_well(ws, "tester", wid, "x", geothermal_f_100ft=9)
+        lim = ""
+    except ValueError as e:
+        lim = str(e)
+    page_src = (pkg / "web" / "app.html").read_text(encoding="utf-8")
+    help_txt = H.page("casing") or ""
+    c4 = {
+        "cli": r1.returncode == 0 and c_a["gas_sg"] == 0.7 and c_a["surface_temp_f"] == 80.0 and c_a["geothermal_f_100ft"] == 1.2 and c_a["gas_gradient_psi_ft"] is None,
+        "fixed_and_back": r2.returncode == 0 and c_b["gas_gradient_psi_ft"] == 0.1 and r3.returncode == 0 and c_c["gas_gradient_psi_ft"] is None,
+        "printed": pr.returncode == 0 and "specific gravity 0.7 as a real gas" in pr.stdout and "swabbed (no underbalance)" in pr.stdout,
+        "sheet": ps["applied"] and c_d["gas_sg"] == 0.75 and c_d["surface_temp_f"] == 60.0 and c_d["geothermal_f_100ft"] == 1.8,
+        "limits": "geothermal_f_100ft must be between" in lim,
+        "page_help": "name=\"gas_gradient_psi_ft\"" in page_src and "'gas_sg', 'Gas gravity'" in page_src and "Swabbed (bbl)" in page_src
+                     and not H.check("casing") and "Dranchuk and Abou-Kassem" in help_txt and "--gas none" in help_txt,
+    }
+    failed4 = [k for k, v in c4.items() if not v]
+    ok(not failed4,
+       "DE4 the gas declared from the command line (its gravity, the surface temperature, the geothermal gradient), a fixed gradient taken in its place "
+       "and the real gas back with 'none'; the declarations sheet's [casing_loads] carries them; out of range answered; the tab, its kick table and "
+       "the help" + (f" [failed: {', '.join(failed4)}]" if failed4 else ""))
+
+
 def PR_read_ok(path) -> bool:
     from . import pdf_report as PR
     try:
@@ -13645,6 +13782,7 @@ def main() -> int:
         section_db_declarations_engineering(tmp)
         section_dc_every_tab(tmp)
         section_dd_casing_design(tmp)
+        section_de_real_gas(tmp)
     if _FAILS:
         print(f"[ACCEPTANCE] {len(_FAILS)} FAILURES ({_PASS} passed):")
         for f in _FAILS:

{gea_program-0.61.0 → gea_program-0.62.0}/gea/casing_design.py

@@ -15,9 +15,12 @@ outside diameter D, the wall t and the grade's minimum yield Yp:
 The loads are the textbook ones (Bourgoyne et al., Applied Drilling Engineering, ch. 7; Rabia, Well Engineering and
 Construction), on the true vertical depth z:
 
-- burst: inside, gas to the surface from the deepest pore pressure the hole below the shoe reaches (gas gradient 0.1
-  psi/ft unless declared), no more than the fracture pressure at the shoe less the gas column above it when there is
-  open hole below; outside, a backup of formation water (0.465 psi/ft unless declared);
+- burst: inside, gas to the surface from the deepest pore pressure the hole below the shoe reaches, no more than the
+  fracture pressure at the shoe less the gas column above it when there is open hole below; outside, a backup of
+  formation water (0.465 psi/ft unless declared). The gas is a real gas: its density p M / (z R T) at each depth's
+  pressure and temperature (the surface temperature and the geothermal gradient), z by Dranchuk and Abou-Kassem's fit
+  of the Standing-Katz chart on Sutton's pseudocritical properties for the declared gas gravity, the column integrated
+  up the well; a gas gradient declared in psi/ft replaces it;
 - collapse: outside, the mud the string was run in; inside, the string emptied (or emptied to a declared fraction of
   its depth) with the next hole's mud below the level;
 - tension: the string's buoyed weight hanging from its top (the buoyancy factor 1 - MW/65.5), checked against the
@@ -62,10 +65,11 @@ WALLS: Dict[float, Dict[float, float]] = {
     20.0: {94.0: 0.438, 106.5: 0.500, 133.0: 0.635},
 }
 DEFAULTS = {'strings': [], 'td_md_ft': None, 'td_hole_in': None, 'td_mw_ppg': None, 'pp_ppg': None, 'fg_ppg': None, 'kick_intensity_ppg': 0.5,
-            'gas_gradient_psi_ft': 0.1, 'backup_gradient_psi_ft': 0.465, 'evacuation': 1.0, 'df_burst': 1.1, 'df_collapse': 1.125, 'df_tension': 1.6,
+            'gas_gradient_psi_ft': None, 'gas_sg': 0.65, 'surface_temp_f': 70.0, 'geothermal_f_100ft': 1.5, 'backup_gradient_psi_ft': 0.465, 'evacuation': 1.0, 'df_burst': 1.1, 'df_collapse': 1.125, 'df_tension': 1.6,
             'overpull_klbf': 100.0, 'bha_od_in': None, 'bha_length_ft': None, 'dp_od_in': None, 'step_ft': 100.0}
 LIMITS = {'td_md_ft': (100.0, 40000.0), 'td_hole_in': (2.0, 40.0), 'td_mw_ppg': (6.0, 22.0), 'pp_ppg': (6.0, 22.0), 'fg_ppg': (6.0, 25.0),
-          'kick_intensity_ppg': (0.0, 5.0), 'gas_gradient_psi_ft': (0.0, 0.3), 'backup_gradient_psi_ft': (0.0, 0.6), 'evacuation': (0.0, 1.0),
+          'kick_intensity_ppg': (0.0, 5.0), 'gas_gradient_psi_ft': (0.0, 0.3), 'gas_sg': (0.55, 1.5), 'surface_temp_f': (-20.0, 150.0),
+          'geothermal_f_100ft': (0.5, 4.0), 'backup_gradient_psi_ft': (0.0, 0.6), 'evacuation': (0.0, 1.0),
           'df_burst': (1.0, 2.0), 'df_collapse': (0.8, 2.0), 'df_tension': (1.0, 3.0), 'overpull_klbf': (0.0, 1000.0), 'bha_od_in': (2.0, 20.0),
           'bha_length_ft': (0.0, 5000.0), 'dp_od_in': (2.0, 10.0), 'step_ft': (20.0, 1000.0)}
 NOT_A_MEASUREMENT = [
@@ -74,8 +78,8 @@ NOT_A_MEASUREMENT = [
     "the loads: the textbook cases on the declared mud and the pore pressure and fracture gradient (the Pore pressure tab's, or declared), "
     "not a well's measured pressures; the temperature and the cement are not in them",
     "tension: the buoyed weight on the measured length, hanging straight; the drag of a deviated hole and the bending in a dogleg are not added",
-    "kick tolerance: a single bubble of gas at the gas gradient, Boyle's law without temperature or compressibility; the volume a well can take, "
-    "not one it has taken",
+    "kick tolerance: a single bubble of gas, a sweet natural gas of the declared gravity (no correction for CO2, H2S or nitrogen), at the "
+    "declared geothermal temperature, not the circulating one; the volume a well can take, not one it has taken",
 ]
 BBL_PER_IN2_FT = 1.0 / 1029.4          # annular capacity: (D^2 - d^2) / 1029.4 bbl per ft
 
@@ -291,6 +295,120 @@ def set_well(ws, actor: str, well_id: str, source: str = '', strings=None, **val
     return well_config(ws, well_id)
 
 
+# -- the gas: a real gas at the well's pressure and temperature -----------------------------------------------------------------
+SUTTON_TPC = (169.2, 349.5, -74.0)        # deg R: Tpc = a + b sg + c sg^2 (Sutton, SPE 14265, 1985)
+SUTTON_PPC = (756.8, -131.0, -3.6)        # psia
+DAK = (0.3265, -1.0700, -0.5339, 0.01569, -0.05165, 0.5475, -0.7361, 0.1844, 0.1056, 0.6134, 0.7210)   # Dranchuk and Abou-Kassem, 1975
+R_GAS = 10.7316                           # psia ft3 / (lb-mol deg R)
+M_AIR = 28.97                             # lb / lb-mol
+ATM = 14.696                              # psi
+
+
+def pseudo_critical(sg: float) -> Tuple[float, float]:
+    """Sutton's pseudocritical temperature (deg R) and pressure (psia) of a sweet natural gas of specific gravity sg."""
+    return (SUTTON_TPC[0] + SUTTON_TPC[1] * sg + SUTTON_TPC[2] * sg * sg, SUTTON_PPC[0] + SUTTON_PPC[1] * sg + SUTTON_PPC[2] * sg * sg)
+
+
+def z_factor(tpr: float, ppr: float) -> float:
+    """The gas deviation factor by Dranchuk and Abou-Kassem's fit of the Standing-Katz chart: the reduced density rho_r
+    solving 0 = 1 + C1 rho + C2 rho^2 - C3 rho^5 + C4 (1 + A11 rho^2) rho^2 exp(-A11 rho^2) - 0.27 Ppr / (Tpr rho),
+    found by Newton's method from the ideal gas; z = 0.27 Ppr / (Tpr rho_r)."""
+    if ppr <= 1e-9:
+        return 1.0
+    A = DAK
+    c1 = A[0] + A[1] / tpr + A[2] / tpr ** 3 + A[3] / tpr ** 4 + A[4] / tpr ** 5
+    c2 = A[5] + A[6] / tpr + A[7] / tpr ** 2
+    c3 = A[8] * (A[6] / tpr + A[7] / tpr ** 2)
+    c4 = A[9] / tpr ** 3
+
+    def f(r):
+        e = math.exp(-A[10] * r * r)
+        return 1 + c1 * r + c2 * r * r - c3 * r ** 5 + c4 * (1 + A[10] * r * r) * r * r * e - 0.27 * ppr / (tpr * r)
+
+    def df(r):
+        e = math.exp(-A[10] * r * r)
+        return (c1 + 2 * c2 * r - 5 * c3 * r ** 4 + 2 * c4 * r * e * (1 + 2 * A[10] * r * r - A[10] * r * r * (1 + A[10] * r * r))
+                + 0.27 * ppr / (tpr * r * r))
+    r = 0.27 * ppr / tpr
+    for _ in range(100):
+        step = f(r) / df(r)
+        nr = r - step
+        if nr <= 0:
+            nr = r / 2
+        if abs(nr - r) < 1e-12:
+            r = nr
+            break
+        r = nr
+    if not (math.isfinite(r) and r > 0 and abs(f(r)) < 1e-8):
+        lo, hi = 1e-6, 3.0                      # the gas root lies where f rises through zero; bisect on it
+        for _ in range(200):
+            mid = 0.5 * (lo + hi)
+            if f(mid) < 0:
+                lo = mid
+            else:
+                hi = mid
+        r = 0.5 * (lo + hi)
+    return 0.27 * ppr / (tpr * r)
+
+
+def gas_state(p_psig: float, t_f: float, sg: float) -> dict:
+    """The gas at a gauge pressure and a temperature: z, its density (lb/ft3, ppg) and its gradient (psi/ft)."""
+    tpc, ppc = pseudo_critical(sg)
+    pa, tr = max(0.0, p_psig) + ATM, t_f + 459.67
+    z = z_factor(tr / tpc, pa / ppc)
+    rho = pa * M_AIR * sg / (z * R_GAS * tr)
+    return {'z': z, 'rho_lb_ft3': rho, 'ppg': rho / 7.48052, 'psi_ft': rho / 144.0, 'p_psia': pa, 't_r': tr}
+
+
+def temperature_f(cfg: dict, tvd_ft: float) -> float:
+    return float(cfg['surface_temp_f']) + float(cfg['geothermal_f_100ft']) * max(0.0, tvd_ft) / 100.0
+
+
+def real_gas(cfg: dict) -> bool:
+    return cfg.get('gas_gradient_psi_ft') in (None, '')
+
+
+def gas_column(cfg: dict, p0_psig: float, z0_ft: float, z_ft: float, step_ft: float = 50.0) -> float:
+    """The pressure at z_ft in a column of gas whose pressure at z0_ft is p0_psig: the declared gradient, or the real gas's
+    own weight integrated along the geothermal temperature (fourth-order Runge-Kutta, 50 ft steps)."""
+    if not real_gas(cfg):
+        return p0_psig - float(cfg['gas_gradient_psi_ft']) * (z0_ft - z_ft)
+    sg = float(cfg['gas_sg'])
+    n = max(1, int(math.ceil(abs(z0_ft - z_ft) / step_ft)))
+    h = (z_ft - z0_ft) / n
+
+    def g(z, p):
+        return gas_state(p, temperature_f(cfg, z), sg)['psi_ft']
+    z, p = z0_ft, p0_psig
+    for _ in range(n):
+        k1 = g(z, p); k2 = g(z + h / 2, p + h * k1 / 2); k3 = g(z + h / 2, p + h * k2 / 2); k4 = g(z + h, p + h * k3)
+        p += h * (k1 + 2 * k2 + 2 * k3 + k4) / 6
+        z += h
+    return p
+
+
+def _bubble(cfg: dict, gm: float, maasp: float, sidpp: float, p_anchor: float, z_anchor: float, down: bool) -> dict:
+    """A gas bubble whose top (down=True: at the shoe, the anchor) or bottom (down=False: at the bottom of the hole) is at the
+    anchor pressure: its height H = (MAASP - SIDPP) / (mud gradient - gas gradient), the gas gradient taken at the bubble's
+    middle, found by fixed point; its middle's pressure, temperature and z."""
+    gg = float(cfg['gas_gradient_psi_ft']) if not real_gas(cfg) else 0.1
+    st = None
+    for _ in range(30):
+        h = (maasp - sidpp) / (gm - gg) if gm > gg else -1.0
+        hm = max(0.0, h) / 2
+        zm = z_anchor + hm if down else z_anchor - hm
+        pm = p_anchor + gg * hm if down else p_anchor - gg * hm
+        if not real_gas(cfg):
+            break
+        st = gas_state(pm, temperature_f(cfg, zm), float(cfg['gas_sg']))
+        if abs(st['psi_ft'] - gg) < 1e-7:
+            gg = st['psi_ft']
+            break
+        gg = st['psi_ft']
+    h = (maasp - sidpp) / (gm - gg) if gm > gg else -1.0
+    return {'h': h, 'gg': gg, 'mid_p_psig': pm, 'mid_tvd_ft': zm, 'state': st}
+
+
 # -- the loads -------------------------------------------------------------------------------------------------------------------
 def _section_below(cfg: dict, i: int) -> Optional[dict]:
     """The hole drilled below string i's shoe: to the next string's shoe (its hole, its mud), or for the deepest to the
@@ -318,9 +436,28 @@ def _fg(win, tvd: float) -> Optional[float]:
     return _at(win, tvd)[1]
 
 
+def gas_how(cfg: dict) -> str:
+    if real_gas(cfg):
+        return (f"a natural gas of specific gravity {float(cfg['gas_sg']):g} as a real gas (z by Dranchuk and Abou-Kassem, pseudocritical properties by "
+                f"Sutton) at the well's temperature, {float(cfg['surface_temp_f']):g} F at the surface rising {float(cfg['geothermal_f_100ft']):g} F per 100 ft")
+    return f"a gas gradient of {float(cfg['gas_gradient_psi_ft']):g} psi/ft as declared"
+
+
+def _column_at(cfg: dict, p0: float, z0: float, zs: List[float]) -> List[float]:
+    """The gas column's pressure at each of the TVDs zs (shallower than z0), from p0 at z0: integrated once, upward, through them."""
+    order = sorted(range(len(zs)), key=lambda k: -zs[k])
+    out = [0.0] * len(zs)
+    z, p = z0, p0
+    for k in order:
+        p = gas_column(cfg, p, z, min(zs[k], z)) if zs[k] < z else p
+        z = min(zs[k], z)
+        out[k] = p if zs[k] <= z0 else p0
+    return out
+
+
 def string_loads(cfg: dict, i: int, tvd_of, win) -> dict:
     s = cfg['strings'][i]
-    gg, gb = float(cfg['gas_gradient_psi_ft']), float(cfg['backup_gradient_psi_ft'])
+    gb = float(cfg['backup_gradient_psi_ft'])
     below = _section_below(cfg, i)
     ds = tvd_of(s['shoe_md_ft'])
     open_below = below is not None
@@ -341,12 +478,15 @@ def string_loads(cfg: dict, i: int, tvd_of, win) -> dict:
     mds = sorted(set([s['top_md_ft'], s['shoe_md_ft']] + [float(x) for x in np.arange(math.ceil(s['top_md_ft'] / step) * step, s['shoe_md_ft'], step)]))
     rows = []
     level = float(cfg['evacuation']) * ds
-    for md in mds:
-        z = tvd_of(md)
-        pin_b = p_res - gg * (dres - z)
+    zs = [tvd_of(md) for md in mds]
+    col_res = _column_at(cfg, p_res, dres, zs)
+    col_frac = _column_at(cfg, p_frac, ds, zs) if p_frac is not None else None
+    for k, md in enumerate(mds):
+        z = zs[k]
+        pin_b = col_res[k]
         limited = False
-        if p_frac is not None and p_frac - gg * (ds - z) < pin_b:
-            pin_b, limited = p_frac - gg * (ds - z), True
+        if col_frac is not None and col_frac[k] < pin_b:
+            pin_b, limited = col_frac[k], True
         pout_b = gb * z
         net_b = pin_b - pout_b
         pout_c = 0.052 * s['mw_ppg'] * z
@@ -380,6 +520,7 @@ def string_loads(cfg: dict, i: int, tvd_of, win) -> dict:
     return {'string': s, 'below': below, 'shoe_tvd_ft': round(ds, 1), 'reservoir_tvd_ft': round(dres, 1), 'pore_ppg': round(pp, 3), 'pore_how': pp_how,
             'fg_shoe_ppg': round(fg_shoe, 3) if fg_shoe is not None else None, 'mud_inside_ppg': mw_in, 'buoyancy_factor': round(bf, 4),
             'rows': rows, 'checks': checks, 'ok': all(c['ok'] for c in checks.values()),
+            'gas': gas_how(cfg),
             'burst_case': ('gas to the surface from the pore pressure at the bottom of the hole below (' + pp_how + ')'
                            + (', no more than the fracture pressure at the shoe less the gas above it' if p_frac is not None else '')
                            if open_below else 'gas to the surface from the pore pressure at the shoe (' + pp_how + ')'),
@@ -439,33 +580,46 @@ def kick_tolerance(cfg: dict, i: int, tvd_of, win) -> Optional[dict]:
     if fg is None:
         out.update({'status': 'NOT KNOWN', 'detail': 'the fracture gradient at the shoe is not known (the Pore pressure tab, or declare one)'})
         return out
-    gm, gg = 0.052 * mw, float(cfg['gas_gradient_psi_ft'])
+    gm = 0.052 * mw
     maasp = 0.052 * (fg - mw) * ds
     sidpp = 0.052 * (pp - mw) * dt
-    out.update({'maasp_psi': round(maasp), 'sidpp_psi': round(sidpp)})
-    if gm <= gg:
-        out.update({'status': 'NOT KNOWN', 'detail': 'the mud is lighter than the gas gradient declared'})
+    p_frac, p_bot = 0.052 * fg * ds, 0.052 * pp * dt
+    out.update({'maasp_psi': round(maasp), 'sidpp_psi': round(sidpp), 'gas': gas_how(cfg)})
+    bot = _bubble(cfg, gm, maasp, sidpp, p_bot, dt, down=False)        # the bubble on bottom, as it is shut in
+    sho = _bubble(cfg, gm, maasp, sidpp, p_frac, ds, down=True)        # the bubble circulated up to the shoe
+    out.update({'gas_gradient_bottom_psi_ft': round(bot['gg'], 6), 'gas_gradient_shoe_psi_ft': round(sho['gg'], 6)})
+    if real_gas(cfg):
+        out.update({'z_bottom': round(bot['state']['z'], 4), 'z_shoe': round(sho['state']['z'], 4),
+                    'temp_bottom_f': round(temperature_f(cfg, bot['mid_tvd_ft']), 1), 'temp_shoe_f': round(temperature_f(cfg, sho['mid_tvd_ft']), 1)})
+    if gm <= max(bot['gg'], sho['gg']):
+        out.update({'status': 'NOT KNOWN', 'detail': 'the mud is no heavier than the gas'})
         return out
-    h = (maasp - sidpp) / (gm - gg)
     open_h = dt - ds
-    out['height_ft'] = round(max(0.0, min(h, open_h)), 1)
-    out['height_capped'] = h > open_h
-    if h <= 0:
+    hb, hs = min(bot['h'], open_h), min(sho['h'], open_h)
+    out['height_ft'] = round(max(0.0, hb), 1)
+    out['height_shoe_ft'] = round(max(0.0, hs), 1)
+    out['height_capped'] = bot['h'] > open_h
+    if bot['h'] <= 0:
         out.update({'volume_bbl': 0.0, 'detail': 'the shoe cannot hold the shut-in pressure of a kick of this intensity: no kick tolerance'})
         return out
     cap = _capacity_profile(cfg, below['hole_in'] or 0.0, md_b)
     if cap is None:
         out.update({'status': 'HEIGHT ONLY', 'detail': 'declare the BHA (outside diameter, length) and the drill pipe (outside diameter) for the volume'})
         return out
-    hh = min(h, open_h)
-    md_top_bottom = _md_at_tvd(tvd_of, dt - hh, md_s, md_b)
+    md_top_bottom = _md_at_tvd(tvd_of, dt - hb, md_s, md_b)
     v_bottom = _volume(cap, tvd_of, md_top_bottom, md_b)
-    md_low_shoe = _md_at_tvd(tvd_of, ds + hh, md_s, md_b)
+    md_low_shoe = _md_at_tvd(tvd_of, ds + max(0.0, hs), md_s, md_b)
     v_shoe = _volume(cap, tvd_of, md_s, md_low_shoe)
-    p_frac, p_bot = 0.052 * fg * ds, 0.052 * pp * dt
-    v_shoe_at_bottom = v_shoe * p_frac / p_bot
+    if real_gas(cfg):                                  # the same moles of gas: p V / (z T) at the shoe's middle and at the bottom's
+        sb, ss = bot['state'], sho['state']
+        v_shoe_at_bottom = v_shoe * (ss['p_psia'] / (ss['z'] * ss['t_r'])) / (sb['p_psia'] / (sb['z'] * sb['t_r']))
+        law = "the real-gas law (p V / z T) from the shoe's conditions to the bottom's"
+    else:
+        v_shoe_at_bottom = v_shoe * p_frac / p_bot
+        law = "Boyle's law (p V) from the fracture pressure at the shoe to the pressure at the bottom"
     out.update({'volume_at_bottom_bbl': round(v_bottom, 1), 'volume_at_shoe_bbl': round(v_shoe, 1), 'volume_shoe_as_bottom_bbl': round(v_shoe_at_bottom, 1),
-                'volume_bbl': round(min(v_bottom, v_shoe_at_bottom), 1), 'governs': 'the bubble at the bottom' if v_bottom <= v_shoe_at_bottom else 'the bubble at the shoe'})
+                'volume_bbl': round(min(v_bottom, v_shoe_at_bottom), 1), 'carried_by': law,
+                'governs': 'the bubble at the bottom' if v_bottom <= v_shoe_at_bottom else 'the bubble at the shoe'})
     return out
 
 
@@ -474,6 +628,11 @@ def analyse(cfg: dict, tvd_of, win, path_how: str = '', window_how: str = '') ->
         raise ValueError('declare the casing strings: what:od:weight:grade:top-shoe:hole:mw for each, shallowest shoe first')
     strings = [string_loads(cfg, i, tvd_of, win) for i in range(len(cfg['strings']))]
     kicks = [k for k in (kick_tolerance(cfg, i, tvd_of, win) for i in range(len(cfg['strings']))) if k]
+    if float(cfg['kick_intensity_ppg']) > 0:          # a swabbed kick: gas pulled in with no underbalance
+        sw = {k['shoe_md_ft']: k for k in (kick_tolerance({**cfg, 'kick_intensity_ppg': 0.0}, i, tvd_of, win) for i in range(len(cfg['strings']))) if k}
+        for k in kicks:
+            s_ = sw.get(k['shoe_md_ft']) or {}
+            k['swabbed'] = {x: s_.get(x) for x in ('kick_ppg', 'kick_how', 'sidpp_psi', 'height_ft', 'volume_bbl', 'status', 'detail', 'governs')}
     return {'strings': strings, 'kicks': kicks, 'ok': all(s['ok'] for s in strings), 'config': cfg, 'path_how': path_how, 'window_how': window_how}
 
 
@@ -543,7 +702,7 @@ def text(p: dict) -> str:
     r = p.get('result')
     if not r:
         return f"Casing design: {p.get('detail', '')}"
-    L = [f"Casing design - {r['display']} ({r['path_how']}; window: {r['window_how']})"]
+    L = [f"Casing design - {r['display']} ({r['path_how']}; window: {r['window_how']})", f"  the gas: {gas_how(r['config'])}"]
     for s in r['strings']:
         st, c = s['string'], s['checks']
         L.append(f"  {st['what']}: {st['od_in']:g} in {st['weight_lbft']:g} lb/ft {st['grade']} to {st['shoe_md_ft']:,.0f} ft MD - burst {st['burst_psi']:,} psi, "
@@ -551,7 +710,9 @@ def text(p: dict) -> str:
         L.append('    ' + '; '.join(f"{k} SF {('%.2f' % v['sf']) if v['sf'] is not None else '-'} (design {v['df']:g}) {'OK' if v['ok'] else 'BELOW'}" for k, v in c.items()))
     for k in r['kicks']:
         if k.get('volume_bbl') is not None:
-            L.append(f"  kick tolerance below {k['shoe_what']}: {k['volume_bbl']:g} bbl ({k['governs'] if k.get('governs') else k.get('detail', '')}); MAASP {k['maasp_psi']:,} psi")
+            sw = k.get('swabbed') or {}
+            L.append(f"  kick tolerance below {k['shoe_what']}: {k['volume_bbl']:g} bbl at {k['kick_ppg']:.2f} ppg ({k['governs'] if k.get('governs') else k.get('detail', '')}); "
+                     f"MAASP {k['maasp_psi']:,} psi" + (f"; swabbed (no underbalance) {sw['volume_bbl']:g} bbl" if sw.get('volume_bbl') is not None else ''))
         else:
             L.append(f"  kick tolerance below {k['shoe_what']}: {k['status']} - {k.get('detail', '')}" + (f"; MAASP {k['maasp_psi']:,} psi, height {k.get('height_ft', 0):,.0f} ft" if k.get('maasp_psi') is not None else ''))
     return '\n'.join(L)
@@ -603,14 +764,19 @@ def build_report(ws, version: str, well: Optional[str] = None, scene: str = 'wor
                                      f"{s['rows'][i]['collapse_rating_psi']:,}", '-' if s['rows'][i]['sf_collapse'] is None else f"{s['rows'][i]['sf_collapse']:.2f}",
                                      f"{s['rows'][i]['axial_klbf']:,.0f}"] for i in idx]))
         secs.append(sec)
-    s4 = CR.Section('4', 'Kick tolerance', [f"A single gas bubble at {cfg['gas_gradient_psi_ft']:g} psi/ft; MAASP = 0.052 (FG - MW) D_shoe; SIDPP = 0.052 (kick - MW) D_bottom; "
-                                             f"the tallest bubble H = (MAASP - SIDPP) / (mud gradient - gas gradient); its volume at the bottom and at the shoe "
-                                             f"(Boyle's law back to the bottom), the smaller governing. Annulus: BHA {cfg.get('bha_od_in') or '-'} in over "
+    s4 = CR.Section('4', 'Kick tolerance', [f"A single gas bubble: {gas_how(cfg)}. MAASP = 0.052 (FG - MW) D_shoe; SIDPP = 0.052 (kick - MW) D_bottom; "
+                                             f"the tallest bubble H = (MAASP - SIDPP) / (mud gradient - gas gradient), the gas's gradient taken at the bubble's middle on bottom "
+                                             f"and at the shoe; its volume at the bottom and at the shoe "
+                                             f"({'the real-gas law, p V / z T' if real_gas(cfg) else 'Boyle' + chr(39) + 's law'} back to the bottom), the smaller governing; "
+                                             f"and the same for a swabbed kick, gas pulled in with no underbalance. Annulus: BHA {cfg.get('bha_od_in') or '-'} in over "
                                              f"{cfg.get('bha_length_ft') or '-'} ft, drill pipe {cfg.get('dp_od_in') or '-'} in."], [])
-    s4.tables.append(CR.Table(['Below', 'Open hole (ft MD)', 'Mud (ppg)', 'Kick (ppg)', 'FG at shoe (ppg)', 'MAASP (psi)', 'Height (ft)', 'Kick tolerance (bbl)'],
+    s4.tables.append(CR.Table(['Below', 'Open hole (ft MD)', 'Mud (ppg)', 'Kick (ppg)', 'FG at shoe (ppg)', 'MAASP (psi)', 'Gas (psi/ft) bottom / shoe', 'Height (ft)',
+                               'Kick tolerance (bbl)', 'Swabbed (bbl)'],
                               [[k['shoe_what'], f"{k['shoe_md_ft']:,.0f}-{k['bottom_md_ft']:,.0f}", f"{k['mw_ppg']:g}", f"{k['kick_ppg']:.2f}",
                                 '-' if k['fg_shoe_ppg'] is None else f"{k['fg_shoe_ppg']:.2f}", '-' if k.get('maasp_psi') is None else f"{k['maasp_psi']:,}",
-                                '-' if k.get('height_ft') is None else f"{k['height_ft']:,.0f}", f"{k['volume_bbl']:g}" if k.get('volume_bbl') is not None else k['status']]
+                                '-' if k.get('gas_gradient_bottom_psi_ft') is None else f"{k['gas_gradient_bottom_psi_ft']:.3f} / {k['gas_gradient_shoe_psi_ft']:.3f}",
+                                '-' if k.get('height_ft') is None else f"{k['height_ft']:,.0f}", f"{k['volume_bbl']:g}" if k.get('volume_bbl') is not None else k['status'],
+                                f"{(k.get('swabbed') or {}).get('volume_bbl'):g}" if (k.get('swabbed') or {}).get('volume_bbl') is not None else '-']
                                for k in r['kicks']]))
     secs += [s4, CR.Section('5', 'What this will not call a measurement', ['; '.join(p['not_a_measurement']) + '.'], [])]
     return CR.Document(f"Casing design and kick tolerance - {r['display']}", rid, front, secs,

{gea_program-0.61.0 → gea_program-0.62.0}/gea/declarations.py

@@ -829,10 +829,10 @@ ENG_TABLES: Dict[str, dict] = {
     'casing_design': {'cols': ('well', 'what', 'od_in', 'weight_lbft', 'grade', 'top_md_ft', 'shoe_md_ft', 'hole_in', 'mw_ppg', 'wall_in', 'source'),
                       'need': ('well', 'what', 'od_in', 'weight_lbft', 'grade', 'shoe_md_ft', 'hole_in', 'mw_ppg', 'source'),
                       'about': "the casing program for casing design and kick tolerance: a row per string - its outside diameter (9.625 or 9-5/8), nominal weight (lb/ft), grade (H40 to Q125), top (0 to the surface) and shoe (ft MD), the hole it was run in (in), the mud it was run in (ppg), the wall (in) for a size not in the program's table; a well's rows together replace its program"},
-    'casing_loads': {'cols': ('well', 'td_md_ft', 'td_hole_in', 'td_mw_ppg', 'pp_ppg', 'fg_ppg', 'kick_intensity_ppg', 'gas_gradient_psi_ft', 'backup_gradient_psi_ft',
-                              'evacuation', 'df_burst', 'df_collapse', 'df_tension', 'overpull_klbf', 'bha_od_in', 'bha_length_ft', 'dp_od_in', 'source'),
+    'casing_loads': {'cols': ('well', 'td_md_ft', 'td_hole_in', 'td_mw_ppg', 'pp_ppg', 'fg_ppg', 'kick_intensity_ppg', 'gas_gradient_psi_ft', 'gas_sg',
+                              'surface_temp_f', 'geothermal_f_100ft', 'backup_gradient_psi_ft', 'evacuation', 'df_burst', 'df_collapse', 'df_tension', 'overpull_klbf', 'bha_od_in', 'bha_length_ft', 'dp_od_in', 'source'),
                      'need': ('well', 'source'),
-                     'about': "the casing loads' terms: the hole below the deepest string (TD ft MD, hole in, mud ppg), a pore pressure and fracture gradient when the Pore pressure tab has none, the kick intensity (ppg), the gas and backup gradients (psi/ft), the evacuation (0 to 1), the design factors, the overpull (klbf), and the BHA and drill pipe for the kick volume; blank keeps the default"},
+                     'about': "the casing loads' terms: the hole below the deepest string (TD ft MD, hole in, mud ppg), a pore pressure and fracture gradient when the Pore pressure tab has none, the kick intensity (ppg), the gas (its gravity, the surface temperature in F and the geothermal gradient in F per 100 ft; or a fixed gradient in psi/ft in place of the real gas), the backup gradient (psi/ft), the evacuation (0 to 1), the design factors, the overpull (klbf), and the BHA and drill pipe for the kick volume; blank keeps the default"},
     'frac_stages': {'cols': ('well', 'file', 'depth_unit', 'utc_offset_h', 'source'), 'need': ('well', 'file', 'source'),
                     'about': "a treatment well's stage table (a path beside this sheet: CSV or Excel, one row per stage with its start and end of pumping), its depth unit (ft or m), the stage clock's hours from UTC, and the report it came from"},
     'frac_monitors': {'cols': ('well', 'channel'), 'need': ('well', 'channel'),
@@ -1073,6 +1073,9 @@ def _plan_engineering(ws, tables, wells, add, guard, base_dir: str) -> None:
             for k in CSG.LIMITS:
                 if k == 'step_ft' or not (rec.get(k) or '').strip():
                     continue
+                if rec[k].strip().lower() == 'none' and CSG.DEFAULTS.get(k) is None:
+                    want[k] = None
+                    continue
                 v = CSG.size_in(rec[k]) if k in ('td_hole_in', 'bha_od_in', 'dp_od_in') else _f(rec.get(k), k, False)
                 lo, hi = CSG.LIMITS[k]
                 if not lo <= v <= hi: