Upload essd_scripts/audit_manuscript_numbers.py

essd_scripts/audit_manuscript_numbers.py

@@ -13,6 +13,7 @@ import json
 import math
 import sqlite3
 import statistics
+import sys
 from collections import Counter, defaultdict
 from pathlib import Path
 from typing import Any
@@ -26,9 +27,15 @@ except Exception:  # pragma: no cover
 
 
 ROOT = Path(__file__).resolve().parents[1]
+if str(ROOT) not in sys.path:
+    sys.path.insert(0, str(ROOT))
+
+from scripts.evaluate_picks import WaveformCoverageIndex, parse_utc_to_epoch_seconds
+
 LABEL_JSON = ROOT / "data" / "label" / "annotations_for_continuous_hdf5.json"
 CONSENSUS_JSON = ROOT / "data" / "label" / "consensus_nn_picks.json"
 WAVEFORM_DB = ROOT / "data" / "index" / "waveform_index.sqlite"
+REFERENCE_DB = ROOT / "data" / "label" / "reference_arrivals.sqlite"
 H5_DIR = ROOT / "data" / "hdf5"
 EVAL_DIR = ROOT / "eval_picks"
 
@@ -192,38 +199,133 @@ def waveform_inventory() -> dict[str, Any]:
     }
 
 
-def label_coverage_from_matches() -> dict[str, Any]:
-    matches = EVAL_DIR / "eval_phasenet" / "matches.jsonl"
+def label_coverage_from_index(annotation: dict[str, Any]) -> dict[str, Any]:
+    """Compute point coverage from exact NSLC segments and finite HDF5 samples."""
+    coverage = WaveformCoverageIndex(
+        WAVEFORM_DB, channel_families=("HH", "BH", "EH", "HN")
+    )
     counts: Counter = Counter()
     by_period: dict[str, Counter] = defaultdict(Counter)
     by_period_subset: dict[str, Counter] = defaultdict(Counter)
-    with matches.open() as f:
-        for line in f:
-            rec = json.loads(line)
-            period = "2019" if rec["label_time_epoch"] < 1600000000 else "2021"
-            phase = rec.get("label_phase")
-            subset = rec.get("subset")
-            if subset == "all":
-                counts["labels"] += 1
-                counts[f"{phase}_labels"] += 1
-                by_period[period]["labels"] += 1
-                by_period[period][f"{phase}_labels"] += 1
-                if rec.get("has_waveform"):
-                    counts["covered_labels"] += 1
-                    counts[f"{phase}_covered_labels"] += 1
-                    by_period[period]["covered_labels"] += 1
-                    by_period[period][f"{phase}_covered_labels"] += 1
-            if subset in {"manual", "automatic"}:
-                key = f"{subset}_{phase}"
-                by_period_subset[period][f"{key}_labels"] += 1
-                if rec.get("has_waveform"):
-                    by_period_subset[period][f"{key}_covered_labels"] += 1
+    by_family: Counter = Counter()
+    by_components: Counter = Counter()
 
-    return {
+    for day, _, station_id, pick in iter_picks(annotation):
+        period = period_from_day(day)
+        phase = str(pick.get("phase"))
+        status = str(pick.get("status", "unknown"))
+        time_epoch = parse_utc_to_epoch_seconds(pick.get("time"))
+        details = coverage.coverage_details(station_id, time_epoch)
+
+        counts["labels"] += 1
+        counts[f"{phase}_labels"] += 1
+        by_period[period]["labels"] += 1
+        by_period[period][f"{phase}_labels"] += 1
+        status_key = f"{status}_{phase}"
+        by_period_subset[period][f"{status_key}_labels"] += 1
+
+        if details["point_covered"]:
+            counts["covered_labels"] += 1
+            counts[f"{phase}_covered_labels"] += 1
+            by_period[period]["covered_labels"] += 1
+            by_period[period][f"{phase}_covered_labels"] += 1
+            by_period_subset[period][f"{status_key}_covered_labels"] += 1
+            by_family[str(details["channel_family"])] += 1
+            by_components[str(details["component_count"])] += 1
+
+    result = {
         "overall": dict(sorted(counts.items())),
         "by_period": {k: dict(v) for k, v in sorted(by_period.items())},
         "by_period_and_label_status": {k: dict(v) for k, v in sorted(by_period_subset.items())},
-        "source": str(matches.relative_to(ROOT)),
+        "covered_by_selected_family": dict(sorted(by_family.items())),
+        "covered_by_component_count": dict(sorted(by_components.items())),
+        "definition": {
+            "coverage_level": "C0 point coverage",
+            "channel_families": ["HH", "BH", "EH", "HN"],
+            "interval_source": (
+                "exact NSLC waveform_segments rows with finite-sample checks "
+                "for floating-point HDF5 arrays"
+            ),
+            "location_rule": (
+                "explicit locations match exactly; '--' annotations are treated as "
+                "unspecified and match one released location without combining locations"
+            ),
+        },
+        "sources": [
+            str(LABEL_JSON.relative_to(ROOT)),
+            str(WAVEFORM_DB.relative_to(ROOT)),
+            str(H5_DIR.relative_to(ROOT)),
+        ],
+    }
+    coverage.close()
+    return result
+
+
+def reference_arrival_composition() -> dict[str, Any]:
+    """Summarize C0--C3 eligibility by period, phase, and provenance."""
+    con = sqlite3.connect(REFERENCE_DB)
+    rows = con.execute(
+        """
+        SELECT period, phase, status, COUNT(*) AS total,
+               SUM(c0_point_covered) AS c0,
+               SUM(c1_window_covered) AS c1,
+               SUM(c2_component_covered) AS c2,
+               SUM(c3_processing_ready) AS c3
+        FROM reference_arrivals
+        GROUP BY period, phase, status
+        ORDER BY CAST(period AS INTEGER),
+                 CASE phase WHEN 'P' THEN 0 ELSE 1 END,
+                 CASE status WHEN 'manual' THEN 0 ELSE 1 END
+        """
+    ).fetchall()
+    total = con.execute(
+        """
+        SELECT COUNT(*), SUM(c0_point_covered), SUM(c1_window_covered),
+               SUM(c2_component_covered), SUM(c3_processing_ready)
+        FROM reference_arrivals
+        """
+    ).fetchone()
+    con.close()
+
+    groups = []
+    for period, phase, status, n_total, c0, c1, c2, c3 in rows:
+        role = "primary" if status == "manual" else "expanded only"
+        groups.append(
+            {
+                "period": str(period),
+                "phase": str(phase),
+                "status": str(status),
+                "total_labels": int(n_total),
+                "C0": int(c0),
+                "without_C0": int(n_total - c0),
+                "C0_fraction": float(c0 / n_total),
+                "C1": int(c1),
+                "C2": int(c2),
+                "C3": int(c3),
+                "reference_role": role,
+            }
+        )
+
+    n_total, c0, c1, c2, c3 = map(int, total)
+    return {
+        "groups": groups,
+        "full_release": {
+            "total_labels": n_total,
+            "C0": c0,
+            "without_C0": n_total - c0,
+            "C0_fraction": c0 / n_total,
+            "C1": c1,
+            "C2": c2,
+            "C3": c3,
+            "reference_role": "primary plus expanded",
+        },
+        "sequential_attrition": {
+            "annotation_to_C0": n_total - c0,
+            "C0_to_C1": c0 - c1,
+            "C1_to_C2": c1 - c2,
+            "C2_to_C3": c2 - c3,
+        },
+        "source": str(REFERENCE_DB.relative_to(ROOT)),
     }
 
 
@@ -351,29 +453,35 @@ def consensus_audit() -> dict[str, Any]:
     }
 
 
-def build_report() -> dict[str, Any]:
+def build_report(include_example_outputs: bool = False) -> dict[str, Any]:
     annotation = load_json(LABEL_JSON)
-    return {
+    report = {
         "sources": {
             "annotation_json": str(LABEL_JSON.relative_to(ROOT)),
             "waveform_index": str(WAVEFORM_DB.relative_to(ROOT)),
             "hdf5_directory": str(H5_DIR.relative_to(ROOT)),
-            "evaluation_directory": str(EVAL_DIR.relative_to(ROOT)),
         },
         "annotation_inventory": annotation_inventory(annotation),
         "waveform_inventory": waveform_inventory(),
-        "label_coverage": label_coverage_from_matches(),
-        "operational_diagnostics": operational_diagnostics(),
-        "baseline_table": baseline_table(),
-        "consensus_audit": consensus_audit(),
+        "label_coverage": label_coverage_from_index(annotation),
+        "reference_arrival_composition": reference_arrival_composition(),
     }
+    if include_example_outputs:
+        report["sources"]["evaluation_directory"] = str(EVAL_DIR.relative_to(ROOT))
+        report["operational_diagnostics"] = operational_diagnostics()
+        report["baseline_table"] = baseline_table()
+        report["consensus_audit"] = consensus_audit()
+        report["example_output_warning"] = (
+            "These stored outputs predate the current one-to-one matching policy "
+            "unless they have been regenerated with the current evaluate_picks.py."
+        )
+    return report
 
 
 def print_text(report: dict[str, Any]) -> None:
     inv = report["waveform_inventory"]
     ann = report["annotation_inventory"]
     cov = report["label_coverage"]["overall"]
-    ops = report["operational_diagnostics"]
     print("ESSD manuscript number audit")
     print(f"HDF5 files: {inv['daily_hdf5_files']}")
     print(f"Compressed waveform size: {inv['compressed_waveform_size_gib']:.1f} GiB")
@@ -386,14 +494,22 @@ def print_text(report: dict[str, Any]) -> None:
     print(f"Manual labels: {ann['status_counts']['manual']:,}")
     print(f"Automatic labels: {ann['status_counts']['automatic']:,}")
     print(f"Covered arrivals: {cov['covered_labels']:,}")
+    ref = report["reference_arrival_composition"]["full_release"]
     print(
-        "Operational diagnostics: "
-        f"recall max={ops['coverage_aware_recall_max']:.2f}, "
-        f"matched fraction={100*ops['catalog_matched_fraction_min']:.1f}-"
-        f"{100*ops['catalog_matched_fraction_max']:.1f}%, "
-        f"pick volume={ops['automatic_picks_per_day_min']:.1e}-"
-        f"{ops['automatic_picks_per_day_max']:.1e} picks/day"
+        "Configured reference eligibility: "
+        f"C0={ref['C0']:,}, C1={ref['C1']:,}, "
+        f"C2={ref['C2']:,}, C3={ref['C3']:,}"
     )
+    if "operational_diagnostics" in report:
+        ops = report["operational_diagnostics"]
+        print(
+            "Example-output diagnostics: "
+            f"recall max={ops['coverage_aware_recall_max']:.2f}, "
+            f"matched fraction={100*ops['catalog_matched_fraction_min']:.1f}-"
+            f"{100*ops['catalog_matched_fraction_max']:.1f}%, "
+            f"pick volume={ops['automatic_picks_per_day_min']:.1e}-"
+            f"{ops['automatic_picks_per_day_max']:.1e} picks/day"
+        )
 
 
 def print_latex_baseline(report: dict[str, Any]) -> None:
@@ -423,14 +539,79 @@ def print_latex_baseline(report: dict[str, Any]) -> None:
             print("\\middlehline")
 
 
+def print_latex_reference(report: dict[str, Any]) -> None:
+    composition = report["reference_arrival_composition"]
+    for row in composition["groups"]:
+        period = "2019 Ridgecrest" if row["period"] == "2019" else "2021 background"
+        provenance = (
+            f"{row['status'].capitalize()} {row['phase']}"
+            if row["status"] == "manual"
+            else f"Operational automatic {row['phase']}"
+        )
+        role = "Primary" if row["reference_role"] == "primary" else "Expanded only"
+        values = [
+            period,
+            provenance,
+            f"{row['total_labels']:,}".replace(",", r"\,"),
+            f"{row['C0']:,}".replace(",", r"\,"),
+            f"{row['without_C0']:,}".replace(",", r"\,"),
+            f"{100 * row['C0_fraction']:.1f}\\,\\%",
+            f"{row['C1']:,}".replace(",", r"\,"),
+            f"{row['C2']:,}".replace(",", r"\,"),
+            f"{row['C3']:,}".replace(",", r"\,"),
+            role,
+        ]
+        print(" & ".join(values) + r" \\")
+    total = composition["full_release"]
+    values = [
+        "Full release",
+        "All P/S labels",
+        f"{total['total_labels']:,}".replace(",", r"\,"),
+        f"{total['C0']:,}".replace(",", r"\,"),
+        f"{total['without_C0']:,}".replace(",", r"\,"),
+        f"{100 * total['C0_fraction']:.1f}\\,\\%",
+        f"{total['C1']:,}".replace(",", r"\,"),
+        f"{total['C2']:,}".replace(",", r"\,"),
+        f"{total['C3']:,}".replace(",", r"\,"),
+        "Primary + expanded",
+    ]
+    print("\\middlehline")
+    print(" & ".join(values) + r" \\")
+
+
 def main() -> None:
     parser = argparse.ArgumentParser(description=__doc__)
-    parser.add_argument("--format", choices=("json", "text", "latex-baseline"), default="text")
+    parser.add_argument(
+        "--format",
+        choices=(
+            "json",
+            "json-reference",
+            "text",
+            "latex-reference",
+            "latex-baseline",
+        ),
+        default="text",
+    )
+    parser.add_argument(
+        "--include-example-outputs",
+        action="store_true",
+        help="Also read stored non-standardized picker and consensus outputs.",
+    )
     args = parser.parse_args()
-
-    report = build_report()
-    if args.format == "json":
+    if args.format == "latex-baseline" and not args.include_example_outputs:
+        parser.error("--format latex-baseline requires --include-example-outputs")
+
+    if args.format in {"latex-reference", "json-reference"}:
+        report = {
+            "sources": {"reference_arrival_table": str(REFERENCE_DB.relative_to(ROOT))},
+            "reference_arrival_composition": reference_arrival_composition(),
+        }
+    else:
+        report = build_report(include_example_outputs=args.include_example_outputs)
+    if args.format in {"json", "json-reference"}:
         print(json.dumps(report, indent=2, sort_keys=True))
+    elif args.format == "latex-reference":
+        print_latex_reference(report)
     elif args.format == "latex-baseline":
         print_latex_baseline(report)
     else: