gea-program 0.24.0__tar.gz → 0.25.0__tar.gz

{gea_program-0.24.0 → gea_program-0.25.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gea-program
-Version: 0.24.0
+Version: 0.25.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
@@ -125,7 +125,7 @@ gea dashboard --catalog-well volve_f12_f14_production_excerpt:15/9-F-12:10000 --
 gea client-report --report accuracy --out client_report
 gea model-cards --out model_cards
 gea sbom --out sbom
-gea accept                     # the product gate (359 checks)
+gea accept                     # the product gate (362 checks)
 gea help drift                 # the help library, by the job (16 pages; the same text is on every dashboard page)
 gea guide                      # the click-by-click tester guide (docs/TESTER_GUIDE.md)
 gea gui                        # the desktop window (pip install "gea-program[desktop]")
@@ -648,6 +648,19 @@ 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`.
 
+### The catalogue accounted for
+
+`gea catalog --list` is the register of the 52 shipped public datasets: for
+each, what in this program reads it, or CARRIED, NO BAND with the reason;
+the gate holds the register to the code both ways and reads every entry.
+`gea survey --catalog <entry>` runs the strata survey on any catalogue log
+with its provenance; `gea catalog --friction` reads seven laboratory
+datasets on natural fault and sediment samples as the measured friction
+envelope (0.21-0.90 on 70 measurements, none from the Permian) against
+Byerlee's 0.6; `gea catalog --core` checks the published sandstone range
+against the Volve core (65 of 70 plugs inside), an evaluation on the rock
+inventory model card. `gea help catalog`.
+
 ### The log as delivered, and the historian
 
 A well log arrives as DLIS (API RP66 V1); `gea/dlis.py` reads the container

{gea_program-0.24.0 → gea_program-0.25.0}/README.md

@@ -86,7 +86,7 @@ gea dashboard --catalog-well volve_f12_f14_production_excerpt:15/9-F-12:10000 --
 gea client-report --report accuracy --out client_report
 gea model-cards --out model_cards
 gea sbom --out sbom
-gea accept                     # the product gate (359 checks)
+gea accept                     # the product gate (362 checks)
 gea help drift                 # the help library, by the job (16 pages; the same text is on every dashboard page)
 gea guide                      # the click-by-click tester guide (docs/TESTER_GUIDE.md)
 gea gui                        # the desktop window (pip install "gea-program[desktop]")
@@ -609,6 +609,19 @@ 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`.
 
+### The catalogue accounted for
+
+`gea catalog --list` is the register of the 52 shipped public datasets: for
+each, what in this program reads it, or CARRIED, NO BAND with the reason;
+the gate holds the register to the code both ways and reads every entry.
+`gea survey --catalog <entry>` runs the strata survey on any catalogue log
+with its provenance; `gea catalog --friction` reads seven laboratory
+datasets on natural fault and sediment samples as the measured friction
+envelope (0.21-0.90 on 70 measurements, none from the Permian) against
+Byerlee's 0.6; `gea catalog --core` checks the published sandstone range
+against the Volve core (65 of 70 plugs inside), an evaluation on the rock
+inventory model card. `gea help catalog`.
+
 ### The log as delivered, and the historian
 
 A well log arrives as DLIS (API RP66 V1); `gea/dlis.py` reads the container

{gea_program-0.24.0 → gea_program-0.25.0}/gea/__init__.py

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

{gea_program-0.24.0 → gea_program-0.25.0}/gea/__main__.py

@@ -278,6 +278,11 @@ def main(argv=None) -> int:
         p_lp.add_argument("--stream-csv", type=str, default=None, help="also write a historian-style CSV the other commands ingest")
         p_lp.add_argument("--selftest", action="store_true", help="etp: the codec round-trip and a session against the simulated store on the loopback")
 
+    p_cat = sub.add_parser("catalog", help="the shipped catalogue: --list every entry with what reads it; --unused the carried ones; --check reads every entry; --friction the measured friction envelope; --core the core check; --entry X --info | --stream-csv")
+    p_cat.add_argument("--list", action="store_true"); p_cat.add_argument("--unused", action="store_true"); p_cat.add_argument("--check", action="store_true")
+    p_cat.add_argument("--friction", action="store_true"); p_cat.add_argument("--core", action="store_true")
+    p_cat.add_argument("--entry", type=str, default=None); p_cat.add_argument("--info", action="store_true"); p_cat.add_argument("--stream-csv", type=str, default=None)
+    p_cat.add_argument("--json", action="store_true")
     p_dl = sub.add_parser("dlis", help="a DLIS (RP66 V1) well log: --info describes it (origin, channels, frames, what was skipped); --frame --out writes the frame as a historian-style CSV; --to-las writes LAS 2.0")
     p_dl.add_argument("--file", type=str, required=True)
     p_dl.add_argument("--info", action="store_true")
@@ -689,6 +694,7 @@ def main(argv=None) -> int:
     p_sy = sub.add_parser("survey", help="a LAS or DLIS file in, one strata report out (--demo: the bundled public KTB excerpt); --out writes report.txt + survey.json")
     p_sy.add_argument("--file", type=str, default=None, help="LAS 2.0 or DLIS (RP66 V1) file")
     p_sy.add_argument("--frame", type=str, default=None, help="DLIS: the frame to read when the file holds several (gea dlis --file X --info lists them)")
+    p_sy.add_argument("--catalog", type=str, default=None, help="a catalogue LAS entry instead of a file (gea catalog --list names them)")
     p_sy.add_argument("--demo", action="store_true")
     p_sy.add_argument("--family", type=str, default="continental_crystalline", help="prior family for the estimator")
     p_sy.add_argument("--lat", type=float, default=None)
@@ -823,9 +829,9 @@ def main(argv=None) -> int:
     elif a.cmd == "survey":
         import json as _json
         from .survey_cmd import run_survey
-        if not (a.file or a.demo):
-            raise SystemExit("survey needs --file <LAS or DLIS> or --demo")
-        txt, machine = run_survey(path=a.file, demo=a.demo, family=a.family, lat=a.lat, elev=a.elev, frame=a.frame)
+        if not (a.file or a.demo or a.catalog):
+            raise SystemExit("survey needs --file <LAS or DLIS>, --catalog <entry> or --demo")
+        txt, machine = run_survey(path=a.file, demo=a.demo, family=a.family, lat=a.lat, elev=a.elev, frame=a.frame, catalog=a.catalog)
         print(txt)
         if a.out:
             os.makedirs(a.out, exist_ok=True)
@@ -2298,6 +2304,58 @@ def main(argv=None) -> int:
             stop.set()
             print("etp-sim: stopped")
         return 0
+    elif a.cmd == "catalog":
+        import json as _json
+        from . import catalog_register as _CR
+        if a.friction:
+            from . import friction_priors as _FP
+            print(_json.dumps({"measured": _FP.measured(), "envelope": _FP.envelope()}, indent=1, default=str) if a.json else _FP.text()); return 0
+        if a.core:
+            from .rock_inventory import core_check
+            c = core_check()
+            print(_json.dumps(c, indent=1) if a.json else (f"core check ({c.get('entry')}): {c.get('how')}\n  grain density {c['grain_density']['min']}-{c['grain_density']['max']} g/cc, porosity "
+                  f"{c['porosity_frac']['min']:.3f}-{c['porosity_frac']['max']:.3f}, bulk {c['bulk_density']['min']}-{c['bulk_density']['max']} g/cc; {c['outside']} plug(s) outside the range\n  source: {c['source']} [{c['license']}]" if c.get('status') == 'OK' else str(c)))
+            return 0
+        if a.check:
+            rows = _CR.check_all()
+            bad = [r for r in rows if not r["ok"]]
+            for r in rows:
+                print(f"  {'ok ' if r['ok'] else 'BAD'} {r['entry']:<40s} {r['shape']}")
+            print(f"catalog: {len(rows) - len(bad)} of {len(rows)} entries read through their own readers" + (f"; {len(bad)} did not" if bad else ""))
+            return 0 if not bad else 1
+        if a.entry:
+            from .profile_catalog import CATALOG as _CAT
+            e = _CAT.get(a.entry)
+            if e is None:
+                raise SystemExit(f"catalog: no entry {a.entry!r} (gea catalog --list)")
+            if a.stream_csv:
+                st = e.stream()
+                import csv as _csv
+                with open(a.stream_csv, "w", newline="", encoding="utf-8") as f:
+                    wr = _csv.writer(f)
+                    wr.writerow([st.index_kind] + list(st.channels)); wr.writerow([""] + [st.channels[c].unit for c in st.channels])
+                    for i in range(len(st.index)):
+                        wr.writerow([float(st.index[i])] + ["" if st.channels[c].values[i] != st.channels[c].values[i] else float(st.channels[c].values[i]) for c in st.channels])
+                print(f"{a.entry}: {len(st.index)} rows x {len(st.channels)} channels -> {a.stream_csv}")
+            reg = next(r for r in _CR.register() if r["entry"] == a.entry)
+            if a.json:
+                print(_json.dumps({"register": reg, "provenance": e.provenance}, indent=1, default=str))
+            else:
+                print(f"{a.entry}: {reg['kind']} ({reg['tier']}), {reg['file']} {reg['bytes']:,} bytes, {reg['status']}")
+                for u in reg["used_by"]:
+                    print("  used by:", u)
+                for k in ("well", "source_database", "source_url", "license", "fetch_date", "coverage", "purpose"):
+                    if e.provenance.get(k):
+                        print(f"  {k}: {str(e.provenance[k])[:300]}")
+                print("  reads as:", _CR.check_entry(e)["shape"])
+            return 0
+        rows = _CR.register()
+        if a.json:
+            print(_json.dumps({"entries": rows, "audit": _CR.audit()}, indent=1, default=str)); return 0
+        print(_CR.text(rows, unused_only=a.unused))
+        if a.unused:
+            print(f"\n  {_CR.NO_BAND_REASON}")
+        return 0
     elif a.cmd == "dlis":
         import json as _json
         from .dlis import DlisError, DlisFile, read as _read_dlis

{gea_program-0.24.0 → gea_program-0.25.0}/gea/acceptance_tests.py

@@ -6966,6 +6966,112 @@ def section_br_logs_historian(tmp: str) -> None:
        + (f" [failed: {', '.join(failed3)}]" if failed3 else ""))
 
 
+def section_bs_catalog(tmp: str) -> None:
+    """Section BS - the catalogue accounted for: every entry reads; the register against the code both ways; the
+    measured friction envelope with provenance; the core check in the model card; every LAS entry through the
+    survey with an estimate or a named refusal; the CLI; the help."""
+    import subprocess as _sp
+    from . import catalog_register as CR
+    from . import friction_priors as FP
+    from . import helplib as H
+    from .profile_catalog import CATALOG
+    from .rock_inventory import core_check
+    from .survey_cmd import run_survey
+    pkg = Path(__file__).parent
+    d = Path(tmp, "bs"); d.mkdir()
+
+    checks = CR.check_all()
+    bad = [c for c in checks if not c["ok"]]
+    aud = CR.audit()
+    reg = CR.register()
+    used = [r for r in reg if r["status"] == "USED"]
+    carried = [r for r in reg if r["status"] != "USED"]
+    c1 = {
+        "every_entry_reads": not bad and len(checks) == len(CR.public()) >= 50 and len(reg) == len(CR.public()) and aud["n_operator"] == len(CATALOG) - len(CR.public()),
+        "register_matches_code": aud["unregistered"] == [] and aud["unnamed"] == [] and aud["n_used"] == len(used) and aud["n_total"] == len(reg),
+        "carried_stated": all(r["why"].startswith("a science-hole dataset") and not r["used_by"] for r in carried) and all(r["used_by"] for r in used),
+        "sidecars": all(r["source"] and r["license"] and r["kind"] for r in reg),
+    }
+    failed1 = [k for k, v in c1.items() if not v]
+    ok(not failed1,
+       f"BS1 the catalogue accounted for: {len(checks)} public entries each read through its own reader (an operator tier, when present on a machine, is counted and never listed); the register against the code both ways (an entry a "
+       "module names is registered as used, an entry registered as used is named or is a LAS the survey takes); every carried entry says so with the "
+       "reason and no use; every entry carries its source, licence and kind"
+       + (f" [failed: {', '.join(failed1)}]" if failed1 else ""))
+
+    meas = FP.measured(); env = FP.envelope()
+    by = {m["entry"]: m for m in meas}
+    cc = core_check()
+    cc2 = core_check(brine_gcc=1.0)
+    from .model_card import build_cards
+    cards = build_cards()
+    inv_card = next(c for c in cards if c.model_id == "rock_density_inventory")
+    ev = [e for e in inv_card.evaluation if e["metric"] == "sandstone range against a real core"]
+    c2 = {
+        "friction_read": len(meas) == 7 and by["costa_rica_odp_friction_envelope"]["mu"]["n"] == 31 and by["costa_rica_odp_friction_envelope"]["mu"]["min"] == 0.21
+                         and by["costa_rica_odp_friction_envelope"]["mu"]["max"] == 0.88 and by["hikurangi_u1520_friction_insitu"]["mu_peak"]["n"] == 12
+                         and by["hikurangi_u1520_friction_insitu"]["a_minus_b"]["min"] < 0 and by["nankai_megasplay_shear_strength"]["mu_how"].startswith("shear strength / effective")
+                         and by["sumatra_362_cohesion"]["strength"]["unit"] == "kPa" and by["sumatra_362_cohesion"]["strength"]["max"] == 990.0
+                         and by["ktb_vb_rockmech_compress"]["strength"]["n"] == 113 and by["jfast_c0019_slow_slip_events"]["strength"]["n"] == 5
+                         and by["barbados_110_consolidation"]["strength"]["what"] == "vane shear strength",
+        "envelope": env["n_entries"] == 3 and env["n_samples"] == 70 and env["min"] == 0.21 and env["max"] == 0.9 and env["byerlee"] == 0.6
+                    and "none from the Permian Basin" in env["statement"] and all(m["source"] and m["license"] and m["url"] for m in meas),
+        "core_check": cc["status"] == "OK" and cc["n_plugs"] == 70 and cc["inside"] == 65 and cc["outside"] == 5 and cc["sandstone_range"] == [2.05, 2.55]
+                      and cc["bulk_density"]["min"] == 2.054 and "grain x (1 - phi) + 1.03 x phi" in cc["how"] and cc2["inside"] != cc["inside"] or (cc2["brine_gcc"] == 1.0 and cc2["inside"] <= 70),
+        "in_model_card": len(ev) == 1 and "65 of 70 Volve 15/9-19 A core plugs inside 2.05-2.55" in ev[0]["value"] and "Equinor Volve" in ev[0]["method"],
+    }
+    failed2 = [k for k, v in c2.items() if not v]
+    ok(not failed2,
+       "BS2 the measured friction and strength read from seven catalogue entries with their sources and licences (Costa Rica 31 coefficients 0.21-0.88, Hikurangi "
+       "peak and steady-state with a-b, Nankai as shear strength over effective stress, Sumatra cohesion, Barbados vane shear, JFAST peak strength, KTB "
+       "compressive strength); the envelope 0.21-0.90 on 70 measurements from three datasets against Byerlee's 0.6, none from the Permian; the core check "
+       "(70 Volve plugs, bulk from grain density and porosity with the brine stated, 65 inside the published sandstone range) in the rock inventory model card"
+       + (f" [failed: {', '.join(failed2)}]" if failed2 else ""))
+
+    outcomes = {}
+    for name in ("scorpio_e1_sa_excerpt", "university_6_17_no1_tx_excerpt", "kennetcook_2_p129_excerpt", "collingwood_1_28_ks_complete", "l07_01_nl_excerpt", "volve_15_9_19_sr_excerpt"):
+        txt, m = run_survey(catalog=name)
+        outcomes[name] = ("ESTIMATED" if "Vp (compressional velocity) estimate" in txt and "NOT ESTIMATED" not in txt else "NOT ESTIMATED", txt)
+    not_las = None
+    try:
+        run_survey(catalog="volve_15_9_19a_core_excerpt")
+    except SystemExit as e:
+        not_las = str(e)
+    no_entry = None
+    try:
+        run_survey(catalog="nope")
+    except SystemExit as e:
+        no_entry = str(e)
+    r_list = _sp.run([sys.executable, "-m", "gea", "catalog", "--list"], capture_output=True, text=True)
+    r_unused = _sp.run([sys.executable, "-m", "gea", "catalog", "--unused"], capture_output=True, text=True)
+    r_check = _sp.run([sys.executable, "-m", "gea", "catalog", "--check"], capture_output=True, text=True)
+    r_fr = _sp.run([sys.executable, "-m", "gea", "catalog", "--friction"], capture_output=True, text=True)
+    r_core = _sp.run([sys.executable, "-m", "gea", "catalog", "--core"], capture_output=True, text=True)
+    r_ent = _sp.run([sys.executable, "-m", "gea", "catalog", "--entry", "scorpio_e1_sa_excerpt", "--info", "--stream-csv", str(d / "scorpio.csv")], capture_output=True, text=True)
+    r_sv = _sp.run([sys.executable, "-m", "gea", "survey", "--catalog", "l07_01_nl_excerpt"], capture_output=True, text=True)
+    help_md = (pkg / "help" / "catalog.md").read_text(encoding="utf-8")
+    c3 = {
+        "surveys": outcomes["l07_01_nl_excerpt"][0] == "ESTIMATED" and "density 2.64 - 2.74 g/cc" in outcomes["l07_01_nl_excerpt"][1]
+                   and outcomes["scorpio_e1_sa_excerpt"][0] == "NOT ESTIMATED" and "no density (RHOB) and no gravity" in outcomes["scorpio_e1_sa_excerpt"][1]
+                   and outcomes["university_6_17_no1_tx_excerpt"][0] == "NOT ESTIMATED" and "fewer than 5 usable stations" in outcomes["university_6_17_no1_tx_excerpt"][1]
+                   and outcomes["collingwood_1_28_ks_complete"][0] == "NOT ESTIMATED" and outcomes["kennetcook_2_p129_excerpt"][0] == "NOT ESTIMATED"
+                   and outcomes["volve_15_9_19_sr_excerpt"][0] == "NOT ESTIMATED" and all("catalogue entry " in o[1] for o in outcomes.values()),
+        "refusals": not_las and "not a LAS log" in not_las and no_entry and "no catalogue entry" in no_entry,
+        "cli": r_list.returncode == 0 and f"catalogue: {len(reg)} entries, {len(used)} used, {len(carried)} carried with no band" in r_list.stdout
+               and r_unused.returncode == 0 and "CARRIED, NO BAND" in r_unused.stdout and "USED" not in r_unused.stdout.split("\n", 1)[1].replace("UNUSED", "")
+               and r_check.returncode == 0 and f"{len(reg)} of {len(reg)} entries read" in r_check.stdout
+               and r_fr.returncode == 0 and "run from 0.21 to 0.9" in r_fr.stdout and r_core.returncode == 0 and "contains 65 of 70 plugs" in r_core.stdout
+               and r_ent.returncode == 0 and "used by: gea survey --catalog" in r_ent.stdout and os.path.isfile(d / "scorpio.csv") and r_sv.returncode == 0 and "density -> RHOB" in r_sv.stdout,
+        "help": any(t["topic"] == "catalog" for t in H.topics()) and not H.check("catalog") and "it does not give the fault's own" in help_md.split("will not call a measurement")[1],
+    }
+    failed3 = [k for k, v in c3.items() if not v]
+    ok(not failed3,
+       "BS3 every LAS entry through the strata survey with its catalogue provenance: L07-01 estimated (density 2.64-2.74 g/cc), Scorpio E1 NOT ESTIMATED "
+       "(no density), University 6-17, Kennetcook, Collingwood and 15/9-19 SR NOT ESTIMATED on too little support, each with the reason; a core entry and "
+       "an unknown name refused; `gea catalog --list --unused --check --friction --core --entry`; `gea survey --catalog`; the help"
+       + (f" [failed: {', '.join(failed3)}]" if failed3 else ""))
+
+
 def main() -> int:
     print("GEA-Program - ACCEPTANCE SUITE (the product gate)")
     # a handle a job subprocess still holds at the end must not turn a finished gate into a traceback on Windows:
@@ -7039,6 +7145,7 @@ def main() -> int:
         section_bp_interval(tmp)
         section_bq_field_ports(tmp)
         section_br_logs_historian(tmp)
+        section_bs_catalog(tmp)
     if _FAILS:
         print(f"[ACCEPTANCE] {len(_FAILS)} FAILURES ({_PASS} passed):")
         for f in _FAILS:

gea_program-0.25.0/gea/catalog_register.py

@@ -0,0 +1,146 @@
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at https://mozilla.org/MPL/2.0/.
+"""catalog_register - what every shipped catalogue entry is for, and what reads it.
+
+The catalogue ships 58 public entries with provenance sidecars. A sidecar says where an entry came from; it does
+not say what in this program reads it. This register does: for each entry, the bands, commands and reports that
+take it (USED BY), or the plain statement that nothing does yet (CARRIED, NO BAND). The gate holds the register
+to the code - an entry a module names by its stem must be registered as used, an entry registered as used must
+be named somewhere - and reads every entry through its own reader so a carried file is at least a readable one.
+
+The measured-friction entries feed `friction_priors` (the envelope a slip-tendency statement discloses its
+coefficient against); the Volve core feeds `rock_inventory.core_check` (the published sandstone range checked
+against core-derived bulk density); every LAS entry runs through `gea survey --catalog`; the rest are stated.
+"""
+from __future__ import annotations
+
+import os
+import re
+from pathlib import Path
+from typing import Dict, List
+
+from .profile_catalog import CATALOG, CatalogEntry
+
+# entry -> the places in this program that read it, in the user's terms
+USES: Dict[str, List[str]] = {
+    'volve_f12_f14_production_excerpt': ['gea quickstart (the Volve catalogue well)', 'gea dashboard --catalog-well', 'the drift report, well tests, alarms and SLA on the sample reports',
+                                         'the Volve well-test validation samples'],
+    'ktb_hb_complog_6020_excerpt': ['gea survey --demo (the bundled strata survey)', 'the KTB lithology validation and the rock inventory model card', 'the accuracy statement, blind harness, inverse engine'],
+    'ktb_hb_bhgm_density': ['the ktb_hb assembly (gea wells): density'],
+    'ktb_hb_hlog246_temperature': ['the ktb_hb assembly (gea wells): temperature'],
+    'ktb_hb_tvd_0_9080_excerpt': ['the ktb_hb assembly (gea wells): the trajectory (CatalogEntry.survey)'],
+    'ktb_hb_rockmech_compress': ['the ktb_hb assembly (gea wells): the strength attachment (strata_join)'],
+    'dsdp_504b_physical_properties': ['the odp_504b assembly (gea wells): density'],
+    'dsdp_504b_sound_velocity': ['the odp_504b assembly (gea wells): the measured Vp'],
+    'odp_504b_dike_elastic_moduli': ['the odp_504b assembly (gea wells): the elastics attachment'],
+    'odp_504b_leg137_borehole_fluids': ['the odp_504b assembly (gea wells): the fluids attachment'],
+    'odp_1027c_cork_temperature': ['the site_1027 assembly (gea wells): the CORK temperature record'],
+    'odp_1027b_thermal_conductivity': ['the site_1027 assembly (gea wells): the thermal-conductivity attachment'],
+    'iodp_u1324_pore_pressure': ['the u1324 assembly (gea wells): pore pressure and overburden'],
+    'gom_308_t2p_insitu': ['the u1324 assembly (gea wells): in-situ temperature'],
+    'volve_15_9_19_sr_excerpt': ['gea gamma (lithology from GR)', 'the las2 port end-to-end (profile_catalog)', 'gea survey --catalog'],
+    'ktb_vb_vlog251_temperature': ['gea gamma (lithology from GR)'],
+    'l07_01_nl_excerpt': ['gea gamma (lithology from GR)', 'gea survey --catalog'],
+    # v0.25.0: the entries that now have a use
+    'kennetcook_2_p129_excerpt': ['gea survey --catalog (a real Nova Scotia log through the strata survey)'],
+    'collingwood_1_28_ks_complete': ['gea survey --catalog (a real Kansas log through the strata survey)'],
+    'scorpio_e1_sa_excerpt': ['gea survey --catalog (a real South Australian log through the strata survey)'],
+    'university_6_17_no1_tx_excerpt': ['gea survey --catalog (a real Texas log through the strata survey)'],
+    'volve_15_9_19a_core_excerpt': ['rock_inventory.core_check: the published sandstone density range against core-derived bulk density (model card evaluation)'],
+    'costa_rica_odp_friction_envelope': ['friction_priors: measured friction coefficient envelope (slip tendency discloses its coefficient against it)'],
+    'hikurangi_u1520_friction_insitu': ['friction_priors: peak and steady-state friction per lithology, a-b'],
+    'jfast_c0019_slow_slip_events': ['friction_priors: the Tohoku fault-zone friction at slow-slip rates'],
+    'nankai_megasplay_shear_strength': ['friction_priors: shear strength over effective stress'],
+    'sumatra_362_cohesion': ['friction_priors: cohesion of intact and powdered samples'],
+    'ktb_vb_rockmech_compress': ['friction_priors: compressive strength of crystalline basement cores (the strength end of the envelope)'],
+    'barbados_110_consolidation': ['friction_priors: vane shear strength over effective overburden of accretionary sediments'],
+}
+NO_BAND_REASON = ('a science-hole dataset gathered for the simulator\'s priors; no band of a gauge-monitoring and disposal-well program reads it. '
+                  'Carried with its provenance; dropping it from the wheel is the owner\'s call (gea catalog --unused).')
+
+
+def _source_text() -> str:
+    """Every module of the package except this register and the gate, as one string."""
+    pkg = Path(__file__).parent
+    parts = []
+    for p in sorted(pkg.glob('*.py')):
+        if p.name in ('catalog_register.py', 'acceptance_tests.py'):
+            continue
+        parts.append(p.read_text(encoding='utf-8', errors='replace'))
+    for p in sorted((pkg.parent / 'tools').glob('*.py')) if (pkg.parent / 'tools').is_dir() else []:
+        parts.append(p.read_text(encoding='utf-8', errors='replace'))
+    return '\n'.join(parts)
+
+
+def public() -> Dict[str, CatalogEntry]:
+    """The shipped tier only. Operator-tier entries (a private folder on one machine, never in the wheel) are not registered,
+    listed, audited or named by this module: their presence is counted and nothing more."""
+    return {n: e for n, e in CATALOG.items() if e.provenance.get('tier', 'public') == 'public'}
+
+
+def n_operator() -> int:
+    return sum(1 for e in CATALOG.values() if e.provenance.get('tier', 'public') != 'public')
+
+
+def referenced_in_code() -> Dict[str, int]:
+    """Public entry stems named in the package source (outside this register and the gate)."""
+    src = _source_text()
+    return {name: len(re.findall(re.escape(name), src)) for name in public() if re.search(re.escape(name), src)}
+
+
+def register() -> List[dict]:
+    rows = []
+    for name, e in sorted(public().items()):
+        prov = e.provenance
+        uses = USES.get(name, [])
+        rows.append({'entry': name, 'kind': prov.get('kind', ''), 'tier': prov.get('tier', 'public'), 'file': e.las_path.name,
+                     'bytes': os.path.getsize(e.las_path), 'source': str(prov.get('source_database', ''))[:80], 'license': str(prov.get('license', ''))[:40],
+                     'used_by': uses, 'status': 'USED' if uses else 'CARRIED, NO BAND', 'why': '' if uses else NO_BAND_REASON})
+    return rows
+
+
+def check_entry(e: CatalogEntry) -> dict:
+    """Read one entry through its own reader; the shape or the error."""
+    try:
+        if e.las_path.suffix.lower() == '.csv':
+            from .profile_catalog import _csv_kind
+            if _csv_kind(e.las_path) == 'survey':
+                sv = e.survey()
+                return {'entry': e.name, 'ok': True, 'shape': f'deviation survey, {len(sv.md_ft)} stations'}
+        st = e.stream()
+        return {'entry': e.name, 'ok': True, 'shape': f'{st.index_kind}, {len(st.index)} rows, {len(st.channels)} channels'}
+    except Exception as ex:                                      # noqa: BLE001 - the point is to name it
+        return {'entry': e.name, 'ok': False, 'shape': f'{type(ex).__name__}: {ex}'}
+
+
+def check_all() -> List[dict]:
+    return [check_entry(e) for _, e in sorted(public().items())]
+
+
+def audit() -> dict:
+    """The register against the code: registered-as-used but never named; named in code but not registered."""
+    ref = referenced_in_code()
+    used = {n for n, u in USES.items() if u}
+    # an entry whose only use is this leg's own modules is named in those modules; check that too
+    unregistered = sorted(n for n in ref if n not in used)
+    # a LAS entry is reachable by `gea survey --catalog <entry>` without any module naming it
+    unnamed = sorted(n for n in used if n not in ref and CATALOG[n].las_path.suffix.lower() != '.las')
+    pub = public()
+    return {'referenced': ref, 'unregistered': unregistered, 'unnamed': unnamed, 'n_used': len(used), 'n_carried': len(pub) - len(used), 'n_total': len(pub),
+            'n_operator': n_operator()}
+
+
+def text(rows: List[dict], unused_only: bool = False) -> str:
+    out = []
+    n_used = sum(1 for r in rows if r['status'] == 'USED')
+    out.append(f"catalogue: {len(rows)} entries, {n_used} used, {len(rows) - n_used} carried with no band"
+               + (f"; operator tier: {n_operator()} entries present on this machine (private; not listed here)" if n_operator() else ''))
+    w = max(len(r['entry']) for r in rows)
+    for r in rows:
+        if unused_only and r['status'] == 'USED':
+            continue
+        out.append(f"  {r['entry']:{w}s}  {r['status']:<17s} {r['kind']}")
+        for u in r['used_by']:
+            out.append(f"  {'':{w}s}    - {u}")
+    return '\n'.join(out)

gea_program-0.25.0/gea/friction_priors.py

@@ -0,0 +1,133 @@
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at https://mozilla.org/MPL/2.0/.
+"""friction_priors - the measured friction and strength the catalogue holds, as the envelope a slip statement discloses.
+
+A slip-tendency number needs a friction coefficient, and the one everyone uses (0.6, Byerlee) is a law from
+crystalline rock at crustal stress - not a measurement on the fault in question. This module reads the
+laboratory measurements the catalogue carries on natural fault and sediment samples - ODP Costa Rica friction
+ladders (0.21-0.88 across 15-90 MPa and 19-212 C), IODP Hikurangi peak and steady-state friction per
+lithology, the Tohoku (JFAST) fault-zone material at slow-slip rates, Nankai shear strength over effective
+stress, Sumatra cohesion, Barbados vane shear over overburden, and the KTB pilot hole's compressive strength
+of crystalline cores - and states them as what they are: the range of measured coefficients on real samples,
+each with its provenance, none of them the Permian's. A slip-tendency statement built on 0.6 prints this
+envelope beside it so the reader sees how far a measured coefficient can sit from the law.
+"""
+from __future__ import annotations
+
+from typing import Dict, List, Optional
+
+import numpy as np
+
+from .profile_catalog import CATALOG
+
+ENTRIES = ('costa_rica_odp_friction_envelope', 'hikurangi_u1520_friction_insitu', 'jfast_c0019_slow_slip_events', 'nankai_megasplay_shear_strength',
+           'sumatra_362_cohesion', 'barbados_110_consolidation', 'ktb_vb_rockmech_compress')
+BYERLEE = 0.6
+
+
+def _vals(st, name: str) -> np.ndarray:
+    c = st.channels.get(name)
+    if c is None:
+        return np.array([])
+    v = np.asarray(c.values, dtype=float)
+    return v[~np.isnan(v)]
+
+
+def _stat(v: np.ndarray) -> Optional[dict]:
+    if v.size == 0:
+        return None
+    return {'n': int(v.size), 'min': round(float(v.min()), 4), 'median': round(float(np.median(v)), 4), 'max': round(float(v.max()), 4)}
+
+
+def measured() -> List[dict]:
+    """Per entry: the friction coefficient (or the strength the entry measures), the conditions, the provenance."""
+    out: List[dict] = []
+    for name in ENTRIES:
+        e = CATALOG.get(name)
+        if e is None:
+            continue
+        st = e.stream()
+        prov = e.provenance
+        row = {'entry': name, 'kind': prov.get('kind', ''), 'source': str(prov.get('source_database', ''))[:90], 'url': str(prov.get('source_url', '')),
+               'license': str(prov.get('license', ''))[:60], 'material': '', 'mu': None, 'strength': None, 'conditions': ''}
+        if name == 'costa_rica_odp_friction_envelope':
+            row['material'] = 'ODP 170/205 Costa Rica margin sediments (Ikari et al. 2013/2014)'
+            row['mu'] = _stat(_vals(st, 'Coeff (of friction)'))
+            p, t = _vals(st, 'P (effective normal stress)'), _vals(st, 'T:temp')
+            row['conditions'] = f'effective normal stress {p.min():g}-{p.max():g} MPa, {t.min():g}-{t.max():g} C'
+        elif name == 'hikurangi_u1520_friction_insitu':
+            row['material'] = 'IODP U1520 Hikurangi input sediments, six lithologies (Eijsink & Ikari 2022)'
+            pk, ss = _vals(st, 'µ (peak)'), _vals(st, 'µ (steady-state)')
+            row['mu'] = _stat(np.concatenate([pk, ss]))
+            row['mu_peak'] = _stat(pk); row['mu_steady'] = _stat(ss)
+            ab = _vals(st, 'a-b')
+            row['a_minus_b'] = _stat(ab)
+            sn = _vals(st, 'SigmaN (eff)')
+            row['conditions'] = f'in-situ effective normal stress {sn.min() / 1000:g}-{sn.max() / 1000:g} MPa; a-b {ab.min():+.4f} to {ab.max():+.4f} (velocity weakening where negative)'
+        elif name == 'jfast_c0019_slow_slip_events':
+            row['material'] = 'IODP 343 JFAST Tohoku plate-boundary fault zone (Ikari et al. 2015)'
+            tau = _vals(st, 'Shear str max'); mu_inc = _vals(st, 'µ (increase)')
+            row['strength'] = {'what': 'peak shear strength during slow slip events', 'unit': 'kPa', **(_stat(tau) or {})}
+            row['mu_change_during_sse'] = _stat(mu_inc)
+            row['conditions'] = 'plate-rate shearing; five of seven experiments produced slow slip events'
+        elif name == 'nankai_megasplay_shear_strength':
+            row['material'] = 'IODP 315/316 Nankai megasplay slope sediments (Ikari et al. 2011)'
+            tau, sv = _vals(st, 'Tau'), _vals(st, 'SigmaV ef')
+            n = min(tau.size, sv.size)
+            mu = tau[:n] / np.where(sv[:n] > 0, sv[:n], np.nan)
+            row['mu'] = _stat(mu[~np.isnan(mu)])
+            row['mu_how'] = 'shear strength / effective vertical stress, per sample'
+            row['conditions'] = f'effective vertical stress {sv.min():g}-{sv.max():g} kPa'
+        elif name == 'sumatra_362_cohesion':
+            row['material'] = 'IODP 362 Sumatra input sediments (Stanislowski & Ikari 2025)'
+            c = _vals(st, 'C'); cc = _vals(st, 'C coef')
+            row['strength'] = {'what': 'cohesion', 'unit': 'kPa', **(_stat(c) or {})}
+            row['cohesion_coefficient'] = _stat(cc)
+            row['conditions'] = 'effective stresses 10.7-14.0 MPa; intact and powdered samples'
+        elif name == 'barbados_110_consolidation':
+            row['material'] = 'ODP 110 Barbados accretionary prism sediments (Taylor & Leonard 1990)'
+            vane = _vals(st, 'Shear str (vane)')
+            ob = next((_vals(st, k) for k in st.channels if k.startswith('Overb press')), np.array([0.0]))
+            row['strength'] = {'what': 'vane shear strength', 'unit': 'kPa', **(_stat(vane) or {})}
+            row['conditions'] = f'effective overburden {ob.min():g}-{ob.max():g} kPa'
+        elif name == 'ktb_vb_rockmech_compress':
+            row['material'] = 'KTB pilot hole crystalline cores, 190-3,832 m (gneisses, amphibolites)'
+            cs = _vals(st, 'COMPRESSIVE_STRENGTH'); em = _vals(st, 'E_MODUL')
+            row['strength'] = {'what': 'uniaxial compressive strength', 'unit': 'MPa', **(_stat(cs) or {})}
+            row['youngs_modulus_GPa'] = _stat(em)
+            row['conditions'] = 'laboratory, cores by depth; foliated rocks anisotropic'
+        out.append(row)
+    return out
+
+
+def envelope() -> dict:
+    """The union of the measured friction coefficients, against Byerlee's 0.6."""
+    rows = measured()
+    mus = [r['mu'] for r in rows if r.get('mu')]
+    if not mus:
+        return {'n_entries': 0}
+    lo = min(m['min'] for m in mus); hi = max(m['max'] for m in mus)
+    return {'n_entries': len(mus), 'n_samples': sum(m['n'] for m in mus), 'min': lo, 'max': hi, 'byerlee': BYERLEE,
+            'entries': [r['entry'] for r in rows if r.get('mu')],
+            'statement': (f"measured friction coefficients on natural samples in this program's catalogue run from {lo:g} to {hi:g} "
+                          f"({sum(m['n'] for m in mus)} measurements, {len(mus)} datasets; none from the Permian Basin); Byerlee's law gives {BYERLEE:g}. "
+                          f"A slip-tendency statement that assumes {BYERLEE:g} is one point in that range, and the reader should know it.")}
+
+
+def text() -> str:
+    out = ['Measured friction and strength in the catalogue (each with its provenance; none from the site):']
+    for r in measured():
+        out.append(f"  {r['entry']}: {r['material']}")
+        if r.get('mu'):
+            m = r['mu']; out.append(f"    friction coefficient {m['min']:g}-{m['max']:g} (median {m['median']:g}, n={m['n']})" + (f"; {r['mu_how']}" if r.get('mu_how') else ''))
+        if r.get('strength'):
+            sg = r['strength']; out.append(f"    {sg['what']} {sg.get('min', '?'):g}-{sg.get('max', '?'):g} {sg['unit']} (n={sg.get('n', 0)})")
+        if r.get('a_minus_b'):
+            ab = r['a_minus_b']; out.append(f"    a-b {ab['min']:+.4f} to {ab['max']:+.4f} (n={ab['n']})")
+        out.append(f"    conditions: {r['conditions']}")
+        out.append(f"    source: {r['source']} [{r['license']}]")
+    env = envelope()
+    out.append('')
+    out.append(env.get('statement', 'no friction coefficients found'))
+    return '\n'.join(out)

gea_program-0.25.0/gea/help/catalog.md

@@ -0,0 +1,11 @@
+# The catalogue
+
+> The program ships 52 public datasets, each with a provenance sidecar saying where it came from, under what licence, and what it covers. A sidecar does not say what in this program reads the entry; the register does. `gea catalog --list` prints every entry with the bands, commands and reports that take it, or the plain statement that nothing does yet - CARRIED, NO BAND - and the gate holds that register to the code. The entries with a use since this page was written: every LAS log runs through the strata survey; seven measured-friction and strength datasets become the envelope a slip statement discloses its coefficient against; the Volve core checks the published sandstone range.
+
+**The command**: `gea catalog --list` (the register), `--unused` (the carried entries, with the reason), `--check` (every entry read through its own reader, the shape or the error), `--entry <name> --info` (the provenance in full and how it reads), `--entry <name> --stream-csv out.csv` (the entry as a stream file any other command ingests), `--friction` (the measured friction and strength, each with its source, and the envelope against Byerlee's 0.6), `--core` (the Volve 15/9-19 A core plugs against the published sandstone range). `gea survey --catalog <entry>` runs the strata survey on any LAS entry - Scorpio E1 (South Australia), University 6-17 (Texas), Kennetcook #2 (Nova Scotia), Collingwood 1-28 (Kansas), L07-01 (Dutch North Sea), 15/9-19 SR (Volve) - and says what it found or why it did not estimate.
+
+**What it writes**: the register - entry, kind, tier, file size, USED or CARRIED, and each use in the user's terms; the check - 52 of 52 entries read; the friction envelope - friction coefficients 0.21 to 0.90 on 70 measurements from three datasets (ODP Costa Rica, IODP Hikurangi, IODP Nankai), cohesion 188-990 kPa (Sumatra), vane shear 19.5-290 kPa (Barbados), fault-zone peak shear strength 1.7-1.9 MPa at slow slip (JFAST), uniaxial compressive strength 3-265 MPa on crystalline cores (KTB pilot hole) - none from the Permian, and the page says so; the core check - bulk density per plug as grain density x (1 - porosity) + brine x porosity, the brine stated, 65 of 70 Volve plugs inside the published 2.05-2.55 g/cc sandstone range, written into the rock inventory model card's evaluation.
+
+**The number to check**: `--check` must read every entry; `--list` must show no entry registered as used that no module names (the gate checks both ways); the core check's count against the model card's evaluation line.
+
+**What this page will not call a measurement**: a friction coefficient for the site - the envelope is what was measured on other rocks elsewhere, with each source named; it bounds how far a law can sit from a measurement, it does not give the fault's own. A use an entry does not have - a carried entry is said to be carried, and whether to drop it from the wheel is the owner's call, not this page's. A survey estimate from too little support - a log excerpt with fewer than five usable stations is NOT ESTIMATED with the reason, as the real excerpts above show. A core bulk density the core did not report - it is derived from grain density and porosity with the brine density stated, and labelled as derived.

{gea_program-0.24.0 → gea_program-0.25.0}/gea/helplib.py

@@ -39,6 +39,7 @@ INDEX: List[tuple] = [
     ('files', 'Files', 'import and export roots, detection by content, the evidence pack'),
     ('notifications', 'Notifications', 'rules, channels, the delivery log'),
     ('structure', 'Mapped structure', 'the nearest fault and fold to a well from a structure layer the site brought, by distance and bearing'),
+    ('catalog', 'The catalogue', 'every shipped public dataset, what in this program reads it or that nothing does; the measured friction envelope; the core check; any log through the survey'),
     ('dlis', 'The DLIS log', 'a well log as it is delivered (API RP66 V1), read as the standard lays it out: the frames, the channels, what was skipped; into the strata survey'),
     ('historian', 'The historian pull', 'an operator\'s gauge history out of the PI System through PI Web API, read-only, every value with its archive time and flags'),
     ('field-ports', 'The field ports', 'Modbus RTU on the serial line, DNP3 from the pad RTU, HART-IP from the transmitter itself - read-only, polled, with the stand-ins to rehearse against'),

{gea_program-0.24.0 → gea_program-0.25.0}/gea/model_card.py

@@ -110,7 +110,7 @@ def build_cards(monitor_log_dir: Optional[str] = None, program_version: str = ''
     from .accuracy_statement import library_backtest, MIN_TRIALS, N_BOOT, SEED
     from .sample_record import DEFAULT_TAG_CLASSES
     from .well_test_validation import DEFAULT_CRITERIA
-    from .rock_inventory import rock_inventory
+    from .rock_inventory import core_check, rock_inventory
     from . import strata_join as SJ
     from .reconciler import ReconcilerConfig
     ver = program_version or _v
@@ -203,7 +203,9 @@ def build_cards(monitor_log_dir: Optional[str] = None, program_version: str = ''
         inputs=[{'name': f"{k} ({v['tier']})", 'unit': f"g/cc, anchor {v['anchor']}, range {v['lo']}-{v['hi']}", 'source': str(v['citation'])[:120]} for k, v in inv.items()],
         settings=[{'setting': 'anchors', 'value': str(len(inv)), 'basis': 'standard geophysics density tables (Telford et al. 1990; Schoen 2015)'}],
         calibration_data=[{'dataset': 'published density tables', 'records': len(inv), 'database': 'Telford, Geldart & Sheriff (1990); Schoen (2015)', 'url': '', 'licence': 'published reference values', 'fetch_date': ''}],
-        evaluation=[{'metric': 'anchor reproduction', 'value': f"worst anchor residual {max(abs(float(v['residual_pct'])) for v in inv.values()):.3f} %", 'method': 'each anchor re-derived at gate time'}],
+        evaluation=[{'metric': 'anchor reproduction', 'value': f"worst anchor residual {max(abs(float(v['residual_pct'])) for v in inv.values()):.3f} %", 'method': 'each anchor re-derived at gate time'},
+                    {'metric': 'sandstone range against a real core', 'value': (lambda c: f"{c['inside']} of {c['n_plugs']} Volve 15/9-19 A core plugs inside {c['sandstone_range'][0]}-{c['sandstone_range'][1]} g/cc (core bulk {c['bulk_density']['min']}-{c['bulk_density']['max']})" if c.get('status') == 'OK' else c.get('status', '?'))(core_check()),
+                     'method': 'core grain density x (1 - porosity) + brine x porosity per plug, the catalogue core entry (Equinor Volve, open licence)'}],
         limitations=['Ranges overlap; the classifier returns ranked candidates, never one confident name.'],
         components=[{'role': 'inventory and classifier', 'sha256': _sha('rock_inventory.py')}],
         generated_utc=now))