#!/usr/bin/env python3 # -*- coding: utf-8 -*- import glob import json import os import warnings from concurrent.futures import ThreadPoolExecutor from fractions import Fraction from pathlib import Path # Disable HDF5 POSIX file locking before h5py initialises. # Must be set before the first h5py import / H5open() call. # Prevents h5py.File() from blocking indefinitely on lock acquisition # (e.g. due to Spotlight, Time Machine, NFS, or a crashed prior run). os.environ.setdefault("HDF5_USE_FILE_LOCKING", "FALSE") import h5py import numpy as np import torch from torch.utils.data import Dataset, DataLoader from obspy import Trace, UTCDateTime from obspy.core.inventory import Channel, Inventory, Network, Site, Station from obspy.core.inventory.response import ( CoefficientsTypeResponseStage, FIRResponseStage, InstrumentSensitivity, PolesZerosResponseStage, PolynomialResponseStage, Response, ResponseStage, ) try: from scipy.signal import resample_poly except Exception: # pragma: no cover - optional dependency resample_poly = None 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): 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 has_three_components(channels): suffixes = {channel_suffix(ch) for ch in channels} return {"E", "N", "Z"}.issubset(suffixes) or {"1", "2", "3"}.issubset(suffixes) def is_z_only_channels(channels): suffixes = {channel_suffix(ch) for ch in channels} return len(channels) == 1 and suffixes == {"Z"} 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 resolve_h5_files(h5_input): if isinstance(h5_input, (list, tuple)): files = [] for item in h5_input: files.extend(resolve_h5_files(item)) return sorted(set(files)) h5_input = str(h5_input) p = Path(h5_input) if p.is_file(): return [str(p)] if p.is_dir(): files = sorted(str(x) for x in p.glob("*.h5")) files += sorted(str(x) for x in p.glob("*.hdf5")) return files files = sorted(glob.glob(h5_input)) if files: return files raise FileNotFoundError(f"No HDF5 files found from input: {h5_input}") def make_sample_key_from_index_item(item): """Build a stable sample key from index metadata only.""" channels = item.get("channels", []) if not channels and item.get("channel", ""): channels = [item.get("channel", "")] channels = ",".join(str(x) for x in channels) return "|".join([ str(item.get("h5_file", "")), str(item.get("year_id", "")), str(item.get("day_id", "")), str(item.get("station_id", "")), str(item.get("channel_family", item.get("channel", ""))), channels, ]) def make_sample_key_from_record(record): """Build the same sample key from one output JSONL record. Must produce a key identical to make_sample_key_from_index_item so that the resume scanner can match written records back to index entries. Two known pitfalls: 1. station_id: the pick record stores it inside station_info (and now also at the top level after the station_id fix). We try both places. 2. Z-only replicated channels: _getitem_three stores ["EHZ","EHZ","EHZ"] in channels_out when replicate_z_only=True, but the index entry stores the raw ["EHZ"] list. Deduplicate before joining to match the index key. """ channels = record.get("channels") or [] # handle None / missing # Deduplicate for Z-only replicated samples so the key matches the index # entry, which was built from the raw (non-replicated) channel list. if record.get("z_only_replicated", False): seen: set = set() channels = [ch for ch in channels if not (ch in seen or seen.add(ch))] channels = ",".join(str(x) for x in channels) station_info = record.get("station_info", {}) or {} station_id = station_info.get("station_id", record.get("station_id", "")) return "|".join([ str(record.get("h5_file", "")), str(record.get("year_id", "")), str(record.get("day_id", "")), str(station_id), str(record.get("channel_family", record.get("channel", ""))), channels, ]) def _parse_jsonl_chunk(path, start_byte, end_byte, record_type): """Parse one byte-range chunk of a JSONL file and return finished sample keys. Called from load_finished_sample_keys via ThreadPoolExecutor. Python's built-in json.loads (C extension) releases the GIL during parsing, so multiple threads genuinely run in parallel for large files. Both ``phase_pick`` and ``error`` records are treated as "finished" so that samples which errored on a previous run are skipped on resume rather than retried indefinitely. Error records store the pre-built key in the ``sample_key`` field; phase_pick records reconstruct the key from individual fields via make_sample_key_from_record. """ keys = set() total = 0 bad = 0 with open(path, "rb") as f: f.seek(start_byte) if start_byte > 0: f.readline() # discard partial line at chunk boundary while f.tell() < end_byte: raw = f.readline() if not raw: break line = raw.decode("utf-8", errors="ignore").strip() if not line: continue total += 1 try: record = json.loads(line) except Exception: bad += 1 continue rt = record.get("record_type", "") # Accept phase_pick records (primary output), error records # (inference failures), and no_pick records (successful runs # with zero detections above min_confidence). All three mean # the station-day was fully processed and should be skipped on # resume. error and no_pick records carry a pre-built # sample_key field; phase_pick records are reconstructed below. if rt in ("error", "no_pick"): key = record.get("sample_key", "") if key and key.strip("|"): keys.add(key) continue if record_type and rt != record_type: continue try: key = make_sample_key_from_record(record) if key.strip("|"): keys.add(key) except Exception: bad += 1 continue return keys, total, bad def load_finished_sample_keys(jsonl_file, record_type="phase_pick", num_threads=4): """Return (finished_keys_set, total_lines, bad_lines) for resume filtering. The JSONL file is split into ``num_threads`` byte-range chunks and parsed concurrently via ThreadPoolExecutor. Python's json.loads (C extension) releases the GIL during parsing, so multiple threads genuinely overlap. Sample keys are reconstructed directly from JSONL record fields (h5_file, year_id, day_id, station_id, channel_family, channels) — no companion index file is needed. """ jsonl_file = Path(jsonl_file) finished = set() if not jsonl_file.exists(): return finished, 0, 0 file_size = jsonl_file.stat().st_size if file_size == 0: return finished, 0, 0 # Don't spin up more threads than make sense for small files. n = max(1, min(num_threads, file_size // (256 * 1024))) chunk_size = file_size // n chunks = [ (i * chunk_size, (i + 1) * chunk_size if i < n - 1 else file_size) for i in range(n) ] def _parse(args): return _parse_jsonl_chunk(str(jsonl_file), args[0], args[1], record_type) if n == 1: results = [_parse(chunks[0])] else: with ThreadPoolExecutor(max_workers=n) as pool: results = list(pool.map(_parse, chunks)) total_lines = 0 bad_lines = 0 for keys, count, bad in results: finished.update(keys) total_lines += count bad_lines += bad return finished, total_lines, bad_lines def fill_segments_to_array( segments, fill_value=0.0, dtype=np.float32, use_overlap_mask=True, return_validity_mask=False, max_duration_sec=90000.0, ): if len(segments) == 0: empty = (None, None, None, None) return empty + (None,) if return_validity_mask else empty segments = sorted(segments, key=lambda x: x["starttime"]) sampling_rate = float(segments[0]["sampling_rate"]) global_start = min(s["starttime"] for s in segments) global_end = max(s["endtime"] for s in segments) duration_sec = float(global_end - global_start) npts = int(round(duration_sec * sampling_rate)) + 1 if (not np.isfinite(sampling_rate)) or sampling_rate <= 0: raise ValueError(f"Invalid sampling_rate={sampling_rate}") if npts <= 0: raise ValueError( f"Invalid npts={npts}, start={global_start}, end={global_end}, sr={sampling_rate}" ) if max_duration_sec and max_duration_sec > 0 and duration_sec > float(max_duration_sec): raise ValueError( f"Abnormal segment time span: duration={duration_sec:.3f}s, " f"npts={npts}, sr={sampling_rate}, start={global_start}, end={global_end}" ) 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) seg_valid = np.isfinite(seg_data) if not np.all(seg_valid): seg_data = np.where(seg_valid, seg_data, fill_value).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:] seg_valid = seg_valid[-i0:] i0 = 0 if i1 > npts: seg_data = seg_data[: npts - i0] seg_valid = seg_valid[: npts - i0] i1 = npts if i0 >= i1: continue target = slice(i0, i1) seg_data = seg_data[: i1 - i0] seg_valid = seg_valid[: i1 - i0] if use_overlap_mask: mask = (~filled[target]) & seg_valid data_view = data[target] data_view[mask] = seg_data[mask] filled[target][mask] = True else: data_view = data[target] data_view[seg_valid] = seg_data[seg_valid] filled[target][seg_valid] = True result = (data, global_start, global_end, sampling_rate) return result + (filled,) if return_validity_mask else result def resample_1d_array(x, original_sr, target_sr=None, dtype=np.float32): """ 线性插值重采样，不依赖 scipy。 x: [T] original_sr: 原始采样率 target_sr: 目标采样率；None 表示不重采样 """ if x is None: return x, original_sr x = np.asarray(x, dtype=dtype) if target_sr is None: return x, float(original_sr) original_sr = float(original_sr) target_sr = float(target_sr) if not np.isfinite(original_sr) or original_sr <= 0: return x, original_sr if abs(original_sr - target_sr) < 1e-6: return x, original_sr if len(x) <= 1: return x.astype(dtype, copy=False), target_sr duration = (len(x) - 1) / original_sr new_npts = int(round(duration * target_sr)) + 1 old_t = np.arange(len(x), dtype=np.float64) / original_sr new_t = np.arange(new_npts, dtype=np.float64) / target_sr if resample_poly is not None: ratio = Fraction(target_sr / original_sr).limit_denominator(1000) y = resample_poly(x, ratio.numerator, ratio.denominator).astype(dtype) if len(y) < new_npts: y = np.pad(y, (0, new_npts - len(y)), mode="edge") y = y[:new_npts] else: warnings.warn( "scipy is unavailable; falling back to linear interpolation without " "an anti-aliasing filter", RuntimeWarning, stacklevel=2, ) y = np.interp(new_t, old_t, x).astype(dtype) return y, target_sr def resample_validity_mask(mask, original_sr, target_sr=None): """Resample a validity mask conservatively to match waveform samples.""" mask = np.asarray(mask, dtype=bool) if mask.size <= 1: return mask if target_sr is None or abs(float(original_sr) - float(target_sr)) < 1e-6: return mask duration = (len(mask) - 1) / float(original_sr) new_npts = int(round(duration * float(target_sr))) + 1 old_t = np.arange(len(mask), dtype=np.float64) / float(original_sr) new_t = np.arange(new_npts, dtype=np.float64) / float(target_sr) # A resampled point is valid only when the surrounding original samples are # valid; this prevents interpolation across a missing-data interval. return np.interp(new_t, old_t, mask.astype(np.float32)) >= 1.0 - 1e-6 def resample_2d_array(x, original_sr, target_sr=None, dtype=np.float32): """ x: [T, C] """ x = np.asarray(x, dtype=dtype) if target_sr is None: return x, float(original_sr) if x.ndim != 2: raise ValueError(f"Expected 2D array [T, C], got shape={x.shape}") ys = [] current_sr = original_sr for i in range(x.shape[1]): y, current_sr = resample_1d_array( x[:, i], original_sr=original_sr, target_sr=target_sr, dtype=dtype, ) ys.append(y) min_len = min(len(y) for y in ys) ys = [y[:min_len] for y in ys] return np.stack(ys, axis=1).astype(dtype), current_sr def utc_or_none(value): if value is None: return None value = decode_attr(value) value = "" if value is None else str(value).strip() if not value or value.lower() in {"none", "null", "nan"}: return None try: return UTCDateTime(value) except Exception: return None def finite_float_or_none(value): try: value = float(value) except Exception: return None if not np.isfinite(value): return None return value def finite_float(value, default=0.0): out = finite_float_or_none(value) return float(default) if out is None else float(out) def int_or_none(value): try: return int(value) except Exception: return None def complex_list_from_json(items): out = [] for item in items or []: if isinstance(item, dict): out.append(complex(float(item.get("real", 0.0)), float(item.get("imag", 0.0)))) elif isinstance(item, (list, tuple)) and len(item) >= 2: out.append(complex(float(item[0]), float(item[1]))) else: out.append(complex(item)) return out def _stage_common_kwargs(stage): return { "stage_sequence_number": int(stage.get("stage_sequence_number", 0)), "stage_gain": finite_float(stage.get("stage_gain", 1.0), 1.0), "stage_gain_frequency": finite_float(stage.get("stage_gain_frequency", 0.0), 0.0), "input_units": stage.get("input_units") or "", "output_units": stage.get("output_units") or "", "input_units_description": stage.get("input_units_description"), "output_units_description": stage.get("output_units_description"), "decimation_input_sample_rate": finite_float_or_none( stage.get("decimation_input_sample_rate") ), "decimation_factor": int_or_none(stage.get("decimation_factor")), "decimation_offset": int_or_none(stage.get("decimation_offset")), "decimation_delay": finite_float_or_none(stage.get("decimation_delay")), "decimation_correction": finite_float_or_none(stage.get("decimation_correction")), } def response_stage_from_json(stage): stage_type = stage.get("type", "ResponseStage") common = _stage_common_kwargs(stage) if stage_type == "PolesZerosResponseStage": return PolesZerosResponseStage( **common, pz_transfer_function_type=stage.get( "pz_transfer_function_type", "LAPLACE (RADIANS/SECOND)", ), normalization_frequency=finite_float( stage.get("normalization_frequency", common["stage_gain_frequency"]), common["stage_gain_frequency"], ), normalization_factor=finite_float(stage.get("normalization_factor", 1.0), 1.0), zeros=complex_list_from_json(stage.get("zeros", [])), poles=complex_list_from_json(stage.get("poles", [])), ) if stage_type == "CoefficientsTypeResponseStage": return CoefficientsTypeResponseStage( **common, cf_transfer_function_type=stage.get("cf_transfer_function_type", "DIGITAL"), numerator=list(stage.get("numerator", stage.get("numerators", [])) or []), denominator=list(stage.get("denominator", stage.get("denominators", [])) or []), ) if stage_type == "FIRResponseStage": return FIRResponseStage( **common, symmetry=stage.get("symmetry", "NONE"), coefficients=list(stage.get("coefficients", []) or []), ) if stage_type == "PolynomialResponseStage": return PolynomialResponseStage( **common, frequency_lower_bound=finite_float(stage.get("frequency_lower_bound", 0.0), 0.0), frequency_upper_bound=finite_float(stage.get("frequency_upper_bound", 0.0), 0.0), approximation_lower_bound=finite_float( stage.get("approximation_lower_bound", 0.0), 0.0, ), approximation_upper_bound=finite_float( stage.get("approximation_upper_bound", 0.0), 0.0, ), maximum_error=finite_float(stage.get("maximum_error", 0.0), 0.0), coefficients=list(stage.get("coefficients", []) or []), approximation_type=stage.get("approximation_type", "MACLAURIN"), ) return ResponseStage(**common) def response_from_json_record(record): sensitivity = None sens = record.get("instrument_sensitivity") or {} if sens: sensitivity = InstrumentSensitivity( value=finite_float(sens.get("value", 1.0), 1.0), frequency=finite_float(sens.get("frequency", 0.0), 0.0), input_units=sens.get("input_units") or "", output_units=sens.get("output_units") or "", input_units_description=sens.get("input_units_description"), output_units_description=sens.get("output_units_description"), ) stages = [response_stage_from_json(stage) for stage in record.get("stages", []) or []] return Response( resource_id=record.get("response_id"), instrument_sensitivity=sensitivity, response_stages=stages, ) def inventory_from_response_record(record, response): start_date = utc_or_none(record.get("epoch_start")) end_date = utc_or_none(record.get("epoch_end")) latitude = finite_float(record.get("latitude", 0.0), 0.0) longitude = finite_float(record.get("longitude", 0.0), 0.0) elevation = finite_float(record.get("elevation_m", 0.0), 0.0) channel = Channel( code=str(record.get("channel", "")), location_code=normalize_location(record.get("location", DEFAULT_LOCATION), DEFAULT_LOCATION), latitude=latitude, longitude=longitude, elevation=elevation, depth=finite_float(record.get("depth_m", 0.0), 0.0), azimuth=finite_float_or_none(record.get("azimuth")), dip=finite_float_or_none(record.get("dip")), sample_rate=finite_float_or_none(record.get("sample_rate")), start_date=start_date, end_date=end_date, response=response, ) station = Station( code=str(record.get("station", "")), latitude=latitude, longitude=longitude, elevation=elevation, site=Site(name=str(record.get("station", ""))), channels=[channel], start_date=start_date, end_date=end_date, ) network = Network(code=str(record.get("network", "")), stations=[station]) return Inventory(networks=[network], source="SeismicX-Cont response JSON") def load_response_json(path): path = Path(path) with path.open("r", encoding="utf-8") as f: obj = json.load(f) by_key = {} by_id = {} responses = obj.get("responses", []) for record in responses: key = ( str(record.get("network", "")), str(record.get("station", "")), normalize_location(record.get("location", DEFAULT_LOCATION), DEFAULT_LOCATION), str(record.get("channel", "")), ) by_key.setdefault(key, []).append(record) response_id = record.get("response_id") if response_id: by_id[str(response_id)] = record for records in by_key.values(): records.sort(key=lambda item: str(item.get("epoch_start", ""))) return { "path": str(path), "schema": obj.get("schema", ""), "source": obj.get("source", {}), "summary": obj.get("summary", {}), "responses_by_key": by_key, "responses_by_id": by_id, "response_count": len(responses), } def response_record_matches_time(record, starttime, endtime=None): epoch_start = utc_or_none(record.get("epoch_start")) epoch_end = utc_or_none(record.get("epoch_end")) if starttime is None: return True if epoch_start is not None and starttime < epoch_start: return False if epoch_end is not None and starttime > epoch_end: return False return True def next_pow_2(n): n = int(n) if n <= 1: return 1 return 1 << (n - 1).bit_length() def apply_response_spectrum(data, sampling_rate, response, output="VEL"): data = np.asarray(data, dtype=np.float64) npts = int(data.shape[0]) if npts <= 1: return data nfft = next_pow_2(npts) delta = 1.0 / float(sampling_rate) spectrum = np.fft.rfft(data, n=nfft) resp, _freq = response.get_evalresp_response( t_samp=delta, nfft=nfft, output=output, ) spectrum *= resp return np.fft.irfft(spectrum, n=nfft)[:npts] 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): """ HDF5 连续波形 dataloader。 默认行为： 1. mode="three" 2. 默认保留 HH/BH/EH/HN 三分量 3. 默认保留 EHZ 单通道 4. 默认将单通道 Z 复制为 [Z, Z, Z] 5. 可选重采样到 target_sampling_rate mode: single: 每个 channel 一个样本，返回 waveform: [T] three: 每个通道族一个样本，返回 waveform: [T, 3] 分量顺序为 E/N/Z 或 1/2/3 multi: 每个通道族一个样本，返回 waveform: [T, C] """ def __init__( self, h5_file, mode="three", fill_value=0.0, dtype=np.float32, default_location=DEFAULT_LOCATION, allowed_families=("HH", "BH", "EH", "HN"), allowed_z_only_channels=("EHZ",), allow_z_only=True, replicate_z_only=False, target_sampling_rate=None, skip_sample_keys=None, skip_jsonl=None, skip_record_type="phase_pick", keep_h5_open=True, include_segments_metadata=True, use_overlap_mask=True, h5_rdcc_nbytes=8 * 1024 * 1024, max_duration_sec=90000.0, instrument_response_json=None, remove_instrument_response=False, response_output="VEL", response_pre_filt=None, response_water_level=60, response_zero_mean=True, response_taper=True, response_taper_fraction=0.05, response_error_behavior="raise", simulate_instrument_response=False, simulation_response_json=None, simulation_response_id=None, simulation_response_selector=None, simulation_paz=None, simulation_output=None, simulation_sensitivity=True, ): assert mode in ["single", "three", "multi"] assert response_error_behavior in ["raise", "warn", "skip"] self.h5_files = resolve_h5_files(h5_file) self.mode = mode self.fill_value = fill_value self.dtype = dtype self.default_location = default_location self.allowed_families = tuple(x.upper() for x in allowed_families) self.allowed_z_only_channels = tuple(x.upper() for x in allowed_z_only_channels) self.allow_z_only = bool(allow_z_only) self.replicate_z_only = bool(replicate_z_only) self.target_sampling_rate = target_sampling_rate self.keep_h5_open = bool(keep_h5_open) self.include_segments_metadata = bool(include_segments_metadata) self.use_overlap_mask = bool(use_overlap_mask) # HDF5 raw-data chunk cache per open file handle. h5py default is 1 MB. # 8 MB is a good balance for single-pass inference: large enough to avoid # re-reading chunks within one channel, small enough not to waste RAM. # (Training / repeated-access workloads can benefit from a larger value.) self.h5_rdcc_nbytes = max(0, int(h5_rdcc_nbytes)) # Hard safety limit for one consolidated channel waveform. # Default 90000 s = 25 h, enough for one UTC day with small tolerance. self.max_duration_sec = float(max_duration_sec) if max_duration_sec is not None else 0.0 self.instrument_response_json = ( str(instrument_response_json) if instrument_response_json is not None else None ) self.remove_instrument_response = bool(remove_instrument_response) self.response_output = str(response_output).upper() if response_output is not None else "VEL" self.response_pre_filt = ( tuple(float(x) for x in response_pre_filt) if response_pre_filt is not None else None ) self.response_water_level = response_water_level self.response_zero_mean = bool(response_zero_mean) self.response_taper = bool(response_taper) self.response_taper_fraction = float(response_taper_fraction) self.response_error_behavior = response_error_behavior self.simulate_instrument_response = bool(simulate_instrument_response) self.simulation_response_json = ( str(simulation_response_json) if simulation_response_json is not None else None ) self.simulation_response_id = ( str(simulation_response_id) if simulation_response_id is not None else None ) self.simulation_response_selector = dict(simulation_response_selector or {}) self.simulation_paz = simulation_paz self.simulation_output = ( str(simulation_output).upper() if simulation_output is not None else self.response_output ) self.simulation_sensitivity = bool(simulation_sensitivity) if self.remove_instrument_response and self.instrument_response_json is None: raise ValueError( "instrument_response_json is required when remove_instrument_response is enabled." ) if self.simulate_instrument_response and ( self.simulation_paz is None and self.simulation_response_id is None and not self.simulation_response_selector and self.simulation_response_json is None ): raise ValueError( "simulate_instrument_response=True requires simulation_paz, " "simulation_response_id, simulation_response_selector, or " "simulation_response_json." ) if self.simulate_instrument_response and ( self.simulation_response_json is None and self.simulation_paz is None and self.instrument_response_json is None ): raise ValueError( "simulation_response_json is required when simulation selects a " "response record and instrument_response_json is not set." ) # Per-process HDF5 handle cache. DataLoader workers get their own cache. self._h5_cache = {} self._response_store = None self._simulation_response_store = None self._response_object_cache = {} self._inventory_cache = {} self._simulation_response_record = None self._simulation_response_object = None self.index = [] self._build_index() # Resume filtering happens on metadata-only index entries. Removed samples # will never enter __getitem__, so their waveform data are not read. self.finished_sample_keys = set(skip_sample_keys or []) self.skip_jsonl_stats = None if skip_jsonl is not None: keys, total_lines, bad_lines = load_finished_sample_keys( skip_jsonl, record_type=skip_record_type, ) self.finished_sample_keys.update(keys) self.skip_jsonl_stats = { "jsonl_file": str(skip_jsonl), "total_lines": total_lines, "bad_lines": bad_lines, "finished_keys": len(keys), } self.original_index_size = len(self.index) self.filtered_index_size = 0 if self.finished_sample_keys: self.filter_index_by_finished_keys(self.finished_sample_keys) def __getstate__(self): """Do not pickle open h5py handles into DataLoader workers.""" state = self.__dict__.copy() state["_h5_cache"] = {} state["_response_store"] = None state["_simulation_response_store"] = None state["_response_object_cache"] = {} state["_inventory_cache"] = {} state["_simulation_response_record"] = None state["_simulation_response_object"] = None return state def __setstate__(self, state): """Restore state in a worker process with a fresh, empty handle cache. Called by pickle when DataLoader workers deserialize the dataset. Ensures _h5_cache is always empty in the new process regardless of start method (spawn, forkserver, or fork), so each worker opens its own HDF5 handles lazily on the first __getitem__ call. """ self.__dict__.update(state) self._h5_cache = {} # always start clean in every process self._response_object_cache = {} self._inventory_cache = {} def close(self): """Close all cached HDF5 handles and free their chunk + metadata caches.""" cache = getattr(self, "_h5_cache", {}) for h5 in list(cache.values()): try: h5.close() except Exception: pass cache.clear() def flush_h5_cache(self): """Close the current HDF5 handle and clear _h5_cache. Call this periodically (e.g. every N samples) to flush the per-file HDF5 metadata cache that the C library accumulates as it visits dataset groups. The handle is reopened lazily on the next __getitem__ call, so this is safe to call at any time between samples. """ self.close() def __del__(self): try: self.close() except Exception: pass def _get_h5_handle(self, h5_file): rdcc = getattr(self, "h5_rdcc_nbytes", 8 * 1024 * 1024) if not self.keep_h5_open: return h5py.File(h5_file, "r", rdcc_nbytes=rdcc) if not hasattr(self, "_h5_cache"): self._h5_cache = {} h5 = self._h5_cache.get(h5_file) if h5 is None: # Inference is a single pass over sorted files: when a new file is # requested the previous file will not be accessed again. Close all # stale handles immediately so their HDF5 chunk caches (rdcc_nbytes # each) are released rather than accumulating for the life of the # process. Keeping only the current file's handle preserves the # within-file I/O benefit while bounding cache memory to O(1) files. for _f, _h in list(self._h5_cache.items()): if _f != h5_file: try: _h.close() except Exception: pass self._h5_cache.pop(_f, None) h5 = h5py.File(h5_file, "r", rdcc_nbytes=rdcc) self._h5_cache[h5_file] = h5 return h5 def sample_key(self, idx_or_item): if isinstance(idx_or_item, int): item = self.index[idx_or_item] else: item = idx_or_item return make_sample_key_from_index_item(item) def filter_index_by_finished_keys(self, finished_keys): """Remove finished samples from self.index before waveform reading.""" finished_keys = set(finished_keys or []) if not finished_keys: return 0 old_n = len(self.index) self.index = [ item for item in self.index if make_sample_key_from_index_item(item) not in finished_keys ] removed = old_n - len(self.index) self.filtered_index_size += removed return removed def filter_index_by_jsonl(self, jsonl_file, record_type="phase_pick"): keys, total_lines, bad_lines = load_finished_sample_keys( jsonl_file, record_type=record_type, ) removed = self.filter_index_by_finished_keys(keys) self.skip_jsonl_stats = { "jsonl_file": str(jsonl_file), "total_lines": total_lines, "bad_lines": bad_lines, "finished_keys": len(keys), "removed_from_index": removed, } return removed, keys, total_lines, bad_lines def _ensure_response_store(self): if self._response_store is None: if self.instrument_response_json is None: raise ValueError("instrument_response_json is not configured") self._response_store = load_response_json(self.instrument_response_json) return self._response_store def _ensure_simulation_response_store(self): if self._simulation_response_store is None: path = self.simulation_response_json or self.instrument_response_json if path is None: raise ValueError("No simulation response JSON is configured") self._simulation_response_store = load_response_json(path) return self._simulation_response_store def _get_response_object(self, record): response_id = str(record.get("response_id", "")) cache_key = response_id or id(record) if cache_key not in self._response_object_cache: self._response_object_cache[cache_key] = response_from_json_record(record) return self._response_object_cache[cache_key] def _get_inventory(self, record): response_id = str(record.get("response_id", "")) cache_key = response_id or id(record) if cache_key not in self._inventory_cache: response = self._get_response_object(record) self._inventory_cache[cache_key] = inventory_from_response_record(record, response) return self._inventory_cache[cache_key] def _find_response_record(self, network, station, location, channel, starttime, endtime=None): store = self._ensure_response_store() key = ( str(network), str(station), normalize_location(location, self.default_location), str(channel), ) candidates = store["responses_by_key"].get(key, []) for record in candidates: if response_record_matches_time(record, starttime, endtime): return record return None def _select_simulation_response_record(self): if self._simulation_response_record is not None: return self._simulation_response_record store = self._ensure_simulation_response_store() record = None if self.simulation_response_id: record = store["responses_by_id"].get(self.simulation_response_id) if record is None: raise KeyError( f"simulation_response_id not found: {self.simulation_response_id}" ) elif self.simulation_response_selector: sel = self.simulation_response_selector key = ( str(sel.get("network", "")), str(sel.get("station", "")), normalize_location(sel.get("location", self.default_location), self.default_location), str(sel.get("channel", "")), ) starttime = utc_or_none(sel.get("time")) or utc_or_none(sel.get("starttime")) candidates = store["responses_by_key"].get(key, []) for item in candidates: if response_record_matches_time(item, starttime): record = item break if record is None: raise KeyError(f"simulation_response_selector did not match any response: {sel}") else: records_by_id = store["responses_by_id"] if len(records_by_id) != 1: raise ValueError( "simulation_response_json must contain exactly one response unless " "simulation_response_id or simulation_response_selector is provided." ) record = next(iter(records_by_id.values())) self._simulation_response_record = record self._simulation_response_object = self._get_response_object(record) return record def _handle_response_error(self, message): if self.response_error_behavior == "raise": raise RuntimeError(message) if self.response_error_behavior == "warn": warnings.warn(message, RuntimeWarning, stacklevel=2) return None def _apply_instrument_processing( self, waveform, segments, channel, starttime, endtime, sampling_rate, ): metadata = { "remove_instrument_response": self.remove_instrument_response, "simulate_instrument_response": self.simulate_instrument_response, "response_output": self.response_output, "simulation_output": self.simulation_output, "response_id": "", "response_epoch_start": "", "response_epoch_end": "", "simulation_response_id": "", "error": "", "processed": False, } if waveform is None or len(waveform) == 0: return waveform, metadata if not self.remove_instrument_response and not self.simulate_instrument_response: return waveform, metadata first_segment = segments[0] if segments else {} network = first_segment.get("network", "") station = first_segment.get("station", "") location = first_segment.get("location", self.default_location) channel = first_segment.get("channel", channel) try: trace = Trace( data=np.asarray(waveform, dtype=np.float64), header={ "network": str(network), "station": str(station), "location": normalize_location(location, self.default_location), "channel": str(channel), "starttime": starttime, "sampling_rate": float(sampling_rate), }, ) if self.remove_instrument_response: record = self._find_response_record( network, station, location, channel, starttime, endtime=endtime, ) if record is None: key = ".".join([ str(network), str(station), normalize_location(location, self.default_location), str(channel), ]) raise KeyError(f"No response found for {key} at {starttime}") metadata.update( { "response_id": record.get("response_id", ""), "response_epoch_start": record.get("epoch_start", ""), "response_epoch_end": record.get("epoch_end", ""), } ) trace.remove_response( inventory=self._get_inventory(record), output=self.response_output, water_level=self.response_water_level, pre_filt=self.response_pre_filt, zero_mean=self.response_zero_mean, taper=self.response_taper, taper_fraction=self.response_taper_fraction, ) if self.simulate_instrument_response: if self.simulation_paz is not None: trace.simulate( paz_remove=None, paz_simulate=self.simulation_paz, remove_sensitivity=False, simulate_sensitivity=self.simulation_sensitivity, ) metadata["simulation_response_id"] = "simulation_paz" else: sim_record = self._select_simulation_response_record() sim_response = self._simulation_response_object trace.data = apply_response_spectrum( trace.data, sampling_rate=trace.stats.sampling_rate, response=sim_response, output=self.simulation_output, ) metadata["simulation_response_id"] = sim_record.get("response_id", "") metadata["processed"] = True return np.asarray(trace.data, dtype=self.dtype), metadata except Exception as exc: metadata["error"] = str(exc) self._handle_response_error(str(exc)) return np.asarray(waveform, dtype=self.dtype), metadata def _is_allowed_channel(self, channel): ch = str(channel).upper() prefix = channel_prefix(ch) if prefix in self.allowed_families: return True if self.allow_z_only and ch in self.allowed_z_only_channels: return True return False def _is_allowed_family_sample(self, prefix, family_channels): prefix = str(prefix).upper() family_channels = [str(x).upper() for x in family_channels] if prefix not in self.allowed_families: if not any(ch in self.allowed_z_only_channels for ch in family_channels): return False if self.mode == "multi": return True if has_three_components(family_channels): return True if self.allow_z_only: z_only = [ ch for ch in family_channels if ch in self.allowed_z_only_channels ] return len(z_only) > 0 return False def _build_index(self): for h5_file in self.h5_files: with h5py.File(h5_file, "r") as h5: for year_id in sorted(h5.keys()): year_grp = h5[year_id] if not isinstance(year_grp, h5py.Group): continue for day_id in sorted(year_grp.keys()): day_grp = year_grp[day_id] if not isinstance(day_grp, h5py.Group): continue 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( ch for ch in waveform_grp.keys() if self._is_allowed_channel(ch) ) if len(channels) == 0: continue if self.mode == "single": for cha in channels: self.index.append( { "h5_file": h5_file, "year_id": year_id, "day_id": day_id, "station_id": station_id, "channel": cha, } ) continue 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 not self._is_allowed_family_sample(prefix, family_channels): continue self.index.append( { "h5_file": h5_file, "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] h5_file = item["h5_file"] h5 = self._get_h5_handle(h5_file) should_close = not self.keep_h5_open try: 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}") finally: if should_close: try: h5.close() except Exception: pass 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, original_sr, validity_mask = fill_segments_to_array( segments, fill_value=self.fill_value, dtype=self.dtype, use_overlap_mask=self.use_overlap_mask, return_validity_mask=True, max_duration_sec=self.max_duration_sec, ) # Free raw HDF5 data arrays immediately after consolidation. # For day-long waveforms each segment["data"] can be tens of MB; # holding them until function return causes unbounded RSS growth. for _seg in segments: _seg.pop("data", None) if waveform is None: waveform = np.zeros(0, dtype=self.dtype) validity_mask = np.zeros(0, dtype=bool) waveform, instrument_processing = self._apply_instrument_processing( waveform, segments=segments, channel=channel, starttime=starttime, endtime=endtime, sampling_rate=original_sr, ) waveform, current_sr = resample_1d_array( waveform, original_sr=original_sr, target_sr=self.target_sampling_rate, dtype=self.dtype, ) validity_mask = resample_validity_mask( validity_mask, original_sr=original_sr, target_sr=self.target_sampling_rate ) position_info = get_position_from_segments(segments) station_info = dict(station_info) station_info.update(position_info) return { "mode": "single", "h5_file": item["h5_file"], "year_id": year_id, "day_id": day_id, "station_id": station_id, "station_info": station_info, "channel_info": channel_info, "channel": channel, "channels": [channel], "instrument_processing": instrument_processing, "waveform": torch.from_numpy(waveform), "validity_mask": torch.from_numpy(validity_mask), "component_mask": torch.tensor([True], dtype=torch.bool), "segments": ( [ {k: v for k, v in seg.items() if k != "data"} for seg in segments ] if self.include_segments_metadata else [] ), "starttime": str(starttime) if starttime is not None else "", "endtime": str(endtime) if endtime is not None else "", "original_sampling_rate": original_sr, "sampling_rate": current_sr, "target_sampling_rate": self.target_sampling_rate, "resampled": ( self.target_sampling_rate is not None and np.isfinite(original_sr) and abs(float(original_sr) - float(self.target_sampling_rate)) > 1e-6 ), "npts_original_estimated": int(round((endtime - starttime) * original_sr)) + 1 if starttime is not None and endtime is not None and np.isfinite(original_sr) else 0, "npts": waveform.shape[0], } def _select_three_channels(self, candidate_channels): candidate_channels = sorted(candidate_channels, key=component_rank) 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 is_z_only = False z_only_replicated = False if not has_three_components(candidate_channels): z_candidates = [ ch for ch in candidate_channels if str(ch).upper() in self.allowed_z_only_channels ] if len(z_candidates) > 0: zch = z_candidates[0] selected = {2: zch} is_z_only = True if self.replicate_z_only: selected = {0: zch, 1: zch, 2: zch} z_only_replicated = True return selected, is_z_only, z_only_replicated 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, is_z_only, z_only_replicated = self._select_three_channels( candidate_channels ) arrays = {} starts = [] ends = [] srs = [] all_segments = [] channel_infos = {} instrument_processing = {} unique_channels = sorted(set(selected.values())) channel_arrays = {} channel_validity = {} 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, arr_validity = fill_segments_to_array( segments, fill_value=self.fill_value, dtype=self.dtype, use_overlap_mask=self.use_overlap_mask, return_validity_mask=True, max_duration_sec=self.max_duration_sec, ) # Free raw HDF5 data arrays immediately after consolidation. # all_segments holds the same dict objects, so popping here # also clears the data refs from all_segments — no deep copy needed. for _seg in segments: _seg.pop("data", None) if arr is None: continue arr, instrument_processing[cha] = self._apply_instrument_processing( arr, segments=segments, channel=cha, starttime=st, endtime=et, sampling_rate=sr, ) channel_arrays[cha] = arr channel_validity[cha] = arr_validity 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] selected_component_mask = [index in arrays for index in range(3)] observed_component_mask = [ any(channel_suffix(ch) in {"E", "1"} for ch in candidate_channels), any(channel_suffix(ch) in {"N", "2"} for ch in candidate_channels), any(channel_suffix(ch) in {"Z", "3"} for ch in candidate_channels), ] _arrays_empty = len(arrays) == 0 if _arrays_empty: waveform = np.zeros((0, 3), dtype=self.dtype) validity_mask = np.zeros((0, 3), dtype=bool) starttime = None endtime = None original_sr = np.nan else: original_sr = float(srs[0]) starttime = min(starts) endtime = max(ends) # Align components by absolute start time. The previous version # blindly wrote each channel from index 0, which silently misaligned # E/N/Z if their first segment start times differed. channel_starts = {} for cha, arr in channel_arrays.items(): # Find the start time recorded for this channel by matching the # selected channel and using the minimum segment start. cha_starts = [ seg["starttime"] for seg in all_segments if str(seg.get("channel", "")) == str(cha) ] if cha_starts: channel_starts[cha] = min(cha_starts) else: channel_starts[cha] = starttime if is_z_only and not self.replicate_z_only: comp_count = 1 max_end_index = 0 for comp_idx, arr in arrays.items(): cha = selected.get(comp_idx, "") offset = int(round((channel_starts.get(cha, starttime) - starttime) * original_sr)) max_end_index = max(max_end_index, max(0, offset) + len(arr)) waveform = np.full((max_end_index, comp_count), self.fill_value, dtype=self.dtype) validity_mask = np.zeros((max_end_index, comp_count), dtype=bool) if 2 in arrays: cha = selected.get(2, "") offset = int(round((channel_starts.get(cha, starttime) - starttime) * original_sr)) offset = max(0, offset) waveform[offset: offset + len(arrays[2]), 0] = arrays[2] validity_mask[offset: offset + len(arrays[2]), 0] = channel_validity[cha] else: comp_count = 3 max_end_index = 0 for comp_idx, arr in arrays.items(): cha = selected.get(comp_idx, "") offset = int(round((channel_starts.get(cha, starttime) - starttime) * original_sr)) max_end_index = max(max_end_index, max(0, offset) + len(arr)) waveform = np.full((max_end_index, comp_count), self.fill_value, dtype=self.dtype) validity_mask = np.zeros((max_end_index, comp_count), dtype=bool) for comp_idx, arr in arrays.items(): cha = selected.get(comp_idx, "") offset = int(round((channel_starts.get(cha, starttime) - starttime) * original_sr)) offset = max(0, offset) waveform[offset: offset + len(arr), comp_idx] = arr validity_mask[offset: offset + len(arr), comp_idx] = channel_validity[cha] waveform, current_sr = resample_2d_array( waveform, original_sr=original_sr, target_sr=self.target_sampling_rate, dtype=self.dtype, ) if self.target_sampling_rate is not None: masks = [ resample_validity_mask( validity_mask[:, i], original_sr=original_sr, target_sr=self.target_sampling_rate, ) for i in range(validity_mask.shape[1]) ] min_len = min(len(mask) for mask in masks) if masks else 0 validity_mask = np.stack( [mask[:min_len] for mask in masks], axis=1 ) if masks else np.zeros((0, 0), dtype=bool) waveform = waveform[: len(validity_mask)] # Release per-channel intermediate arrays now that waveform is built. del arrays, channel_arrays _arrays_empty = False if _arrays_empty: current_sr = np.nan position_info = get_position_from_segments(all_segments) station_info = dict(station_info) station_info.update(position_info) if is_z_only and not self.replicate_z_only: channels_out = [selected.get(2, "")] component_order = "Z only" else: channels_out = [ selected.get(0, ""), selected.get(1, ""), selected.get(2, ""), ] component_order = "E/N/Z or 1/2/3" return { "mode": "three", "h5_file": item["h5_file"], "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": component_order, "is_z_only": is_z_only, "z_only_replicated": z_only_replicated, "instrument_processing": instrument_processing, "waveform": torch.from_numpy(waveform), "validity_mask": torch.from_numpy(validity_mask), "component_mask": torch.tensor( [True] if is_z_only and not self.replicate_z_only else selected_component_mask, dtype=torch.bool, ), "observed_component_mask": torch.tensor(observed_component_mask, dtype=torch.bool), "segments": ( [ {k: v for k, v in seg.items() if k != "data"} for seg in all_segments ] if self.include_segments_metadata else [] ), "starttime": str(starttime) if starttime is not None else "", "endtime": str(endtime) if endtime is not None else "", "original_sampling_rate": original_sr, "sampling_rate": current_sr, "target_sampling_rate": self.target_sampling_rate, "resampled": ( self.target_sampling_rate is not None and np.isfinite(original_sr) and abs(float(original_sr) - float(self.target_sampling_rate)) > 1e-6 ), "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 = [] validity_arrays = [] used_channels = [] starts = [] ends = [] srs = [] all_segments = [] channel_infos = {} instrument_processing = {} 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, arr_validity = fill_segments_to_array( segments, fill_value=self.fill_value, dtype=self.dtype, use_overlap_mask=self.use_overlap_mask, return_validity_mask=True, max_duration_sec=self.max_duration_sec, ) # Free raw HDF5 data arrays immediately after consolidation. for _seg in segments: _seg.pop("data", None) if arr is None: continue arr, instrument_processing[cha] = self._apply_instrument_processing( arr, segments=segments, channel=cha, starttime=st, endtime=et, sampling_rate=sr, ) arrays.append(arr) validity_arrays.append(arr_validity) 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) validity_mask = np.zeros((0, 0), dtype=bool) starttime = None endtime = None original_sr = np.nan current_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, ) validity_mask = np.zeros((max_len, len(arrays)), dtype=bool) for i, arr in enumerate(arrays): waveform[: len(arr), i] = arr validity_mask[: len(arr), i] = validity_arrays[i] starttime = min(starts) endtime = max(ends) original_sr = float(srs[0]) waveform, current_sr = resample_2d_array( waveform, original_sr=original_sr, target_sr=self.target_sampling_rate, dtype=self.dtype, ) if self.target_sampling_rate is not None: masks = [ resample_validity_mask( validity_mask[:, i], original_sr=original_sr, target_sr=self.target_sampling_rate, ) for i in range(validity_mask.shape[1]) ] min_len = min(len(mask) for mask in masks) if masks else 0 validity_mask = np.stack( [mask[:min_len] for mask in masks], axis=1 ) if masks else np.zeros((0, 0), dtype=bool) waveform = waveform[: len(validity_mask)] # Release per-channel arrays now that waveform is built. del arrays position_info = get_position_from_segments(all_segments) station_info = dict(station_info) station_info.update(position_info) return { "mode": "multi", "h5_file": item["h5_file"], "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, "instrument_processing": instrument_processing, "waveform": torch.from_numpy(waveform), "validity_mask": torch.from_numpy(validity_mask), "component_mask": torch.ones(len(used_channels), dtype=torch.bool), "segments": ( [ {k: v for k, v in seg.items() if k != "data"} for seg in all_segments ] if self.include_segments_metadata else [] ), "starttime": str(starttime) if starttime is not None else "", "endtime": str(endtime) if endtime is not None else "", "original_sampling_rate": original_sr, "sampling_rate": current_sr, "target_sampling_rate": self.target_sampling_rate, "resampled": ( self.target_sampling_rate is not None and np.isfinite(original_sr) and abs(float(original_sr) - float(self.target_sampling_rate)) > 1e-6 ), "npts": waveform.shape[0], } def waveform_collate_fn(batch): return batch def hdf5_worker_init_fn(worker_id): """Worker initializer for DataLoader when using fork-based multiprocessing. With 'fork', child processes inherit the parent's open h5py file handles. Accessing inherited handles from multiple processes simultaneously causes HDF5 library errors or silent data corruption. This function walks all live objects and resets the handle cache of every HDF5WaveformDataset instance it finds, forcing each worker to open fresh, independent handles on its first __getitem__ call. Usage:: from torch.utils.data import DataLoader loader = DataLoader( dataset, num_workers=4, multiprocessing_context='fork', # only if you must use fork worker_init_fn=hdf5_worker_init_fn, ) Note: With 'spawn' or 'forkserver' (the recommended and default choice on Linux when num_workers > 0), this function is not needed because the worker process starts fresh and HDF5WaveformDataset.__setstate__ already ensures an empty _h5_cache. It is safe to pass it regardless. """ import gc as _gc for obj in _gc.get_objects(): if isinstance(obj, HDF5WaveformDataset): try: obj.close() except Exception: pass try: obj._h5_cache = {} except Exception: pass 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_input = "data/continuous_waveform_usa_20190701.h5" """ # 1. single file h5_input = "data/continuous_waveform_usa.h5" # 2. glob multiple files h5_input = "data/continuous_waveform_usa_*.h5" # 3. data directory h5_input = "data/" # 4. explicit file list h5_input = [ "data/continuous_waveform_usa_20190701.h5", "data/continuous_waveform_usa_20211108.h5", ] """ dataset = HDF5WaveformDataset( h5_file=h5_input, mode="three", # Default: keep commonly used seismic channel families allowed_families=("HH", "BH", "EH", "HN"), # Additionally allow single-component (Z only) samples such as EHZ allowed_z_only_channels=("EHZ",), allow_z_only=True, # Whether to replicate single Z component to three channels [Z, Z, Z] replicate_z_only=False, # Target sampling rate (Hz); None means no resampling # e.g., 100.0 → resample all waveforms to 100 Hz target_sampling_rate=100.0, 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("HDF5 files:", len(dataset.h5_files)) for f in dataset.h5_files: print(" ", f) print("Number of samples:", len(dataset)) for batch in loader: for item in batch: print("=" * 80) print("h5_file:", item["h5_file"]) print("station_id:", item["station_id"]) print("mode:", item["mode"]) print("channel_family:", item.get("channel_family", "")) print("channels:", item["channels"]) print("is_z_only:", item.get("is_z_only", False)) print("z_only_replicated:", item.get("z_only_replicated", False)) print("starttime:", item["starttime"]) print("endtime:", item["endtime"]) print("original_sampling_rate:", item["original_sampling_rate"]) print("sampling_rate:", item["sampling_rate"]) print("target_sampling_rate:", item["target_sampling_rate"]) print("resampled:", item["resampled"]) print("waveform shape:", tuple(item["waveform"].shape)) break