scripts/makeh5.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

import os
import csv
import argparse
from pathlib import Path
from collections import defaultdict
from concurrent.futures import ThreadPoolExecutor, wait, FIRST_COMPLETED

import h5py
import numpy as np
from obspy import read, UTCDateTime


DEFAULT_LOCATION = "--"


def normalize_location(location, default=DEFAULT_LOCATION):
    if location is None:
        return default
    location = str(location).strip()
    return location if location else default


def make_station_id(network, station, location, default_location=DEFAULT_LOCATION):
    network = str(network or "").strip()
    station = str(station or "").strip()
    location = normalize_location(location, default_location)
    return f"{network}.{station}.{location}"


def make_station_key(network, station):
    network = str(network or "").strip()
    station = str(station or "").strip()
    return f"{network}.{station}"


def split_station_id(station_id, default_location=DEFAULT_LOCATION):
    parts = str(station_id).split(".")
    network = parts[0] if len(parts) > 0 else ""
    station = parts[1] if len(parts) > 1 else ""
    location = parts[2] if len(parts) > 2 else default_location
    return network, station, normalize_location(location, default_location)


def parse_utc_or_none(value):
    value = str(value or "").strip()
    if not value:
        return None
    return UTCDateTime(value)


def utc_to_group_id(t: UTCDateTime, level: str) -> str:
    if level == "year":
        return f"{t.year:04d}-01-01T00:00:00.000000Z"
    if level == "day":
        return f"{t.year:04d}-{t.month:02d}-{t.day:02d}T00:00:00.000000Z"
    raise ValueError(f"Unsupported level: {level}")


def day_file_id(t: UTCDateTime) -> str:
    return f"{t.year:04d}{t.month:02d}{t.day:02d}"


def set_common_attrs(obj, level, node_type, parent_type):
    obj.attrs["level"] = level
    obj.attrs["type"] = node_type
    obj.attrs["parent_type"] = parent_type


def load_station_locations_csv(loc_file, default_location=DEFAULT_LOCATION):
    """
    支持两种格式：

    1. 有表头：
       net,sta,lat,lon,elev_m,start,end

    2. 无表头：
       CI,WBM,35.60839,-117.89049,892.0,1979-09-26T00:00:00.000000Z,3000-01-01T00:00:00.000000Z

    注意：
    位置匹配只使用 network.station，不使用 location。
    """
    locations = defaultdict(list)

    if not loc_file or not os.path.exists(loc_file):
        print(f"[WARN] Location CSV file not found: {loc_file}")
        return dict(locations)

    with open(loc_file, "r", encoding="utf-8-sig", newline="") as f:
        sample = f.readline()
        f.seek(0)

        first_cols = [x.strip().lower() for x in sample.strip().split(",")]
        has_header = {"net", "sta", "lat", "lon"}.issubset(set(first_cols))

        if has_header:
            reader = csv.DictReader(f)

            for line_no, row in enumerate(reader, start=2):
                try:
                    net = row["net"].strip()
                    sta = row["sta"].strip()
                    loc = normalize_location(row.get("location", default_location), default_location)

                    start = parse_utc_or_none(row["start"])
                    end = parse_utc_or_none(row["end"])

                    key = make_station_key(net, sta)

                    locations[key].append(
                        {
                            "network": net,
                            "station": sta,
                            "location": loc,
                            "latitude": float(row["lat"]),
                            "longitude": float(row["lon"]),
                            "elevation": float(row["elev_m"]),
                            "start": start,
                            "end": end,
                            "starttime": str(start) if start is not None else "",
                            "endtime": str(end) if end is not None else "",
                        }
                    )
                except Exception as e:
                    print(f"[WARN] Failed to parse location CSV line {line_no}: {row}, error={e}")

        else:
            reader = csv.reader(f)

            for line_no, row in enumerate(reader, start=1):
                if not row or len(row) < 7:
                    continue

                try:
                    net = row[0].strip()
                    sta = row[1].strip()
                    lat = float(row[2])
                    lon = float(row[3])
                    elev = float(row[4])
                    start = parse_utc_or_none(row[5])
                    end = parse_utc_or_none(row[6])

                    key = make_station_key(net, sta)

                    locations[key].append(
                        {
                            "network": net,
                            "station": sta,
                            "location": default_location,
                            "latitude": lat,
                            "longitude": lon,
                            "elevation": elev,
                            "start": start,
                            "end": end,
                            "starttime": str(start) if start is not None else "",
                            "endtime": str(end) if end is not None else "",
                        }
                    )
                except Exception as e:
                    print(f"[WARN] Failed to parse location CSV line {line_no}: {row}, error={e}")

    for key in locations:
        locations[key].sort(
            key=lambda x: x["start"] if x["start"] is not None else UTCDateTime(0)
        )

    return dict(locations)


def match_station_location(
    station_locations,
    station_id,
    trace_start=None,
    trace_end=None,
    allow_fallback=True,
):
    """
    只按 network.station 匹配台站位置。
    不使用 location code。

    例如：
        waveform station_id = BK.BDM.00
        location key        = BK.BDM
    """
    net, sta, _ = split_station_id(station_id)
    station_key = make_station_key(net, sta)

    records = station_locations.get(station_key, [])

    if not records:
        return None, "default_nan_no_station_record"

    if trace_start is None and trace_end is None:
        if allow_fallback:
            return records[-1], "fallback_nearest_time_network_station_only"
        return None, "default_nan_no_time_matched_position"

    matched = []

    for rec in records:
        rec_start = rec.get("start")
        rec_end = rec.get("end")

        left_ok = True if rec_end is None or trace_start is None else trace_start < rec_end
        right_ok = True if rec_start is None or trace_end is None else trace_end >= rec_start

        if left_ok and right_ok:
            matched.append(rec)

    if matched:
        def strict_score(rec):
            rec_start = rec.get("start")
            if rec_start is None or trace_start is None:
                return 0
            if rec_start <= trace_start:
                return abs(trace_start - rec_start)
            return abs(trace_start - rec_start) + 1e12

        return sorted(matched, key=strict_score)[0], "strict_time_matched_network_station_only"

    if not allow_fallback:
        return None, "default_nan_no_time_matched_position"

    def fallback_score(rec):
        if trace_start is None:
            return 0

        candidates = []
        if rec.get("start") is not None:
            candidates.append(abs(trace_start - rec["start"]))
        if rec.get("end") is not None:
            candidates.append(abs(trace_start - rec["end"]))

        return min(candidates) if candidates else 0

    return sorted(records, key=fallback_score)[0], "fallback_nearest_time_network_station_only"


def find_mseed_files(input_dir):
    input_dir = Path(input_dir)

    suffixes = {
        ".mseed", ".msd", ".miniseed", ".seed",
        ".MSEED", ".MSD", ".MINISEED", ".SEED",
    }

    return sorted(
        p for p in input_dir.rglob("*")
        if p.is_file() and p.suffix in suffixes
    )


def read_one_mseed(mseed_file, default_location=DEFAULT_LOCATION):
    records = []

    try:
        st = read(str(mseed_file))
    except Exception as e:
        return records, f"[WARN] Failed to read {mseed_file}: {e}"

    for tr in st:
        net = tr.stats.network or ""
        sta = tr.stats.station or ""
        loc = normalize_location(tr.stats.location, default_location)
        cha = tr.stats.channel or ""

        start = tr.stats.starttime
        end = tr.stats.endtime

        station_id = make_station_id(net, sta, loc, default_location)

        records.append(
            {
                "year_id": utc_to_group_id(start, "year"),
                "day_id": utc_to_group_id(start, "day"),
                "day_file_id": day_file_id(start),
                "station_id": station_id,
                "channel": cha,
                "starttime_obj": start,
                "endtime_obj": end,
                "starttime": str(start),
                "endtime": str(end),
                "sampling_rate": float(tr.stats.sampling_rate),
                "delta": float(tr.stats.delta),
                "npts": int(tr.stats.npts),
                "network": net,
                "station": sta,
                "location": loc,
                "data": np.asarray(tr.data),
                "dtype": str(tr.data.dtype),
                "source_file": str(mseed_file),
            }
        )

    return records, None


def write_position_attrs(obj, matched, match_mode):
    obj.attrs["position_match_mode"] = match_mode
    obj.attrs["position_is_fallback"] = "fallback" in str(match_mode)

    if matched is not None:
        obj.attrs["longitude"] = matched.get("longitude", np.nan)
        obj.attrs["latitude"] = matched.get("latitude", np.nan)
        obj.attrs["elevation"] = matched.get("elevation", np.nan)
        obj.attrs["location_available"] = True
        obj.attrs["location_source"] = match_mode
        obj.attrs["station_position_starttime"] = matched.get("starttime", "")
        obj.attrs["station_position_endtime"] = matched.get("endtime", "")
    else:
        obj.attrs["longitude"] = np.nan
        obj.attrs["latitude"] = np.nan
        obj.attrs["elevation"] = np.nan
        obj.attrs["location_available"] = False
        obj.attrs["location_source"] = match_mode
        obj.attrs["station_position_starttime"] = ""
        obj.attrs["station_position_endtime"] = ""


def write_station_position_history(station_grp, station_id, station_locations, default_location):
    if "position_history" in station_grp:
        return

    net, sta, _ = split_station_id(station_id, default_location)
    station_key = make_station_key(net, sta)

    pos_grp = station_grp.create_group("position_history")
    set_common_attrs(pos_grp, "position_history", "position_history_group", "station_group")

    records = station_locations.get(station_key, [])
    pos_grp.attrs["record_count"] = len(records)
    pos_grp.attrs["match_key"] = station_key
    pos_grp.attrs["match_rule"] = "network.station only; location ignored"

    for i, rec in enumerate(records):
        item_grp = pos_grp.create_group(str(i))
        set_common_attrs(item_grp, "position_record", "position_record_group", "position_history_group")

        item_grp.attrs["network"] = rec.get("network", "")
        item_grp.attrs["station"] = rec.get("station", "")
        item_grp.attrs["location"] = rec.get("location", default_location)
        item_grp.attrs["longitude"] = rec.get("longitude", np.nan)
        item_grp.attrs["latitude"] = rec.get("latitude", np.nan)
        item_grp.attrs["elevation"] = rec.get("elevation", np.nan)
        item_grp.attrs["starttime"] = rec.get("starttime", "")
        item_grp.attrs["endtime"] = rec.get("endtime", "")


def init_hdf5_root(h5, default_location, split_by_day=False):
    set_common_attrs(h5, "root", "hdf5_file", "none")
    h5.attrs["description"] = "Continuous waveform dataset converted from MiniSEED"
    h5.attrs["station_id_format"] = "network.station.location"
    h5.attrs["station_location_match_rule"] = "network.station only; location ignored"
    h5.attrs["empty_location_value"] = default_location
    h5.attrs["missing_coordinate_value"] = "NaN"
    h5.attrs["station_location_format"] = (
        "CSV with header: net,sta,lat,lon,elev_m,start,end "
        "or no-header: net,sta,lat,lon,elev_m,start,end"
    )
    h5.attrs["split_by_day"] = bool(split_by_day)


def get_or_create_station_group(
    h5,
    year_id,
    day_id,
    station_id,
    station_locations,
    trace_start,
    trace_end,
    default_location,
):
    year_grp = h5.require_group(year_id)
    set_common_attrs(year_grp, "year", "year_group", "root")
    year_grp.attrs["utc_time"] = year_id

    day_grp = year_grp.require_group(day_id)
    set_common_attrs(day_grp, "day", "day_group", "year_group")
    day_grp.attrs["utc_time"] = day_id

    stations_grp = day_grp.require_group("stations")
    set_common_attrs(stations_grp, "stations", "stations_group", "day_group")
    stations_grp.attrs["description"] = "Container group for all stations under this day"

    station_grp = stations_grp.require_group(station_id)
    set_common_attrs(station_grp, "station", "station_group", "stations_group")

    network, station, location = split_station_id(station_id, default_location)
    station_grp.attrs["station_id"] = station_id
    station_grp.attrs["station_key"] = make_station_key(network, station)
    station_grp.attrs["network"] = network
    station_grp.attrs["station"] = station
    station_grp.attrs["location"] = location
    station_grp.attrs["location_default_value"] = default_location
    station_grp.attrs["location_is_default"] = location == default_location
    station_grp.attrs["instrument_time_range_start"] = str(trace_start)
    station_grp.attrs["instrument_time_range_end"] = str(trace_end)

    matched, match_mode = match_station_location(
        station_locations=station_locations,
        station_id=station_id,
        trace_start=trace_start,
        trace_end=trace_end,
        allow_fallback=True,
    )
    write_position_attrs(station_grp, matched, match_mode)

    write_station_position_history(
        station_grp=station_grp,
        station_id=station_id,
        station_locations=station_locations,
        default_location=default_location,
    )

    waveform_grp = station_grp.require_group("waveform")
    set_common_attrs(waveform_grp, "waveform", "waveform_group", "station_group")

    return station_grp, waveform_grp


def next_dataset_index(channel_grp):
    max_idx = -1
    for key in channel_grp.keys():
        if str(key).isdigit():
            max_idx = max(max_idx, int(key))
    return max_idx + 1


def update_channel_summary_attrs(channel_grp, rec):
    channel_grp.attrs["channel"] = rec["channel"]

    old_count = int(channel_grp.attrs.get("segment_count", 0))
    channel_grp.attrs["segment_count"] = old_count + 1

    rec_start = rec["starttime_obj"]
    rec_end = rec["endtime_obj"]

    old_start = channel_grp.attrs.get("starttime", "")
    old_end = channel_grp.attrs.get("endtime", "")

    if not old_start:
        channel_grp.attrs["starttime"] = str(rec_start)
    else:
        old_start_t = UTCDateTime(str(old_start))
        channel_grp.attrs["starttime"] = str(min(old_start_t, rec_start))

    if not old_end:
        channel_grp.attrs["endtime"] = str(rec_end)
    else:
        old_end_t = UTCDateTime(str(old_end))
        channel_grp.attrs["endtime"] = str(max(old_end_t, rec_end))


def write_one_record(
    h5,
    rec,
    station_locations,
    default_location,
    compression,
    compression_opts,
    shuffle,
):
    station_grp, waveform_grp = get_or_create_station_group(
        h5=h5,
        year_id=rec["year_id"],
        day_id=rec["day_id"],
        station_id=rec["station_id"],
        station_locations=station_locations,
        trace_start=rec["starttime_obj"],
        trace_end=rec["endtime_obj"],
        default_location=default_location,
    )

    channel_grp = waveform_grp.require_group(rec["channel"])
    set_common_attrs(channel_grp, "channel", "channel_group", "waveform_group")

    update_channel_summary_attrs(channel_grp, rec)

    matched, match_mode = match_station_location(
        station_locations=station_locations,
        station_id=rec["station_id"],
        trace_start=rec["starttime_obj"],
        trace_end=rec["endtime_obj"],
        allow_fallback=True,
    )
    write_position_attrs(channel_grp, matched, match_mode)

    ds_name = str(next_dataset_index(channel_grp))

    create_kwargs = {}
    if compression and compression.lower() != "none":
        create_kwargs["compression"] = compression
        if compression.lower() == "gzip":
            create_kwargs["compression_opts"] = compression_opts
        create_kwargs["shuffle"] = shuffle

    ds = channel_grp.create_dataset(
        ds_name,
        data=rec["data"],
        **create_kwargs,
    )

    set_common_attrs(ds, "segment", "waveform_dataset", "channel_group")

    write_position_attrs(ds, matched, match_mode)

    ds.attrs["segment_index"] = int(ds_name)
    ds.attrs["network"] = rec["network"]
    ds.attrs["station"] = rec["station"]
    ds.attrs["station_key"] = make_station_key(rec["network"], rec["station"])
    ds.attrs["location"] = rec["location"]
    ds.attrs["location_is_default"] = rec["location"] == default_location
    ds.attrs["channel"] = rec["channel"]
    ds.attrs["sampling_rate"] = rec["sampling_rate"]
    ds.attrs["delta"] = rec["delta"]
    ds.attrs["npts"] = rec["npts"]
    ds.attrs["starttime"] = rec["starttime"]
    ds.attrs["endtime"] = rec["endtime"]
    ds.attrs["mseed_source_file"] = rec["source_file"]
    ds.attrs["dtype"] = rec["dtype"]


def output_path_for_day(output, day_id):
    output = Path(output)

    if output.suffix.lower() in [".h5", ".hdf5"]:
        out_dir = output.parent
        stem = output.stem
    else:
        out_dir = output
        stem = "continuous_waveform"

    out_dir.mkdir(parents=True, exist_ok=True)
    return out_dir / f"{stem}_{day_id}.h5"


def convert_mseed_to_hdf5_streaming(
    mseed_files,
    station_locations,
    output_file,
    num_workers=4,
    max_pending=16,
    default_location=DEFAULT_LOCATION,
    compression="gzip",
    compression_opts=4,
    shuffle=True,
    split_by_day=False,
):
    total = len(mseed_files)
    submitted = 0
    finished = 0
    written_records = 0

    h5_files = {}

    def get_h5_for_record(rec):
        if not split_by_day:
            key = "__single__"
            if key not in h5_files:
                output_path = Path(output_file)
                output_path.parent.mkdir(parents=True, exist_ok=True)
                h5 = h5py.File(output_path, "w")
                init_hdf5_root(h5, default_location, split_by_day=False)
                h5_files[key] = h5
            return h5_files[key]

        key = rec["day_file_id"]
        if key not in h5_files:
            output_path = output_path_for_day(output_file, key)
            h5 = h5py.File(output_path, "w")
            init_hdf5_root(h5, default_location, split_by_day=True)
            h5.attrs["day_file_id"] = key
            h5_files[key] = h5
        return h5_files[key]

    try:
        with ThreadPoolExecutor(max_workers=num_workers) as executor:
            pending = set()

            def submit_more():
                nonlocal submitted
                while submitted < total and len(pending) < max_pending:
                    future = executor.submit(
                        read_one_mseed,
                        mseed_files[submitted],
                        default_location,
                    )
                    pending.add(future)
                    submitted += 1

            submit_more()

            while pending:
                done, pending_remaining = wait(pending, return_when=FIRST_COMPLETED)
                pending = pending_remaining

                for future in done:
                    finished += 1
                    records, warning = future.result()

                    if warning:
                        print(warning)

                    records.sort(
                        key=lambda r: (
                            r["day_file_id"],
                            r["year_id"],
                            r["day_id"],
                            r["station_id"],
                            r["channel"],
                            r["starttime_obj"],
                        )
                    )

                    for rec in records:
                        h5 = get_h5_for_record(rec)

                        write_one_record(
                            h5=h5,
                            rec=rec,
                            station_locations=station_locations,
                            default_location=default_location,
                            compression=compression,
                            compression_opts=compression_opts,
                            shuffle=shuffle,
                        )
                        written_records += 1

                    if finished % 100 == 0 or finished == total:
                        print(
                            f"[INFO] Progress: files {finished}/{total}, "
                            f"written waveform segments {written_records}, "
                            f"open hdf5 files {len(h5_files)}"
                        )

                    del records

                submit_more()

    finally:
        for h5 in h5_files.values():
            h5.close()

    print(f"[OK] Written waveform segments: {written_records}")

    if split_by_day:
        print(f"[OK] HDF5 files written by day under: {Path(output_file).parent if Path(output_file).suffix else output_file}")
    else:
        print(f"[OK] HDF5 written to: {output_file}")


def main():
    parser = argparse.ArgumentParser(
        description="Convert MiniSEED files to hierarchical HDF5."
    )

    parser.add_argument(
        "--input_dir",
        default="data/continous_usa/data",
        help="Directory containing MiniSEED files.",
    )

    parser.add_argument(
        "--loc_file",
        default="data/continous_usa/stations.csv",
        help="Station CSV file.",
    )

    parser.add_argument(
        "--output",
        default="data/hdf5/continuous_waveform_usa.h5",
        help=(
            "Output HDF5 file. If --split_by_day is enabled, this is used as "
            "a filename prefix, e.g. continuous_waveform_usa_20190701.h5."
        ),
    )

    parser.add_argument(
        "--split_by_day",
        action="store_true",
        default=True, 
        help="Write one HDF5 file per day.",
    )

    parser.add_argument(
        "--num_workers",
        type=int,
        default=2,
        help="Number of threads for reading MiniSEED files.",
    )

    parser.add_argument(
        "--max_pending",
        type=int,
        default=4,
        help="Maximum number of pending read tasks.",
    )

    parser.add_argument(
        "--default_location",
        default=DEFAULT_LOCATION,
        help='Default location code when MiniSEED location is empty. Default: "--".',
    )

    parser.add_argument(
        "--compression",
        default="gzip",
        choices=["gzip", "lzf", "none"],
        help="Dataset compression method.",
    )

    parser.add_argument(
        "--compression_opts",
        type=int,
        default=4,
        help="Compression level for gzip.",
    )

    parser.add_argument(
        "--no_shuffle",
        action="store_true",
        help="Disable HDF5 shuffle filter.",
    )

    args = parser.parse_args()

    station_locations = load_station_locations_csv(
        args.loc_file,
        default_location=args.default_location,
    )
    print(f"[INFO] Loaded station location histories for {len(station_locations)} station keys.")

    mseed_files = find_mseed_files(args.input_dir)
    print(f"[INFO] Found {len(mseed_files)} MiniSEED files.")

    convert_mseed_to_hdf5_streaming(
        mseed_files=mseed_files,
        station_locations=station_locations,
        output_file=args.output,
        num_workers=args.num_workers,
        max_pending=args.max_pending,
        default_location=args.default_location,
        compression=args.compression,
        compression_opts=args.compression_opts,
        shuffle=not args.no_shuffle,
        split_by_day=args.split_by_day,
    )


if __name__ == "__main__":
    main()