| |
| """Calculate precision proxy 1 and its reference-window sensitivity. |
| |
| The script extracts one declared output from the compact multi-output catalogue, |
| intersects merged manual-reference windows with that output's eligibility |
| domain, and performs deterministic one-to-one station-phase-time matching. |
| """ |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import csv |
| import json |
| import sqlite3 |
| import sys |
| from collections import defaultdict |
| from pathlib import Path |
| from typing import Iterable |
|
|
| import numpy as np |
|
|
| ROOT = Path(__file__).resolve().parents[1] |
| if str(ROOT) not in sys.path: |
| sys.path.insert(0, str(ROOT)) |
|
|
| from scripts.validate_leave_one_output_precision_proxy import ( |
| PERIODS, |
| assign_sorted_one_to_one, |
| iter_station_phase_groups, |
| load_eligibility, |
| ) |
|
|
|
|
| def load_manual_references( |
| path: Path, |
| ) -> dict[tuple[str, str, str], np.ndarray]: |
| con = sqlite3.connect(path) |
| grouped: dict[tuple[str, str, str], list[int]] = defaultdict(list) |
| for period, station, phase, epoch in con.execute( |
| """ |
| SELECT period, station_id, phase, pick_time_epoch |
| FROM evaluation_references |
| WHERE has_manual_reference=1 AND c0_point_covered=1 |
| ORDER BY period, station_id, phase, pick_time_epoch |
| """ |
| ): |
| grouped[(str(period), str(station), str(phase))].append( |
| int(round(float(epoch) * 1_000_000)) |
| ) |
| con.close() |
| return {key: np.asarray(values, dtype=np.int64) for key, values in grouped.items()} |
|
|
|
|
| def merge_windows(times: np.ndarray, half_width_us: int) -> list[tuple[int, int]]: |
| merged: list[tuple[int, int]] = [] |
| for value in times: |
| left = int(value) - half_width_us |
| right = int(value) + half_width_us |
| if merged and left <= merged[-1][1]: |
| merged[-1] = (merged[-1][0], max(merged[-1][1], right)) |
| else: |
| merged.append((left, right)) |
| return merged |
|
|
|
|
| def intersect_windows( |
| left: list[tuple[int, int]], |
| right_starts: np.ndarray, |
| right_ends: np.ndarray, |
| ) -> list[tuple[int, int]]: |
| result: list[tuple[int, int]] = [] |
| i = 0 |
| j = 0 |
| while i < len(left) and j < len(right_starts): |
| start = max(left[i][0], int(right_starts[j])) |
| end = min(left[i][1], int(right_ends[j])) |
| if start <= end: |
| if result and start <= result[-1][1]: |
| result[-1] = (result[-1][0], max(result[-1][1], end)) |
| else: |
| result.append((start, end)) |
| if left[i][1] <= right_ends[j]: |
| i += 1 |
| else: |
| j += 1 |
| return result |
|
|
|
|
| def select_in_windows(times: np.ndarray, windows: list[tuple[int, int]]) -> np.ndarray: |
| selected: list[np.ndarray] = [] |
| for left, right in windows: |
| begin = int(np.searchsorted(times, left, side="left")) |
| end = int(np.searchsorted(times, right, side="right")) |
| if end > begin: |
| selected.append(times[begin:end]) |
| return np.concatenate(selected) if selected else np.empty(0, dtype=np.int64) |
|
|
|
|
| def main() -> None: |
| parser = argparse.ArgumentParser(description=__doc__) |
| parser.add_argument( |
| "--candidates", type=Path, |
| default=ROOT / "data/label/all_model_phase_picks.jsonl.zst", |
| ) |
| parser.add_argument( |
| "--references", type=Path, |
| default=ROOT / "data/label/reference_arrivals.sqlite", |
| ) |
| parser.add_argument( |
| "--eligibility", type=Path, |
| default=ROOT / "data/label/output_eligibility.sqlite", |
| ) |
| parser.add_argument("--output-name", default="seismicxm.01") |
| parser.add_argument("--epsilon-s", type=float, default=0.5) |
| parser.add_argument("--window-s", type=float, action="append") |
| parser.add_argument( |
| "--output-tsv", type=Path, |
| default=ROOT / "data/validation/reference_window_precision_proxy_sensitivity.tsv", |
| ) |
| parser.add_argument( |
| "--output-json", type=Path, |
| default=ROOT / "data/validation/reference_window_precision_proxy_sensitivity.json", |
| ) |
| args = parser.parse_args() |
| windows_s = args.window_s or [1.0, 5.0, 10.0, 30.0] |
| if any(value < args.epsilon_s for value in windows_s): |
| raise ValueError("every T must be at least epsilon") |
|
|
| references = load_manual_references(args.references) |
| reference_totals: dict[tuple[str, str], int] = defaultdict(int) |
| for (period, _, phase), values in references.items(): |
| reference_totals[(period, phase)] += len(values) |
| eligibility, output_names = load_eligibility(args.eligibility) |
| name_to_id = {name: output_id for output_id, name in output_names.items()} |
| if args.output_name not in name_to_id: |
| raise KeyError(f"output is absent from registry: {args.output_name}") |
| output_id = name_to_id[args.output_name] |
| epsilon_us = int(round(args.epsilon_s * 1_000_000)) |
| counters: dict[tuple[str, str, float], list[int]] = defaultdict( |
| lambda: [0, 0, 0, 0, 0] |
| ) |
|
|
| def process_group(station: str, phase: str, assessed: np.ndarray) -> None: |
| domain = eligibility.get((station, phase, output_id)) |
| if domain is None: |
| return |
| domain_starts, domain_ends = domain |
| for period in PERIODS: |
| refs = references.get((period, station, phase)) |
| if refs is None or not len(refs): |
| continue |
| ref_indices = np.searchsorted(domain_starts, refs, side="right") - 1 |
| valid = ref_indices >= 0 |
| valid &= domain_ends[np.maximum(ref_indices, 0)] >= refs |
| eligible_refs = refs[valid] |
| if not len(eligible_refs): |
| continue |
| for window_s in windows_s: |
| raw_windows = merge_windows( |
| eligible_refs, int(round(window_s * 1_000_000)) |
| ) |
| effective = intersect_windows(raw_windows, domain_starts, domain_ends) |
| selected_picks = select_in_windows(assessed, effective) |
| assignments = assign_sorted_one_to_one( |
| eligible_refs, selected_picks, epsilon_us |
| ) |
| matched = int(np.sum(assignments >= 0)) |
| values = counters[(period, phase, float(window_s))] |
| values[0] += len(refs) |
| values[1] += len(eligible_refs) |
| values[2] += len(effective) |
| values[3] += int(sum(right - left for left, right in effective)) |
| values[4] += len(selected_picks) |
| if len(values) == 5: |
| values.append(0) |
| values[5] += matched |
|
|
| seen_groups: set[tuple[str, str]] = set() |
| for group_index, (station, phase, times, models) in enumerate( |
| iter_station_phase_groups(args.candidates), 1 |
| ): |
| seen_groups.add((station, phase)) |
| assessed = times[models == output_id] |
| process_group(station, phase, assessed) |
| if group_index % 100 == 0: |
| print(f"[PROXY1] groups={group_index:,}", flush=True) |
|
|
| for _, station, phase in references: |
| if (station, phase) not in seen_groups: |
| process_group(station, phase, np.empty(0, dtype=np.int64)) |
| seen_groups.add((station, phase)) |
|
|
| rows = [] |
| for (period, phase, window_s), values in sorted(counters.items()): |
| _, eligible_refs, n_windows, duration_us, picks, matched = values |
| rows.append( |
| { |
| "output_id": output_id, |
| "output_name": args.output_name, |
| "period": period, |
| "phase": phase, |
| "window_half_width_T_s": window_s, |
| "matching_tolerance_epsilon_s": args.epsilon_s, |
| "c0_manual_reference_count": reference_totals[(period, phase)], |
| "workflow_eligible_reference_count": eligible_refs, |
| "effective_window_count": n_windows, |
| "effective_window_duration_s": duration_us / 1_000_000, |
| "reported_pick_count_in_effective_windows": picks, |
| "matched_pick_count": matched, |
| "catalogue_conditioned_precision_proxy": matched / picks if picks else None, |
| } |
| ) |
| payload = { |
| "schema": "seismicx-cont-reference-window-precision-proxy-v1", |
| "candidate_file": args.candidates.relative_to(ROOT).as_posix(), |
| "reference_file": args.references.relative_to(ROOT).as_posix(), |
| "eligibility_file": args.eligibility.relative_to(ROOT).as_posix(), |
| "reference_definition": ( |
| "canonical C0-covered station-location-phase-time references with " |
| "at least one manual source reading" |
| ), |
| "assignment": "deterministic earliest-feasible one-to-one station-phase-time matching", |
| "rows": rows, |
| } |
| args.output_json.parent.mkdir(parents=True, exist_ok=True) |
| args.output_json.write_text(json.dumps(payload, indent=2, sort_keys=True) + "\n") |
| with args.output_tsv.open("w", newline="") as stream: |
| writer = csv.DictWriter(stream, fieldnames=list(rows[0]), delimiter="\t") |
| writer.writeheader() |
| writer.writerows(rows) |
| print(json.dumps({"rows": len(rows), "output": args.output_name}, indent=2)) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
