scripts/example_query_waveform.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
python example_query_waveform.py \
  --db data/index/waveform_index.sqlite \
  --network BK \
  --station CMB \
  --starttime 2019-07-01T00:00:00 \
  --endtime 2019-07-01T01:00:00
"""
import argparse
import sys
from pathlib import Path

import numpy as np

sys.path.insert(0, str(Path(__file__).resolve().parents[1]))

from utils.waveform_index_api import query_and_merge, save_merged_to_npz


def parse_optional_float(value):
    if value is None:
        return None
    text = str(value).strip().lower()
    if text in {"none", "null", ""}:
        return None
    out = float(value)
    return None if out < 0 else out


def build_simulation_selector(args):
    fields = {
        "network": args.simulation_network,
        "station": args.simulation_station,
        "location": args.simulation_location,
        "channel": args.simulation_channel,
        "time": args.simulation_time,
    }
    selector = {key: value for key, value in fields.items() if value not in (None, "")}
    return selector or None


def main():
    parser = argparse.ArgumentParser(
        description="Example API client for querying and merging waveform data."
    )

    parser.add_argument(
        "--db",
        required=True,
        help="SQLite waveform index database, e.g. data/index/waveform_index.sqlite",
    )

    parser.add_argument(
        "--network",
        default="*",
        help='Network code or wildcard, e.g. "BK", "C*", "*".',
    )

    parser.add_argument(
        "--station",
        default="*",
        help='Station code or wildcard, e.g. "BDM", "BD*", "*".',
    )

    parser.add_argument(
        "--location",
        default="*",
        help='Location code or wildcard, e.g. "00", "--", "*".',
    )

    parser.add_argument(
        "--channel",
        default="*",
        help='Channel code or wildcard, e.g. "BHE", "BH*", "*Z", "*".',
    )

    parser.add_argument(
        "--starttime",
        required=True,
        help="Query start time, e.g. 2019-07-01T00:00:00",
    )

    parser.add_argument(
        "--endtime",
        required=True,
        help="Query end time, e.g. 2019-07-01T01:00:00",
    )

    parser.add_argument(
        "--fill_value",
        type=float,
        default=0.0,
        help="Fill value for gaps.",
    )

    parser.add_argument(
        "--limit",
        type=int,
        default=None,
        help="Optional limit for matched segments.",
    )

    parser.add_argument(
        "--output_npz",
        default=None,
        help="Optional output NPZ file.",
    )

    parser.add_argument(
        "--show_segments",
        action="store_true",
        help="Print segment details.",
    )
    parser.add_argument(
        "--response_json",
        default="data/response/instrument_responses.json",
        help="Instrument-response JSON used by --remove_response or --simulate_response.",
    )
    parser.add_argument(
        "--remove_response",
        action="store_true",
        help="Remove the native instrument response with ObsPy before returning arrays.",
    )
    parser.add_argument(
        "--response_output",
        default="VEL",
        help="Physical output unit for response removal: DISP, VEL, or ACC.",
    )
    parser.add_argument(
        "--response_pre_filt",
        nargs=4,
        type=float,
        default=None,
        metavar=("F1", "F2", "F3", "F4"),
        help="Four-corner frequency pre-filter passed to ObsPy remove_response.",
    )
    parser.add_argument(
        "--response_water_level",
        default="60",
        help='ObsPy water level. Use "none" or a negative value to pass None.',
    )
    parser.add_argument(
        "--response_error_behavior",
        choices=("raise", "warn", "skip"),
        default="raise",
        help="How to handle response-processing failures.",
    )
    parser.add_argument(
        "--simulate_response",
        action="store_true",
        help="Simulate a target instrument response after optional native-response removal.",
    )
    parser.add_argument(
        "--simulation_response_json",
        default=None,
        help="Response JSON containing the target response; defaults to --response_json.",
    )
    parser.add_argument(
        "--simulation_response_id",
        default=None,
        help="Exact target response_id to simulate.",
    )
    parser.add_argument("--simulation_network", default=None)
    parser.add_argument("--simulation_station", default=None)
    parser.add_argument("--simulation_location", default=None)
    parser.add_argument("--simulation_channel", default=None)
    parser.add_argument(
        "--simulation_time",
        default=None,
        help="Time used with station-channel target-response selection.",
    )
    parser.add_argument(
        "--simulation_output",
        default=None,
        help="Physical unit used when evaluating the target response; defaults to --response_output.",
    )

    args = parser.parse_args()
    simulation_selector = build_simulation_selector(args)

    merged, rows = query_and_merge(
        db_file=args.db,
        network=args.network,
        station=args.station,
        location=args.location,
        channel=args.channel,
        starttime=args.starttime,
        endtime=args.endtime,
        fill_value=args.fill_value,
        dtype=np.float32,
        limit=args.limit,
        instrument_response_json=args.response_json,
        remove_instrument_response=args.remove_response,
        response_output=args.response_output,
        response_pre_filt=tuple(args.response_pre_filt) if args.response_pre_filt else None,
        response_water_level=parse_optional_float(args.response_water_level),
        response_error_behavior=args.response_error_behavior,
        simulate_instrument_response=args.simulate_response,
        simulation_response_json=args.simulation_response_json,
        simulation_response_id=args.simulation_response_id,
        simulation_response_selector=simulation_selector,
        simulation_output=args.simulation_output,
    )

    print("=" * 80)
    print("Query")
    print("=" * 80)
    print(f"network   : {args.network}")
    print(f"station   : {args.station}")
    print(f"location  : {args.location}")
    print(f"channel   : {args.channel}")
    print(f"starttime : {args.starttime}")
    print(f"endtime   : {args.endtime}")

    print()
    print("=" * 80)
    print("Matched segments")
    print("=" * 80)
    print(f"Segment count: {len(rows)}")

    if args.show_segments:
        for row in rows:
            print(
                f"{row['network']}.{row['station']}.{row['location']} "
                f"{row['channel']} "
                f"{row['starttime']} -> {row['endtime']} "
                f"sr={row['sampling_rate']} "
                f"npts={row['npts']} "
                f"path={row['dataset_path']} "
                f"h5={row['h5_file']}"
            )

    print()
    print("=" * 80)
    print("Merged waveforms")
    print("=" * 80)

    if len(merged) == 0:
        print("No waveform found.")
        return

    for key, item in merged.items():
        print(
            f"{key}: "
            f"shape={item['data'].shape}, "
            f"sr={item['sampling_rate']}, "
            f"filled_ratio={item['filled_ratio']:.4f}, "
            f"segments={len(item['segments'])}"
        )
        if "instrument_processing" in item:
            proc = item["instrument_processing"]
            print(
                "  instrument_processing: "
                f"processed={proc.get('processed')} "
                f"response_id={proc.get('response_id', '')} "
                f"simulation_response_id={proc.get('simulation_response_id', '')} "
                f"error={proc.get('error', '')}"
            )

    if args.output_npz:
        save_merged_to_npz(merged, args.output_npz)
        print()
        print(f"[OK] Saved merged waveform NPZ: {args.output_npz}")


if __name__ == "__main__":
    main()