| |
| """Build an independent, coverage-qualified reference-arrival table. |
| |
| The output is derived only from the annotation JSON, waveform-segment SQLite |
| index, and optional response JSON. It does not read automatic-picker outputs. |
| C0 requires an exact NSLC segment and a finite sample at the arrival time. |
| C1--C3 are configuration-dependent and |
| their window, gap, component, sample-rate, and response requirements are stored |
| in the output metadata table. |
| """ |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import json |
| import sqlite3 |
| import sys |
| from collections import Counter, defaultdict |
| from pathlib import Path |
| from typing import Any, Iterable |
|
|
|
|
| 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 |
|
|
|
|
| def norm_location(value: Any) -> str: |
| text = "" if value is None else str(value).strip() |
| return text if text else "--" |
|
|
|
|
| def release_path(path: Path | None) -> str | None: |
| """Store release-relative paths when inputs are inside the repository.""" |
| if path is None: |
| return None |
| resolved = path.expanduser().resolve() |
| try: |
| return resolved.relative_to(ROOT.resolve()).as_posix() |
| except ValueError: |
| return str(resolved) |
|
|
|
|
| def iter_arrivals(annotation: dict[str, Any]) -> Iterable[dict[str, Any]]: |
| for year in annotation["years"].values(): |
| for day_key, day in year["days"].items(): |
| period = "2019" if day_key.startswith("2019") else "2021" |
| for event_id, event in day["events"].items(): |
| for station_id, station in event["stations"].items(): |
| for pick in station.get("picks", []): |
| yield { |
| "period": period, |
| "event_id": str(event_id), |
| "station_id": str(pick.get("station_id") or station_id), |
| "phase": str(pick.get("phase", "")).upper(), |
| "status": str(pick.get("status", "unknown")), |
| "pick_time": str(pick.get("time")), |
| "pick_time_epoch": parse_utc_to_epoch_seconds(pick.get("time")), |
| "distance_km": pick.get("distance_km"), |
| } |
|
|
|
|
| class ResponseIndex: |
| def __init__(self, path: Path | None) -> None: |
| self.by_key: dict[tuple[str, str, str, str], list[tuple[float, float]]] = defaultdict(list) |
| if path is None: |
| return |
| with path.open() as f: |
| payload = json.load(f) |
| for item in payload.get("responses", []): |
| key = ( |
| str(item.get("network", "")), |
| str(item.get("station", "")), |
| norm_location(item.get("location")), |
| str(item.get("channel", "")).upper(), |
| ) |
| start = parse_utc_to_epoch_seconds(item.get("epoch_start")) |
| end_value = item.get("epoch_end") |
| end = ( |
| parse_utc_to_epoch_seconds(end_value) |
| if end_value |
| else float("inf") |
| ) |
| self.by_key[key].append((start, end)) |
|
|
| def response_match_count( |
| self, |
| station_key: str, |
| location: str, |
| channel: str, |
| time_epoch: float, |
| ) -> int: |
| try: |
| network, station = station_key.split(".", 1) |
| except ValueError: |
| return 0 |
| key = (network, station, norm_location(location), str(channel).upper()) |
| return sum( |
| 1 for start, end in self.by_key.get(key, []) |
| if start <= time_epoch < end |
| ) |
|
|
|
|
| def create_output(path: Path) -> sqlite3.Connection: |
| if path.exists(): |
| path.unlink() |
| path.parent.mkdir(parents=True, exist_ok=True) |
| con = sqlite3.connect(path) |
| con.executescript( |
| """ |
| CREATE TABLE metadata (key TEXT PRIMARY KEY, value_json TEXT NOT NULL); |
| CREATE TABLE reference_arrivals ( |
| arrival_id INTEGER PRIMARY KEY, |
| period TEXT NOT NULL, |
| event_id TEXT NOT NULL, |
| station_id TEXT NOT NULL, |
| phase TEXT NOT NULL, |
| status TEXT NOT NULL, |
| pick_time TEXT NOT NULL, |
| pick_time_epoch REAL NOT NULL, |
| distance_km REAL, |
| c0_point_covered INTEGER NOT NULL, |
| c1_window_covered INTEGER NOT NULL, |
| c2_component_covered INTEGER NOT NULL, |
| c3_processing_ready INTEGER NOT NULL, |
| matched_location TEXT, |
| channel_family TEXT, |
| component_count INTEGER NOT NULL, |
| channels_json TEXT NOT NULL, |
| component_channels_json TEXT NOT NULL, |
| component_gap_fractions_json TEXT NOT NULL, |
| window_gap_fraction REAL NOT NULL, |
| required_component_gap_fraction REAL NOT NULL, |
| response_available INTEGER NOT NULL, |
| sample_rate_ready INTEGER NOT NULL, |
| manual_primary_reference INTEGER NOT NULL |
| ); |
| CREATE INDEX idx_reference_station_phase_time |
| ON reference_arrivals(station_id, phase, pick_time_epoch); |
| CREATE INDEX idx_reference_period_status_coverage |
| ON reference_arrivals(period, status, c0_point_covered); |
| CREATE INDEX idx_reference_event ON reference_arrivals(event_id); |
| """ |
| ) |
| return con |
|
|
|
|
| def build(args: argparse.Namespace) -> Counter: |
| with args.annotation_json.open() as f: |
| annotation = json.load(f) |
| coverage = WaveformCoverageIndex(args.waveform_db, args.channel_families) |
| responses = ResponseIndex(args.response_json) |
| con = create_output(args.output) |
|
|
| config = { |
| "schema": "seismicx-cont-reference-arrivals-v1", |
| "sources": { |
| "annotation_json": release_path(args.annotation_json), |
| "waveform_db": release_path(args.waveform_db), |
| "hdf5_waveforms": "h5_file and dataset_path fields in waveform_db", |
| "response_json": release_path(args.response_json), |
| }, |
| "coverage": { |
| "C0": "exact NSLC point coverage with finite-sample validation", |
| "C1": "at least one observed component satisfies the finite-sample window gap threshold", |
| "C2": "all declared observed components satisfy the finite-sample window gap threshold", |
| "C3": ( |
| "C2 plus declared sample-rate requirements and, when requested, " |
| "exactly one NSLC-and-epoch response match per required component" |
| ), |
| "channel_families": list(args.channel_families), |
| "finite_sample_validation": True, |
| "window_before_s": args.window_before_s, |
| "window_after_s": args.window_after_s, |
| "max_gap_fraction": args.max_gap_fraction, |
| "required_components": list(args.required_components), |
| "minimum_sample_rate_hz": args.minimum_sample_rate_hz, |
| "require_response": args.require_response, |
| }, |
| "reference_settings": { |
| "primary": "manual labels satisfying the declared coverage level", |
| "expanded": "manual plus operational automatic labels satisfying the declared coverage level", |
| }, |
| } |
| con.executemany( |
| "INSERT INTO metadata(key, value_json) VALUES (?, ?)", |
| [(key, json.dumps(value, sort_keys=True)) for key, value in config.items()], |
| ) |
|
|
| sql = """ |
| INSERT INTO reference_arrivals ( |
| period, event_id, station_id, phase, status, pick_time, |
| pick_time_epoch, distance_km, c0_point_covered, c1_window_covered, |
| c2_component_covered, c3_processing_ready, matched_location, |
| channel_family, component_count, channels_json, |
| component_channels_json, component_gap_fractions_json, |
| window_gap_fraction, required_component_gap_fraction, |
| response_available, sample_rate_ready, manual_primary_reference |
| ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) |
| """ |
| counts: Counter = Counter() |
| rows: list[tuple[Any, ...]] = [] |
| for arrival in iter_arrivals(annotation): |
| details = coverage.coverage_window_details( |
| arrival["station_id"], |
| arrival["pick_time_epoch"], |
| args.window_before_s, |
| args.window_after_s, |
| args.max_gap_fraction, |
| args.required_components, |
| ) |
| component_channels = details["component_channels"] |
| required_channels = [ |
| component_channels[item] |
| for item in args.required_components |
| if item in component_channels |
| ] |
| response_available = bool(required_channels) and len(required_channels) == len( |
| args.required_components |
| ) and all( |
| responses.response_match_count( |
| str(details["station_key"]), |
| str(details["matched_location"]), |
| channel, |
| arrival["pick_time_epoch"], |
| ) == 1 |
| for channel in required_channels |
| ) |
| sample_rates = details["component_sample_rates_hz"] |
| sample_rate_ready = all( |
| component in sample_rates |
| and any(rate >= args.minimum_sample_rate_hz for rate in sample_rates[component]) |
| for component in args.required_components |
| ) |
| c3 = bool(details["component_covered"] and sample_rate_ready) |
| if args.require_response: |
| c3 = c3 and response_available |
|
|
| rows.append( |
| ( |
| arrival["period"], arrival["event_id"], arrival["station_id"], |
| arrival["phase"], arrival["status"], arrival["pick_time"], |
| arrival["pick_time_epoch"], arrival["distance_km"], |
| int(details["point_covered"]), int(details["window_covered"]), |
| int(details["component_covered"]), int(c3), |
| details["matched_location"], details["channel_family"], |
| int(details["component_count"]), json.dumps(details["channels"]), |
| json.dumps(component_channels, sort_keys=True), |
| json.dumps(details["component_gap_fractions"], sort_keys=True), |
| float(details["window_gap_fraction"]), |
| float(details["required_component_gap_fraction"]), |
| int(response_available), int(sample_rate_ready), |
| int(arrival["status"] == "manual"), |
| ) |
| ) |
| counts["arrivals"] += 1 |
| for level, field in ( |
| ("C0", "point_covered"), |
| ("C1", "window_covered"), |
| ("C2", "component_covered"), |
| ): |
| if details[field]: |
| counts[level] += 1 |
| if c3: |
| counts["C3"] += 1 |
| if len(rows) >= 5000: |
| con.executemany(sql, rows) |
| rows.clear() |
| if rows: |
| con.executemany(sql, rows) |
| con.execute( |
| "INSERT INTO metadata(key, value_json) VALUES (?, ?)", |
| ("summary", json.dumps(dict(counts), sort_keys=True)), |
| ) |
| con.commit() |
| con.close() |
| coverage.close() |
| return counts |
|
|
|
|
| def main() -> None: |
| parser = argparse.ArgumentParser(description=__doc__) |
| parser.add_argument( |
| "--annotation-json", |
| type=Path, |
| default=ROOT / "data" / "label" / "annotations_for_continuous_hdf5.json", |
| ) |
| parser.add_argument( |
| "--waveform-db", |
| type=Path, |
| default=ROOT / "data" / "index" / "waveform_index.sqlite", |
| ) |
| parser.add_argument( |
| "--response-json", |
| type=Path, |
| default=ROOT / "data" / "response" / "instrument_responses.json", |
| ) |
| parser.add_argument( |
| "--output", |
| type=Path, |
| default=ROOT / "data" / "label" / "reference_arrivals.sqlite", |
| ) |
| parser.add_argument("--channel-families", nargs="+", default=["HH", "BH", "EH", "HN"]) |
| parser.add_argument("--window-before-s", type=float, required=True) |
| parser.add_argument("--window-after-s", type=float, required=True) |
| parser.add_argument("--max-gap-fraction", type=float, default=0.0) |
| parser.add_argument( |
| "--required-components", nargs="+", default=["Z", "H1", "H2"] |
| ) |
| parser.add_argument("--minimum-sample-rate-hz", type=float, default=0.0) |
| parser.add_argument("--require-response", action="store_true") |
| args = parser.parse_args() |
| counts = build(args) |
| print(json.dumps({"output": str(args.output), "counts": dict(counts)}, indent=2)) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
