utils/continous_dataloader_singlefile.py

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

import h5py
import numpy as np
import torch
from torch.utils.data import Dataset, DataLoader
from obspy import UTCDateTime


DEFAULT_LOCATION = "--"


def parse_time(t):
    return UTCDateTime(str(t))


def decode_attr(value):
    if isinstance(value, bytes):
        return value.decode("utf-8", errors="ignore")
    if isinstance(value, np.bytes_):
        return value.decode("utf-8", errors="ignore")
    return value


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


def channel_suffix(channel):
    return str(channel)[-1].upper()


def channel_prefix(channel):
    # 前两位作为 family，例如 BHE/BHN/BHZ -> BH
    ch = str(channel).upper()
    if len(ch) >= 3:
        return ch[:2]
    return ch[:-1]


def component_rank(channel):
    order = {
        "E": 0,
        "1": 0,
        "N": 1,
        "2": 1,
        "Z": 2,
        "3": 2,
    }
    return order.get(channel_suffix(channel), 99)


def is_valid_waveform_family(channels):
    """
    判断一个 channel family 是否可以构成三分量输入。

    支持：
    1. E/N/Z
    2. 1/2/3
    3. only Z，后续复制成三分量
    """
    suffixes = {channel_suffix(ch) for ch in channels}

    if {"E", "N", "Z"}.issubset(suffixes):
        return True

    if {"1", "2", "3"}.issubset(suffixes):
        return True

    if suffixes == {"Z"}:
        return True

    return False


def get_attr(obj, name, default=None):
    if name in obj.attrs:
        return decode_attr(obj.attrs[name])
    return default


def get_float_attr(obj, name, default=np.nan):
    try:
        return float(get_attr(obj, name, default))
    except Exception:
        return float(default)


def get_bool_attr(obj, name, default=False):
    value = get_attr(obj, name, default)

    if isinstance(value, (bool, np.bool_)):
        return bool(value)

    if isinstance(value, (int, np.integer)):
        return bool(value)

    if isinstance(value, str):
        return value.lower() in ["true", "1", "yes"]

    return bool(value)


def fill_segments_to_array(segments, fill_value=0.0, dtype=np.float32):
    if len(segments) == 0:
        return None, None, None, None

    segments = sorted(segments, key=lambda x: x["starttime"])

    sampling_rate = segments[0]["sampling_rate"]
    global_start = min(s["starttime"] for s in segments)
    global_end = max(s["endtime"] for s in segments)

    npts = int(round((global_end - global_start) * sampling_rate)) + 1

    data = np.full(npts, fill_value, dtype=dtype)
    filled = np.zeros(npts, dtype=bool)

    for seg in segments:
        seg_data = seg["data"].astype(dtype, copy=False)

        i0 = int(round((seg["starttime"] - global_start) * sampling_rate))
        i1 = i0 + len(seg_data)

        if i0 < 0:
            seg_data = seg_data[-i0:]
            i0 = 0

        if i1 > npts:
            seg_data = seg_data[: npts - i0]
            i1 = npts

        if i0 >= i1:
            continue

        target = slice(i0, i1)
        mask = ~filled[target]

        data[target][mask] = seg_data[: i1 - i0][mask]
        filled[target][mask] = True

    return data, global_start, global_end, sampling_rate


def get_position_from_segments(segments):
    for seg in segments:
        if seg.get("location_available", False):
            return {
                "longitude": seg.get("longitude", np.nan),
                "latitude": seg.get("latitude", np.nan),
                "elevation": seg.get("elevation", np.nan),
                "location_available": True,
                "location_source": seg.get("location_source", ""),
                "position_match_mode": seg.get("position_match_mode", ""),
                "position_is_fallback": seg.get("position_is_fallback", False),
                "station_position_starttime": seg.get("station_position_starttime", ""),
                "station_position_endtime": seg.get("station_position_endtime", ""),
            }

    return {
        "longitude": np.nan,
        "latitude": np.nan,
        "elevation": np.nan,
        "location_available": False,
        "location_source": "default_nan_no_station_record",
        "position_match_mode": "default_nan_no_station_record",
        "position_is_fallback": False,
        "station_position_starttime": "",
        "station_position_endtime": "",
    }


class HDF5WaveformDataset(Dataset):
    """
    mode:
        single: 每个 channel 一个样本，返回 [T]
        three : 每个 channel family 一个样本，返回 [T, 3]
        multi : 每个 channel family 一个样本，返回 [T, C]
    """

    def __init__(
        self,
        h5_file,
        mode="three",
        fill_value=0.0,
        dtype=np.float32,
        default_location=DEFAULT_LOCATION,
    ):
        assert mode in ["single", "three", "multi"]

        self.h5_file = h5_file
        self.mode = mode
        self.fill_value = fill_value
        self.dtype = dtype
        self.default_location = default_location

        self.index = []
        self._build_index()

    def _build_index(self):
        with h5py.File(self.h5_file, "r") as h5:
            for year_id in sorted(h5.keys()):
                year_grp = h5[year_id]

                for day_id in sorted(year_grp.keys()):
                    day_grp = year_grp[day_id]

                    if "stations" not in day_grp:
                        continue

                    stations_grp = day_grp["stations"]

                    for station_id in sorted(stations_grp.keys()):
                        station_grp = stations_grp[station_id]

                        if "waveform" not in station_grp:
                            continue

                        waveform_grp = station_grp["waveform"]
                        channels = sorted(list(waveform_grp.keys()))

                        if self.mode == "single":
                            for cha in channels:
                                self.index.append(
                                    {
                                        "year_id": year_id,
                                        "day_id": day_id,
                                        "station_id": station_id,
                                        "channel": cha,
                                    }
                                )

                        else:
                            families = {}

                            for cha in channels:
                                prefix = channel_prefix(cha)
                                families.setdefault(prefix, []).append(cha)

                            for prefix, family_channels in families.items():
                                family_channels = sorted(
                                    family_channels,
                                    key=component_rank,
                                )

                                if self.mode == "three":
                                    if not is_valid_waveform_family(family_channels):
                                        continue

                                self.index.append(
                                    {
                                        "year_id": year_id,
                                        "day_id": day_id,
                                        "station_id": station_id,
                                        "channel_family": prefix,
                                        "channels": family_channels,
                                    }
                                )

    def __len__(self):
        return len(self.index)

    def _get_station_group(self, h5, year_id, day_id, station_id):
        return h5[year_id][day_id]["stations"][station_id]

    def _read_position_history(self, station_grp):
        if "position_history" not in station_grp:
            return []

        pos_grp = station_grp["position_history"]
        out = []

        for key in sorted(pos_grp.keys(), key=lambda x: int(x) if str(x).isdigit() else str(x)):
            item = pos_grp[key]

            out.append(
                {
                    "network": get_attr(item, "network", ""),
                    "station": get_attr(item, "station", ""),
                    "location": normalize_location(
                        get_attr(item, "location", self.default_location),
                        self.default_location,
                    ),
                    "longitude": get_float_attr(item, "longitude", np.nan),
                    "latitude": get_float_attr(item, "latitude", np.nan),
                    "elevation": get_float_attr(item, "elevation", np.nan),
                    "starttime": get_attr(item, "starttime", ""),
                    "endtime": get_attr(item, "endtime", ""),
                }
            )

        return out

    def _read_station_attrs(self, station_grp):
        location = normalize_location(
            get_attr(station_grp, "location", self.default_location),
            self.default_location,
        )

        return {
            "station_id": get_attr(station_grp, "station_id", ""),
            "network": get_attr(station_grp, "network", ""),
            "station": get_attr(station_grp, "station", ""),
            "location": location,
            "location_is_default": get_bool_attr(
                station_grp,
                "location_is_default",
                location == self.default_location,
            ),
            "longitude": get_float_attr(station_grp, "longitude", np.nan),
            "latitude": get_float_attr(station_grp, "latitude", np.nan),
            "elevation": get_float_attr(station_grp, "elevation", np.nan),
            "location_available": get_bool_attr(station_grp, "location_available", False),
            "location_source": get_attr(station_grp, "location_source", ""),
            "position_match_mode": get_attr(station_grp, "position_match_mode", ""),
            "position_is_fallback": get_bool_attr(station_grp, "position_is_fallback", False),
            "station_position_starttime": get_attr(station_grp, "station_position_starttime", ""),
            "station_position_endtime": get_attr(station_grp, "station_position_endtime", ""),
            "instrument_time_range_start": get_attr(station_grp, "instrument_time_range_start", ""),
            "instrument_time_range_end": get_attr(station_grp, "instrument_time_range_end", ""),
            "position_history": self._read_position_history(station_grp),
        }

    def _read_channel_attrs(self, channel_grp):
        return {
            "channel": get_attr(channel_grp, "channel", ""),
            "segment_count": int(get_attr(channel_grp, "segment_count", 0)),
            "starttime": get_attr(channel_grp, "starttime", ""),
            "endtime": get_attr(channel_grp, "endtime", ""),
            "longitude": get_float_attr(channel_grp, "longitude", np.nan),
            "latitude": get_float_attr(channel_grp, "latitude", np.nan),
            "elevation": get_float_attr(channel_grp, "elevation", np.nan),
            "location_available": get_bool_attr(channel_grp, "location_available", False),
            "location_source": get_attr(channel_grp, "location_source", ""),
            "position_match_mode": get_attr(channel_grp, "position_match_mode", ""),
            "position_is_fallback": get_bool_attr(channel_grp, "position_is_fallback", False),
            "station_position_starttime": get_attr(channel_grp, "station_position_starttime", ""),
            "station_position_endtime": get_attr(channel_grp, "station_position_endtime", ""),
        }

    def _read_channel_segments(self, h5, year_id, day_id, station_id, channel):
        station_grp = self._get_station_group(h5, year_id, day_id, station_id)
        channel_grp = station_grp["waveform"][channel]

        segments = []

        for ds_key in sorted(channel_grp.keys(), key=lambda x: int(x)):
            ds = channel_grp[ds_key]

            segments.append(
                {
                    "data": ds[()],
                    "segment_index": int(get_attr(ds, "segment_index", ds_key)),
                    "starttime": parse_time(get_attr(ds, "starttime", "")),
                    "endtime": parse_time(get_attr(ds, "endtime", "")),
                    "sampling_rate": float(get_attr(ds, "sampling_rate", np.nan)),
                    "delta": float(get_attr(ds, "delta", np.nan)),
                    "npts": int(get_attr(ds, "npts", ds.shape[0])),
                    "network": get_attr(ds, "network", ""),
                    "station": get_attr(ds, "station", ""),
                    "location": normalize_location(
                        get_attr(ds, "location", self.default_location),
                        self.default_location,
                    ),
                    "channel": get_attr(ds, "channel", channel),
                    "mseed_source_file": get_attr(ds, "mseed_source_file", ""),
                    "dtype": get_attr(ds, "dtype", str(ds.dtype)),
                    "longitude": get_float_attr(ds, "longitude", np.nan),
                    "latitude": get_float_attr(ds, "latitude", np.nan),
                    "elevation": get_float_attr(ds, "elevation", np.nan),
                    "location_available": get_bool_attr(ds, "location_available", False),
                    "location_source": get_attr(ds, "location_source", ""),
                    "station_position_starttime": get_attr(ds, "station_position_starttime", ""),
                    "station_position_endtime": get_attr(ds, "station_position_endtime", ""),
                    "position_match_mode": get_attr(ds, "position_match_mode", ""),
                    "position_is_fallback": get_bool_attr(ds, "position_is_fallback", False),
                }
            )

        channel_info = self._read_channel_attrs(channel_grp)
        return segments, channel_info

    def __getitem__(self, idx):
        item = self.index[idx]

        with h5py.File(self.h5_file, "r") as h5:
            year_id = item["year_id"]
            day_id = item["day_id"]
            station_id = item["station_id"]

            station_grp = self._get_station_group(h5, year_id, day_id, station_id)
            station_info = self._read_station_attrs(station_grp)

            if self.mode == "single":
                return self._getitem_single(h5, item, station_info)

            if self.mode == "three":
                return self._getitem_three(h5, item, station_info)

            if self.mode == "multi":
                return self._getitem_multi(h5, item, station_info)

            raise ValueError(f"Unsupported mode: {self.mode}")

    def _getitem_single(self, h5, item, station_info):
        year_id = item["year_id"]
        day_id = item["day_id"]
        station_id = item["station_id"]
        channel = item["channel"]

        segments, channel_info = self._read_channel_segments(
            h5, year_id, day_id, station_id, channel
        )

        waveform, starttime, endtime, sr = fill_segments_to_array(
            segments,
            fill_value=self.fill_value,
            dtype=self.dtype,
        )

        if waveform is None:
            waveform = np.zeros(0, dtype=self.dtype)

        position_info = get_position_from_segments(segments)
        station_info = dict(station_info)
        station_info.update(position_info)

        return {
            "mode": "single",
            "year_id": year_id,
            "day_id": day_id,
            "station_id": station_id,
            "station_info": station_info,
            "channel_info": channel_info,
            "channel": channel,
            "channels": [channel],
            "waveform": torch.from_numpy(waveform),
            "segments": [
                {k: v for k, v in seg.items() if k != "data"}
                for seg in segments
            ],
            "starttime": str(starttime) if starttime is not None else "",
            "endtime": str(endtime) if endtime is not None else "",
            "sampling_rate": sr,
            "npts": waveform.shape[0],
        }

    def _getitem_three(self, h5, item, station_info):
        year_id = item["year_id"]
        day_id = item["day_id"]
        station_id = item["station_id"]
        channel_family = item["channel_family"]
        candidate_channels = item["channels"]

        selected = {}

        for cha in candidate_channels:
            suf = channel_suffix(cha)

            if suf in ["E", "1"] and 0 not in selected:
                selected[0] = cha
            elif suf in ["N", "2"] and 1 not in selected:
                selected[1] = cha
            elif suf in ["Z", "3"] and 2 not in selected:
                selected[2] = cha

        z_only_replicated = False

        # 只有 Z 的情况：复制为三分量
        if 2 in selected and 0 not in selected and 1 not in selected:
            selected[0] = selected[2]
            selected[1] = selected[2]
            z_only_replicated = True

        arrays = {}
        starts = []
        ends = []
        srs = []
        all_segments = []
        channel_infos = {}

        # 避免 Z-only 情况重复读取同一个 channel 三次
        unique_channels = sorted(set(selected.values()))

        channel_arrays = {}

        for cha in unique_channels:
            segments, channel_info = self._read_channel_segments(
                h5, year_id, day_id, station_id, cha
            )

            all_segments.extend(segments)
            channel_infos[cha] = channel_info

            arr, st, et, sr = fill_segments_to_array(
                segments,
                fill_value=self.fill_value,
                dtype=self.dtype,
            )

            if arr is None:
                continue

            channel_arrays[cha] = arr
            starts.append(st)
            ends.append(et)
            srs.append(sr)

        for comp_idx, cha in selected.items():
            if cha in channel_arrays:
                arrays[comp_idx] = channel_arrays[cha]

        if len(arrays) == 0:
            waveform = np.zeros((0, 3), dtype=self.dtype)
            starttime = None
            endtime = None
            sr = np.nan
        else:
            sr = srs[0]
            starttime = min(starts)
            endtime = max(ends)

            max_len = max(len(a) for a in arrays.values())
            waveform = np.full((max_len, 3), self.fill_value, dtype=self.dtype)

            for comp_idx, arr in arrays.items():
                waveform[: len(arr), comp_idx] = arr

        position_info = get_position_from_segments(all_segments)
        station_info = dict(station_info)
        station_info.update(position_info)

        channels_out = [
            selected.get(0, ""),
            selected.get(1, ""),
            selected.get(2, ""),
        ]

        return {
            "mode": "three",
            "year_id": year_id,
            "day_id": day_id,
            "station_id": station_id,
            "station_info": station_info,
            "channel_family": channel_family,
            "channel_info": channel_infos,
            "channels": channels_out,
            "component_order": "E/N/Z or 1/2/3; Z-only is replicated",
            "z_only_replicated": z_only_replicated,
            "waveform": torch.from_numpy(waveform),
            "segments": [
                {k: v for k, v in seg.items() if k != "data"}
                for seg in all_segments
            ],
            "starttime": str(starttime) if starttime is not None else "",
            "endtime": str(endtime) if endtime is not None else "",
            "sampling_rate": sr,
            "npts": waveform.shape[0],
        }

    def _getitem_multi(self, h5, item, station_info):
        year_id = item["year_id"]
        day_id = item["day_id"]
        station_id = item["station_id"]
        channel_family = item["channel_family"]
        channels = item["channels"]

        arrays = []
        used_channels = []
        starts = []
        ends = []
        srs = []
        all_segments = []
        channel_infos = {}

        for cha in channels:
            segments, channel_info = self._read_channel_segments(
                h5, year_id, day_id, station_id, cha
            )

            all_segments.extend(segments)
            channel_infos[cha] = channel_info

            arr, st, et, sr = fill_segments_to_array(
                segments,
                fill_value=self.fill_value,
                dtype=self.dtype,
            )

            if arr is None:
                continue

            arrays.append(arr)
            used_channels.append(cha)
            starts.append(st)
            ends.append(et)
            srs.append(sr)

        if len(arrays) == 0:
            waveform = np.zeros((0, 0), dtype=self.dtype)
            starttime = None
            endtime = None
            sr = np.nan
        else:
            max_len = max(len(a) for a in arrays)
            waveform = np.full(
                (max_len, len(arrays)),
                self.fill_value,
                dtype=self.dtype,
            )

            for i, arr in enumerate(arrays):
                waveform[: len(arr), i] = arr

            starttime = min(starts)
            endtime = max(ends)
            sr = srs[0]

        position_info = get_position_from_segments(all_segments)
        station_info = dict(station_info)
        station_info.update(position_info)

        return {
            "mode": "multi",
            "year_id": year_id,
            "day_id": day_id,
            "station_id": station_id,
            "station_info": station_info,
            "channel_family": channel_family,
            "channel_info": channel_infos,
            "channels": used_channels,
            "waveform": torch.from_numpy(waveform),
            "segments": [
                {k: v for k, v in seg.items() if k != "data"}
                for seg in all_segments
            ],
            "starttime": str(starttime) if starttime is not None else "",
            "endtime": str(endtime) if endtime is not None else "",
            "sampling_rate": sr,
            "npts": waveform.shape[0],
        }


def waveform_collate_fn(batch):
    return batch


def padded_collate_fn(batch, fill_value=0.0):
    lengths = []
    arrays = []

    max_t = 0
    max_c = 1

    for item in batch:
        x = item["waveform"]

        if x.ndim == 1:
            x = x[:, None]

        t, c = x.shape
        max_t = max(max_t, t)
        max_c = max(max_c, c)

        lengths.append(t)
        arrays.append(x)

    out = torch.full(
        (len(batch), max_t, max_c),
        fill_value=float(fill_value),
        dtype=arrays[0].dtype,
    )

    for i, x in enumerate(arrays):
        t, c = x.shape
        out[i, :t, :c] = x

    meta = []

    for item in batch:
        d = dict(item)
        d.pop("waveform")
        meta.append(d)

    return {
        "waveform": out,
        "lengths": torch.tensor(lengths, dtype=torch.long),
        "meta": meta,
    }


if __name__ == "__main__":
    h5_file = "data/continuous_waveform_usa.h5"

    dataset = HDF5WaveformDataset(
        h5_file=h5_file,
        mode="three",
        fill_value=0.0,
        dtype=np.float32,
        default_location="--",
    )

    loader = DataLoader(
        dataset,
        batch_size=2,
        shuffle=False,
        num_workers=0,
        collate_fn=waveform_collate_fn,
    )

    print("Number of samples:", len(dataset))

    for batch in loader:
        for item in batch:
            print("=" * 80)
            print("station_id:", item["station_id"])
            print("station_info:", item["station_info"])
            print("mode:", item["mode"])
            print("channel_family:", item["channel_family"])
            print("channels:", item["channels"])
            print("z_only_replicated:", item["z_only_replicated"])
            print("starttime:", item["starttime"])
            print("endtime:", item["endtime"])
            print("sampling_rate:", item["sampling_rate"])
            print("waveform shape:", tuple(item["waveform"].shape))
            print("first segment meta:", item["segments"][0] if item["segments"] else None)
        break