Python tool for aircraft Doppler audio geolocation using historical ADS-B flight data (Source-available)
Python acoustic-geolocationads-baircraft-trackingairplaneaudio-forensicsdoppler-effectdoppler-shiftgeolocationosintsignal-processing
Reuse exact refinement inputs and contiguous spectral reductions
Cinna Davisb98a0fa3e9dc
diff --git a/.github/workflows/real-performance.yml b/.github/workflows/real-performance.ymlindex 3a3d35d..a552267 100644--- a/.github/workflows/real-performance.yml+++ b/.github/workflows/real-performance.yml@@ -22,6 +22,9 @@ on:- scripts/export_real_acoustic_controls.py- scripts/benchmark_real_regional_upload.py- scripts/benchmark_real_bounded_upload.py+ - scripts/benchmark_real_bounded_comparison.py+ - scripts/benchmark_real_refinement.py+ - scripts/benchmark_real_discovery_normalization.py- scripts/prepare_reference_upload.py- scripts/restore_artifacts.py- scripts/compare_real_upload_performance.py@@ -31,6 +34,8 @@ on:- tests/data/real-ridge-batch-arithmetic.json- tests/data/reference-empty-tiles-real.json- tests/data/reference-retention-real.json+ - tests/data/real-refinement-profile.json+ - tests/fixtures/real_discovery_normalization.jsonpermissions:contents: readenv:@@ -110,7 +115,7 @@ jobs:DOPPLERGEIST_REAL_CPA_FIXTURE: benchmark-inputs/point-120.jsonDOPPLERGEIST_REAL_REFERENCE_ROOT: benchmark-inputs/reference-checkoutDOPPLERGEIST_REAL_REFERENCE_DISCOVERY: evidence/audio/w1-sensitivity-20261102/reference/discovery.json- run: python -m pytest -q tests/test_real_prepared_measurements.py tests/test_real_geometry_kinematics.py tests/test_real_batch_scalar_parity.py tests/test_real_motion_support_batch.py tests/test_real_single_pass_sieve.py tests/test_real_refinement_lookup.py tests/test_real_cpa_preparation.py tests/test_real_native_ridge.py tests/test_real_native_ridge_long.py tests/test_real_ridge_backend.py tests/test_real_legacy_batch_cache.py tests/test_real_native_acoustic.py tests/test_real_native_acoustic_pipeline.py tests/test_real_batch_ceilings.py tests/test_real_acoustic_screen_cache.py tests/test_real_cpa_spatial_sieve.py tests/test_real_native_validation.py tests/test_real_index_columns.py tests/test_real_track_cache.py tests/test_real_native_convergence.py tests/test_real_flight_payload.py tests/test_real_prepared_index.py tests/test_real_trial_vectors.py+ run: python -m pytest -q tests/test_real_prepared_measurements.py tests/test_real_geometry_kinematics.py tests/test_real_batch_scalar_parity.py tests/test_real_motion_support_batch.py tests/test_real_single_pass_sieve.py tests/test_real_refinement_lookup.py tests/test_real_cpa_preparation.py tests/test_real_native_ridge.py tests/test_real_native_ridge_long.py tests/test_real_ridge_backend.py tests/test_real_legacy_batch_cache.py tests/test_real_native_acoustic.py tests/test_real_native_acoustic_pipeline.py tests/test_real_batch_ceilings.py tests/test_real_acoustic_screen_cache.py tests/test_real_cpa_spatial_sieve.py tests/test_real_native_validation.py tests/test_real_index_columns.py tests/test_real_track_cache.py tests/test_real_native_convergence.py tests/test_real_flight_payload.py tests/test_real_prepared_index.py tests/test_real_trial_vectors.py tests/test_real_refinement_reuse.py tests/test_real_discovery_normalization.py- name: Verify the explicit Python fallback on recorded arithmeticenv:DOPPLERGEIST_REAL_CPA_FIXTURE: benchmark-inputs/point-120.jsondiff --git a/scripts/benchmark_real_bounded_comparison.py b/scripts/benchmark_real_bounded_comparison.pynew file mode 100644index 0000000..44a3757--- /dev/null+++ b/scripts/benchmark_real_bounded_comparison.py@@ -0,0 +1,267 @@+"""Compare fresh bounded real-recording HTTP uploads from two source checkouts.++Supply one shared input directory: recording.mp3, request.json, and operator.json.+The existing bounded-upload runner fixes the archived regional workload and+requires an inconclusive/search_incomplete result. This measures runtime and+exact output parity, not localization accuracy or national coverage.++Every pair uses fresh services and jobs. Pair order alternates baseline/current+then current/baseline. Both existing scientific and array comparators must pass.+Use a new output directory; keep inputs and both source checkouts unchanged.+Dependencies come from the active Python environment and inherited PYTHONPATH.+"""+import argparse+import json+import math+import os+from pathlib import Path+import signal+import statistics+import subprocess+import sys+import time+++SCRIPTS = Path(__file__).resolve().parent+ARMS = ("baseline", "current")+THREAD_CONTROLS = {+ "OPENBLAS_NUM_THREADS": "1", "OMP_NUM_THREADS": "1",+ "MKL_NUM_THREADS": "1", "NUMEXPR_NUM_THREADS": "1",+}+COMPARATORS = (+ ("science", "compare_real_upload_performance.py"),+ ("arrays", "check_real_upload_arrays.py"),+)+++def emit(value):+ print(json.dumps(value, allow_nan=False), flush=True)+++def read_json(path):+ return json.loads(path.read_text())+++def positive_int(value):+ number = int(value)+ if number < 1:+ raise argparse.ArgumentTypeError("must be positive")+ return number+++def positive_seconds(value):+ number = float(value)+ if not math.isfinite(number) or number <= 0:+ raise argparse.ArgumentTypeError("must be finite and positive")+ return number+++def stop_runner(process):+ """Let the existing verifier stop its service and preserve its receipt."""+ if process.poll() is not None:+ return+ # The verifier records SIGTERM and protects service teardown from repeated+ # signals. A raw SIGINT would bypass its final receipt write.+ process.terminate()+ try:+ process.wait(timeout=30)+ except subprocess.TimeoutExpired:+ process.kill()+ process.wait(timeout=5)+++def run_arm(pair, name, source, args, env, runs):+ destination = args.output / f"{pair}-{name}"+ log = args.output / f"{pair}-{name}.log"+ command = [sys.executable, str(SCRIPTS / "benchmark_real_bounded_upload.py"),+ "--source", str(source), "--inputs", str(args.inputs),+ "--output", str(destination), "--timeout-s", str(args.timeout_s)]+ row = {"pair": pair, "source": name, "output": str(destination),+ "log": str(log), "command": command,+ "receipt": str(destination / "http-verification.json")}+ runs.append(row)+ emit({"starting": row})+ with log.open("x") as stream:+ process = subprocess.Popen(command, env=env, stdout=stream,+ stderr=subprocess.STDOUT, start_new_session=True)+ previous = None+ # The verifier deadline starts after imports. Bound startup and final+ # verification too, then request its normal SIGTERM service cleanup.+ deadline = time.monotonic() + args.timeout_s + 60.0+ try:+ while process.poll() is None:+ if time.monotonic() >= deadline:+ raise TimeoutError(f"Pair {pair} {name} exceeded its verifier timeout plus 60 seconds")+ history = destination / "history.jsonl"+ if history.exists():+ lines = history.read_text().splitlines()+ if lines:+ try:+ result = json.loads(lines[-1])["result"]+ state = (result.get("status"), result.get("stage"))+ if state != previous:+ emit({"pair": pair, "source": name,+ "status": state[0], "stage": state[1]})+ previous = state+ except (json.JSONDecodeError, KeyError):+ # The verifier can be between writes to its last line.+ pass+ time.sleep(1)+ finally:+ try:+ stop_runner(process)+ finally:+ row["returncode"] = process.returncode+ receipt_path = destination / "http-verification.json"+ receipt = read_json(receipt_path) if receipt_path.exists() else {}+ for key in ("elapsed_s", "verification_passed", "status", "reason_code",+ "candidate_count", "event_count", "full_pipeline_observed",+ "full_pipeline_requirements_met"):+ row[key] = receipt.get(key)+ row["receipt"] = str(receipt_path)+ if process.returncode:+ raise RuntimeError(f"Pair {pair} {name} runner failed; see {log}")+ if not all(receipt.get(key) is True for key in+ ("verification_passed", "full_pipeline_observed", "full_pipeline_requirements_met")):+ raise RuntimeError(f"Pair {pair} {name} did not verify the full workflow; see {receipt_path}")+ elapsed = receipt.get("elapsed_s")+ if isinstance(elapsed, bool) or not isinstance(elapsed, (int, float)) or not math.isfinite(elapsed) or elapsed <= 0:+ raise RuntimeError(f"Pair {pair} {name} has no finite positive elapsed time")+ emit({"completed": row})+ return receipt+++def compare_pair(pair, args, env, comparisons):+ for kind, filename in COMPARATORS:+ report_path = args.output / f"{pair}-{kind}.json"+ log = args.output / f"{pair}-{kind}.log"+ command = [sys.executable, str(SCRIPTS / filename),+ "--baseline", str(args.output / f"{pair}-baseline"),+ "--current", str(args.output / f"{pair}-current"),+ "--output", str(report_path)]+ row = {"pair": pair, "kind": kind, "passed": False,+ "report": str(report_path), "log": str(log), "command": command}+ comparisons.append(row)+ with log.open("x") as stream:+ result = subprocess.run(command, env=env, stdout=stream,+ stderr=subprocess.STDOUT, timeout=args.timeout_s)+ row["returncode"] = result.returncode+ if report_path.exists():+ row["passed"] = read_json(report_path).get("passed") is True+ if result.returncode or not row["passed"]:+ raise RuntimeError(f"Pair {pair} {kind} exact comparison failed; see {report_path} and {log}")+ emit(row)+++def summarize(report):+ samples = {name: [row["elapsed_s"] for row in report["runs"]+ if row["source"] == name and row.get("verification_passed") is True+ and isinstance(row.get("elapsed_s"), (int, float))+ and not isinstance(row["elapsed_s"], bool)+ and math.isfinite(row["elapsed_s"]) and row["elapsed_s"] > 0]+ for name in ARMS}+ medians = {name: statistics.median(values) if values else None+ for name, values in samples.items()}+ report["wall_seconds_samples"] = samples+ report["wall_seconds_median"] = medians+ report["wall_seconds_range"] = {+ name: [min(values), max(values)] if values else None for name, values in samples.items()}+ passed = (report["completed"] and len(report["comparisons"]) == 2 * report["repeats"]+ and all(row["passed"] for row in report["comparisons"]))+ report["all_exact_comparisons_passed"] = passed+ report["speedup"] = medians["baseline"] / medians["current"] if passed else None+ report["wall_reduction_fraction"] = 1 - medians["current"] / medians["baseline"] if passed else None+++def main(argv=None):+ parser = argparse.ArgumentParser(description=__doc__)+ parser.add_argument("--baseline-source", type=Path, required=True, help="Pinned checkout's src directory")+ parser.add_argument("--current-source", type=Path, required=True, help="Candidate checkout's src directory")+ parser.add_argument("--inputs", type=Path, required=True, help="Shared real recording and JSON configuration directory")+ parser.add_argument("--output", type=Path, required=True, help="New comparison directory; existing results are preserved")+ parser.add_argument("--repeats", type=positive_int, default=3, help="Alternating paired repetitions (default: 3)")+ parser.add_argument("--timeout-s", type=positive_seconds, default=900.0,+ help="Verifier and comparator timeout; upload runners have a 60-second startup/finalization margin")+ args = parser.parse_args(argv)+ args.inputs, args.output = args.inputs.resolve(), args.output.resolve()+ sources = {name: getattr(args, f"{name}_source").resolve() for name in ARMS}+ required = [args.inputs / name for name in ("recording.mp3", "request.json", "operator.json")]+ required += [SCRIPTS / "benchmark_real_bounded_upload.py"]+ required += [SCRIPTS / filename for _, filename in COMPARATORS]+ for source in sources.values():+ required += [source / "dopplergeist/__init__.py", source.parent / "scripts/verify_upload_http.py"]+ for path in required:+ if not path.is_file():+ parser.error(f"Required input or source file is missing: {path}")+ if args.output.exists():+ parser.error(f"Use a new output directory: {args.output}")+ settings = {name: (args.inputs / name).read_bytes() for name in ("request.json", "operator.json")}+ for name, data in settings.items():+ try:+ value = json.loads(data)+ except (json.JSONDecodeError, UnicodeDecodeError) as error:+ parser.error(f"Invalid {name}: {error}")+ if not isinstance(value, dict):+ parser.error(f"{name} must contain a JSON object")+ env = dict(os.environ, PYTHONDONTWRITEBYTECODE="1", **THREAD_CONTROLS)+ report = {+ "repeats": args.repeats, "timeout_s": args.timeout_s, "completed": False,+ "inputs": str(args.inputs), "sources": {name: str(path) for name, path in sources.items()},+ "runs": [], "comparisons": [],+ "controls": {"python_executable": sys.executable, "python_version": sys.version,+ "thread_environment": THREAD_CONTROLS,+ "runner_margin_s": 60, "interrupt_cleanup_limit_s": 35,+ "cpu_affinity": "Inherited unchanged from the invoking process",+ "dependencies": "Active Python environment and inherited PYTHONPATH"},+ "scope": "Fresh bounded regional HTTP uploads with source-informed receiver bounds and clock; expected inconclusive/search_incomplete. No localization accuracy claim.",+ "timing_scope": "Existing verifier elapsed_s includes the workflow and its verification. It excludes parent interpreter startup and the two cross-run comparators. Comparator phase observations have one-second polling uncertainty.",+ "cache_scope": "Fresh service and job per arm, shared recording and operator configuration. OS file caches are not flushed. Index preparation is outside this measurement.",+ "order": "Odd pairs: baseline,current. Even pairs: current,baseline.",+ }+ args.output.mkdir(parents=True, exist_ok=False)+ first_receipts = {}+ input_identity = None+ exit_code = 0+ previous_term = signal.getsignal(signal.SIGTERM)++ def interrupted(signum, frame):+ raise KeyboardInterrupt(f"Received signal {signum}")++ signal.signal(signal.SIGTERM, interrupted)+ try:+ for pair in range(1, args.repeats + 1):+ order = ARMS if pair % 2 else ARMS[::-1]+ for name in order:+ if any((args.inputs / filename).read_bytes() != data for filename, data in settings.items()):+ raise RuntimeError("Input JSON configuration changed during the comparison")+ receipt = run_arm(pair, name, sources[name], args, env, report["runs"])+ identity = {key: receipt.get(key) for key in ("source_sha256", "source_bytes", "request")}+ if input_identity is None:+ input_identity = identity+ elif identity != input_identity:+ raise RuntimeError("Recording or request changed between uploads")+ if name in first_receipts:+ for key in ("implementation_files", "verifier_sha256"):+ if receipt.get(key) != first_receipts[name].get(key):+ raise RuntimeError(f"The {name} implementation changed between repetitions")+ else:+ first_receipts[name] = receipt+ compare_pair(pair, args, env, report["comparisons"])+ report["completed"] = True+ except (Exception, KeyboardInterrupt) as error:+ report["error"] = f"{type(error).__name__}: {error}"+ exit_code = 130 if isinstance(error, KeyboardInterrupt) else 1+ emit({"failed": report["error"], "output": str(args.output)})+ finally:+ signal.signal(signal.SIGTERM, previous_term)+ summarize(report)+ with (args.output / "comparison.json").open("x") as stream:+ json.dump(report, stream, indent=2, allow_nan=False)+ stream.write("\n")+ emit({"report": str(args.output / "comparison.json"),+ **{key: report[key] for key in ("all_exact_comparisons_passed", "wall_seconds_median", "speedup")}})+ return exit_code+++if __name__ == "__main__":+ raise SystemExit(main())diff --git a/scripts/benchmark_real_discovery_normalization.py b/scripts/benchmark_real_discovery_normalization.pynew file mode 100644index 0000000..c3e2801--- /dev/null+++ b/scripts/benchmark_real_discovery_normalization.py@@ -0,0 +1,268 @@+#!/usr/bin/env python3+"""Compare discovery normalization on an existing real decoded recording.++The untimed check compares every Spectrum array directly as bytes. Timed workers+run uninstrumented discovery, including its normal JSON, CSV, and summary PNG.+No audio or aircraft observations are generated by this script.+"""+from __future__ import annotations++import argparse+from dataclasses import replace+import importlib.util+import json+import os+from pathlib import Path+import resource+import statistics+import subprocess+import sys+import time+++def write_json(path, value):+ with Path(path).open("x") as stream:+ json.dump(value, stream, indent=2, allow_nan=False)+ stream.write("\n")+++def canonical(value):+ return json.dumps(value, sort_keys=True, allow_nan=False)+++def compare_array(left, right, label):+ signature = lambda value: (+ value.dtype.str, value.shape, value.strides,+ value.flags.c_contiguous, value.flags.f_contiguous, value.flags.writeable,+ )+ if signature(left) != signature(right):+ raise AssertionError(f"Array dtype, shape, or layout differs: {label}")+ if left.tobytes(order="C") != right.tobytes(order="C"):+ raise AssertionError(f"Array bytes differ: {label}")+++def compare_spectrum(left, right, label):+ if left is None or right is None:+ if left is not right:+ raise AssertionError(f"Spectrum availability differs: {label}")+ return+ for field in ("time", "frequency", "db", "contrast"):+ compare_array(getattr(left, field), getattr(right, field), f"{label}.{field}")+++def compare_artifacts(reference, current):+ from PIL import Image++ reference, current = Path(reference), Path(current)+ names = lambda path: sorted(p.name for p in path.iterdir() if p.is_file())+ if names(reference) != names(current):+ raise AssertionError("Discovery diagnostic file set differs")+ png_bytes_exact, csv_count = True, 0+ for name in names(reference):+ left, right = reference / name, current / name+ if name.endswith(".png"):+ png_bytes_exact &= left.read_bytes() == right.read_bytes()+ with Image.open(left) as a, Image.open(right) as b:+ if a.mode != b.mode or a.size != b.size or a.tobytes() != b.tobytes():+ raise AssertionError(f"PNG pixels differ: {name}")+ elif left.read_bytes() != right.read_bytes():+ raise AssertionError(f"Diagnostic bytes differ: {name}")+ csv_count += name.endswith(".csv")+ return {"exact_json_and_csv_bytes": True, "csv_files": csv_count,+ "exact_png_pixels": True, "exact_png_file_bytes": bool(png_bytes_exact)}+++def load_baseline_spectrum(source):+ # Only discovery.py differs in this experiment. Relative imports deliberately+ # use the same unchanged audio/contracts modules and numerical dependencies.+ name = "dopplergeist._normalization_comparison_baseline"+ path = Path(source).resolve() / "dopplergeist/discovery.py"+ spec = importlib.util.spec_from_file_location(name, path)+ module = importlib.util.module_from_spec(spec)+ sys.modules[name] = module+ spec.loader.exec_module(module)+ return module._spectrum+++def worker(args):+ sys.path.insert(0, str(args.source.resolve()))+ import numpy as np+ import scipy+ from dopplergeist import discovery+ from dopplergeist.intake import IntakeRecording++ args.output.mkdir(parents=True, exist_ok=False)+ reference = json.loads((args.job / "discovery/discovery.json").read_text())+ recording = IntakeRecording(+ args.job / "intake/recording.f32",+ json.loads((args.job / "intake/recording.json").read_text()),+ json.loads((args.job / "intake/intake.json").read_text()),+ )+ if recording.samples_path.stat().st_size != 4 * recording.diagnostics["sample_count"]:+ raise AssertionError("Saved decoded recording size differs from intake metadata")+ settings = discovery.DiscoverySettings(**reference["settings"])+ spectra, original = [], discovery._spectrum+ baseline_spectrum = None+ if args.compare_spectrum_source is not None:+ baseline_spectrum = load_baseline_spectrum(args.compare_spectrum_source)++ def checked_spectrum(data, sr, start, settings):+ expected = baseline_spectrum(data, sr, start, settings)+ result = original(data, sr, start, settings)+ compare_spectrum(expected, result, f"chunk-{len(spectra)}")+ spectra.append({+ "start_s": start, "samples": len(data), "available": result is not None,+ "shape": list(result.db.shape) if result is not None else None,+ "finite_float32": bool(result is not None and result.db.dtype == np.float32+ and np.isfinite(result.db).all()),+ })+ return result++ discovery._spectrum = checked_spectrum+ wall, cpu = time.perf_counter(), time.process_time()+ try:+ events = discovery.discover_events(+ recording, output_dir=args.output / "discovery", settings=settings,+ plot_summary=True, plot_event_details=False,+ )+ finally:+ elapsed, used = time.perf_counter() - wall, time.process_time() - cpu+ discovery._spectrum = original+ if canonical(events) != canonical(reference["events"]):+ raise AssertionError("Complete discovered event payload differs from the recorded job")+ artifacts = compare_artifacts(args.job / "discovery", args.output / "discovery")+ extra_checks = {}+ if baseline_spectrum is not None:+ if len(spectra) != len(reference["chunks"]):+ raise AssertionError("Not every original chunk received an array comparison")+ first, data = next(recording.iter_chunks(settings.chunk_s, settings.overlap_s))+ sr = recording.metadata["sample_rate_hz"]+ double = data.astype(np.float64)+ compare_spectrum(baseline_spectrum(double, sr, first, settings),+ original(double, sr, first, settings), "real-float64-fallback")+ short = data[:round(sr * settings.window_s) - 1]+ compare_spectrum(baseline_spectrum(short, sr, first, settings),+ original(short, sr, first, settings), "real-short-prefix")+ median, calls = np.median, []++ def recording_median(*values, **keywords):+ calls.append(keywords.get("axis"))+ return median(*values, **keywords)++ try:+ np.median = recording_median+ expected = baseline_spectrum(data, sr, first, settings)+ baseline_axes = calls[:]+ calls.clear()+ actual = original(data, sr, first, settings)+ current_axes = calls[:]+ finally:+ np.median = median+ compare_spectrum(expected, actual, "custom-median-fallback")+ if baseline_axes != [1, 0, 0] or current_axes != baseline_axes:+ raise AssertionError("Custom median dispatch no longer uses the original axes")+ upper = expected.frequency[-2 if len(expected.frequency) % 2 else -1]+ even_settings = replace(settings, max_frequency_hz=float(upper))+ even_expected = baseline_spectrum(data, sr, first, even_settings)+ even_actual = original(data, sr, first, even_settings)+ compare_spectrum(even_expected, even_actual, "real-even-frequency-median")+ if len(even_actual.frequency) % 2:+ raise AssertionError("The even-median check did not use an even frequency count")+ extra_checks = {"real_float64_fallback_exact": True, "short_real_prefix_exact": True,+ "custom_median_fallback_exact": True, "median_axes": current_axes,+ "real_even_frequency_median_exact": True,+ "even_median_frequency_bins": len(even_actual.frequency)}+ report = {+ "source": str(args.source.resolve()), "job": str(args.job.resolve()),+ "wall_s": elapsed, "cpu_s": used,+ "peak_rss_mib": resource.getrusage(resource.RUSAGE_SELF).ru_maxrss / 1024,+ "timed_run": baseline_spectrum is None,+ "event_records": len(events),+ "independent_groups": len({event["harmonic_group_id"] for event in events}),+ "exact_events": True, **artifacts,+ "sample_count": recording.diagnostics["sample_count"],+ "duration_s": recording.metadata["duration_s"],+ "source_sha256": recording.metadata["source_sha256"],+ "settings": reference["settings"],+ "python": sys.version, "numpy": np.__version__, "scipy": scipy.__version__,+ "spectrum_array_checks": len(spectra), "spectra": spectra, **extra_checks,+ }+ write_json(args.output / "summary.json", report)+ print(json.dumps({key: value for key, value in report.items() if key != "spectra"}), flush=True)+++def compare(args):+ args.output.mkdir(parents=True, exist_ok=False)+ environment = dict(os.environ)+ environment.update(PYTHONDONTWRITEBYTECODE="1", OPENBLAS_NUM_THREADS="1",+ OMP_NUM_THREADS="1", MKL_NUM_THREADS="1", NUMEXPR_NUM_THREADS="1")++ def run(name, source, baseline=None):+ output = args.output / name+ command = [sys.executable, str(Path(__file__).resolve()), "worker",+ "--source", str(source.resolve()), "--job", str(args.job.resolve()),+ "--output", str(output.resolve())]+ if baseline is not None:+ command += ["--compare-spectrum-source", str(baseline.resolve())]+ with (args.output / f"{name}.log").open("x") as stream:+ result = subprocess.run(command, env=environment, stdout=stream, stderr=subprocess.STDOUT)+ if result.returncode:+ raise RuntimeError(f"Worker {name} failed; see {args.output / (name + '.log')}")+ report = json.loads((output / "summary.json").read_text())+ print(json.dumps({"worker": name, "wall_s": report["wall_s"],+ "cpu_s": report["cpu_s"], "exact_events": True}), flush=True)+ return report++ check = run("array-check", args.current_source, args.baseline_source)+ pairs, first_pair_passed = [], False+ for index in range(1, args.pairs + 1):+ order = ("baseline", "current") if index % 2 else ("current", "baseline")+ reports = {}+ for arm in order:+ source = args.baseline_source if arm == "baseline" else args.current_source+ reports[arm] = run(f"{index}-{arm}", source)+ artifacts = compare_artifacts(args.output / f"{index}-baseline/discovery",+ args.output / f"{index}-current/discovery")+ pairs.append({"pair": index, "order": list(order), **reports, **artifacts})+ if index == 1:+ first_pair_passed = reports["current"]["wall_s"] <= 0.95 * reports["baseline"]["wall_s"]+ if not first_pair_passed:+ break+ medians = {arm: {metric: statistics.median(pair[arm][metric] for pair in pairs)+ for metric in ("wall_s", "cpu_s", "peak_rss_mib")}+ for arm in ("baseline", "current")}+ report = {+ "scope": "Whole real saved-PCM discovery with normal JSON/CSV/summary PNG; no intake, decoding, or flight search.",+ "method": "Fresh interpreter per arm; pre-call imports excluded and lazy in-call imports included; no numerical instrumentation in timed workers; three alternating pairs only if first exact pair lowers wall time at least 5%.",+ "cache_conditions": "OS caches are not flushed; recording already existed; no CPU affinity; team coordinates an exclusive local timing slot, unrelated host load is uncontrolled.",+ "array_check": check, "pairs": pairs, "medians": medians,+ "first_pair_5_percent_gate_passed": first_pair_passed,+ "wall_speedup": medians["baseline"]["wall_s"] / medians["current"]["wall_s"],+ "cpu_speedup": medians["baseline"]["cpu_s"] / medians["current"]["cpu_s"],+ "wall_time_reduction_fraction": 1 - medians["current"]["wall_s"] / medians["baseline"]["wall_s"],+ "all_event_and_diagnostic_checks_exact": True,+ }+ write_json(args.output / "comparison.json", report)+ print(json.dumps({key: value for key, value in report.items()+ if key not in ("array_check", "pairs")}, indent=2), flush=True)+++def main():+ parser = argparse.ArgumentParser(description=__doc__)+ subparsers = parser.add_subparsers(dest="command", required=True)+ run_parser = subparsers.add_parser("worker")+ run_parser.add_argument("--source", type=Path, required=True)+ run_parser.add_argument("--compare-spectrum-source", type=Path)+ compare_parser = subparsers.add_parser("compare")+ compare_parser.add_argument("--baseline-source", type=Path, required=True)+ compare_parser.add_argument("--current-source", type=Path, required=True)+ compare_parser.add_argument("--pairs", type=int, choices=(1, 2, 3), default=3)+ for child in (run_parser, compare_parser):+ child.add_argument("--job", type=Path, required=True)+ child.add_argument("--output", type=Path, required=True)+ args = parser.parse_args()+ (worker if args.command == "worker" else compare)(args)+++if __name__ == "__main__":+ main()diff --git a/scripts/benchmark_real_refinement.py b/scripts/benchmark_real_refinement.pynew file mode 100644index 0000000..de07da0--- /dev/null+++ b/scripts/benchmark_real_refinement.py@@ -0,0 +1,191 @@+"""Compare complete sensitivity profiling on the frozen real-recording case.++Each arm uses a fresh interpreter, the same observed flight index, and restored+terrain. The input candidate is the recorded finalist before its full profile.+Input loading and that earlier finalist refinement are outside the timed span.+This source-informed development replay does not measure localization accuracy.+"""+from __future__ import annotations++import argparse+import hashlib+import json+import math+import os+from pathlib import Path+import statistics+import subprocess+import sys+import time++ROOT = Path(__file__).resolve().parents[1]+++def scalar(value):+ return value.tolist() if hasattr(value, "tolist") else value.item()+++def encoded(value):+ return json.dumps(value, sort_keys=True, separators=(",", ":"),+ allow_nan=True, default=scalar)+++def write_new(path, value):+ path.parent.mkdir(parents=True, exist_ok=True)+ with path.open("x") as stream:+ json.dump(value, stream, indent=2, allow_nan=True, default=scalar)+ stream.write("\n")+++def close_terrain(sampler):+ for raster in sampler.rasters:+ raster.close()+ if sampler.geoid is not None:+ close_terrain(sampler.geoid)+++def source_hashes(source):+ return {str(path.relative_to(source)): hashlib.sha256(path.read_bytes()).hexdigest()+ for path in sorted((source / "dopplergeist").rglob("*"))+ if path.is_file() and path.suffix in (".py", ".c", ".so", ".pyd")}+++def worker(args):+ source = args.source.resolve()+ sys.path.insert(0, str(source))+ import dopplergeist+ from dopplergeist import matching, native_acoustic+ from dopplergeist.data_access import FlightIndex+ from dopplergeist.terrain import Terrain++ if Path(dopplergeist.__file__).resolve().parent != source / "dopplergeist":+ raise RuntimeError("The worker imported a different source tree")+ if args.require_native and not callable(getattr(matching, "_native_fit_irls", None)):+ raise RuntimeError("The selected source's native ridge backend is unavailable")+ native = getattr(native_acoustic, "_native", None)+ counter = getattr(native, "successful_calls", None)+ if args.require_native_acoustic and not callable(counter):+ raise RuntimeError("The selected source's native acoustic counter is unavailable")+ fixture = json.loads(args.fixture.read_text())+ candidate = fixture["candidate"]+ index = FlightIndex(args.index)+ tracks = {track.id: track for track in index.lookup(candidate["flight_ids"])}+ if set(tracks) != set(candidate["flight_ids"]):+ raise ValueError("The observed index is missing a recorded candidate flight")+ events, measurements = matching.prepare_events(fixture["events"], c=343., max_distance_m=20000.)+ dem, geoid = [args.terrain_root / path for path in fixture["source"]["terrain_data"]]+ terrain = Terrain([dem], geoid_path=geoid)+ before_native = counter() if callable(counter) else None+ call = matching._cache_ridge_fits(matching.profile_candidate)+ try:+ began, cpu = time.perf_counter(), time.process_time()+ result = call(candidate, tracks, events, measurements, terrain,+ radius_m=500., c=343.,+ recording_start_window_s=fixture["recording_start_window_s"])+ elapsed, cpu_seconds = time.perf_counter() - began, time.process_time() - cpu+ cache_entries = {"terrain": len(getattr(terrain, "_pixel_cache", {})),+ "geoid": len(getattr(terrain.geoid, "_pixel_cache", {}))}+ finally:+ close_terrain(terrain)+ profiles = len(result["sensitivity"]["profiles"])+ if profiles != fixture["expected_profile_count"]:+ raise AssertionError("The complete recorded scenario inventory changed")+ native_calls = counter() - before_native if before_native is not None else None+ if args.require_native_acoustic and not native_calls:+ raise RuntimeError("The worker did not perform a successful native acoustic solve")+ workload = {"recording_sha256": fixture["source"]["recording_sha256"],+ "fixture_sha256": hashlib.sha256(args.fixture.read_bytes()).hexdigest(),+ "recorded_job": fixture["source"]["job_id"],+ "index_input_hash": index.report["input_hash"],+ "event_records": len(fixture["events"]), "independent_groups": len(events),+ "matched_groups": len(candidate["event_indices"]),+ "trajectories": len(tracks),+ "trajectory_samples": sum(len(track.time) for track in tracks.values()),+ "profiles": profiles}+ summary = {"wall_seconds": elapsed, "cpu_seconds": cpu_seconds,+ "source_sha256": source_hashes(source),+ "native_acoustic_successes": native_calls, "workload": workload,+ "pixel_cache_entries": cache_entries,+ "ridge_fit_backend": matching.RIDGE_FIT_BACKEND,+ "acoustic_backend": native_acoustic.ACOUSTIC_BACKEND,+ "timing_scope": "Complete profile_candidate and its exact-fit cache; excludes imports, index lookup, terrain construction, event preparation and earlier finalist refinement."}+ args.output.mkdir(parents=True, exist_ok=False)+ write_new(args.output / "result.json", result)+ write_new(args.output / "summary.json", summary)+ print(json.dumps(summary), flush=True)+++def compare(args):+ args.output.mkdir(parents=True, exist_ok=False)+ sources = {"baseline": args.baseline_source.resolve(), "current": args.current_source.resolve()}+ environment = dict(os.environ, PYTHONDONTWRITEBYTECODE="1", OPENBLAS_NUM_THREADS="1",+ OMP_NUM_THREADS="1", MKL_NUM_THREADS="1", NUMEXPR_NUM_THREADS="1")+ rows, expected, workload = [], None, None+ for repeat in range(1, args.repeats + 1):+ order = ("baseline", "current") if repeat % 2 else ("current", "baseline")+ for label in order:+ output = args.output / f"{repeat}-{label}"+ command = [sys.executable, str(Path(__file__).resolve()), "_worker",+ "--source", str(sources[label]), "--fixture", str(args.fixture.resolve()),+ "--index", str(args.index.resolve()), "--terrain-root", str(args.terrain_root.resolve()),+ "--output", str(output.resolve())]+ if args.require_native:+ command.append("--require-native")+ if args.require_native_acoustic:+ command.append("--require-native-acoustic")+ subprocess.run(command, check=True, env=environment, timeout=args.timeout_s)+ result = encoded(json.loads((output / "result.json").read_text()))+ summary = json.loads((output / "summary.json").read_text())+ if expected is None:+ expected, workload = result, summary["workload"]+ if result != expected or summary["workload"] != workload:+ raise AssertionError(f"Recorded profile or workload changed in {output}")+ rows.append(dict(summary, source=label, pair=repeat))+ medians = {label: {metric: statistics.median(row[metric] for row in rows if row["source"] == label)+ for metric in ("wall_seconds", "cpu_seconds")} for label in sources}+ report = {"identical_results": True, "repeats": args.repeats,+ "fixture": str(args.fixture.resolve()), "index": str(args.index.resolve()),+ "terrain_root": str(args.terrain_root.resolve()),+ "sources": {key: str(value) for key, value in sources.items()},+ "workload": workload, "medians": medians,+ "speedup": {metric: medians["baseline"][metric] / medians["current"][metric]+ for metric in ("wall_seconds", "cpu_seconds")},+ "timing_scope": rows[0]["timing_scope"],+ "cache_scope": "Fresh interpreter and terrain per arm; operating-system caches are not flushed. Numerical libraries use one thread.",+ "scope": "Recorded finalist with source-informed bounds and clock; not an independent location-accuracy or complete HTTP benchmark.",+ "runs": rows}+ write_new(args.output / "comparison.json", report)+ print(json.dumps({key: report[key] for key in ("identical_results", "medians", "speedup", "workload")}), flush=True)+++def main():+ parser = argparse.ArgumentParser(description=__doc__)+ commands = parser.add_subparsers(dest="command", required=True)+ comparison = commands.add_parser("compare", help="Compare full recorded profiles in alternating fresh processes")+ comparison.add_argument("--baseline-source", type=Path, required=True)+ comparison.add_argument("--current-source", type=Path, default=ROOT / "src")+ comparison.add_argument("--repeats", type=int, default=3)+ comparison.add_argument("--timeout-s", type=float, default=180.)+ internal = commands.add_parser("_worker", help=argparse.SUPPRESS)+ internal.add_argument("--source", type=Path, required=True)+ for command in (comparison, internal):+ command.add_argument("--fixture", type=Path, default=ROOT / "tests/data/real-refinement-profile.json")+ command.add_argument("--index", type=Path, required=True)+ command.add_argument("--terrain-root", type=Path, default=ROOT,+ help="Root containing restored data/terrain files")+ command.add_argument("--output", type=Path, required=True)+ command.add_argument("--require-native", action="store_true",+ help="Require the native ridge backend to be enabled")+ command.add_argument("--require-native-acoustic", action="store_true",+ help="Require successful native acoustic solves")+ args = parser.parse_args()+ if args.command == "compare":+ if args.repeats < 1 or not math.isfinite(args.timeout_s) or args.timeout_s <= 0:+ parser.error("--repeats and --timeout-s must be positive")+ compare(args)+ else:+ worker(args)+++if __name__ == "__main__":+ main()diff --git a/src/dopplergeist/discovery.py b/src/dopplergeist/discovery.pyindex 04dde53..7fb352b 100644--- a/src/dopplergeist/discovery.py+++ b/src/dopplergeist/discovery.py@@ -15,6 +15,7 @@ from .audio import Spectrumfrom .contracts import validate_event_HARMONIC_RATIOS = sorted({a / b for a in range(2, 9) for b in range(1, a) if a / b >= 1.2})+_NORMALIZATION_FUNCTIONS = (np.median, np.abs, np.maximum, np.clip, np.isfinite)@dataclass(frozen=True)@@ -56,9 +57,23 @@ def _spectrum(data, sr, start, settings):f, power = f[keep], power[keep]db = 10 * np.log10(power + np.finfo(np.float32).tiny)whitened = db - np.median(db, axis=1, keepdims=True)- center = np.median(whitened, axis=0, keepdims=True)- scale = 1.4826 * np.median(np.abs(whitened - center), axis=0, keepdims=True)+ contiguous_columns = (+ type(whitened) is np.ndarray and whitened.dtype == np.float32+ and whitened.ndim == 2 and whitened.size > 0 and whitened.flags.c_contiguous+ and all(current is original for current, original in zip(+ (np.median, np.abs, np.maximum, np.clip, np.isfinite), _NORMALIZATION_FUNCTIONS))+ and np.isfinite(whitened).all()+ )+ axis = 0+ if contiguous_columns:+ # Keep each frequency column contiguous for both partition reductions.+ whitened = whitened.T.copy(order="C")+ axis = 1+ center = np.median(whitened, axis=axis, keepdims=True)+ scale = 1.4826 * np.median(np.abs(whitened - center), axis=axis, keepdims=True)contrast = np.clip((whitened - center) / np.maximum(scale, 1.0), -4, 12)+ if contiguous_columns:+ contrast = contrast.T.copy(order="C")return Spectrum(t + start, f, db, contrast)diff --git a/src/dopplergeist/matching.py b/src/dopplergeist/matching.pyindex 88afdcd..2e38359 100644--- a/src/dopplergeist/matching.py+++ b/src/dopplergeist/matching.py@@ -692,8 +692,22 @@ def refine_candidate(candidate, tracks, events, measurements, terrain, radius_m=Returned radius describes the explored alternatives only. A boundary optimumwarns callers that this local search has not enclosed the possible solution."""- forward = Transformer.from_crs("EPSG:4326", crs, always_xy=True)- inverse = Transformer.from_crs(crs, "EPSG:4326", always_xy=True)+ return _refine_candidate(candidate, tracks, events, measurements, terrain,+ radius_m=radius_m, clock_radius_s=clock_radius_s,+ altitude_offsets_m=altitude_offsets_m, crs=crs, c=c,+ recording_start_window_s=recording_start_window_s)+++def _refine_candidate(candidate, tracks, events, measurements, terrain, radius_m=500.0,+ clock_radius_s=5.0, altitude_offsets_m=(-150.0, 0.0, 150.0),+ crs="EPSG:5070", c=343.0, recording_start_window_s=None, *,+ _transformers=None):+ """Share coordinate operations only within one declared sensitivity profile."""+ if _transformers is None:+ forward = Transformer.from_crs("EPSG:4326", crs, always_xy=True)+ inverse = Transformer.from_crs(crs, "EPSG:4326", always_xy=True)+ else:+ forward, inverse = _transformersx0, y0 = forward.transform(candidate["lon"], candidate["lat"])start = candidate["recording_start_time_s"]selected = [tracks[f] for f in candidate["flight_ids"]]@@ -760,6 +774,9 @@ def refine_candidate(candidate, tracks, events, measurements, terrain, radius_m="complete": len(profiles) == len(altitude_offsets_m) and all(p["optimizer_success"] for p in profiles)})+_CANONICAL_REFINE_CANDIDATE = refine_candidate++def profile_candidate(candidate, tracks, events, measurements, terrain, *,recording_start_window_s=None, radius_m=500.0, clock_radius_s=5.0,altitude_uncertainty_m=150.0, sound_speed_uncertainty_mps=5.0,@@ -776,7 +793,21 @@ def profile_candidate(candidate, tracks, events, measurements, terrain, *,kwargs = dict(radius_m=radius_m, clock_radius_s=clock_radius_s,altitude_offsets_m=(0.0,), crs=crs, c=c,recording_start_window_s=recording_start_window_s)- nominal = refine_candidate(candidate, tracks, events, measurements, terrain, **kwargs)+ transformers = None++ def refine(*args, **options):+ nonlocal transformers+ # Custom refiners keep the original dispatch and receive no private+ # arguments. The standard path owns exactly one pair for this profile.+ current_refiner = refine_candidate+ if current_refiner is not _CANONICAL_REFINE_CANDIDATE:+ return current_refiner(*args, **options)+ if transformers is None:+ transformers = (Transformer.from_crs("EPSG:4326", crs, always_xy=True),+ Transformer.from_crs(crs, "EPSG:4326", always_xy=True))+ return _refine_candidate(*args, _transformers=transformers, **options)++ nominal = refine(candidate, tracks, events, measurements, terrain, **kwargs)scenarios = [("nominal", "nominal", events, measurements, {})]for sign in (-1, 1):scenarios.append(("altitude", f"height_{sign:+d}", events, measurements,@@ -833,7 +864,7 @@ def profile_candidate(candidate, tracks, events, measurements, terrain, *,scenario_tracks = dict(tracks)if bias:scenario_tracks[identity] = _altitude_bias(tracks[identity], bias)- row = nominal if source == "nominal" else refine_candidate(+ row = nominal if source == "nominal" else refine(candidate, scenario_tracks, scenario_events, scenario_measurements, terrain, **options)# Height scenarios return a nominal plus the perturbed-height fit;# retain the latter rather than silently measuring the nominal twice.diff --git a/src/dopplergeist/terrain.py b/src/dopplergeist/terrain.pyindex 608a803..934a435 100644--- a/src/dopplergeist/terrain.py+++ b/src/dopplergeist/terrain.py@@ -1,10 +1,16 @@"""Terrain sampling and common projected grids."""+from collections import OrderedDictfrom functools import lru_cachefrom pathlib import Path+import stat+from threading import RLock+from weakref import refimport numpy as npfrom pyproj import Transformer+_PIXEL_CACHE_MAX_ENTRIES = 1024+@lru_cache(maxsize=32)def _raster_transformer(crs):@@ -12,15 +18,94 @@ def _raster_transformer(crs):return Transformer.from_crs("EPSG:4326", crs, always_xy=True)+def _raster_file_signature(paths):+ """Notice replacement, writes, removal and new sidecars without reading data."""+ try:+ records = [path.stat() for path in paths]+ if not stat.S_ISREG(records[0].st_mode):+ return None+ return tuple((record.st_dev, record.st_ino, record.st_size,+ record.st_mtime_ns, record.st_ctime_ns) for record in records)+ except OSError:+ return None+++def _raster_pixel_source(raster):+ """Admit only an ordinary read-only single-file local GeoTIFF reader."""+ from rasterio.io import DatasetReader+ from rasterio._io import DatasetReaderBase++ if (type(raster) is not DatasetReader or raster.closed or raster.mode != "r"+ or DatasetReader.read is not DatasetReaderBase.read+ or "read" in getattr(raster, "__dict__", {})+ or raster.driver != "GTiff" or raster.files != [raster.name]):+ return None+ try:+ path = Path(raster.name).absolute()+ # Directory stamps also notice a mask/auxiliary file created later.+ paths = (path, *dict.fromkeys((path.parent, path.resolve().parent)))+ signature = _raster_file_signature(paths)+ return (ref(raster), DatasetReader.read, paths, signature) if signature is not None else None+ except (OSError, ValueError, TypeError):+ return None++class Terrain:def __init__(self, paths=None, constant_m=None, geoid_path=None):import rasterioself.rasters = [rasterio.open(p) for p in (paths or [])]+ self._pixel_cache = OrderedDict()+ self._pixel_cache_lock = RLock()+ self._pixel_sources = {}+ for raster in self.rasters:+ source = _raster_pixel_source(raster)+ if source is not None:+ self._pixel_sources[id(raster)] = sourceself.constant = constant_mself.geoid = Terrain([geoid_path]) if geoid_path else Noneif not self.rasters and constant_m is None:raise ValueError("Supply DEM raster paths or an explicit constant ground elevation")+ def _read_window(self, raster, window):+ # Only reuse the exact 1x1 reads already requested by the original path.+ # Array coordinates, floor arithmetic, masks and raster order stay there.+ sources = getattr(self, "_pixel_sources", None)+ source = sources.get(id(raster)) if sources is not None else None+ if source is None or window.width != 1 or window.height != 1:+ return raster.read(1, window=window, masked=True)+ with self._pixel_cache_lock:+ signature = _raster_file_signature(source[2])+ if (raster is not source[0]() or raster.closed or raster.mode != "r"+ or type(raster).read is not source[1]+ or "read" in getattr(raster, "__dict__", {}) or signature != source[3]):+ # Do not re-enable a changed reader: an open handle can still+ # refer to the old inode after its path is replaced.+ self._pixel_sources.pop(id(raster), None)+ for key in list(self._pixel_cache):+ if key[0] == id(raster):+ del self._pixel_cache[key]+ return raster.read(1, window=window, masked=True)+ key = (id(raster), window.row_off, window.col_off)+ if key in self._pixel_cache:+ self._pixel_cache.move_to_end(key)+ return self._pixel_cache[key]+ data = raster.read(1, window=window, masked=True)+ if _raster_file_signature(source[2]) != signature:+ self._pixel_sources.pop(id(raster), None)+ for old in list(self._pixel_cache):+ if old[0] == id(raster):+ del self._pixel_cache[old]+ return raster.read(1, window=window, masked=True)+ # The cache never escapes sample(). Returned elevations stay fresh+ # and writable. Both numeric values and masks belong to this entry.+ data.flags.writeable = False+ if isinstance(data.mask, np.ndarray):+ data.mask.flags.writeable = False+ self._pixel_cache[key] = data+ if len(self._pixel_cache) > _PIXEL_CACHE_MAX_ENTRIES:+ self._pixel_cache.popitem(last=False)+ return data+def sample(self, lat, lon):from rasterio.windows import Window@@ -37,7 +122,7 @@ class Terrain:rows,cols=row[inside],col[inside]r0,c0=int(rows.min()),int(cols.min())window=Window(c0,r0,int(cols.max())-c0+1,int(rows.max())-r0+1)- data=raster.read(1,window=window,masked=True)+ data=self._read_window(raster,window)values[inside]=data[rows-r0,cols-c0]valid = ~np.ma.getmaskarray(values)flat = elevation.ravel()diff --git a/tests/data/real-refinement-profile.json b/tests/data/real-refinement-profile.jsonnew file mode 100644index 0000000..a73e785--- /dev/null+++ b/tests/data/real-refinement-profile.json@@ -0,0 +1,5221 @@+{+ "source": {+ "job_id": "d997a7944e9f470ea9f74500dc6d0316",+ "recording_sha256": "707083f0344823eeea7f130faec6c22b6628b8b9fea04d026915d93df9a07b15",+ "recording_scope": "Complete published real recording, automatic moving-tone proposals; aircraft identity unconfirmed.",+ "flight_data": "Restored data-adsb-derived bundle: data/adsb/2026-09-08/reference-region.parquet",+ "terrain_data": [+ "data/terrain/Copernicus_DSM_COG_10_N40_00_W074_00_DEM.tif",+ "data/terrain/us_nga_egm96_15.tif"+ ],+ "validation_scope": "Source-informed development replay with a historical fitted clock; not independent localization acceptance.",+ "extraction": "Unmodified discovery events and the actual leading finalist before full sensitivity profiling."+ },+ "candidate": {+ "altitude_basis": {+ "a1dfeb:1": [+ "ellipsoidal"+ ],+ "a63e21:2": [+ "ellipsoidal"+ ],+ "a9bd90:37": [+ "ellipsoidal"+ ],+ "aa61d2:3": [+ "ellipsoidal"+ ],+ "ab50b9:11": [+ "ellipsoidal",+ "ellipsoidal_interpolated"+ ],+ "ace391:3": [+ "ellipsoidal"+ ]+ },+ "boundary_limited": false,+ "clock_boundary_limited": false,+ "core_assessment_complete": true,+ "elev_m": -31.25569725036621,+ "event_diagnostics": [+ {+ "drift_at_bound": true,+ "drift_bound_hz": 1.9555526977840607,+ "f0_hz": 97.32639892584645,+ "independent_sample_count": 30,+ "outlier_fraction": 0.4606029066149883,+ "rmse_hz": 3.645240444675128,+ "sample_count": 30,+ "score": -2.150826545572909,+ "source_drift_hz": -1.9555526977840607,+ "source_drift_hz_s": -0.08876946935140981,+ "source_reference_emission_time_s": 1788899339.5010288,+ "source_span_s": 22.029563903808594,+ "support_fraction": 1.0+ },+ {+ "drift_at_bound": false,+ "drift_bound_hz": 1.8767094275842988,+ "f0_hz": 93.84737473787023,+ "independent_sample_count": 48,+ "outlier_fraction": 0.0,+ "rmse_hz": 0.19269890407255608,+ "sample_count": 48,+ "score": -0.1897030039869119,+ "source_drift_hz": -0.009391699078497925,+ "source_drift_hz_s": -0.00037059740241461727,+ "source_reference_emission_time_s": 1788899401.004428,+ "source_span_s": 25.342053174972534,+ "support_fraction": 1.0+ },+ {+ "drift_at_bound": false,+ "drift_bound_hz": 1.6825187416801504,+ "f0_hz": 84.13170299090856,+ "independent_sample_count": 39,+ "outlier_fraction": 0.0,+ "rmse_hz": 0.2998121471832343,+ "sample_count": 39,+ "score": -0.2968342319362565,+ "source_drift_hz": -0.2981572477111744,+ "source_drift_hz_s": -0.014774534168721565,+ "source_reference_emission_time_s": 1788900032.411156,+ "source_span_s": 20.1804838180542,+ "support_fraction": 1.0+ },+ {+ "drift_at_bound": false,+ "drift_bound_hz": 2.2646095658716905,+ "f0_hz": 113.36697024327991,+ "independent_sample_count": 142,+ "outlier_fraction": 0.004713611285711706,+ "rmse_hz": 0.3092541402406911,+ "sample_count": 225,+ "score": -0.26502645466322167,+ "source_drift_hz": -0.8749864817850722,+ "source_drift_hz_s": -0.009724971729954329,+ "source_reference_emission_time_s": 1788900762.684825,+ "source_span_s": 89.97316455841064,+ "support_fraction": 1.0+ },+ {+ "drift_at_bound": false,+ "drift_bound_hz": 2.4873603617831344,+ "f0_hz": 124.39103753305962,+ "independent_sample_count": 84,+ "outlier_fraction": 0.0,+ "rmse_hz": 0.4450253415064155,+ "sample_count": 84,+ "score": -0.40298391330589317,+ "source_drift_hz": 0.3325698597118652,+ "source_drift_hz_s": 0.005917248437340655,+ "source_reference_emission_time_s": 1788901726.4525921,+ "source_span_s": 56.20346403121948,+ "support_fraction": 1.0+ },+ {+ "drift_at_bound": true,+ "drift_bound_hz": 1.561566593387734,+ "f0_hz": 78.61379620310488,+ "independent_sample_count": 63,+ "outlier_fraction": 0.5299059605429844,+ "rmse_hz": 3.526636356704065,+ "sample_count": 63,+ "score": -2.18645788666092,+ "source_drift_hz": -1.561566593387734,+ "source_drift_hz_s": -0.04612157949200296,+ "source_reference_emission_time_s": 1788901875.741193,+ "source_span_s": 33.85761308670044,+ "support_fraction": 1.0+ }+ ],+ "event_ids": [+ "event-0005",+ "event-0006",+ "event-0009",+ "event-0010",+ "event-0012",+ "event-0014"+ ],+ "event_indices": [+ 4,+ 5,+ 8,+ 9,+ 11,+ 13+ ],+ "event_scores": [+ -2.150826545572909,+ -0.1897030039869119,+ -0.2968342319362565,+ -0.26502645466322167,+ -0.40298391330589317,+ -2.18645788666092+ ],+ "f0_hz": [+ 97.32639892584645,+ 93.84737473787023,+ 84.13170299090856,+ 113.36697024327991,+ 124.39103753305962,+ 78.61379620310488+ ],+ "flight_ids": [+ "ab50b9:11",+ "a63e21:2",+ "aa61d2:3",+ "a1dfeb:1",+ "ace391:3",+ "a9bd90:37"+ ],+ "lat": 40.87527856914744,+ "lon": -73.52482322363304,+ "mode_id": "mode-81af2214443fc031dc3b3c020dfb10843b401258e4a79c6341100e7e0c284c68",+ "mode_seed": {+ "event_indices": [+ 4,+ 5,+ 8,+ 9,+ 11,+ 13+ ],+ "flight_ids": [+ "ab50b9:11",+ "a63e21:2",+ "aa61d2:3",+ "a1dfeb:1",+ "ace391:3",+ "a9bd90:37"+ ],+ "pass_emission_times_s": [+ 1788899360.29,+ 1788899409.29,+ 1788900032.62,+ 1788900787.8924088,+ 1788901720.1022885,+ 1788901882.91+ ],+ "position": [+ 1861500.0,+ 2206000.0,+ 40.87348267287692,+ -73.52240429826175,+ -26.383710861206055+ ],+ "recording_start_time_s": 1788898650.1249554+ },+ "optimizer_success": true,+ "pass_emission_times_s": [+ 1788899360.29,+ 1788899409.29,+ 1788900032.62,+ 1788900787.8924088,+ 1788901720.1022885,+ 1788901882.91+ ],+ "point_id": 3,+ "position_boundary_limited": false,+ "recording_start_time_s": 1788898649.6315057,+ "refinement_clock_bounds_s": [+ 1788898645.1249554,+ 1788898655.1249554+ ],+ "residual_score": -5.491832036126112,+ "score": 4.169389321291296,+ "score_kind": "matched_group_support_minus_normalized_residual",+ "scoring_assessment": {+ "complete": true,+ "empty_clock_domain": false,+ "evaluated_trials": 22,+ "reasons": [],+ "rejected_trials": 0,+ "scheduled_trials": 22,+ "trial_count_semantics": "disjoint_evaluated_rejected_unknown",+ "unknown_trials": 0+ },+ "sensitivity": {+ "boundary_limited": false,+ "complete": true,+ "kind": "sensitivity",+ "method": "profiled_relative_altitude_offsets",+ "profiles": [+ {+ "altitude_offset_m": -150.0,+ "boundary_limited": false,+ "clock_boundary_limited": false,+ "elev_m": -31.25569725036621,+ "event_diagnostics": [+ {+ "drift_at_bound": true,+ "drift_bound_hz": 1.9557168758362349,+ "f0_hz": 97.33627691198396,+ "independent_sample_count": 30,+ "outlier_fraction": 0.4606029066149883,+ "rmse_hz": 3.6422399875470246,+ "sample_count": 30,+ "score": -2.1499388239198787,+ "source_drift_hz": -1.9557168758362349,+ "source_drift_hz_s": -0.08879145265290983,+ "source_reference_emission_time_s": 1788899339.4627566,+ "source_span_s": 22.025958776474,+ "support_fraction": 1.0+ },+ {+ "drift_at_bound": false,+ "drift_bound_hz": 1.8760850875031516,+ "f0_hz": 93.81634596882584,+ "independent_sample_count": 48,+ "outlier_fraction": 0.0,+ "rmse_hz": 0.19272106062446417,+ "sample_count": 48,+ "score": -0.18972025297792325,+ "source_drift_hz": -0.005575122456865824,+ "source_drift_hz_s": -0.00021992208261180517,+ "source_reference_emission_time_s": 1788899401.01081,+ "source_span_s": 25.350444078445435,+ "support_fraction": 1.0+ },+ {+ "drift_at_bound": false,+ "drift_bound_hz": 1.6823227783624657,+ "f0_hz": 84.1298448748555,+ "independent_sample_count": 39,+ "outlier_fraction": 0.0,+ "rmse_hz": 0.29821579280154054,+ "sample_count": 39,+ "score": -0.2961689063489273,+ "source_drift_hz": -0.3170510554789275,+ "source_drift_hz_s": -0.01571027998036626,+ "source_reference_emission_time_s": 1788900032.4149961,+ "source_span_s": 20.18112063407898,+ "support_fraction": 1.0+ },+ {+ "drift_at_bound": false,+ "drift_bound_hz": 2.256579619361823,+ "f0_hz": 113.26072639969232,+ "independent_sample_count": 142,+ "outlier_fraction": 0.004713611285711706,+ "rmse_hz": 0.3334277854684211,+ "sample_count": 225,+ "score": -0.31857389099166294,+ "source_drift_hz": -1.958741014374808,+ "source_drift_hz_s": -0.021747595793865423,+ "source_reference_emission_time_s": 1788900762.328755,+ "source_span_s": 90.06701397895813,+ "support_fraction": 1.0+ },+ {+ "drift_at_bound": false,+ "drift_bound_hz": 2.48828809937321,+ "f0_hz": 124.39236469275184,+ "independent_sample_count": 84,+ "outlier_fraction": 0.0,+ "rmse_hz": 0.45145172567338804,+ "sample_count": 84,+ "score": -0.40828596054095434,+ "source_drift_hz": -0.14472886417968645,+ "source_drift_hz_s": -0.002574789297972262,+ "source_reference_emission_time_s": 1788901726.3416605,+ "source_span_s": 56.209983587265015,+ "support_fraction": 1.0+ },+ {+ "drift_at_bound": true,+ "drift_bound_hz": 1.5619790221664047,+ "f0_hz": 78.61004319633597,+ "independent_sample_count": 63,+ "outlier_fraction": 0.5299059605429844,+ "rmse_hz": 3.5260392467384984,+ "sample_count": 63,+ "score": -2.186786041186924,+ "source_drift_hz": -1.5619790221664047,+ "source_drift_hz_s": -0.04613498098789196,+ "source_reference_emission_time_s": 1788901875.7143104,+ "source_span_s": 33.856717586517334,+ "support_fraction": 1.0+ }+ ],+ "event_scores": [+ -2.1499388239198787,+ -0.18972025297792325,+ -0.2961689063489273,+ -0.31857389099166294,+ -0.40828596054095434,+ -2.186786041186924+ ],+ "f0_hz": [+ 97.33627691198396,+ 93.81634596882584,+ 84.1298448748555,+ 113.26072639969232,+ 124.39236469275184,+ 78.61004319633597+ ],+ "lat": 40.87541471569624,+ "lon": -73.52470167243045,+ "optimizer_success": true,+ "position_boundary_limited": false,+ "recording_start_time_s": 1788898649.6267543,+ "residual_score": -5.549473875966271,+ "score": 4.15017537467791,+ "score_kind": "matched_group_support_minus_normalized_residual"+ },+ {+ "altitude_offset_m": 0.0,+ "boundary_limited": false,+ "clock_boundary_limited": false,+ "elev_m": -31.25569725036621,+ "event_diagnostics": [+ {+ "drift_at_bound": true,+ "drift_bound_hz": 1.9555526977840607,+ "f0_hz": 97.32639892584645,+ "independent_sample_count": 30,+ "outlier_fraction": 0.4606029066149883,+ "rmse_hz": 3.645240444675128,+ "sample_count": 30,+ "score": -2.150826545572909,+ "source_drift_hz": -1.9555526977840607,+ "source_drift_hz_s": -0.08876946935140981,+ "source_reference_emission_time_s": 1788899339.5010288,+ "source_span_s": 22.029563903808594,+ "support_fraction": 1.0+ },+ {+ "drift_at_bound": false,+ "drift_bound_hz": 1.8767094275842988,+ "f0_hz": 93.84737473787023,+ "independent_sample_count": 48,+ "outlier_fraction": 0.0,+ "rmse_hz": 0.19269890407255608,+ "sample_count": 48,+ "score": -0.1897030039869119,+ "source_drift_hz": -0.009391699078497925,+ "source_drift_hz_s": -0.00037059740241461727,+ "source_reference_emission_time_s": 1788899401.004428,+ "source_span_s": 25.342053174972534,+ "support_fraction": 1.0+ },+ {+ "drift_at_bound": false,+ "drift_bound_hz": 1.6825187416801504,+ "f0_hz": 84.13170299090856,+ "independent_sample_count": 39,+ "outlier_fraction": 0.0,+ "rmse_hz": 0.2998121471832343,+ "sample_count": 39,+ "score": -0.2968342319362565,+ "source_drift_hz": -0.2981572477111744,+ "source_drift_hz_s": -0.014774534168721565,+ "source_reference_emission_time_s": 1788900032.411156,+ "source_span_s": 20.1804838180542,+ "support_fraction": 1.0+ },+ {+ "drift_at_bound": false,+ "drift_bound_hz": 2.2646095658716905,+ "f0_hz": 113.36697024327991,+ "independent_sample_count": 142,+ "outlier_fraction": 0.004713611285711706,+ "rmse_hz": 0.3092541402406911,+ "sample_count": 225,+ "score": -0.26502645466322167,+ "source_drift_hz": -0.8749864817850722,+ "source_drift_hz_s": -0.009724971729954329,+ "source_reference_emission_time_s": 1788900762.684825,+ "source_span_s": 89.97316455841064,+ "support_fraction": 1.0+ },+ {+ "drift_at_bound": false,+ "drift_bound_hz": 2.4873603617831344,+ "f0_hz": 124.39103753305962,+ "independent_sample_count": 84,+ "outlier_fraction": 0.0,+ "rmse_hz": 0.4450253415064155,+ "sample_count": 84,+ "score": -0.40298391330589317,+ "source_drift_hz": 0.3325698597118652,+ "source_drift_hz_s": 0.005917248437340655,+ "source_reference_emission_time_s": 1788901726.4525921,+ "source_span_s": 56.20346403121948,+ "support_fraction": 1.0+ },+ {+ "drift_at_bound": true,+ "drift_bound_hz": 1.561566593387734,+ "f0_hz": 78.61379620310488,+ "independent_sample_count": 63,+ "outlier_fraction": 0.5299059605429844,+ "rmse_hz": 3.526636356704065,+ "sample_count": 63,+ "score": -2.18645788666092,+ "source_drift_hz": -1.561566593387734,+ "source_drift_hz_s": -0.04612157949200296,+ "source_reference_emission_time_s": 1788901875.741193,+ "source_span_s": 33.85761308670044,+ "support_fraction": 1.0+ }+ ],+ "event_scores": [+ -2.150826545572909,+ -0.1897030039869119,+ -0.2968342319362565,+ -0.26502645466322167,+ -0.40298391330589317,+ -2.18645788666092+ ],+ "f0_hz": [+ 97.32639892584645,+ 93.84737473787023,+ 84.13170299090856,+ 113.36697024327991,+ 124.39103753305962,+ 78.61379620310488+ ],+ "lat": 40.87527856914744,+ "lon": -73.52482322363304,+ "optimizer_success": true,+ "position_boundary_limited": false,+ "recording_start_time_s": 1788898649.6315057,+ "residual_score": -5.491832036126112,+ "score": 4.169389321291296,+ "score_kind": "matched_group_support_minus_normalized_residual"+ },+ {+ "altitude_offset_m": 150.0,+ "boundary_limited": false,+ "clock_boundary_limited": false,+ "elev_m": -31.25569725036621,+ "event_diagnostics": [+ {+ "drift_at_bound": true,+ "drift_bound_hz": 1.9551667010109872,+ "f0_hz": 97.30840540788162,+ "independent_sample_count": 30,+ "outlier_fraction": 0.4606029066149883,+ "rmse_hz": 3.644157720459607,+ "sample_count": 30,+ "score": -2.150349315323083,+ "source_drift_hz": -1.9551667010109872,+ "source_drift_hz_s": -0.08873614772121957,+ "source_reference_emission_time_s": 1788899339.5047398,+ "source_span_s": 22.033486366271973,+ "support_fraction": 1.0+ },+ {+ "drift_at_bound": false,+ "drift_bound_hz": 1.8779420913232396,+ "f0_hz": 93.90893240472435,+ "independent_sample_count": 48,+ "outlier_fraction": 0.0,+ "rmse_hz": 0.19265787062497872,+ "sample_count": 48,+ "score": -0.18966314767339493,+ "source_drift_hz": -0.009876530879879523,+ "source_drift_hz_s": -0.00038998445562438085,+ "source_reference_emission_time_s": 1788899401.041475,+ "source_span_s": 25.32544755935669,+ "support_fraction": 1.0+ },+ {+ "drift_at_bound": false,+ "drift_bound_hz": 1.682381892345416,+ "f0_hz": 84.11071753795466,+ "independent_sample_count": 39,+ "outlier_fraction": 0.0,+ "rmse_hz": 0.3017961075152238,+ "sample_count": 39,+ "score": -0.2977167031021817,+ "source_drift_hz": -0.2742900354971501,+ "source_drift_hz_s": -0.013588611475033409,+ "source_reference_emission_time_s": 1788900032.415618,+ "source_span_s": 20.185287952423096,+ "support_fraction": 1.0+ },+ {+ "drift_at_bound": false,+ "drift_bound_hz": 2.2711735166987084,+ "f0_hz": 113.51163188371203,+ "independent_sample_count": 142,+ "outlier_fraction": 0.004713611285711706,+ "rmse_hz": 0.31256550242671005,+ "sample_count": 225,+ "score": -0.2624163942269973,+ "source_drift_hz": 0.2025555461788988,+ "source_drift_hz_s": 0.0022543064713573513,+ "source_reference_emission_time_s": 1788900763.0438275,+ "source_span_s": 89.8527102470398,+ "support_fraction": 1.0+ },+ {+ "drift_at_bound": false,+ "drift_bound_hz": 2.4889609841030502,+ "f0_hz": 124.45207065455271,+ "independent_sample_count": 84,+ "outlier_fraction": 0.0,+ "rmse_hz": 0.4446694678555746,+ "sample_count": 84,+ "score": -0.40827568669456077,+ "source_drift_hz": 0.8158480715060248,+ "source_drift_hz_s": 0.01452514526402433,+ "source_reference_emission_time_s": 1788901726.598112,+ "source_span_s": 56.1679801940918,+ "support_fraction": 1.0+ },+ {+ "drift_at_bound": true,+ "drift_bound_hz": 1.5615044663619346,+ "f0_hz": 78.6042082191254,+ "independent_sample_count": 63,+ "outlier_fraction": 0.5299059605429844,+ "rmse_hz": 3.528665253662825,+ "sample_count": 63,+ "score": -2.1872224712587824,+ "source_drift_hz": -1.5615044663619346,+ "source_drift_hz_s": -0.046113163771991525,+ "source_reference_emission_time_s": 1788901875.7362804,+ "source_span_s": 33.86244487762451,+ "support_fraction": 1.0+ }+ ],+ "event_scores": [+ -2.150349315323083,+ -0.18966314767339493,+ -0.2977167031021817,+ -0.2624163942269973,+ -0.40827568669456077,+ -2.1872224712587824+ ],+ "f0_hz": [+ 97.30840540788162,+ 93.90893240472435,+ 84.11071753795466,+ 113.51163188371203,+ 124.45207065455271,+ 78.6042082191254+ ],+ "lat": 40.875238984895994,+ "lon": -73.52506677594829,+ "optimizer_success": true,+ "position_boundary_limited": false,+ "recording_start_time_s": 1788898649.6506264,+ "residual_score": -5.495643718279,+ "score": 4.168118760573667,+ "score_kind": "matched_group_support_minus_normalized_residual"+ }+ ],+ "radius_m": 20.99525599974103+ },+ "time_adjustment_s": -18.49969744682312,+ "unmatched_event_ids": [+ "event-0001",+ "event-0002",+ "event-0003",+ "event-0004",+ "event-0007",+ "event-0008",+ "event-0011",+ "event-0013",+ "event-0015"+ ],+ "x": 1861256.3029461065,+ "y": 2206148.136317972+ },+ "events": [+ {+ "event_id": "event-0001",+ "harmonic_group_id": "harmonics-0001",+ "start_s": 293.5,+ "end_s": 308.5,+ "band_hz": [+ 1088.75,+ 1250.547802299261+ ],+ "ridge": [+ {+ "time_s": 294.5,+ "frequency_hz": 1249.547802299261,+ "weight": 2.8777732849121094+ },+ {+ "time_s": 295.0,+ "frequency_hz": 1243.0382833741605,+ "weight": 3.3810184001922607+ },+ {+ "time_s": 295.5,+ "frequency_hz": 1243.0224252510816,+ "weight": 3.299999713897705+ },+ {+ "time_s": 296.0,+ "frequency_hz": 1239.25,+ "weight": 2.781999349594116+ },+ {+ "time_s": 296.5,+ "frequency_hz": 1233.9241161048412,+ "weight": 3.1209261417388916+ },+ {+ "time_s": 297.0,+ "frequency_hz": 1225.4808915741742,+ "weight": 2.6617114543914795+ },+ {+ "time_s": 297.5,+ "frequency_hz": 1206.092030160129,+ "weight": 3.122915506362915+ },+ {+ "time_s": 298.0,+ "frequency_hz": 1206.0485456362367,+ "weight": 3.004866361618042+ },+ {+ "time_s": 299.0,+ "frequency_hz": 1177.1920129656792,+ "weight": 2.701629638671875+ },+ {+ "time_s": 299.5,+ "frequency_hz": 1167.9850930953398,+ "weight": 3.5671420097351074+ },+ {+ "time_s": 300.0,+ "frequency_hz": 1159.689205929637,+ "weight": 2.5834555625915527+ },+ {+ "time_s": 300.5,+ "frequency_hz": 1150.25,+ "weight": 3.631985902786255+ },+ {+ "time_s": 301.0,+ "frequency_hz": 1150.3372136056423,+ "weight": 3.43243408203125+ },+ {+ "time_s": 301.5,+ "frequency_hz": 1140.8817619606853,+ "weight": 2.974381446838379+ },+ {+ "time_s": 302.0,+ "frequency_hz": 1141.389750547707,+ "weight": 2.686331033706665+ },+ {+ "time_s": 303.0,+ "frequency_hz": 1117.5290702376515,+ "weight": 2.651913642883301+ },+ {+ "time_s": 303.5,+ "frequency_hz": 1117.25,+ "weight": 2.983452081680298+ },+ {+ "time_s": 304.0,+ "frequency_hz": 1116.5834736898541,+ "weight": 2.8092455863952637+ },+ {+ "time_s": 305.0,+ "frequency_hz": 1104.75,+ "weight": 2.6589415073394775+ },+ {+ "time_s": 305.5,+ "frequency_hz": 1098.25,+ "weight": 3.0589823722839355+ },+ {+ "time_s": 306.5,+ "frequency_hz": 1093.4979960024357,+ "weight": 2.795626401901245+ },+ {+ "time_s": 307.0,+ "frequency_hz": 1089.9549681134522,+ "weight": 2.957446813583374+ },+ {+ "time_s": 307.5,+ "frequency_hz": 1089.75,+ "weight": 3.061095952987671+ }+ ],+ "quality": {+ "median_contrast": 2.974381446838379,+ "harmonic_count": 1.0,+ "support_fraction": 0.8518518518518519,+ "frequency_resolution_hz": 0.5,+ "time_uncertainty_s": 1.0,+ "frequency_uncertainty_hz": 0.5,+ "frequency_sigma_hz": 0.5,+ "fragment_count": 1.0,+ "max_observed_gap_s": 1.0,+ "frequency_drop_hz": 153.08331526070833+ }+ },+ {+ "event_id": "event-0002",+ "harmonic_group_id": "harmonics-0002",+ "start_s": 493.0,+ "end_s": 515.0,+ "band_hz": [+ 62.54794663563371,+ 70.84431332349777+ ],+ "ridge": [+ {+ "time_s": 494.0,+ "frequency_hz": 69.000796400127,+ "weight": 3.334707260131836+ },+ {+ "time_s": 494.5,+ "frequency_hz": 69.20017920434475,+ "weight": 3.518777847290039+ },+ {+ "time_s": 495.0,+ "frequency_hz": 69.32195530831814,+ "weight": 3.2223000526428223+ },+ {+ "time_s": 497.0,+ "frequency_hz": 69.84431332349777,+ "weight": 3.706312656402588+ },+ {+ "time_s": 497.5,+ "frequency_hz": 69.81262668967247,+ "weight": 3.822808027267456+ },+ {+ "time_s": 498.0,+ "frequency_hz": 69.41190458834171,+ "weight": 4.0718889236450195+ },+ {+ "time_s": 498.5,+ "frequency_hz": 69.18135164678097,+ "weight": 4.163730144500732+ },+ {+ "time_s": 499.0,+ "frequency_hz": 68.82196933031082,+ "weight": 3.8733415603637695+ },+ {+ "time_s": 499.5,+ "frequency_hz": 68.2603750526905,+ "weight": 3.53249192237854+ },+ {+ "time_s": 500.0,+ "frequency_hz": 68.10892079770565,+ "weight": 2.8054795265197754+ },+ {+ "time_s": 500.5,+ "frequency_hz": 67.75,+ "weight": 2.9310624599456787+ },+ {+ "time_s": 501.0,+ "frequency_hz": 67.56514550000429,+ "weight": 3.291046619415283+ },+ {+ "time_s": 501.5,+ "frequency_hz": 66.75,+ "weight": 2.8205995559692383+ },+ {+ "time_s": 502.0,+ "frequency_hz": 65.75,+ "weight": 2.9116649627685547+ },+ {+ "time_s": 502.5,+ "frequency_hz": 65.28100465238094,+ "weight": 2.629196882247925+ },+ {+ "time_s": 504.0,+ "frequency_hz": 65.75,+ "weight": 2.8020529747009277+ },+ {+ "time_s": 504.5,+ "frequency_hz": 65.47841335833073,+ "weight": 2.9971678256988525+ },+ {+ "time_s": 505.0,+ "frequency_hz": 65.42899303883314,+ "weight": 3.181246757507324+ },+ {+ "time_s": 505.5,+ "frequency_hz": 65.48817101120949,+ "weight": 3.607776641845703+ },+ {+ "time_s": 506.0,+ "frequency_hz": 65.41242394596338,+ "weight": 3.3996479511260986+ },+ {+ "time_s": 506.5,+ "frequency_hz": 65.2252188026905,+ "weight": 2.913186550140381+ },+ {+ "time_s": 507.0,+ "frequency_hz": 65.69744223356247,+ "weight": 3.4847946166992188+ },+ {+ "time_s": 507.5,+ "frequency_hz": 64.75,+ "weight": 3.6911473274230957+ },+ {+ "time_s": 508.0,+ "frequency_hz": 64.49251451482996,+ "weight": 3.8633172512054443+ },+ {+ "time_s": 508.5,+ "frequency_hz": 64.64836272597313,+ "weight": 3.784708261489868+ },+ {+ "time_s": 509.0,+ "frequency_hz": 64.75,+ "weight": 3.7748608589172363+ },+ {+ "time_s": 509.5,+ "frequency_hz": 64.59369346499443,+ "weight": 4.01419734954834+ },+ {+ "time_s": 510.0,+ "frequency_hz": 64.16506668925285,+ "weight": 3.858379364013672+ },+ {+ "time_s": 510.5,+ "frequency_hz": 64.34762923419476,+ "weight": 3.540637969970703+ },+ {+ "time_s": 511.0,+ "frequency_hz": 64.75,+ "weight": 3.4720375537872314+ },+ {+ "time_s": 511.5,+ "frequency_hz": 64.63569143414497,+ "weight": 3.267094373703003+ },+ {+ "time_s": 512.0,+ "frequency_hz": 64.14358824491501,+ "weight": 3.5422115325927734+ },+ {+ "time_s": 512.5,+ "frequency_hz": 64.02803279459476,+ "weight": 3.8467817306518555+ },+ {+ "time_s": 513.0,+ "frequency_hz": 63.851750656962395,+ "weight": 3.6684377193450928+ },+ {+ "time_s": 513.5,+ "frequency_hz": 63.54794663563371,+ "weight": 3.7492027282714844+ },+ {+ "time_s": 514.0,+ "frequency_hz": 63.54938545823097,+ "weight": 3.350447654724121+ }+ ],+ "quality": {+ "median_contrast": 3.5256348848342896,+ "harmonic_count": 1.0,+ "support_fraction": 0.8780487804878049,+ "frequency_resolution_hz": 0.5,+ "time_uncertainty_s": 1.0,+ "frequency_uncertainty_hz": 0.5,+ "frequency_sigma_hz": 0.5,+ "fragment_count": 1.0,+ "max_observed_gap_s": 2.0,+ "frequency_drop_hz": 5.427038222551346+ }+ },+ {+ "event_id": "event-0003",+ "harmonic_group_id": "harmonics-0003",+ "start_s": 676.0,+ "end_s": 690.0,+ "band_hz": [+ 629.75,+ 775.3418394625187+ ],+ "ridge": [+ {+ "time_s": 677.0,+ "frequency_hz": 773.5477838553488,+ "weight": 2.7979354858398438+ },+ {+ "time_s": 677.5,+ "frequency_hz": 774.3418394625187,+ "weight": 2.5387659072875977+ },+ {+ "time_s": 678.0,+ "frequency_hz": 768.3859910219908,+ "weight": 2.841888904571533+ },+ {+ "time_s": 679.5,+ "frequency_hz": 756.3894713744521,+ "weight": 2.8573501110076904+ },+ {+ "time_s": 680.0,+ "frequency_hz": 749.3812200948596,+ "weight": 2.9973177909851074+ },+ {+ "time_s": 680.5,+ "frequency_hz": 749.40802244097,+ "weight": 3.5026440620422363+ },+ {+ "time_s": 681.0,+ "frequency_hz": 743.487863810733,+ "weight": 2.876250982284546+ },+ {+ "time_s": 681.5,+ "frequency_hz": 737.9899213816971,+ "weight": 2.6558682918548584+ },+ {+ "time_s": 682.0,+ "frequency_hz": 732.653811186552,+ "weight": 2.9473774433135986+ },+ {+ "time_s": 682.5,+ "frequency_hz": 727.25,+ "weight": 3.1619019508361816+ },+ {+ "time_s": 683.0,+ "frequency_hz": 718.7913203388453,+ "weight": 2.8764796257019043+ },+ {+ "time_s": 684.0,+ "frequency_hz": 707.382537201047,+ "weight": 2.6562962532043457+ },+ {+ "time_s": 684.5,+ "frequency_hz": 697.7694919407368,+ "weight": 2.6722939014434814+ },+ {+ "time_s": 685.0,+ "frequency_hz": 697.3133299350739,+ "weight": 3.555149793624878+ },+ {+ "time_s": 686.0,+ "frequency_hz": 674.7795519977808,+ "weight": 2.6712381839752197+ },+ {+ "time_s": 687.0,+ "frequency_hz": 661.8900452256203,+ "weight": 3.13871431350708+ },+ {+ "time_s": 687.5,+ "frequency_hz": 653.7437313199043,+ "weight": 2.674705743789673+ },+ {+ "time_s": 688.0,+ "frequency_hz": 644.0840753614902,+ "weight": 2.5137481689453125+ },+ {+ "time_s": 689.0,+ "frequency_hz": 630.75,+ "weight": 2.5652449131011963+ }+ ],+ "quality": {+ "median_contrast": 2.841888904571533,+ "harmonic_count": 1.0,+ "support_fraction": 0.76,+ "frequency_resolution_hz": 0.5,+ "time_uncertainty_s": 1.0,+ "frequency_uncertainty_hz": 0.5,+ "frequency_sigma_hz": 0.5,+ "fragment_count": 1.0,+ "max_observed_gap_s": 1.5,+ "frequency_drop_hz": 129.46370849385858+ }+ },+ {+ "event_id": "event-0004",+ "harmonic_group_id": "harmonics-0004",+ "start_s": 698.5,+ "end_s": 716.5,+ "band_hz": [+ 64.75,+ 74.680678114295+ ],+ "ridge": [+ {+ "time_s": 699.5,+ "frequency_hz": 71.98835494555533,+ "weight": 2.6804614067077637+ },+ {+ "time_s": 700.0,+ "frequency_hz": 72.40427328646183,+ "weight": 2.7825469970703125+ },+ {+ "time_s": 700.5,+ "frequency_hz": 72.62793473899364,+ "weight": 2.5767300128936768+ },+ {+ "time_s": 701.0,+ "frequency_hz": 72.95201842859387,+ "weight": 2.9412596225738525+ },+ {+ "time_s": 701.5,+ "frequency_hz": 73.05120927840471,+ "weight": 2.867142915725708+ },+ {+ "time_s": 702.0,+ "frequency_hz": 73.17277990281582,+ "weight": 2.613265037536621+ },+ {+ "time_s": 702.5,+ "frequency_hz": 73.29578739404678,+ "weight": 3.214609146118164+ },+ {+ "time_s": 703.0,+ "frequency_hz": 73.33156515657902,+ "weight": 3.539111375808716+ },+ {+ "time_s": 703.5,+ "frequency_hz": 73.39991942048073,+ "weight": 3.6357803344726562+ },+ {+ "time_s": 704.0,+ "frequency_hz": 73.40980537980795,+ "weight": 3.6101608276367188+ },+ {+ "time_s": 704.5,+ "frequency_hz": 73.43474498391151,+ "weight": 3.78637433052063+ },+ {+ "time_s": 705.0,+ "frequency_hz": 73.5295634381473,+ "weight": 4.20522928237915+ },+ {+ "time_s": 705.5,+ "frequency_hz": 73.63067837059498,+ "weight": 4.110439777374268+ },+ {+ "time_s": 706.0,+ "frequency_hz": 73.62017954140902,+ "weight": 3.963181972503662+ },+ {+ "time_s": 706.5,+ "frequency_hz": 73.57721058279276,+ "weight": 4.052421569824219+ },+ {+ "time_s": 707.0,+ "frequency_hz": 73.680678114295,+ "weight": 3.9374847412109375+ },+ {+ "time_s": 707.5,+ "frequency_hz": 73.57664869725704,+ "weight": 4.311135292053223+ },+ {+ "time_s": 708.0,+ "frequency_hz": 73.49337696703151,+ "weight": 4.148069858551025+ },+ {+ "time_s": 708.5,+ "frequency_hz": 73.32921762764454,+ "weight": 4.12125825881958+ },+ {+ "time_s": 709.0,+ "frequency_hz": 72.86783991754055,+ "weight": 4.134531021118164+ },+ {+ "time_s": 709.5,+ "frequency_hz": 71.75,+ "weight": 4.291455268859863+ },+ {+ "time_s": 710.0,+ "frequency_hz": 71.08225592970848,+ "weight": 4.148694038391113+ },+ {+ "time_s": 710.5,+ "frequency_hz": 69.48873958457261,+ "weight": 4.182913780212402+ },+ {+ "time_s": 711.0,+ "frequency_hz": 68.75,+ "weight": 4.010362148284912+ },+ {+ "time_s": 711.5,+ "frequency_hz": 67.47525701485574,+ "weight": 4.337605953216553+ },+ {+ "time_s": 712.0,+ "frequency_hz": 66.9613605812192,+ "weight": 4.418043613433838+ },+ {+ "time_s": 712.5,+ "frequency_hz": 66.40155109018087,+ "weight": 4.640461444854736+ },+ {+ "time_s": 713.0,+ "frequency_hz": 66.25,+ "weight": 4.444750785827637+ },+ {+ "time_s": 713.5,+ "frequency_hz": 65.81103168427944,+ "weight": 4.070103168487549+ },+ {+ "time_s": 714.0,+ "frequency_hz": 65.75,+ "weight": 3.9205644130706787+ },+ {+ "time_s": 714.5,+ "frequency_hz": 65.75,+ "weight": 3.684089183807373+ },+ {+ "time_s": 715.0,+ "frequency_hz": 65.75,+ "weight": 3.0070552825927734+ },+ {+ "time_s": 715.5,+ "frequency_hz": 65.75,+ "weight": 2.6314311027526855+ }+ ],+ "quality": {+ "median_contrast": 3.963181972503662,+ "harmonic_count": 1.0,+ "support_fraction": 1.0,+ "frequency_resolution_hz": 0.5,+ "time_uncertainty_s": 1.0,+ "frequency_uncertainty_hz": 0.5,+ "frequency_sigma_hz": 0.5,+ "fragment_count": 1.0,+ "max_observed_gap_s": 0.5,+ "frequency_drop_hz": 6.877934738993645+ }+ },+ {+ "event_id": "event-0005",+ "harmonic_group_id": "harmonics-0005",+ "start_s": 730.5,+ "end_s": 752.5,+ "band_hz": [+ 97.3092510253191,+ 114.75+ ],+ "ridge": [+ {+ "time_s": 731.5,+ "frequency_hz": 113.75,+ "weight": 2.6466352939605713+ },+ {+ "time_s": 732.0,+ "frequency_hz": 113.69372263550758,+ "weight": 2.806791305541992+ },+ {+ "time_s": 733.0,+ "frequency_hz": 112.95944985747337,+ "weight": 2.570406198501587+ },+ {+ "time_s": 735.0,+ "frequency_hz": 112.09129034727812,+ "weight": 3.149136543273926+ },+ {+ "time_s": 735.5,+ "frequency_hz": 112.22441145777702,+ "weight": 2.6715688705444336+ },+ {+ "time_s": 736.5,+ "frequency_hz": 111.12213359773159,+ "weight": 3.0138955116271973+ },+ {+ "time_s": 737.0,+ "frequency_hz": 110.55695219710469,+ "weight": 3.261744976043701+ },+ {+ "time_s": 737.5,+ "frequency_hz": 110.32967400550842,+ "weight": 2.6786532402038574+ },+ {+ "time_s": 738.0,+ "frequency_hz": 109.80799417197704,+ "weight": 2.6690711975097656+ },+ {+ "time_s": 738.5,+ "frequency_hz": 109.37732354551554,+ "weight": 2.674424648284912+ },+ {+ "time_s": 739.0,+ "frequency_hz": 109.01921674609184,+ "weight": 3.0679931640625+ },+ {+ "time_s": 739.5,+ "frequency_hz": 108.8178278952837,+ "weight": 3.1191787719726562+ },+ {+ "time_s": 740.0,+ "frequency_hz": 108.25,+ "weight": 3.2631871700286865+ },+ {+ "time_s": 740.5,+ "frequency_hz": 107.94760690629482,+ "weight": 3.184753656387329+ },+ {+ "time_s": 741.0,+ "frequency_hz": 107.61738567054272,+ "weight": 3.7007572650909424+ },+ {+ "time_s": 741.5,+ "frequency_hz": 107.48944966774434,+ "weight": 3.181230068206787+ },+ {+ "time_s": 742.0,+ "frequency_hz": 106.25,+ "weight": 2.8826889991760254+ },+ {+ "time_s": 742.5,+ "frequency_hz": 105.99500890774652,+ "weight": 3.0314507484436035+ },+ {+ "time_s": 744.5,+ "frequency_hz": 104.6674993634224,+ "weight": 2.9810986518859863+ },+ {+ "time_s": 745.0,+ "frequency_hz": 104.25,+ "weight": 3.1857502460479736+ },+ {+ "time_s": 745.5,+ "frequency_hz": 103.5798007696867,+ "weight": 2.901762008666992+ },+ {+ "time_s": 746.0,+ "frequency_hz": 102.99620893737301,+ "weight": 4.054580211639404+ },+ {+ "time_s": 746.5,+ "frequency_hz": 102.56428946554661,+ "weight": 4.157207489013672+ },+ {+ "time_s": 747.0,+ "frequency_hz": 101.91074030846357,+ "weight": 3.3490371704101562+ },+ {+ "time_s": 748.5,+ "frequency_hz": 100.75,+ "weight": 2.529965400695801+ },+ {+ "time_s": 749.0,+ "frequency_hz": 100.75,+ "weight": 2.6465201377868652+ },+ {+ "time_s": 749.5,+ "frequency_hz": 99.69247123599052,+ "weight": 2.5727715492248535+ },+ {+ "time_s": 750.0,+ "frequency_hz": 99.58579208701849,+ "weight": 3.15375018119812+ },+ {+ "time_s": 750.5,+ "frequency_hz": 99.42760767042637,+ "weight": 2.702454090118408+ },+ {+ "time_s": 751.5,+ "frequency_hz": 98.3092510253191,+ "weight": 2.658541679382324+ }+ ],+ "quality": {+ "median_contrast": 2.997497081756592,+ "harmonic_count": 1.0,+ "support_fraction": 0.7317073170731707,+ "frequency_resolution_hz": 0.5,+ "time_uncertainty_s": 1.0,+ "frequency_uncertainty_hz": 0.5,+ "frequency_sigma_hz": 0.5,+ "fragment_count": 1.0,+ "max_observed_gap_s": 2.0,+ "frequency_drop_hz": 13.373657770454884+ }+ },+ {+ "event_id": "event-0006",+ "harmonic_group_id": "harmonics-0006",+ "start_s": 763.0,+ "end_s": 790.0,+ "band_hz": [+ 91.54724462330341,+ 99.28836004436016+ ],+ "ridge": [+ {+ "time_s": 764.0,+ "frequency_hz": 98.28836004436016,+ "weight": 3.3233673572540283+ },+ {+ "time_s": 764.5,+ "frequency_hz": 98.04363683238626,+ "weight": 3.081063747406006+ },+ {+ "time_s": 765.0,+ "frequency_hz": 97.60053431242704,+ "weight": 3.3581361770629883+ },+ {+ "time_s": 765.5,+ "frequency_hz": 97.95339578390121,+ "weight": 2.7451894283294678+ },+ {+ "time_s": 766.5,+ "frequency_hz": 96.64086650311947,+ "weight": 2.824718952178955+ },+ {+ "time_s": 767.0,+ "frequency_hz": 96.96800610795617,+ "weight": 2.711118459701538+ },+ {+ "time_s": 767.5,+ "frequency_hz": 96.99457765277475,+ "weight": 2.7033300399780273+ },+ {+ "time_s": 768.0,+ "frequency_hz": 96.57321328669786,+ "weight": 2.638383150100708+ },+ {+ "time_s": 769.5,+ "frequency_hz": 96.46539046615362,+ "weight": 3.083188533782959+ },+ {+ "time_s": 770.0,+ "frequency_hz": 96.46053096652031,+ "weight": 4.30714225769043+ },+ {+ "time_s": 770.5,+ "frequency_hz": 96.21619592607021,+ "weight": 4.599615573883057+ },+ {+ "time_s": 771.0,+ "frequency_hz": 96.1065811663866,+ "weight": 4.4243927001953125+ },+ {+ "time_s": 771.5,+ "frequency_hz": 96.25,+ "weight": 4.544808387756348+ },+ {+ "time_s": 772.0,+ "frequency_hz": 96.25,+ "weight": 4.877041339874268+ },+ {+ "time_s": 772.5,+ "frequency_hz": 96.2061343640089,+ "weight": 4.658272743225098+ },+ {+ "time_s": 773.0,+ "frequency_hz": 96.15562333166599,+ "weight": 4.011631965637207+ },+ {+ "time_s": 773.5,+ "frequency_hz": 95.98678895831108,+ "weight": 3.6216912269592285+ },+ {+ "time_s": 774.0,+ "frequency_hz": 95.62345840036869,+ "weight": 3.6667699813842773+ },+ {+ "time_s": 774.5,+ "frequency_hz": 95.542799603194,+ "weight": 3.617081642150879+ },+ {+ "time_s": 775.0,+ "frequency_hz": 95.67410679161549,+ "weight": 3.8928732872009277+ },+ {+ "time_s": 775.5,+ "frequency_hz": 95.12695877254009,+ "weight": 2.8886866569519043+ },+ {+ "time_s": 776.0,+ "frequency_hz": 94.99246804928407,+ "weight": 3.2393417358398438+ },+ {+ "time_s": 776.5,+ "frequency_hz": 95.01047173142433,+ "weight": 3.614363670349121+ },+ {+ "time_s": 777.0,+ "frequency_hz": 95.23234751820564,+ "weight": 3.157259941101074+ },+ {+ "time_s": 777.5,+ "frequency_hz": 95.08768554031849,+ "weight": 4.033236503601074+ },+ {+ "time_s": 778.0,+ "frequency_hz": 94.89720185101032,+ "weight": 4.575918197631836+ },+ {+ "time_s": 778.5,+ "frequency_hz": 94.69105876982212,+ "weight": 4.702620029449463+ },+ {+ "time_s": 779.0,+ "frequency_hz": 94.49985515374283,+ "weight": 5.093175888061523+ },+ {+ "time_s": 779.5,+ "frequency_hz": 94.32792007923126,+ "weight": 5.427299499511719+ },+ {+ "time_s": 780.0,+ "frequency_hz": 94.26557171344757,+ "weight": 5.142704010009766+ },+ {+ "time_s": 780.5,+ "frequency_hz": 94.17220371961594,+ "weight": 5.124075412750244+ },+ {+ "time_s": 781.0,+ "frequency_hz": 94.0480330362916,+ "weight": 5.224026203155518+ },+ {+ "time_s": 781.5,+ "frequency_hz": 93.92259629070759,+ "weight": 5.316190242767334+ },+ {+ "time_s": 782.0,+ "frequency_hz": 93.80336092412472,+ "weight": 4.8578290939331055+ },+ {+ "time_s": 782.5,+ "frequency_hz": 93.90719107538462,+ "weight": 5.317373752593994+ },+ {+ "time_s": 783.0,+ "frequency_hz": 93.93783538788557,+ "weight": 4.9207377433776855+ },+ {+ "time_s": 783.5,+ "frequency_hz": 93.79298858344555,+ "weight": 4.480998516082764+ },+ {+ "time_s": 784.0,+ "frequency_hz": 93.3697168380022,+ "weight": 3.852731466293335+ },+ {+ "time_s": 784.5,+ "frequency_hz": 93.48976116534323,+ "weight": 3.7794079780578613+ },+ {+ "time_s": 785.0,+ "frequency_hz": 93.33110536634922,+ "weight": 3.7730281352996826+ },+ {+ "time_s": 785.5,+ "frequency_hz": 93.34281830489635,+ "weight": 3.6222312450408936+ },+ {+ "time_s": 786.0,+ "frequency_hz": 93.02301892265677,+ "weight": 3.4052183628082275+ },+ {+ "time_s": 786.5,+ "frequency_hz": 92.7673367112875,+ "weight": 3.2541306018829346+ },+ {+ "time_s": 787.0,+ "frequency_hz": 92.88780979812145,+ "weight": 3.103541851043701+ },+ {+ "time_s": 787.5,+ "frequency_hz": 92.93444702774286,+ "weight": 3.5148093700408936+ },+ {+ "time_s": 788.0,+ "frequency_hz": 92.6493846476078,+ "weight": 3.670137882232666+ },+ {+ "time_s": 788.5,+ "frequency_hz": 92.61032451689243,+ "weight": 3.36232852935791+ },+ {+ "time_s": 789.0,+ "frequency_hz": 92.54724462330341,+ "weight": 2.5460543632507324+ }+ ],+ "quality": {+ "median_contrast": 3.7215830087661743,+ "harmonic_count": 1.0,+ "support_fraction": 0.9411764705882353,+ "frequency_resolution_hz": 0.5,+ "time_uncertainty_s": 1.0,+ "frequency_uncertainty_hz": 0.5,+ "frequency_sigma_hz": 0.5,+ "fragment_count": 1.0,+ "max_observed_gap_s": 1.5,+ "frequency_drop_hz": 4.469982727896422+ }+ },+ {+ "event_id": "event-0007",+ "harmonic_group_id": "harmonics-0007",+ "start_s": 1028.5,+ "end_s": 1053.5,+ "band_hz": [+ 63.64075717329979,+ 74.25+ ],+ "ridge": [+ {+ "time_s": 1029.5,+ "frequency_hz": 71.75,+ "weight": 5.57882833480835+ },+ {+ "time_s": 1030.0,+ "frequency_hz": 72.15904226899147,+ "weight": 5.190572738647461+ },+ {+ "time_s": 1030.5,+ "frequency_hz": 72.25,+ "weight": 4.735195636749268+ },+ {+ "time_s": 1031.0,+ "frequency_hz": 72.25,+ "weight": 4.029102802276611+ },+ {+ "time_s": 1031.5,+ "frequency_hz": 72.64733891189098,+ "weight": 4.101685523986816+ },+ {+ "time_s": 1032.0,+ "frequency_hz": 72.74677315354347,+ "weight": 4.09249210357666+ },+ {+ "time_s": 1032.5,+ "frequency_hz": 72.75,+ "weight": 4.12748908996582+ },+ {+ "time_s": 1033.0,+ "frequency_hz": 73.25,+ "weight": 3.453917980194092+ },+ {+ "time_s": 1033.5,+ "frequency_hz": 73.25,+ "weight": 3.712665319442749+ },+ {+ "time_s": 1034.0,+ "frequency_hz": 72.75,+ "weight": 3.2167413234710693+ },+ {+ "time_s": 1034.5,+ "frequency_hz": 72.25,+ "weight": 4.598598957061768+ },+ {+ "time_s": 1035.0,+ "frequency_hz": 71.37050074338913,+ "weight": 4.473766326904297+ },+ {+ "time_s": 1035.5,+ "frequency_hz": 70.2326732724905,+ "weight": 4.489382266998291+ },+ {+ "time_s": 1036.0,+ "frequency_hz": 68.75,+ "weight": 4.878511905670166+ },+ {+ "time_s": 1036.5,+ "frequency_hz": 67.64799596369267,+ "weight": 4.305893898010254+ },+ {+ "time_s": 1037.0,+ "frequency_hz": 66.89664138108492,+ "weight": 4.502026081085205+ },+ {+ "time_s": 1037.5,+ "frequency_hz": 66.25,+ "weight": 4.603890419006348+ },+ {+ "time_s": 1038.0,+ "frequency_hz": 65.91888896375895,+ "weight": 5.1501030921936035+ },+ {+ "time_s": 1038.5,+ "frequency_hz": 65.57375885546207,+ "weight": 5.322227478027344+ },+ {+ "time_s": 1039.0,+ "frequency_hz": 65.37403729557991,+ "weight": 5.179803848266602+ },+ {+ "time_s": 1039.5,+ "frequency_hz": 65.25,+ "weight": 5.256326675415039+ },+ {+ "time_s": 1040.0,+ "frequency_hz": 65.06312090158463,+ "weight": 5.401737213134766+ },+ {+ "time_s": 1040.5,+ "frequency_hz": 64.99128822237253,+ "weight": 5.1573638916015625+ },+ {+ "time_s": 1041.0,+ "frequency_hz": 64.87495286762714,+ "weight": 5.252795219421387+ },+ {+ "time_s": 1041.5,+ "frequency_hz": 64.84404391050339,+ "weight": 4.8409953117370605+ },+ {+ "time_s": 1042.0,+ "frequency_hz": 64.69109958410263,+ "weight": 4.620543479919434+ },+ {+ "time_s": 1042.5,+ "frequency_hz": 64.73666469752789,+ "weight": 4.760761260986328+ },+ {+ "time_s": 1043.0,+ "frequency_hz": 64.75,+ "weight": 4.775789260864258+ },+ {+ "time_s": 1043.5,+ "frequency_hz": 64.82223473489285,+ "weight": 5.28117036819458+ },+ {+ "time_s": 1044.0,+ "frequency_hz": 64.93678449839354,+ "weight": 5.466803550720215+ },+ {+ "time_s": 1044.5,+ "frequency_hz": 64.80446290969849,+ "weight": 5.034647464752197+ },+ {+ "time_s": 1045.0,+ "frequency_hz": 64.86486528813839,+ "weight": 4.731871128082275+ },+ {+ "time_s": 1045.5,+ "frequency_hz": 64.91821310669184,+ "weight": 4.522501468658447+ },+ {+ "time_s": 1046.0,+ "frequency_hz": 64.72342473268509,+ "weight": 3.9992456436157227+ },+ {+ "time_s": 1046.5,+ "frequency_hz": 64.64075717329979,+ "weight": 3.7996652126312256+ },+ {+ "time_s": 1047.0,+ "frequency_hz": 64.73106576502323,+ "weight": 3.68377685546875+ },+ {+ "time_s": 1047.5,+ "frequency_hz": 64.73590010404587,+ "weight": 4.060769557952881+ },+ {+ "time_s": 1048.0,+ "frequency_hz": 64.85302682220936,+ "weight": 4.66815185546875+ },+ {+ "time_s": 1048.5,+ "frequency_hz": 64.68293884396553,+ "weight": 4.326352119445801+ },+ {+ "time_s": 1049.0,+ "frequency_hz": 64.84392286837101,+ "weight": 4.313611030578613+ },+ {+ "time_s": 1049.5,+ "frequency_hz": 65.2835443764925,+ "weight": 4.955438137054443+ },+ {+ "time_s": 1050.0,+ "frequency_hz": 65.5588588193059,+ "weight": 4.551701068878174+ },+ {+ "time_s": 1050.5,+ "frequency_hz": 65.75,+ "weight": 2.7519586086273193+ },+ {+ "time_s": 1052.0,+ "frequency_hz": 65.01450868789107,+ "weight": 2.9377262592315674+ },+ {+ "time_s": 1052.5,+ "frequency_hz": 64.96370114758611,+ "weight": 2.9179720878601074+ }+ ],+ "quality": {+ "median_contrast": 4.598598957061768,+ "harmonic_count": 1.0,+ "support_fraction": 0.9574468085106383,+ "frequency_resolution_hz": 0.5,+ "time_uncertainty_s": 1.0,+ "frequency_uncertainty_hz": 0.5,+ "frequency_sigma_hz": 0.5,+ "fragment_count": 1.0,+ "max_observed_gap_s": 1.5,+ "frequency_drop_hz": 7.235491312108934+ }+ },+ {+ "event_id": "event-0008",+ "harmonic_group_id": "harmonics-0008",+ "start_s": 1265.5,+ "end_s": 1282.5,+ "band_hz": [+ 375.02422350272536,+ 483.4118079468608+ ],+ "ridge": [+ {+ "time_s": 1266.5,+ "frequency_hz": 482.4118079468608,+ "weight": 2.5184597969055176+ },+ {+ "time_s": 1267.0,+ "frequency_hz": 478.61788857728243,+ "weight": 2.7683849334716797+ },+ {+ "time_s": 1267.5,+ "frequency_hz": 477.10593555122614,+ "weight": 3.3715033531188965+ },+ {+ "time_s": 1268.0,+ "frequency_hz": 476.57963240146637,+ "weight": 2.647406578063965+ },+ {+ "time_s": 1268.5,+ "frequency_hz": 474.54184931889176,+ "weight": 2.8566489219665527+ },+ {+ "time_s": 1269.0,+ "frequency_hz": 474.08798874914646,+ "weight": 3.0289037227630615+ },+ {+ "time_s": 1269.5,+ "frequency_hz": 473.03302828222513,+ "weight": 2.982215642929077+ },+ {+ "time_s": 1270.0,+ "frequency_hz": 467.4749313276261,+ "weight": 2.531369209289551+ },+ {+ "time_s": 1270.5,+ "frequency_hz": 467.62984459102154,+ "weight": 2.8127143383026123+ },+ {+ "time_s": 1272.0,+ "frequency_hz": 456.87808226048946,+ "weight": 2.576143741607666+ },+ {+ "time_s": 1273.5,+ "frequency_hz": 441.2856249809265,+ "weight": 3.1585962772369385+ },+ {+ "time_s": 1274.0,+ "frequency_hz": 440.75,+ "weight": 4.042668342590332+ },+ {+ "time_s": 1274.5,+ "frequency_hz": 439.41618870198727,+ "weight": 3.5207712650299072+ },+ {+ "time_s": 1275.0,+ "frequency_hz": 431.95338950306177,+ "weight": 2.667498826980591+ },+ {+ "time_s": 1275.5,+ "frequency_hz": 427.2266471236944,+ "weight": 2.5593907833099365+ },+ {+ "time_s": 1276.0,+ "frequency_hz": 421.5605297833681,+ "weight": 3.072807550430298+ },+ {+ "time_s": 1276.5,+ "frequency_hz": 419.01758655533195,+ "weight": 2.6326475143432617+ },+ {+ "time_s": 1278.5,+ "frequency_hz": 399.40979640185833,+ "weight": 3.1913490295410156+ },+ {+ "time_s": 1279.0,+ "frequency_hz": 398.6946306973696,+ "weight": 4.251245498657227+ },+ {+ "time_s": 1279.5,+ "frequency_hz": 395.75,+ "weight": 2.9225873947143555+ },+ {+ "time_s": 1280.0,+ "frequency_hz": 391.26131251454353,+ "weight": 2.874929904937744+ },+ {+ "time_s": 1280.5,+ "frequency_hz": 386.43635323643684,+ "weight": 3.1542723178863525+ },+ {+ "time_s": 1281.0,+ "frequency_hz": 381.60865819454193,+ "weight": 2.8988285064697266+ },+ {+ "time_s": 1281.5,+ "frequency_hz": 376.02422350272536,+ "weight": 2.50705885887146+ }+ ],+ "quality": {+ "median_contrast": 2.8868792057037354,+ "harmonic_count": 1.0,+ "support_fraction": 0.7741935483870968,+ "frequency_resolution_hz": 0.5,+ "time_uncertainty_s": 1.0,+ "frequency_uncertainty_hz": 0.5,+ "frequency_sigma_hz": 0.5,+ "fragment_count": 1.0,+ "max_observed_gap_s": 2.0,+ "frequency_drop_hz": 93.8394063487649+ }+ },+ {+ "event_id": "event-0009",+ "harmonic_group_id": "harmonics-0009",+ "start_s": 1396.5,+ "end_s": 1418.5,+ "band_hz": [+ 75.48960529826581,+ 93.47730490006506+ ],+ "ridge": [+ {+ "time_s": 1397.5,+ "frequency_hz": 92.36873756349087,+ "weight": 2.7631266117095947+ },+ {+ "time_s": 1398.0,+ "frequency_hz": 92.42261733859777,+ "weight": 3.2595481872558594+ },+ {+ "time_s": 1398.5,+ "frequency_hz": 92.47730490006506,+ "weight": 3.5709056854248047+ },+ {+ "time_s": 1399.0,+ "frequency_hz": 92.32872664928436,+ "weight": 3.735276699066162+ },+ {+ "time_s": 1399.5,+ "frequency_hz": 92.37508281320333,+ "weight": 3.7795627117156982+ },+ {+ "time_s": 1400.0,+ "frequency_hz": 92.279814183712,+ "weight": 3.77773380279541+ },+ {+ "time_s": 1400.5,+ "frequency_hz": 92.15065483748913,+ "weight": 4.256247520446777+ },+ {+ "time_s": 1401.0,+ "frequency_hz": 91.84217186272144,+ "weight": 4.105465412139893+ },+ {+ "time_s": 1401.5,+ "frequency_hz": 91.54205491766334,+ "weight": 3.5949952602386475+ },+ {+ "time_s": 1402.0,+ "frequency_hz": 90.99797802884132,+ "weight": 2.9301185607910156+ },+ {+ "time_s": 1402.5,+ "frequency_hz": 90.4166072756052,+ "weight": 3.0380191802978516+ },+ {+ "time_s": 1403.0,+ "frequency_hz": 90.16360810399055,+ "weight": 3.0900373458862305+ },+ {+ "time_s": 1403.5,+ "frequency_hz": 89.74159143865108,+ "weight": 3.0556859970092773+ },+ {+ "time_s": 1404.0,+ "frequency_hz": 89.0157112609595,+ "weight": 3.041625499725342+ },+ {+ "time_s": 1404.5,+ "frequency_hz": 88.38586834818125,+ "weight": 3.236879825592041+ },+ {+ "time_s": 1405.5,+ "frequency_hz": 87.29052782058716,+ "weight": 2.534029483795166+ },+ {+ "time_s": 1406.5,+ "frequency_hz": 85.82140663266182,+ "weight": 2.518751382827759+ },+ {+ "time_s": 1407.0,+ "frequency_hz": 85.55884790420532,+ "weight": 2.6413986682891846+ },+ {+ "time_s": 1407.5,+ "frequency_hz": 84.87761688232422,+ "weight": 3.09525465965271+ },+ {+ "time_s": 1408.0,+ "frequency_hz": 84.3074045330286,+ "weight": 3.1888880729675293+ },+ {+ "time_s": 1408.5,+ "frequency_hz": 83.48303856700659,+ "weight": 3.6824047565460205+ },+ {+ "time_s": 1409.0,+ "frequency_hz": 82.81785021722317,+ "weight": 4.1307373046875+ },+ {+ "time_s": 1409.5,+ "frequency_hz": 82.46707205474377,+ "weight": 4.768126964569092+ },+ {+ "time_s": 1410.0,+ "frequency_hz": 82.05812307074666,+ "weight": 4.905706882476807+ },+ {+ "time_s": 1410.5,+ "frequency_hz": 81.41014652699232,+ "weight": 4.485247611999512+ },+ {+ "time_s": 1411.0,+ "frequency_hz": 80.77479510009289,+ "weight": 4.1536712646484375+ },+ {+ "time_s": 1411.5,+ "frequency_hz": 80.06746470183134,+ "weight": 3.790189743041992+ },+ {+ "time_s": 1412.0,+ "frequency_hz": 79.74573193490505,+ "weight": 3.839203119277954+ },+ {+ "time_s": 1412.5,+ "frequency_hz": 79.39101652801037,+ "weight": 3.65541672706604+ },+ {+ "time_s": 1413.0,+ "frequency_hz": 78.80013233423233,+ "weight": 4.613580226898193+ },+ {+ "time_s": 1413.5,+ "frequency_hz": 78.57393401116133,+ "weight": 4.799997329711914+ },+ {+ "time_s": 1414.0,+ "frequency_hz": 78.25,+ "weight": 4.926913261413574+ },+ {+ "time_s": 1414.5,+ "frequency_hz": 77.96206587553024,+ "weight": 4.8989033699035645+ },+ {+ "time_s": 1415.0,+ "frequency_hz": 77.70727036893368,+ "weight": 4.675944805145264+ },+ {+ "time_s": 1415.5,+ "frequency_hz": 77.52169484458864,+ "weight": 4.452498435974121+ },+ {+ "time_s": 1416.0,+ "frequency_hz": 77.28566211462021,+ "weight": 3.6648290157318115+ },+ {+ "time_s": 1416.5,+ "frequency_hz": 76.93887219578028,+ "weight": 2.8498122692108154+ },+ {+ "time_s": 1417.0,+ "frequency_hz": 76.71686300635338,+ "weight": 2.6015255451202393+ },+ {+ "time_s": 1417.5,+ "frequency_hz": 76.48960529826581,+ "weight": 2.570895195007324+ }+ ],+ "quality": {+ "median_contrast": 3.6648290157318115,+ "harmonic_count": 1.0,+ "support_fraction": 0.9512195121951219,+ "frequency_resolution_hz": 0.5,+ "time_uncertainty_s": 1.0,+ "frequency_uncertainty_hz": 0.5,+ "frequency_sigma_hz": 0.5,+ "fragment_count": 1.0,+ "max_observed_gap_s": 1.0,+ "frequency_drop_hz": 15.259643033146858+ }+ },+ {+ "event_id": "event-0010",+ "harmonic_group_id": "harmonics-0010",+ "start_s": 2100.0,+ "end_s": 2178.5,+ "band_hz": [+ 95.86159448325634,+ 172.97881474718451+ ],+ "ridge": [+ {+ "time_s": 2101.0,+ "frequency_hz": 171.97881474718451,+ "weight": 4.990167140960693+ },+ {+ "time_s": 2101.5,+ "frequency_hz": 171.6226196065545,+ "weight": 4.410919189453125+ },+ {+ "time_s": 2102.0,+ "frequency_hz": 171.25,+ "weight": 4.355745792388916+ },+ {+ "time_s": 2102.5,+ "frequency_hz": 170.96856246888638,+ "weight": 4.749783515930176+ },+ {+ "time_s": 2103.0,+ "frequency_hz": 170.6907735913992,+ "weight": 4.606558322906494+ },+ {+ "time_s": 2103.5,+ "frequency_hz": 170.29215103387833,+ "weight": 4.537185192108154+ },+ {+ "time_s": 2104.0,+ "frequency_hz": 169.71470481157303,+ "weight": 4.901719570159912+ },+ {+ "time_s": 2104.5,+ "frequency_hz": 169.46620858833194,+ "weight": 5.924962043762207+ },+ {+ "time_s": 2105.0,+ "frequency_hz": 169.25,+ "weight": 5.748509407043457+ },+ {+ "time_s": 2105.5,+ "frequency_hz": 168.93719509243965,+ "weight": 6.184662342071533+ },+ {+ "time_s": 2106.0,+ "frequency_hz": 168.67995631694794,+ "weight": 5.120396614074707+ },+ {+ "time_s": 2106.5,+ "frequency_hz": 168.32237960398197,+ "weight": 4.701353549957275+ },+ {+ "time_s": 2107.0,+ "frequency_hz": 167.89806052297354,+ "weight": 4.87755823135376+ },+ {+ "time_s": 2107.5,+ "frequency_hz": 167.62251064926386,+ "weight": 4.348865032196045+ },+ {+ "time_s": 2108.0,+ "frequency_hz": 167.25208070874214,+ "weight": 3.291395425796509+ },+ {+ "time_s": 2108.5,+ "frequency_hz": 166.33777828514576,+ "weight": 4.33064603805542+ },+ {+ "time_s": 2109.0,+ "frequency_hz": 166.1771547049284,+ "weight": 5.020379543304443+ },+ {+ "time_s": 2109.5,+ "frequency_hz": 165.95106259733438,+ "weight": 5.393738269805908+ },+ {+ "time_s": 2110.0,+ "frequency_hz": 165.4638754464686,+ "weight": 5.497627258300781+ },+ {+ "time_s": 2110.5,+ "frequency_hz": 165.1746537834406,+ "weight": 5.9923601150512695+ },+ {+ "time_s": 2111.0,+ "frequency_hz": 164.90565279126167,+ "weight": 6.221395015716553+ },+ {+ "time_s": 2111.5,+ "frequency_hz": 164.4380707591772,+ "weight": 5.668160915374756+ },+ {+ "time_s": 2112.0,+ "frequency_hz": 164.16455967724323,+ "weight": 5.099128723144531+ },+ {+ "time_s": 2112.5,+ "frequency_hz": 163.97203492186964,+ "weight": 4.6756510734558105+ },+ {+ "time_s": 2113.0,+ "frequency_hz": 163.1695318967104,+ "weight": 4.420958518981934+ },+ {+ "time_s": 2113.5,+ "frequency_hz": 162.7386903166771,+ "weight": 4.634740352630615+ },+ {+ "time_s": 2114.0,+ "frequency_hz": 162.25,+ "weight": 4.838869571685791+ },+ {+ "time_s": 2114.5,+ "frequency_hz": 161.75,+ "weight": 5.071739673614502+ },+ {+ "time_s": 2115.0,+ "frequency_hz": 161.5203626975417,+ "weight": 4.937196254730225+ },+ {+ "time_s": 2115.5,+ "frequency_hz": 160.83730593323708,+ "weight": 4.460553169250488+ },+ {+ "time_s": 2116.0,+ "frequency_hz": 160.17149338126183,+ "weight": 5.233838081359863+ },+ {+ "time_s": 2116.5,+ "frequency_hz": 159.77809737622738,+ "weight": 5.261438369750977+ },+ {+ "time_s": 2117.0,+ "frequency_hz": 159.37117037177086,+ "weight": 5.3522467613220215+ },+ {+ "time_s": 2117.5,+ "frequency_hz": 159.07391329854727,+ "weight": 5.1053547859191895+ },+ {+ "time_s": 2118.0,+ "frequency_hz": 158.3722288608551,+ "weight": 4.6313066482543945+ },+ {+ "time_s": 2119.0,+ "frequency_hz": 157.71457135677338,+ "weight": 5.080425262451172+ },+ {+ "time_s": 2119.5,+ "frequency_hz": 157.47302014380693,+ "weight": 4.447283744812012+ },+ {+ "time_s": 2120.0,+ "frequency_hz": 157.00046039931476,+ "weight": 4.080517768859863+ },+ {+ "time_s": 2120.5,+ "frequency_hz": 156.28905183076859,+ "weight": 3.830739736557007+ },+ {+ "time_s": 2121.0,+ "frequency_hz": 155.68298131227493,+ "weight": 3.7183334827423096+ },+ {+ "time_s": 2121.5,+ "frequency_hz": 155.13650189340115,+ "weight": 3.5560479164123535+ },+ {+ "time_s": 2122.0,+ "frequency_hz": 154.75,+ "weight": 2.6620306968688965+ },+ {+ "time_s": 2126.0,+ "frequency_hz": 149.56899818778038,+ "weight": 3.7519586086273193+ },+ {+ "time_s": 2126.5,+ "frequency_hz": 149.30177983641624,+ "weight": 4.141856670379639+ },+ {+ "time_s": 2127.0,+ "frequency_hz": 148.77707487344742,+ "weight": 3.6171085834503174+ },+ {+ "time_s": 2127.5,+ "frequency_hz": 147.96813187375665,+ "weight": 3.7592642307281494+ },+ {+ "time_s": 2128.0,+ "frequency_hz": 147.4028841033578,+ "weight": 3.8244316577911377+ },+ {+ "time_s": 2128.5,+ "frequency_hz": 146.65762135386467,+ "weight": 4.069690704345703+ },+ {+ "time_s": 2129.0,+ "frequency_hz": 146.01485547423363,+ "weight": 4.88048791885376+ },+ {+ "time_s": 2129.5,+ "frequency_hz": 145.25,+ "weight": 5.378705024719238+ },+ {+ "time_s": 2130.0,+ "frequency_hz": 144.80147697031498,+ "weight": 5.898828506469727+ },+ {+ "time_s": 2130.5,+ "frequency_hz": 144.31891232728958,+ "weight": 6.072814464569092+ },+ {+ "time_s": 2131.0,+ "frequency_hz": 143.75,+ "weight": 5.463726043701172+ },+ {+ "time_s": 2131.5,+ "frequency_hz": 142.92558380961418,+ "weight": 5.206787586212158+ },+ {+ "time_s": 2132.0,+ "frequency_hz": 142.32695281505585,+ "weight": 5.022782802581787+ },+ {+ "time_s": 2132.5,+ "frequency_hz": 141.6200854331255,+ "weight": 4.965824604034424+ },+ {+ "time_s": 2133.0,+ "frequency_hz": 140.75,+ "weight": 5.3294548988342285+ },+ {+ "time_s": 2133.5,+ "frequency_hz": 140.23377357423306,+ "weight": 5.803616046905518+ },+ {+ "time_s": 2134.0,+ "frequency_hz": 139.61676401644945,+ "weight": 5.4569993019104+ },+ {+ "time_s": 2134.5,+ "frequency_hz": 139.05141166970134,+ "weight": 5.66601037979126+ },+ {+ "time_s": 2135.0,+ "frequency_hz": 138.33660586178303,+ "weight": 5.36860990524292+ },+ {+ "time_s": 2135.5,+ "frequency_hz": 137.6626528352499,+ "weight": 5.208486080169678+ },+ {+ "time_s": 2136.0,+ "frequency_hz": 137.25,+ "weight": 4.9824299812316895+ },+ {+ "time_s": 2136.5,+ "frequency_hz": 136.25,+ "weight": 4.018782138824463+ },+ {+ "time_s": 2137.0,+ "frequency_hz": 135.61697861552238,+ "weight": 5.522984504699707+ },+ {+ "time_s": 2137.5,+ "frequency_hz": 135.14452962577343,+ "weight": 5.323774814605713+ },+ {+ "time_s": 2138.0,+ "frequency_hz": 134.42672777175903,+ "weight": 4.954157829284668+ },+ {+ "time_s": 2138.5,+ "frequency_hz": 133.76455618441105,+ "weight": 4.954354286193848+ },+ {+ "time_s": 2139.0,+ "frequency_hz": 133.07127437740564,+ "weight": 4.991497993469238+ },+ {+ "time_s": 2139.5,+ "frequency_hz": 132.46478866413236,+ "weight": 4.738309860229492+ },+ {+ "time_s": 2140.0,+ "frequency_hz": 131.74092823266983,+ "weight": 4.45361852645874+ },+ {+ "time_s": 2140.5,+ "frequency_hz": 131.0461087450385,+ "weight": 4.6449689865112305+ },+ {+ "time_s": 2141.0,+ "frequency_hz": 130.4391702786088,+ "weight": 4.463802337646484+ },+ {+ "time_s": 2141.5,+ "frequency_hz": 129.75,+ "weight": 4.175246238708496+ },+ {+ "time_s": 2142.0,+ "frequency_hz": 129.09555900096893,+ "weight": 3.9643452167510986+ },+ {+ "time_s": 2142.5,+ "frequency_hz": 128.35074831545353,+ "weight": 3.1936991214752197+ },+ {+ "time_s": 2143.0,+ "frequency_hz": 127.49528455082327,+ "weight": 3.4320733547210693+ },+ {+ "time_s": 2143.5,+ "frequency_hz": 126.88966520875692,+ "weight": 3.785252571105957+ },+ {+ "time_s": 2144.0,+ "frequency_hz": 126.07314679026604,+ "weight": 4.117589473724365+ },+ {+ "time_s": 2144.5,+ "frequency_hz": 125.49598633591086,+ "weight": 4.547654628753662+ },+ {+ "time_s": 2145.0,+ "frequency_hz": 124.95437390357256,+ "weight": 4.28819465637207+ },+ {+ "time_s": 2145.5,+ "frequency_hz": 124.31804525852203,+ "weight": 4.870362758636475+ },+ {+ "time_s": 2146.0,+ "frequency_hz": 123.75,+ "weight": 4.760158538818359+ },+ {+ "time_s": 2146.5,+ "frequency_hz": 123.12512208521366,+ "weight": 4.392666339874268+ },+ {+ "time_s": 2147.0,+ "frequency_hz": 122.49566528201103,+ "weight": 4.592695236206055+ },+ {+ "time_s": 2147.5,+ "frequency_hz": 121.98231341689825,+ "weight": 4.482040882110596+ },+ {+ "time_s": 2148.0,+ "frequency_hz": 121.40919757634401,+ "weight": 4.839909076690674+ },+ {+ "time_s": 2148.5,+ "frequency_hz": 120.83919528126717,+ "weight": 4.794687747955322+ },+ {+ "time_s": 2149.0,+ "frequency_hz": 120.14977589249611,+ "weight": 4.94584846496582+ },+ {+ "time_s": 2149.5,+ "frequency_hz": 119.52441798336804,+ "weight": 5.412773132324219+ },+ {+ "time_s": 2150.0,+ "frequency_hz": 119.01877694949508,+ "weight": 4.96475076675415+ },+ {+ "time_s": 2150.5,+ "frequency_hz": 118.54788473621011,+ "weight": 5.199691295623779+ },+ {+ "time_s": 2151.0,+ "frequency_hz": 117.8289784938097,+ "weight": 4.737361431121826+ },+ {+ "time_s": 2151.5,+ "frequency_hz": 117.34917187690735,+ "weight": 4.456401824951172+ },+ {+ "time_s": 2152.0,+ "frequency_hz": 116.95277314633131,+ "weight": 4.700220108032227+ },+ {+ "time_s": 2152.5,+ "frequency_hz": 116.25,+ "weight": 4.766197681427002+ },+ {+ "time_s": 2153.0,+ "frequency_hz": 115.71630038321018,+ "weight": 4.4649882316589355+ },+ {+ "time_s": 2153.5,+ "frequency_hz": 115.25,+ "weight": 4.5668158531188965+ },+ {+ "time_s": 2154.0,+ "frequency_hz": 114.75,+ "weight": 4.624249458312988+ },+ {+ "time_s": 2154.5,+ "frequency_hz": 114.22989092767239,+ "weight": 4.344563007354736+ },+ {+ "time_s": 2155.0,+ "frequency_hz": 113.63465596735477,+ "weight": 3.9519920349121094+ },+ {+ "time_s": 2155.5,+ "frequency_hz": 113.05782253295183,+ "weight": 3.249598264694214+ },+ {+ "time_s": 2156.0,+ "frequency_hz": 112.41790413856506,+ "weight": 3.329533100128174+ },+ {+ "time_s": 2156.5,+ "frequency_hz": 112.13878354430199,+ "weight": 3.439723014831543+ },+ {+ "time_s": 2157.0,+ "frequency_hz": 111.66071829199791,+ "weight": 3.236792802810669+ },+ {+ "time_s": 2157.5,+ "frequency_hz": 110.99442724743858,+ "weight": 3.1059072017669678+ },+ {+ "time_s": 2158.0,+ "frequency_hz": 110.44252589717507,+ "weight": 3.299168586730957+ },+ {+ "time_s": 2158.5,+ "frequency_hz": 110.03059769235551,+ "weight": 3.0783843994140625+ },+ {+ "time_s": 2159.0,+ "frequency_hz": 109.56258954107761,+ "weight": 3.3242900371551514+ },+ {+ "time_s": 2161.0,+ "frequency_hz": 107.99739847145975,+ "weight": 4.115121841430664+ },+ {+ "time_s": 2161.5,+ "frequency_hz": 107.25,+ "weight": 3.665501356124878+ },+ {+ "time_s": 2162.0,+ "frequency_hz": 106.89740269631147,+ "weight": 4.508852005004883+ },+ {+ "time_s": 2162.5,+ "frequency_hz": 106.47950829565525,+ "weight": 5.202147483825684+ },+ {+ "time_s": 2163.0,+ "frequency_hz": 106.14334279298782,+ "weight": 5.521327972412109+ },+ {+ "time_s": 2163.5,+ "frequency_hz": 105.82951660454273,+ "weight": 5.236109256744385+ },+ {+ "time_s": 2164.0,+ "frequency_hz": 105.45208228752017,+ "weight": 5.382630825042725+ },+ {+ "time_s": 2164.5,+ "frequency_hz": 104.90512313693762,+ "weight": 4.575706481933594+ },+ {+ "time_s": 2165.0,+ "frequency_hz": 104.3241328895092,+ "weight": 4.757568359375+ },+ {+ "time_s": 2165.5,+ "frequency_hz": 104.07789001613855,+ "weight": 4.810603618621826+ },+ {+ "time_s": 2166.0,+ "frequency_hz": 103.85400702059269,+ "weight": 4.836872577667236+ },+ {+ "time_s": 2166.5,+ "frequency_hz": 103.4197039976716,+ "weight": 5.07625150680542+ },+ {+ "time_s": 2167.0,+ "frequency_hz": 103.11843314766884,+ "weight": 5.019998073577881+ },+ {+ "time_s": 2167.5,+ "frequency_hz": 102.83870294690132,+ "weight": 4.79212760925293+ },+ {+ "time_s": 2168.0,+ "frequency_hz": 102.37335447967052,+ "weight": 5.058922290802002+ },+ {+ "time_s": 2168.5,+ "frequency_hz": 102.01899867504835,+ "weight": 4.891049861907959+ },+ {+ "time_s": 2169.0,+ "frequency_hz": 101.75,+ "weight": 4.6974639892578125+ },+ {+ "time_s": 2169.5,+ "frequency_hz": 101.75,+ "weight": 3.120615243911743+ },+ {+ "time_s": 2170.5,+ "frequency_hz": 100.75,+ "weight": 2.8617513179779053+ },+ {+ "time_s": 2171.0,+ "frequency_hz": 100.25,+ "weight": 3.1719141006469727+ },+ {+ "time_s": 2171.5,+ "frequency_hz": 100.08751738071442,+ "weight": 3.5220892429351807+ },+ {+ "time_s": 2172.5,+ "frequency_hz": 99.10032970458269,+ "weight": 3.0652029514312744+ },+ {+ "time_s": 2173.0,+ "frequency_hz": 99.19501666724682,+ "weight": 3.915484666824341+ },+ {+ "time_s": 2173.5,+ "frequency_hz": 99.07211367040873,+ "weight": 4.438403129577637+ },+ {+ "time_s": 2174.0,+ "frequency_hz": 98.76890076696873,+ "weight": 4.351656913757324+ },+ {+ "time_s": 2174.5,+ "frequency_hz": 98.46451999992132,+ "weight": 4.653117656707764+ },+ {+ "time_s": 2175.0,+ "frequency_hz": 98.22310768067837,+ "weight": 4.459833145141602+ },+ {+ "time_s": 2175.5,+ "frequency_hz": 97.85480508208275,+ "weight": 4.378074645996094+ },+ {+ "time_s": 2176.0,+ "frequency_hz": 97.61878351867199,+ "weight": 4.127694606781006+ },+ {+ "time_s": 2176.5,+ "frequency_hz": 97.33414553105831,+ "weight": 3.6860036849975586+ },+ {+ "time_s": 2177.0,+ "frequency_hz": 97.11652886122465,+ "weight": 3.2799649238586426+ },+ {+ "time_s": 2177.5,+ "frequency_hz": 96.86159448325634,+ "weight": 2.779350519180298+ }+ ],+ "quality": {+ "median_contrast": 4.653117656707764,+ "harmonic_count": 3.0,+ "support_fraction": 0.9155844155844156,+ "frequency_resolution_hz": 0.5,+ "time_uncertainty_s": 1.0,+ "frequency_uncertainty_hz": 0.5,+ "frequency_sigma_hz": 0.5,+ "fragment_count": 2.0,+ "max_observed_gap_s": 4.0,+ "frequency_drop_hz": 68.23486222326756+ }+ },+ {+ "event_id": "event-0010-harmonic-2",+ "harmonic_group_id": "harmonics-0010",+ "start_s": 2138.0,+ "end_s": 2177.0,+ "band_hz": [+ 194.28496399521828,+ 266.4184754639864+ ],+ "ridge": [+ {+ "time_s": 2139.0,+ "frequency_hz": 265.4184754639864,+ "weight": 2.640049457550049+ },+ {+ "time_s": 2139.5,+ "frequency_hz": 264.55218271911144,+ "weight": 3.259176015853882+ },+ {+ "time_s": 2140.0,+ "frequency_hz": 264.190403431654,+ "weight": 3.307673215866089+ },+ {+ "time_s": 2141.0,+ "frequency_hz": 254.20032413303852,+ "weight": 2.9981586933135986+ },+ {+ "time_s": 2142.0,+ "frequency_hz": 257.93370375037193,+ "weight": 2.830857992172241+ },+ {+ "time_s": 2142.5,+ "frequency_hz": 254.58608063310385,+ "weight": 2.6316232681274414+ },+ {+ "time_s": 2143.0,+ "frequency_hz": 254.80680322647095,+ "weight": 3.4167912006378174+ },+ {+ "time_s": 2143.5,+ "frequency_hz": 253.30357912182808,+ "weight": 3.4901111125946045+ },+ {+ "time_s": 2144.0,+ "frequency_hz": 252.4844993026927,+ "weight": 3.654667615890503+ },+ {+ "time_s": 2144.5,+ "frequency_hz": 251.25,+ "weight": 3.5093271732330322+ },+ {+ "time_s": 2145.0,+ "frequency_hz": 250.3043771982193,+ "weight": 3.314883232116699+ },+ {+ "time_s": 2145.5,+ "frequency_hz": 248.504150275141,+ "weight": 3.922623872756958+ },+ {+ "time_s": 2146.0,+ "frequency_hz": 246.75,+ "weight": 3.89849591255188+ },+ {+ "time_s": 2146.5,+ "frequency_hz": 245.75,+ "weight": 4.265208721160889+ },+ {+ "time_s": 2147.0,+ "frequency_hz": 245.25,+ "weight": 4.662040710449219+ },+ {+ "time_s": 2147.5,+ "frequency_hz": 243.75,+ "weight": 4.8843183517456055+ },+ {+ "time_s": 2148.0,+ "frequency_hz": 242.9507615454495,+ "weight": 4.885659217834473+ },+ {+ "time_s": 2148.5,+ "frequency_hz": 241.9294671267271,+ "weight": 4.339558124542236+ },+ {+ "time_s": 2149.0,+ "frequency_hz": 240.25,+ "weight": 4.023378372192383+ },+ {+ "time_s": 2149.5,+ "frequency_hz": 239.12674561142921,+ "weight": 4.521224021911621+ },+ {+ "time_s": 2150.0,+ "frequency_hz": 238.25,+ "weight": 4.131706714630127+ },+ {+ "time_s": 2150.5,+ "frequency_hz": 236.9779888279736,+ "weight": 4.021249294281006+ },+ {+ "time_s": 2151.0,+ "frequency_hz": 235.7231752127409,+ "weight": 3.857435941696167+ },+ {+ "time_s": 2151.5,+ "frequency_hz": 234.25,+ "weight": 3.538818597793579+ },+ {+ "time_s": 2152.0,+ "frequency_hz": 234.07316520810127,+ "weight": 3.809528350830078+ },+ {+ "time_s": 2152.5,+ "frequency_hz": 232.25,+ "weight": 3.8337035179138184+ },+ {+ "time_s": 2153.0,+ "frequency_hz": 231.63581512868404,+ "weight": 3.4445526599884033+ },+ {+ "time_s": 2153.5,+ "frequency_hz": 230.75,+ "weight": 3.305086612701416+ },+ {+ "time_s": 2155.5,+ "frequency_hz": 225.75,+ "weight": 2.667588949203491+ },+ {+ "time_s": 2156.0,+ "frequency_hz": 225.093780182302,+ "weight": 3.2612926959991455+ },+ {+ "time_s": 2156.5,+ "frequency_hz": 224.1213594675064,+ "weight": 3.322129726409912+ },+ {+ "time_s": 2157.0,+ "frequency_hz": 223.36136944592,+ "weight": 3.464418649673462+ },+ {+ "time_s": 2157.5,+ "frequency_hz": 222.75,+ "weight": 2.7906036376953125+ },+ {+ "time_s": 2158.0,+ "frequency_hz": 221.44765966013074,+ "weight": 2.6193363666534424+ },+ {+ "time_s": 2163.0,+ "frequency_hz": 212.13801403343678,+ "weight": 3.3558430671691895+ },+ {+ "time_s": 2163.5,+ "frequency_hz": 211.52617368847132,+ "weight": 3.5952556133270264+ },+ {+ "time_s": 2164.0,+ "frequency_hz": 210.81884196400642,+ "weight": 3.9402267932891846+ },+ {+ "time_s": 2164.5,+ "frequency_hz": 210.04080112278461,+ "weight": 3.514796733856201+ },+ {+ "time_s": 2165.0,+ "frequency_hz": 208.59434317797422,+ "weight": 3.1938908100128174+ },+ {+ "time_s": 2165.5,+ "frequency_hz": 208.2953457981348,+ "weight": 3.8554062843322754+ },+ {+ "time_s": 2166.0,+ "frequency_hz": 207.70747004449368,+ "weight": 3.679333209991455+ },+ {+ "time_s": 2166.5,+ "frequency_hz": 206.76208394765854,+ "weight": 3.24642014503479+ },+ {+ "time_s": 2167.0,+ "frequency_hz": 206.12686151266098,+ "weight": 3.7599217891693115+ },+ {+ "time_s": 2167.5,+ "frequency_hz": 205.75,+ "weight": 3.016772508621216+ },+ {+ "time_s": 2168.0,+ "frequency_hz": 204.62020520865917,+ "weight": 2.8196494579315186+ },+ {+ "time_s": 2168.5,+ "frequency_hz": 203.9047481790185,+ "weight": 3.577558755874634+ },+ {+ "time_s": 2169.0,+ "frequency_hz": 203.38083734363317,+ "weight": 3.717451810836792+ },+ {+ "time_s": 2169.5,+ "frequency_hz": 202.8764232993126,+ "weight": 3.4518916606903076+ },+ {+ "time_s": 2170.0,+ "frequency_hz": 202.10569298267365,+ "weight": 3.667346954345703+ },+ {+ "time_s": 2170.5,+ "frequency_hz": 201.49805314291734,+ "weight": 3.148324966430664+ },+ {+ "time_s": 2171.0,+ "frequency_hz": 200.9383595250547,+ "weight": 3.4129159450531006+ },+ {+ "time_s": 2171.5,+ "frequency_hz": 200.75,+ "weight": 2.653744697570801+ },+ {+ "time_s": 2172.5,+ "frequency_hz": 198.97837148420513,+ "weight": 2.8675315380096436+ },+ {+ "time_s": 2173.0,+ "frequency_hz": 198.11927685886621,+ "weight": 3.320312261581421+ },+ {+ "time_s": 2173.5,+ "frequency_hz": 197.8629441410303,+ "weight": 3.8001363277435303+ },+ {+ "time_s": 2174.0,+ "frequency_hz": 197.39303619414568,+ "weight": 3.778965473175049+ },+ {+ "time_s": 2174.5,+ "frequency_hz": 196.92570895701647,+ "weight": 3.994737386703491+ },+ {+ "time_s": 2175.0,+ "frequency_hz": 196.5376192368567,+ "weight": 4.236444473266602+ },+ {+ "time_s": 2175.5,+ "frequency_hz": 195.6900727301836,+ "weight": 3.181382179260254+ },+ {+ "time_s": 2176.0,+ "frequency_hz": 195.28496399521828,+ "weight": 2.7118117809295654+ }+ ],+ "quality": {+ "median_contrast": 3.4997191429138184,+ "harmonic_count": 3.0,+ "support_fraction": 0.8,+ "frequency_resolution_hz": 0.5,+ "time_uncertainty_s": 1.0,+ "frequency_uncertainty_hz": 0.5,+ "frequency_sigma_hz": 0.5,+ "fragment_count": 2.0,+ "max_observed_gap_s": 5.0,+ "frequency_drop_hz": 57.0684517621994+ }+ },+ {+ "event_id": "event-0010-harmonic-3",+ "harmonic_group_id": "harmonics-0010",+ "start_s": 2126.5,+ "end_s": 2143.5,+ "band_hz": [+ 385.4958651200868,+ 444.15819907188416+ ],+ "ridge": [+ {+ "time_s": 2127.5,+ "frequency_hz": 443.15819907188416,+ "weight": 2.728692054748535+ },+ {+ "time_s": 2128.0,+ "frequency_hz": 443.0550715178251,+ "weight": 3.016624927520752+ },+ {+ "time_s": 2128.5,+ "frequency_hz": 440.22631081938744,+ "weight": 2.9810092449188232+ },+ {+ "time_s": 2129.0,+ "frequency_hz": 438.1587209701538,+ "weight": 2.679097890853882+ },+ {+ "time_s": 2129.5,+ "frequency_hz": 436.5451857484877,+ "weight": 2.556769371032715+ },+ {+ "time_s": 2130.0,+ "frequency_hz": 435.10578291118145,+ "weight": 2.57710337638855+ },+ {+ "time_s": 2130.5,+ "frequency_hz": 431.64944207668304,+ "weight": 2.681272029876709+ },+ {+ "time_s": 2131.0,+ "frequency_hz": 431.67688301205635,+ "weight": 3.15841007232666+ },+ {+ "time_s": 2131.5,+ "frequency_hz": 428.25,+ "weight": 2.92130708694458+ },+ {+ "time_s": 2133.0,+ "frequency_hz": 421.5312282089144,+ "weight": 3.4148242473602295+ },+ {+ "time_s": 2133.5,+ "frequency_hz": 421.25,+ "weight": 3.185295581817627+ },+ {+ "time_s": 2134.0,+ "frequency_hz": 417.75,+ "weight": 2.9459822177886963+ },+ {+ "time_s": 2134.5,+ "frequency_hz": 417.335264146328,+ "weight": 3.0254430770874023+ },+ {+ "time_s": 2135.0,+ "frequency_hz": 415.75,+ "weight": 2.5721185207366943+ },+ {+ "time_s": 2136.0,+ "frequency_hz": 410.50045613074326,+ "weight": 2.6689798831939697+ },+ {+ "time_s": 2137.0,+ "frequency_hz": 406.71825048327446,+ "weight": 3.683039903640747+ },+ {+ "time_s": 2137.5,+ "frequency_hz": 406.25,+ "weight": 3.661461591720581+ },+ {+ "time_s": 2138.0,+ "frequency_hz": 403.64200226962566,+ "weight": 3.064636707305908+ },+ {+ "time_s": 2138.5,+ "frequency_hz": 400.1008463948965,+ "weight": 2.5286192893981934+ },+ {+ "time_s": 2139.0,+ "frequency_hz": 398.9679837934673,+ "weight": 2.9246714115142822+ },+ {+ "time_s": 2139.5,+ "frequency_hz": 397.48428554832935,+ "weight": 3.1066205501556396+ },+ {+ "time_s": 2140.0,+ "frequency_hz": 395.25,+ "weight": 2.741455316543579+ },+ {+ "time_s": 2142.0,+ "frequency_hz": 387.25,+ "weight": 3.09775447845459+ },+ {+ "time_s": 2142.5,+ "frequency_hz": 386.4958651200868,+ "weight": 2.5070061683654785+ }+ ],+ "quality": {+ "median_contrast": 2.9353268146514893,+ "harmonic_count": 3.0,+ "support_fraction": 0.7741935483870968,+ "frequency_resolution_hz": 0.5,+ "time_uncertainty_s": 1.0,+ "frequency_uncertainty_hz": 0.5,+ "frequency_sigma_hz": 0.5,+ "fragment_count": 1.0,+ "max_observed_gap_s": 2.0,+ "frequency_drop_hz": 50.39069116860628+ }+ },+ {+ "event_id": "event-0011",+ "harmonic_group_id": "harmonics-0011",+ "start_s": 2663.0,+ "end_s": 2697.0,+ "band_hz": [+ 58.986744021996856,+ 67.37064364552498+ ],+ "ridge": [+ {+ "time_s": 2664.0,+ "frequency_hz": 66.25687961280346,+ "weight": 2.933136224746704+ },+ {+ "time_s": 2664.5,+ "frequency_hz": 66.37064364552498,+ "weight": 2.985997200012207+ },+ {+ "time_s": 2665.0,+ "frequency_hz": 66.25,+ "weight": 3.1787478923797607+ },+ {+ "time_s": 2665.5,+ "frequency_hz": 66.25,+ "weight": 3.1235272884368896+ },+ {+ "time_s": 2666.0,+ "frequency_hz": 66.28580123186111,+ "weight": 2.8899149894714355+ },+ {+ "time_s": 2666.5,+ "frequency_hz": 66.3257367014885,+ "weight": 2.9342353343963623+ },+ {+ "time_s": 2667.0,+ "frequency_hz": 66.35068525373936,+ "weight": 3.3150296211242676+ },+ {+ "time_s": 2667.5,+ "frequency_hz": 66.25,+ "weight": 3.2342123985290527+ },+ {+ "time_s": 2668.0,+ "frequency_hz": 66.25,+ "weight": 3.3417532444000244+ },+ {+ "time_s": 2668.5,+ "frequency_hz": 66.1934071034193,+ "weight": 3.2670300006866455+ },+ {+ "time_s": 2669.0,+ "frequency_hz": 66.00020245106134,+ "weight": 3.1700963973999023+ },+ {+ "time_s": 2669.5,+ "frequency_hz": 65.7505591660738,+ "weight": 2.8810248374938965+ },+ {+ "time_s": 2670.5,+ "frequency_hz": 65.58405803143978,+ "weight": 2.548736810684204+ },+ {+ "time_s": 2671.0,+ "frequency_hz": 65.51334088202566,+ "weight": 2.9262168407440186+ },+ {+ "time_s": 2671.5,+ "frequency_hz": 65.20768915116787,+ "weight": 3.060812473297119+ },+ {+ "time_s": 2672.0,+ "frequency_hz": 65.10863526910543,+ "weight": 3.31256365776062+ },+ {+ "time_s": 2672.5,+ "frequency_hz": 64.97951135225594,+ "weight": 3.131986618041992+ },+ {+ "time_s": 2673.0,+ "frequency_hz": 65.07444993406534,+ "weight": 2.8698997497558594+ },+ {+ "time_s": 2673.5,+ "frequency_hz": 65.11748646199703,+ "weight": 2.8909075260162354+ },+ {+ "time_s": 2674.0,+ "frequency_hz": 64.80195942521095,+ "weight": 2.8949530124664307+ },+ {+ "time_s": 2674.5,+ "frequency_hz": 64.94565834477544,+ "weight": 3.4395828247070312+ },+ {+ "time_s": 2675.0,+ "frequency_hz": 64.86371773481369,+ "weight": 3.705735921859741+ },+ {+ "time_s": 2675.5,+ "frequency_hz": 64.82467183470726,+ "weight": 3.6808576583862305+ },+ {+ "time_s": 2676.0,+ "frequency_hz": 64.78060656785965,+ "weight": 3.380384922027588+ },+ {+ "time_s": 2676.5,+ "frequency_hz": 64.64031805098057,+ "weight": 3.1584959030151367+ },+ {+ "time_s": 2678.5,+ "frequency_hz": 63.45978070795536,+ "weight": 2.8327016830444336+ },+ {+ "time_s": 2679.0,+ "frequency_hz": 63.6581349670887,+ "weight": 3.1803996562957764+ },+ {+ "time_s": 2679.5,+ "frequency_hz": 63.48257513716817,+ "weight": 3.130000591278076+ },+ {+ "time_s": 2680.0,+ "frequency_hz": 63.51125194784254,+ "weight": 3.378150701522827+ },+ {+ "time_s": 2680.5,+ "frequency_hz": 63.41787050664425,+ "weight": 3.4081356525421143+ },+ {+ "time_s": 2681.0,+ "frequency_hz": 63.32143980264664,+ "weight": 3.4552676677703857+ },+ {+ "time_s": 2681.5,+ "frequency_hz": 63.543144691735506,+ "weight": 3.4603562355041504+ },+ {+ "time_s": 2682.0,+ "frequency_hz": 63.48133361339569,+ "weight": 3.172929048538208+ },+ {+ "time_s": 2682.5,+ "frequency_hz": 63.44480253010988,+ "weight": 3.1304430961608887+ },+ {+ "time_s": 2683.0,+ "frequency_hz": 63.50825337320566,+ "weight": 3.0917866230010986+ },+ {+ "time_s": 2683.5,+ "frequency_hz": 63.413493387401104,+ "weight": 2.8201918601989746+ },+ {+ "time_s": 2685.5,+ "frequency_hz": 63.13692516088486,+ "weight": 2.7365849018096924+ },+ {+ "time_s": 2686.0,+ "frequency_hz": 62.95717652142048,+ "weight": 3.447873830795288+ },+ {+ "time_s": 2686.5,+ "frequency_hz": 62.82845039665699,+ "weight": 3.450704336166382+ },+ {+ "time_s": 2687.0,+ "frequency_hz": 62.70449489355087,+ "weight": 3.719672918319702+ },+ {+ "time_s": 2687.5,+ "frequency_hz": 62.73762130737305,+ "weight": 3.47440242767334+ },+ {+ "time_s": 2688.0,+ "frequency_hz": 62.75,+ "weight": 3.3056933879852295+ },+ {+ "time_s": 2688.5,+ "frequency_hz": 62.8446759134531,+ "weight": 3.6876273155212402+ },+ {+ "time_s": 2689.0,+ "frequency_hz": 62.78797926008701,+ "weight": 3.8795478343963623+ },+ {+ "time_s": 2689.5,+ "frequency_hz": 62.81381507217884,+ "weight": 3.983492851257324+ },+ {+ "time_s": 2690.0,+ "frequency_hz": 62.74707020819187,+ "weight": 4.268084526062012+ },+ {+ "time_s": 2690.5,+ "frequency_hz": 62.71487408876419,+ "weight": 4.440962314605713+ },+ {+ "time_s": 2691.0,+ "frequency_hz": 62.69721606373787,+ "weight": 4.2649641036987305+ },+ {+ "time_s": 2691.5,+ "frequency_hz": 62.63176493346691,+ "weight": 3.939225912094116+ },+ {+ "time_s": 2692.0,+ "frequency_hz": 62.07246521860361,+ "weight": 2.6313936710357666+ },+ {+ "time_s": 2692.5,+ "frequency_hz": 60.75,+ "weight": 3.0188589096069336+ },+ {+ "time_s": 2693.0,+ "frequency_hz": 60.25,+ "weight": 2.8910415172576904+ },+ {+ "time_s": 2693.5,+ "frequency_hz": 60.17976978421211,+ "weight": 3.3216445446014404+ },+ {+ "time_s": 2694.0,+ "frequency_hz": 60.10668370127678,+ "weight": 3.841292381286621+ },+ {+ "time_s": 2694.5,+ "frequency_hz": 60.00441910978407,+ "weight": 3.4975385665893555+ },+ {+ "time_s": 2695.0,+ "frequency_hz": 59.986744021996856,+ "weight": 3.3316006660461426+ },+ {+ "time_s": 2695.5,+ "frequency_hz": 60.08594027161598,+ "weight": 3.3433997631073+ },+ {+ "time_s": 2696.0,+ "frequency_hz": 60.063751600682735,+ "weight": 2.9876763820648193+ }+ ],+ "quality": {+ "median_contrast": 3.250621199607849,+ "harmonic_count": 1.0,+ "support_fraction": 0.8923076923076924,+ "frequency_resolution_hz": 0.5,+ "time_uncertainty_s": 1.0,+ "frequency_uncertainty_hz": 0.5,+ "frequency_sigma_hz": 0.5,+ "fragment_count": 1.0,+ "max_observed_gap_s": 2.0,+ "frequency_drop_hz": 6.15019591152668+ }+ },+ {+ "event_id": "event-0012",+ "harmonic_group_id": "harmonics-0012",+ "start_s": 3060.5,+ "end_s": 3121.0,+ "band_hz": [+ 102.0986068546772,+ 152.40479384362698+ ],+ "ridge": [+ {+ "time_s": 3061.5,+ "frequency_hz": 151.40479384362698,+ "weight": 4.8177571296691895+ },+ {+ "time_s": 3062.0,+ "frequency_hz": 151.26999440789223,+ "weight": 4.917701244354248+ },+ {+ "time_s": 3062.5,+ "frequency_hz": 150.25,+ "weight": 4.936656951904297+ },+ {+ "time_s": 3063.0,+ "frequency_hz": 149.25,+ "weight": 5.0985870361328125+ },+ {+ "time_s": 3063.5,+ "frequency_hz": 148.83560366928577,+ "weight": 4.823880672454834+ },+ {+ "time_s": 3064.0,+ "frequency_hz": 148.18193328380585,+ "weight": 3.795741319656372+ },+ {+ "time_s": 3064.5,+ "frequency_hz": 146.25,+ "weight": 4.191680431365967+ },+ {+ "time_s": 3065.0,+ "frequency_hz": 145.75,+ "weight": 4.73729944229126+ },+ {+ "time_s": 3065.5,+ "frequency_hz": 144.95989198982716,+ "weight": 4.9732890129089355+ },+ {+ "time_s": 3066.0,+ "frequency_hz": 144.61679453402758,+ "weight": 5.3141608238220215+ },+ {+ "time_s": 3066.5,+ "frequency_hz": 143.75,+ "weight": 4.546003341674805+ },+ {+ "time_s": 3067.0,+ "frequency_hz": 142.85302951931953,+ "weight": 3.9029502868652344+ },+ {+ "time_s": 3067.5,+ "frequency_hz": 142.25,+ "weight": 2.8946025371551514+ },+ {+ "time_s": 3068.0,+ "frequency_hz": 140.6652068644762,+ "weight": 3.7554209232330322+ },+ {+ "time_s": 3068.5,+ "frequency_hz": 140.3282971382141,+ "weight": 3.59077787399292+ },+ {+ "time_s": 3069.0,+ "frequency_hz": 139.6490694284439,+ "weight": 3.5528218746185303+ },+ {+ "time_s": 3069.5,+ "frequency_hz": 138.75205750763416,+ "weight": 3.3107028007507324+ },+ {+ "time_s": 3070.0,+ "frequency_hz": 137.90444142371416,+ "weight": 4.054269790649414+ },+ {+ "time_s": 3070.5,+ "frequency_hz": 137.75,+ "weight": 3.4705936908721924+ },+ {+ "time_s": 3071.0,+ "frequency_hz": 136.025056572631,+ "weight": 3.1909496784210205+ },+ {+ "time_s": 3071.5,+ "frequency_hz": 135.5557443909347,+ "weight": 3.795675277709961+ },+ {+ "time_s": 3072.0,+ "frequency_hz": 134.75,+ "weight": 3.8777966499328613+ },+ {+ "time_s": 3072.5,+ "frequency_hz": 134.43208706378937,+ "weight": 3.3116190433502197+ },+ {+ "time_s": 3074.0,+ "frequency_hz": 131.60936857759953,+ "weight": 2.538944721221924+ },+ {+ "time_s": 3074.5,+ "frequency_hz": 131.14847373962402,+ "weight": 2.9567697048187256+ },+ {+ "time_s": 3075.0,+ "frequency_hz": 130.8522271066904,+ "weight": 3.281938314437866+ },+ {+ "time_s": 3075.5,+ "frequency_hz": 130.4050119817257,+ "weight": 3.3155012130737305+ },+ {+ "time_s": 3076.0,+ "frequency_hz": 129.39875827729702,+ "weight": 3.6938164234161377+ },+ {+ "time_s": 3076.5,+ "frequency_hz": 128.97420978918672,+ "weight": 3.1696338653564453+ },+ {+ "time_s": 3077.0,+ "frequency_hz": 128.22587230801582,+ "weight": 2.8790173530578613+ },+ {+ "time_s": 3077.5,+ "frequency_hz": 127.75,+ "weight": 3.3478569984436035+ },+ {+ "time_s": 3078.0,+ "frequency_hz": 127.37181702256203,+ "weight": 3.601600408554077+ },+ {+ "time_s": 3078.5,+ "frequency_hz": 126.34835045039654,+ "weight": 4.094731330871582+ },+ {+ "time_s": 3079.0,+ "frequency_hz": 125.942282512784,+ "weight": 4.662176132202148+ },+ {+ "time_s": 3079.5,+ "frequency_hz": 125.52318672463298,+ "weight": 4.2153849601745605+ },+ {+ "time_s": 3080.0,+ "frequency_hz": 124.68610072135925,+ "weight": 3.752439022064209+ },+ {+ "time_s": 3080.5,+ "frequency_hz": 124.25,+ "weight": 4.283951759338379+ },+ {+ "time_s": 3081.0,+ "frequency_hz": 124.12509407103062,+ "weight": 4.74294376373291+ },+ {+ "time_s": 3081.5,+ "frequency_hz": 123.6951041072607,+ "weight": 4.864185810089111+ },+ {+ "time_s": 3082.0,+ "frequency_hz": 123.25,+ "weight": 4.806948661804199+ },+ {+ "time_s": 3082.5,+ "frequency_hz": 122.49750291532837,+ "weight": 3.909609794616699+ },+ {+ "time_s": 3083.0,+ "frequency_hz": 121.66464783251286,+ "weight": 3.3970580101013184+ },+ {+ "time_s": 3083.5,+ "frequency_hz": 121.09512215852737,+ "weight": 4.3664374351501465+ },+ {+ "time_s": 3084.0,+ "frequency_hz": 121.01050486788154,+ "weight": 4.394524097442627+ },+ {+ "time_s": 3084.5,+ "frequency_hz": 120.50819585006684,+ "weight": 3.7337489128112793+ },+ {+ "time_s": 3085.0,+ "frequency_hz": 120.25,+ "weight": 2.9841930866241455+ },+ {+ "time_s": 3085.5,+ "frequency_hz": 119.45386205613613,+ "weight": 3.2601165771484375+ },+ {+ "time_s": 3086.0,+ "frequency_hz": 119.18922241032124,+ "weight": 3.5930607318878174+ },+ {+ "time_s": 3086.5,+ "frequency_hz": 118.98553363606334,+ "weight": 4.076230049133301+ },+ {+ "time_s": 3087.0,+ "frequency_hz": 118.70224578678608,+ "weight": 3.8067715167999268+ },+ {+ "time_s": 3087.5,+ "frequency_hz": 118.32275749742985,+ "weight": 2.9859156608581543+ },+ {+ "time_s": 3088.0,+ "frequency_hz": 118.0339388512075,+ "weight": 2.5061309337615967+ },+ {+ "time_s": 3088.5,+ "frequency_hz": 117.43238183110952,+ "weight": 3.888978958129883+ },+ {+ "time_s": 3089.0,+ "frequency_hz": 117.16363613307476,+ "weight": 4.6939849853515625+ },+ {+ "time_s": 3089.5,+ "frequency_hz": 116.71644467115402,+ "weight": 4.293790340423584+ },+ {+ "time_s": 3090.0,+ "frequency_hz": 116.46403554826975,+ "weight": 4.347411155700684+ },+ {+ "time_s": 3090.5,+ "frequency_hz": 116.4356849938631,+ "weight": 3.8543176651000977+ },+ {+ "time_s": 3091.0,+ "frequency_hz": 116.02873357757926,+ "weight": 2.927253007888794+ },+ {+ "time_s": 3103.5,+ "frequency_hz": 108.02687229029834,+ "weight": 3.6956489086151123+ },+ {+ "time_s": 3104.0,+ "frequency_hz": 107.98753116838634,+ "weight": 4.1984333992004395+ },+ {+ "time_s": 3104.5,+ "frequency_hz": 107.7629466354847,+ "weight": 4.021620273590088+ },+ {+ "time_s": 3105.0,+ "frequency_hz": 107.5819897428155,+ "weight": 3.9925427436828613+ },+ {+ "time_s": 3105.5,+ "frequency_hz": 107.26672895252705,+ "weight": 3.9628779888153076+ },+ {+ "time_s": 3106.0,+ "frequency_hz": 107.06927190721035,+ "weight": 3.8482935428619385+ },+ {+ "time_s": 3106.5,+ "frequency_hz": 107.05458975210786,+ "weight": 3.6144890785217285+ },+ {+ "time_s": 3107.0,+ "frequency_hz": 106.66711190342903,+ "weight": 3.221658229827881+ },+ {+ "time_s": 3107.5,+ "frequency_hz": 106.32116864621639,+ "weight": 3.635056257247925+ },+ {+ "time_s": 3108.0,+ "frequency_hz": 106.32329419255257,+ "weight": 3.627211570739746+ },+ {+ "time_s": 3108.5,+ "frequency_hz": 106.25316615402699,+ "weight": 3.6480071544647217+ },+ {+ "time_s": 3109.0,+ "frequency_hz": 106.18307493627071,+ "weight": 2.9847326278686523+ },+ {+ "time_s": 3110.5,+ "frequency_hz": 105.71044375002384,+ "weight": 2.802105188369751+ },+ {+ "time_s": 3111.0,+ "frequency_hz": 105.36390766501427,+ "weight": 4.10925817489624+ },+ {+ "time_s": 3111.5,+ "frequency_hz": 105.21463400125504,+ "weight": 4.451345920562744+ },+ {+ "time_s": 3112.0,+ "frequency_hz": 105.18210506439209,+ "weight": 4.458627700805664+ },+ {+ "time_s": 3112.5,+ "frequency_hz": 105.09874807298183,+ "weight": 3.7712950706481934+ },+ {+ "time_s": 3114.0,+ "frequency_hz": 104.55713605880737,+ "weight": 2.8178417682647705+ },+ {+ "time_s": 3116.0,+ "frequency_hz": 103.89633414894342,+ "weight": 2.9239730834960938+ },+ {+ "time_s": 3116.5,+ "frequency_hz": 103.75,+ "weight": 3.0440361499786377+ },+ {+ "time_s": 3117.0,+ "frequency_hz": 103.61415629833937,+ "weight": 2.5686166286468506+ },+ {+ "time_s": 3118.0,+ "frequency_hz": 103.6090342476964,+ "weight": 3.273970127105713+ },+ {+ "time_s": 3118.5,+ "frequency_hz": 103.48705767840147,+ "weight": 3.376293182373047+ },+ {+ "time_s": 3119.0,+ "frequency_hz": 103.12795872986317,+ "weight": 3.199065685272217+ },+ {+ "time_s": 3119.5,+ "frequency_hz": 103.16088768839836,+ "weight": 3.110400438308716+ },+ {+ "time_s": 3120.0,+ "frequency_hz": 103.0986068546772,+ "weight": 2.8353374004364014+ }+ ],+ "quality": {+ "median_contrast": 3.7539299726486206,+ "harmonic_count": 1.0,+ "support_fraction": 0.711864406779661,+ "frequency_resolution_hz": 0.5,+ "time_uncertainty_s": 1.0,+ "frequency_uncertainty_hz": 0.5,+ "frequency_sigma_hz": 0.5,+ "fragment_count": 2.0,+ "max_observed_gap_s": 12.5,+ "frequency_drop_hz": 42.17683292552829+ }+ },+ {+ "event_id": "event-0013",+ "harmonic_group_id": "harmonics-0013",+ "start_s": 3101.0,+ "end_s": 3119.0,+ "band_hz": [+ 136.49415649473667,+ 153.16645699739456+ ],+ "ridge": [+ {+ "time_s": 3102.0,+ "frequency_hz": 151.85512147843838,+ "weight": 2.5742366313934326+ },+ {+ "time_s": 3102.5,+ "frequency_hz": 151.64737862348557,+ "weight": 3.1365418434143066+ },+ {+ "time_s": 3103.0,+ "frequency_hz": 151.20249079167843,+ "weight": 3.1028401851654053+ },+ {+ "time_s": 3103.5,+ "frequency_hz": 150.9814514350146,+ "weight": 3.50321626663208+ },+ {+ "time_s": 3104.0,+ "frequency_hz": 150.8831304013729,+ "weight": 2.729835271835327+ },+ {+ "time_s": 3105.5,+ "frequency_hz": 152.05545149371028,+ "weight": 3.0888352394104004+ },+ {+ "time_s": 3106.0,+ "frequency_hz": 152.16645699739456,+ "weight": 3.5027096271514893+ },+ {+ "time_s": 3106.5,+ "frequency_hz": 152.0172666274011,+ "weight": 3.498502016067505+ },+ {+ "time_s": 3107.0,+ "frequency_hz": 150.18210192024708,+ "weight": 2.527663230895996+ },+ {+ "time_s": 3107.5,+ "frequency_hz": 150.40204996615648,+ "weight": 3.6517133712768555+ },+ {+ "time_s": 3108.0,+ "frequency_hz": 150.68006540834904,+ "weight": 3.324340581893921+ },+ {+ "time_s": 3108.5,+ "frequency_hz": 149.7038954347372,+ "weight": 3.0642130374908447+ },+ {+ "time_s": 3109.0,+ "frequency_hz": 149.45632710680366,+ "weight": 3.5429928302764893+ },+ {+ "time_s": 3109.5,+ "frequency_hz": 148.9803375620395,+ "weight": 2.6878139972686768+ },+ {+ "time_s": 3110.5,+ "frequency_hz": 146.21316108107567,+ "weight": 2.6249303817749023+ },+ {+ "time_s": 3111.0,+ "frequency_hz": 145.77227360010147,+ "weight": 2.7607016563415527+ },+ {+ "time_s": 3111.5,+ "frequency_hz": 144.52278701029718,+ "weight": 2.5348026752471924+ },+ {+ "time_s": 3112.0,+ "frequency_hz": 143.82497453689575,+ "weight": 3.0972177982330322+ },+ {+ "time_s": 3112.5,+ "frequency_hz": 144.08224944025278,+ "weight": 2.974806308746338+ },+ {+ "time_s": 3114.0,+ "frequency_hz": 141.46190899983048,+ "weight": 2.5395593643188477+ },+ {+ "time_s": 3115.0,+ "frequency_hz": 140.75,+ "weight": 3.001019239425659+ },+ {+ "time_s": 3115.5,+ "frequency_hz": 139.9329503327608,+ "weight": 3.096189022064209+ },+ {+ "time_s": 3116.0,+ "frequency_hz": 138.6874197125435,+ "weight": 2.989731788635254+ },+ {+ "time_s": 3116.5,+ "frequency_hz": 138.29703192412853,+ "weight": 3.062269687652588+ },+ {+ "time_s": 3118.0,+ "frequency_hz": 137.49415649473667,+ "weight": 2.7067577838897705+ }+ ],+ "quality": {+ "median_contrast": 3.062269687652588,+ "harmonic_count": 1.0,+ "support_fraction": 0.7575757575757576,+ "frequency_resolution_hz": 0.5,+ "time_uncertainty_s": 1.0,+ "frequency_uncertainty_hz": 0.5,+ "frequency_sigma_hz": 0.5,+ "fragment_count": 1.0,+ "max_observed_gap_s": 1.5,+ "frequency_drop_hz": 12.932708889245987+ }+ },+ {+ "event_id": "event-0014",+ "harmonic_group_id": "harmonics-0014",+ "start_s": 3264.0,+ "end_s": 3299.5,+ "band_hz": [+ 73.25,+ 87.97717272303998+ ],+ "ridge": [+ {+ "time_s": 3265.0,+ "frequency_hz": 83.85353189706802,+ "weight": 4.783148765563965+ },+ {+ "time_s": 3265.5,+ "frequency_hz": 84.25,+ "weight": 4.328521251678467+ },+ {+ "time_s": 3266.0,+ "frequency_hz": 84.61171973496675,+ "weight": 4.860389709472656+ },+ {+ "time_s": 3266.5,+ "frequency_hz": 84.77463088929653,+ "weight": 5.129730224609375+ },+ {+ "time_s": 3267.0,+ "frequency_hz": 84.86120422184467,+ "weight": 4.983401298522949+ },+ {+ "time_s": 3267.5,+ "frequency_hz": 85.16844077408314,+ "weight": 4.95381498336792+ },+ {+ "time_s": 3268.0,+ "frequency_hz": 85.3505999147892,+ "weight": 4.70301628112793+ },+ {+ "time_s": 3268.5,+ "frequency_hz": 85.54001088440418,+ "weight": 4.816659927368164+ },+ {+ "time_s": 3269.0,+ "frequency_hz": 85.7539864629507,+ "weight": 4.7571587562561035+ },+ {+ "time_s": 3269.5,+ "frequency_hz": 85.8088613152504,+ "weight": 4.519597053527832+ },+ {+ "time_s": 3270.0,+ "frequency_hz": 85.98695264477283,+ "weight": 4.468423843383789+ },+ {+ "time_s": 3270.5,+ "frequency_hz": 86.01151918899268,+ "weight": 4.196625709533691+ },+ {+ "time_s": 3272.0,+ "frequency_hz": 86.35526236891747,+ "weight": 4.292510509490967+ },+ {+ "time_s": 3272.5,+ "frequency_hz": 86.53173235431314,+ "weight": 4.343102931976318+ },+ {+ "time_s": 3273.0,+ "frequency_hz": 86.77777782082558,+ "weight": 3.9894766807556152+ },+ {+ "time_s": 3273.5,+ "frequency_hz": 86.7689241617918,+ "weight": 3.7322580814361572+ },+ {+ "time_s": 3274.0,+ "frequency_hz": 86.61648830771446,+ "weight": 3.838651657104492+ },+ {+ "time_s": 3274.5,+ "frequency_hz": 86.8202513307333,+ "weight": 3.6755282878875732+ },+ {+ "time_s": 3275.0,+ "frequency_hz": 86.97717272303998,+ "weight": 3.54651141166687+ },+ {+ "time_s": 3275.5,+ "frequency_hz": 85.89421087503433,+ "weight": 3.2163312435150146+ },+ {+ "time_s": 3276.0,+ "frequency_hz": 85.43757219985127,+ "weight": 3.8040964603424072+ },+ {+ "time_s": 3276.5,+ "frequency_hz": 84.08376082777977,+ "weight": 3.60622239112854+ },+ {+ "time_s": 3277.0,+ "frequency_hz": 82.85632084310055,+ "weight": 3.0739471912384033+ },+ {+ "time_s": 3277.5,+ "frequency_hz": 81.10472751408815,+ "weight": 3.5662782192230225+ },+ {+ "time_s": 3278.0,+ "frequency_hz": 78.95047727972269,+ "weight": 5.160244464874268+ },+ {+ "time_s": 3278.5,+ "frequency_hz": 78.75,+ "weight": 4.506062984466553+ },+ {+ "time_s": 3279.0,+ "frequency_hz": 77.0274888779968,+ "weight": 4.837986946105957+ },+ {+ "time_s": 3279.5,+ "frequency_hz": 76.41404817998409,+ "weight": 5.199017524719238+ },+ {+ "time_s": 3280.0,+ "frequency_hz": 75.8347799628973,+ "weight": 5.203211784362793+ },+ {+ "time_s": 3280.5,+ "frequency_hz": 75.51639879122376,+ "weight": 5.359494686126709+ },+ {+ "time_s": 3281.0,+ "frequency_hz": 75.1671386808157,+ "weight": 5.23914098739624+ },+ {+ "time_s": 3281.5,+ "frequency_hz": 74.93801402300596,+ "weight": 4.17710542678833+ },+ {+ "time_s": 3282.0,+ "frequency_hz": 74.79328671097755,+ "weight": 3.350893974304199+ },+ {+ "time_s": 3282.5,+ "frequency_hz": 74.83272455632687,+ "weight": 3.7143635749816895+ },+ {+ "time_s": 3283.0,+ "frequency_hz": 74.62867629528046,+ "weight": 3.26957368850708+ },+ {+ "time_s": 3284.5,+ "frequency_hz": 74.38852874934673,+ "weight": 2.732896327972412+ },+ {+ "time_s": 3285.0,+ "frequency_hz": 74.53274952247739,+ "weight": 4.153207302093506+ },+ {+ "time_s": 3285.5,+ "frequency_hz": 74.60695581138134,+ "weight": 4.246786117553711+ },+ {+ "time_s": 3286.0,+ "frequency_hz": 74.57320919632912,+ "weight": 5.122730731964111+ },+ {+ "time_s": 3286.5,+ "frequency_hz": 74.52339073829353,+ "weight": 4.426938533782959+ },+ {+ "time_s": 3287.0,+ "frequency_hz": 74.48232175782323,+ "weight": 2.8886349201202393+ },+ {+ "time_s": 3288.0,+ "frequency_hz": 74.41434476524591,+ "weight": 2.8932595252990723+ },+ {+ "time_s": 3288.5,+ "frequency_hz": 74.41325426101685,+ "weight": 4.480024337768555+ },+ {+ "time_s": 3289.0,+ "frequency_hz": 74.3338478654623,+ "weight": 4.798140048980713+ },+ {+ "time_s": 3289.5,+ "frequency_hz": 74.38521704822779,+ "weight": 4.78303861618042+ },+ {+ "time_s": 3290.0,+ "frequency_hz": 74.33799716830254,+ "weight": 4.273313999176025+ },+ {+ "time_s": 3290.5,+ "frequency_hz": 74.38730823248625,+ "weight": 2.894134044647217+ },+ {+ "time_s": 3291.0,+ "frequency_hz": 74.46804731711745,+ "weight": 3.0581681728363037+ },+ {+ "time_s": 3291.5,+ "frequency_hz": 74.27972315251827,+ "weight": 4.804354667663574+ },+ {+ "time_s": 3292.0,+ "frequency_hz": 74.31784458458424,+ "weight": 4.051647663116455+ },+ {+ "time_s": 3292.5,+ "frequency_hz": 74.29795570671558,+ "weight": 2.9597434997558594+ },+ {+ "time_s": 3293.0,+ "frequency_hz": 74.28247514367104,+ "weight": 3.314304828643799+ },+ {+ "time_s": 3293.5,+ "frequency_hz": 74.33737641572952,+ "weight": 4.362371921539307+ },+ {+ "time_s": 3294.0,+ "frequency_hz": 74.33981527388096,+ "weight": 5.116360187530518+ },+ {+ "time_s": 3294.5,+ "frequency_hz": 74.32850180566311,+ "weight": 5.544765949249268+ },+ {+ "time_s": 3295.0,+ "frequency_hz": 74.25,+ "weight": 5.782403945922852+ },+ {+ "time_s": 3295.5,+ "frequency_hz": 74.26062580943108,+ "weight": 5.325423717498779+ },+ {+ "time_s": 3296.0,+ "frequency_hz": 74.3819612339139,+ "weight": 5.37600564956665+ },+ {+ "time_s": 3296.5,+ "frequency_hz": 74.4048477858305,+ "weight": 5.088210105895996+ },+ {+ "time_s": 3297.0,+ "frequency_hz": 74.26959311962128,+ "weight": 5.090640544891357+ },+ {+ "time_s": 3297.5,+ "frequency_hz": 74.25,+ "weight": 5.537797927856445+ },+ {+ "time_s": 3298.0,+ "frequency_hz": 74.25,+ "weight": 5.391990661621094+ },+ {+ "time_s": 3298.5,+ "frequency_hz": 74.25,+ "weight": 4.3881330490112305+ }+ ],+ "quality": {+ "median_contrast": 4.426938533782959,+ "harmonic_count": 1.0,+ "support_fraction": 0.9264705882352942,+ "frequency_resolution_hz": 0.5,+ "time_uncertainty_s": 1.0,+ "frequency_uncertainty_hz": 0.5,+ "frequency_sigma_hz": 0.5,+ "fragment_count": 1.0,+ "max_observed_gap_s": 1.5,+ "frequency_drop_hz": 10.749713033437729+ }+ },+ {+ "event_id": "event-0015",+ "harmonic_group_id": "harmonics-0015",+ "start_s": 3454.0,+ "end_s": 3469.5,+ "band_hz": [+ 246.35918405652046,+ 272.75+ ],+ "ridge": [+ {+ "time_s": 3455.0,+ "frequency_hz": 270.75,+ "weight": 3.474461793899536+ },+ {+ "time_s": 3455.5,+ "frequency_hz": 271.25,+ "weight": 4.191516399383545+ },+ {+ "time_s": 3456.0,+ "frequency_hz": 271.590402521193,+ "weight": 4.562695503234863+ },+ {+ "time_s": 3456.5,+ "frequency_hz": 271.75,+ "weight": 4.239847660064697+ },+ {+ "time_s": 3457.0,+ "frequency_hz": 270.49282905831933,+ "weight": 3.3315823078155518+ },+ {+ "time_s": 3457.5,+ "frequency_hz": 267.75,+ "weight": 3.798478126525879+ },+ {+ "time_s": 3458.0,+ "frequency_hz": 266.92763090133667,+ "weight": 3.4327735900878906+ },+ {+ "time_s": 3458.5,+ "frequency_hz": 266.0120740775019,+ "weight": 3.3248305320739746+ },+ {+ "time_s": 3459.0,+ "frequency_hz": 262.15426371991634,+ "weight": 3.4734363555908203+ },+ {+ "time_s": 3459.5,+ "frequency_hz": 259.1445378214121,+ "weight": 3.5808157920837402+ },+ {+ "time_s": 3460.0,+ "frequency_hz": 257.75,+ "weight": 3.6629252433776855+ },+ {+ "time_s": 3460.5,+ "frequency_hz": 255.75,+ "weight": 3.907412528991699+ },+ {+ "time_s": 3461.0,+ "frequency_hz": 250.79706421494484,+ "weight": 4.4806342124938965+ },+ {+ "time_s": 3461.5,+ "frequency_hz": 249.43655975162983,+ "weight": 4.442955017089844+ },+ {+ "time_s": 3462.0,+ "frequency_hz": 248.87025578320026,+ "weight": 5.245397567749023+ },+ {+ "time_s": 3462.5,+ "frequency_hz": 248.75520431995392,+ "weight": 5.4645915031433105+ },+ {+ "time_s": 3463.0,+ "frequency_hz": 248.554846547544,+ "weight": 5.453758716583252+ },+ {+ "time_s": 3463.5,+ "frequency_hz": 248.2162465453148,+ "weight": 5.1004228591918945+ },+ {+ "time_s": 3464.0,+ "frequency_hz": 247.7071841210127,+ "weight": 5.014849662780762+ },+ {+ "time_s": 3464.5,+ "frequency_hz": 247.62171775847673,+ "weight": 4.955737113952637+ },+ {+ "time_s": 3465.0,+ "frequency_hz": 247.55396964401007,+ "weight": 4.800533771514893+ },+ {+ "time_s": 3465.5,+ "frequency_hz": 247.47378869354725,+ "weight": 4.055933475494385+ },+ {+ "time_s": 3466.0,+ "frequency_hz": 247.56005135551095,+ "weight": 3.6283247470855713+ },+ {+ "time_s": 3466.5,+ "frequency_hz": 247.50792926829308,+ "weight": 3.2188522815704346+ },+ {+ "time_s": 3467.0,+ "frequency_hz": 247.35918405652046,+ "weight": 2.855065107345581+ },+ {+ "time_s": 3467.5,+ "frequency_hz": 248.18092377483845,+ "weight": 2.917581081390381+ },+ {+ "time_s": 3468.0,+ "frequency_hz": 248.21091963350773,+ "weight": 3.164200782775879+ },+ {+ "time_s": 3468.5,+ "frequency_hz": 247.9797350410372,+ "weight": 3.4479660987854004+ }+ ],+ "quality": {+ "median_contrast": 3.852945327758789,+ "harmonic_count": 1.0,+ "support_fraction": 1.0,+ "frequency_resolution_hz": 0.5,+ "time_uncertainty_s": 1.0,+ "frequency_uncertainty_hz": 0.5,+ "frequency_sigma_hz": 0.5,+ "fragment_count": 1.0,+ "max_observed_gap_s": 0.5,+ "frequency_drop_hz": 23.33987185265869+ }+ }+ ],+ "recording_start_window_s": [+ 1788898640.0,+ 1788898660.0+ ],+ "expected_profile_count": 46,+ "positions": [+ [+ 40.87527856914744,+ -73.52482322363304+ ],+ [+ 40.87527960406427,+ -73.5248348000596+ ],+ [+ 40.87348267287692,+ -73.52240429826175+ ],+ [+ 40.873887785435706,+ -73.52381117732966+ ],+ [+ 40.874528770488745,+ -73.52821921340822+ ],+ [+ 40.87348267287692,+ -73.52240429826175+ ],+ [+ 40.868095809160344,+ -73.51799138278676+ ],+ [+ 40.869142103972145,+ -73.52380579132578+ ],+ [+ 40.878869406120586,+ -73.5268178839829+ ],+ [+ 40.878869406120586,+ -73.5268178839829+ ],+ [+ 40.86584749680565,+ -73.53102135784425+ ],+ [+ 40.87348267287692,+ -73.52240429826175+ ],+ [+ 40.874528770488745,+ -73.52821921340822+ ],+ [+ 40.87348267287692,+ -73.52240429826175+ ],+ [+ 40.87348267287692,+ -73.52240429826175+ ],+ [+ 40.87243631052645,+ -73.51658955463307+ ],+ [+ 40.87018813405885,+ -73.52962037135171+ ],+ [+ 40.869142103972145,+ -73.52380579132578+ ],+ [+ 40.87782324096881,+ -73.52100263367996+ ],+ [+ 40.87782324096881,+ -73.52100263367996+ ],+ [+ 40.878869406120586,+ -73.5268178839829+ ],+ [+ 40.867049249635386,+ -73.51217714577056+ ],+ [+ 40.87348267287692,+ -73.52240429826175+ ],+ [+ 40.87527856914744,+ -73.52482322363304+ ],+ [+ 40.87527856914744,+ -73.52482322363304+ ],+ [+ 40.87541209343273,+ -73.52470084819599+ ],+ [+ 40.87520395550061,+ -73.52462465373418+ ],+ [+ 40.87527856914744,+ -73.52482322363304+ ],+ [+ 40.875236429439056,+ -73.5250650770671+ ],+ [+ 40.87527856914744,+ -73.52482322363304+ ],+ [+ 40.87539796716729,+ -73.5251937925925+ ],+ [+ 40.875277095288695,+ -73.5245917326392+ ],+ [+ 40.87527856914744,+ -73.52482322363304+ ],+ [+ 40.87527856914744,+ -73.52482322363304+ ],+ [+ 40.87529155284519,+ -73.52482973248921+ ],+ [+ 40.87526382801294,+ -73.52480707288727+ ],+ [+ 40.87521182851925,+ -73.5248251385459+ ],+ [+ 40.875357824559934,+ -73.5248191698853+ ],+ [+ 40.87527856914744,+ -73.52482322363304+ ],+ [+ 40.87527856914744,+ -73.52482322363304+ ],+ [+ 40.87513855477155,+ -73.52465195898803+ ],+ [+ 40.87541169081278,+ -73.52504291586357+ ],+ [+ 40.87527856914744,+ -73.52482322363304+ ],+ [+ 40.87527856914744,+ -73.52482322363304+ ],+ [+ 40.87527856914744,+ -73.52482322363304+ ],+ [+ 40.87527856914744,+ -73.52482322363304+ ],+ [+ 40.87527856914744,+ -73.52482322363304+ ],+ [+ 40.87527856914744,+ -73.52482322363304+ ],+ [+ 40.87533936741396,+ -73.52484463327308+ ],+ [+ 40.87522885992168,+ -73.52479723399024+ ],+ [+ 40.87528243585439,+ -73.52481950643426+ ],+ [+ 40.87527856914744,+ -73.52482322363304+ ],+ [+ 40.875365973099086,+ -73.52488255638228+ ],+ [+ 40.875202697383656,+ -73.52480013964116+ ],+ [+ 40.875287285047264,+ -73.5246888433303+ ],+ [+ 40.875289344429426,+ -73.52500133857801+ ],+ [+ 40.874921207702165,+ -73.52401266873709+ ],+ [+ 40.875322941322445,+ -73.52550048321216+ ],+ [+ 40.875310052914976,+ -73.52489070990666+ ],+ [+ 40.87525767183193,+ -73.52475364765581+ ],+ [+ 40.874820564409866,+ -73.52501137416495+ ],+ [+ 40.87527856914744,+ -73.52482322363304+ ],+ [+ 40.87527856914744,+ -73.52482322363304+ ],+ [+ 40.87527856914744,+ -73.52482322363304+ ],+ [+ 40.875279908949146,+ -73.52482091073195+ ],+ [+ 40.87531042461824,+ -73.52483694707996+ ],+ [+ 40.8744310602768,+ -73.52428212720557+ ],+ [+ 40.878555819455684,+ -73.51761191078799+ ],+ [+ 40.872549269127674,+ -73.52640270567196+ ]+ ]+}diff --git a/tests/fixtures/real_discovery_normalization.json b/tests/fixtures/real_discovery_normalization.jsonnew file mode 100644index 0000000..f99c23f--- /dev/null+++ b/tests/fixtures/real_discovery_normalization.json@@ -0,0 +1,21 @@+{+ "schema_version": 1,+ "description": "Unmodified decoded PCM excerpts of the real reference upload; values are copied without resampling or generation.",+ "source_sha256": "707083f0344823eeea7f130faec6c22b6628b8b9fea04d026915d93df9a07b15",+ "recorded_job_id": "81f507f42d7042948fef01b5cb589a85",+ "sample_rate_hz": 4000,+ "sample_format": "<f4",+ "decoded_sample_count": 14400738,+ "excerpts": [+ {+ "sample_offset": 0,+ "sample_count": 16000,+ "pcm_f32le_base64": "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"+ },+ {+ "sample_offset": 5586000,+ "sample_count": 16000,+ "pcm_f32le_base64": "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"+ }+ ]+}diff --git a/tests/test_real_discovery_normalization.py b/tests/test_real_discovery_normalization.pynew file mode 100644index 0000000..9dc0ce2--- /dev/null+++ b/tests/test_real_discovery_normalization.py@@ -0,0 +1,142 @@+"""Exact normalization checks on unmodified excerpts of a real recording.++The fixture stores decoded PCM bytes and their offsets in the reference upload.+Hook/failure cases are software compatibility checks on those same observations.+"""+import base64+import json+from pathlib import Path++import numpy as np+import pytest+from scipy import signal++from dopplergeist import discovery+from dopplergeist.audio import Spectrum++[email protected](scope="module")+def real_pcm():+ path = Path(__file__).parent / "fixtures/real_discovery_normalization.json"+ fixture = json.loads(path.read_text())+ assert fixture["sample_format"] == "<f4"+ assert len(fixture["source_sha256"]) == 64+ excerpts = []+ for record in fixture["excerpts"]:+ raw = base64.b64decode(record["pcm_f32le_base64"], validate=True)+ assert len(raw) == record["sample_count"] * 4+ assert 0 <= record["sample_offset"] <= fixture["decoded_sample_count"] - record["sample_count"]+ excerpts.append((record["sample_offset"] / fixture["sample_rate_hz"],+ np.frombuffer(raw, dtype="<f4").copy()))+ return fixture["sample_rate_hz"], excerpts+++def original_spectrum(data, sr, start, settings):+ """Original scalar-axis reductions, retained as the compatibility oracle."""+ n, hop = round(sr * settings.window_s), round(sr * settings.hop_s)+ if len(data) < n:+ return None+ f, t, power = signal.spectrogram(data, fs=sr, window="hann", nperseg=n,+ noverlap=n - hop, nfft=n, scaling="density")+ keep = (f >= settings.min_frequency_hz) & (f <= min(settings.max_frequency_hz, sr * 0.48))+ f, power = f[keep], power[keep]+ db = 10 * np.log10(power + np.finfo(np.float32).tiny)+ whitened = db - np.median(db, axis=1, keepdims=True)+ center = np.median(whitened, axis=0, keepdims=True)+ scale = 1.4826 * np.median(np.abs(whitened - center), axis=0, keepdims=True)+ contrast = np.clip((whitened - center) / np.maximum(scale, 1.0), -4, 12)+ return Spectrum(t + start, f, db, contrast)+++def assert_exact(expected, actual):+ if expected is None:+ assert actual is None+ return+ assert actual is not None+ for name in ("time", "frequency", "db", "contrast"):+ left, right = getattr(expected, name), getattr(actual, name)+ assert left.dtype == right.dtype, name+ assert left.shape == right.shape, name+ assert left.strides == right.strides, name+ assert left.flags.c_contiguous == right.flags.c_contiguous, name+ assert left.flags.f_contiguous == right.flags.f_contiguous, name+ assert left.flags.writeable == right.flags.writeable, name+ assert left.tobytes(order="C") == right.tobytes(order="C"), name++[email protected]("excerpt", [0, 1])[email protected]("upper", [1600.0, 1599.5])[email protected]("dtype", [np.float32, np.float64])+def test_real_spectra_match_original_reductions(real_pcm, excerpt, upper, dtype):+ sr, excerpts = real_pcm+ start, recorded = excerpts[excerpt]+ data = recorded.astype(dtype)+ before = data.tobytes()+ settings = discovery.DiscoverySettings(max_frequency_hz=upper)+ expected = original_spectrum(data, sr, start, settings)+ actual = discovery._spectrum(data, sr, start, settings)+ assert len(actual.time) >= 3+ assert len(actual.frequency) % 2 == (1 if upper == 1600.0 else 0)+ assert_exact(expected, actual)+ assert data.tobytes() == before++[email protected]("name", ["median", "abs", "maximum", "clip", "isfinite"])+def test_real_custom_normalization_hooks_keep_original_dispatch(real_pcm, monkeypatch, name):+ sr, excerpts = real_pcm+ start, data = excerpts[0]+ settings = discovery.DiscoverySettings()+ original, calls = getattr(np, name), []++ def recorded_function(*args, **kwargs):+ calls.append((getattr(args[0], "shape", None), kwargs.get("axis")))+ return original(*args, **kwargs)++ monkeypatch.setattr(np, name, recorded_function)+ expected = original_spectrum(data, sr, start, settings)+ expected_calls = calls[:]+ calls.clear()+ actual = discovery._spectrum(data, sr, start, settings)+ assert calls == expected_calls+ assert_exact(expected, actual)+++def test_real_non_c_layout_keeps_original_layout(real_pcm, monkeypatch):+ sr, excerpts = real_pcm+ start, data = excerpts[0]+ settings = discovery.DiscoverySettings()+ logarithm = np.log10+ monkeypatch.setattr(np, "log10", lambda *args, **kwargs: np.asfortranarray(logarithm(*args, **kwargs)))+ expected = original_spectrum(data, sr, start, settings)+ actual = discovery._spectrum(data, sr, start, settings)+ assert expected.contrast.flags.f_contiguous and not expected.contrast.flags.c_contiguous+ assert_exact(expected, actual)++[email protected]("failure", [np.nan, np.inf, -np.inf])+def test_real_normalization_nonfinite_failure_keeps_original_path(real_pcm, monkeypatch, failure):+ sr, excerpts = real_pcm+ start, data = excerpts[0]+ settings = discovery.DiscoverySettings()+ logarithm = np.log10++ def failing_logarithm(*args, **kwargs):+ result = logarithm(*args, **kwargs)+ result[0, 0] = failure+ return result++ monkeypatch.setattr(np, "log10", failing_logarithm)+ with np.errstate(invalid="ignore"):+ expected = original_spectrum(data, sr, start, settings)+ actual = discovery._spectrum(data, sr, start, settings)+ assert not np.isfinite(actual.db).all()+ assert_exact(expected, actual)+++def test_real_short_prefix_still_has_no_spectrum(real_pcm):+ sr, excerpts = real_pcm+ start, data = excerpts[0]+ settings = discovery.DiscoverySettings()+ prefix = data[:round(sr * settings.window_s) - 1]+ assert original_spectrum(prefix, sr, start, settings) is None+ assert discovery._spectrum(prefix, sr, start, settings) is Nonediff --git a/tests/test_real_refinement_reuse.py b/tests/test_real_refinement_reuse.pynew file mode 100644index 0000000..3c6b041--- /dev/null+++ b/tests/test_real_refinement_reuse.py@@ -0,0 +1,242 @@+"""Exact refinement and terrain.Terrain pixel reuse on archived real inputs."""+from contextlib import contextmanager+from copy import deepcopy+import json+import os+from pathlib import Path+import shutil++import numpy as np+import pytest++from dopplergeist import matching, terrain+from dopplergeist.data_access import FlightIndex+++ROOT = Path(__file__).resolve().parents[1]++[email protected](scope="module")+def recorded_profile():+ return json.loads((ROOT / "tests/data/real-refinement-profile.json").read_text())++[email protected](scope="module")+def real_rasters(recorded_profile):+ root = Path(os.environ.get("DOPPLERGEIST_REAL_REFERENCE_ROOT", ROOT))+ paths = tuple(root / name for name in recorded_profile["source"]["terrain_data"])+ if not all(path.is_file() for path in paths):+ pytest.skip("Restore the real data-terrain bundle or set DOPPLERGEIST_REAL_REFERENCE_ROOT")+ return paths+++def close(sampler):+ for raster in sampler.rasters:+ raster.close()+ if sampler.geoid is not None:+ close(sampler.geoid)+++def uncached(sampler):+ sampler._pixel_sources.clear()+ sampler._pixel_cache.clear()+ if sampler.geoid is not None:+ uncached(sampler.geoid)+++@contextmanager+def samplers(paths, **options):+ fast, original = terrain.Terrain(paths, **options), terrain.Terrain(paths, **options)+ uncached(original)+ try:+ yield fast, original+ finally:+ close(fast)+ close(original)+++def exact_height(actual, expected):+ assert actual.shape == expected.shape and actual.dtype == expected.dtype+ assert actual.tobytes() == expected.tobytes()+ assert actual.flags.writeable and expected.flags.writeable++[email protected]("configuration", ["dem", "ellipsoidal", "geoid_last", "dem_last"])+def test_recorded_positions_keep_exact_heights(real_rasters, recorded_profile, configuration):+ dem, geoid = real_rasters+ paths = {"dem": [dem], "ellipsoidal": [dem],+ "geoid_last": [dem, geoid], "dem_last": [geoid, dem]}[configuration]+ options = {"geoid_path": geoid} if configuration == "ellipsoidal" else {}+ lat, lon = np.asarray(recorded_profile["positions"]).T+ with samplers(paths, **options) as (fast, original):+ assert fast._pixel_sources, "The actual GeoTIFF must exercise pixel reuse"+ exact_height(fast.sample(lat, lon), original.sample(lat, lon))+ for a, b in zip(lat, lon):+ exact_height(fast.sample(a, b), original.sample(a, b))+ exact_height(fast.sample(a, b), original.sample(a, b))+ assert fast._pixel_cache+ changed = fast.sample(lat[0], lon[0])+ changed[...] += 1.+ exact_height(fast.sample(lat[0], lon[0]), original.sample(lat[0], lon[0]))+++def test_pixel_cache_bound_uses_original_heights(real_rasters, recorded_profile, monkeypatch):+ monkeypatch.setattr(terrain, "_PIXEL_CACHE_MAX_ENTRIES", 2)+ with samplers([real_rasters[0]]) as (fast, original):+ for lat, lon in recorded_profile["positions"]:+ exact_height(fast.sample(lat, lon), original.sample(lat, lon))+ assert len(fast._pixel_cache) <= 2+ assert len(fast._pixel_cache) == 2+ lat, lon = recorded_profile["positions"][0]+ exact_height(fast.sample(lat, lon), original.sample(lat, lon))+++def test_closed_real_reader_keeps_original_error(real_rasters, recorded_profile):+ lat, lon = recorded_profile["positions"][0]+ with samplers([real_rasters[0]]) as (fast, original):+ exact_height(fast.sample(lat, lon), original.sample(lat, lon))+ close(fast)+ close(original)+ with pytest.raises(Exception) as expected:+ original.sample(lat, lon)+ with pytest.raises(type(expected.value)) as actual:+ fast.sample(lat, lon)+ assert str(actual.value) == str(expected.value)++[email protected]("change", ["mtime", "replacement", "sidecar"])+def test_changed_real_raster_discards_cached_pixels(real_rasters, recorded_profile, tmp_path, change):+ copied = tmp_path / "observed.tif"+ shutil.copyfile(real_rasters[0], copied)+ lat, lon = recorded_profile["positions"][0]+ with samplers([copied]) as (fast, original):+ exact_height(fast.sample(lat, lon), original.sample(lat, lon))+ assert fast._pixel_cache+ if change == "mtime":+ info = copied.stat()+ os.utime(copied, ns=(info.st_atime_ns, info.st_mtime_ns + 1_000_000))+ elif change == "replacement":+ replacement = tmp_path / "replacement.tif"+ shutil.copyfile(real_rasters[0], replacement)+ replacement.replace(copied)+ else:+ copied.with_name(copied.name + ".aux.xml").write_text("<PAMDataset/>\n")+ exact_height(fast.sample(lat, lon), original.sample(lat, lon))+ assert not fast._pixel_cache and not fast._pixel_sources+++def test_custom_reader_keeps_each_real_read(real_rasters, recorded_profile):+ class ReaderProxy:+ def __init__(self, reader):+ self.reader, self.calls = reader, 0++ def __getattr__(self, name):+ return getattr(self.reader, name)++ def read(self, *args, **kwargs):+ self.calls += 1+ return self.reader.read(*args, **kwargs)++ lat, lon = recorded_profile["positions"][0]+ with samplers([real_rasters[0]]) as (fast, original):+ exact_height(fast.sample(lat, lon), original.sample(lat, lon))+ proxy = ReaderProxy(fast.rasters[0])+ fast.rasters = [proxy]+ for _ in range(2):+ exact_height(fast.sample(lat, lon), original.sample(lat, lon))+ assert proxy.calls == 2+++def test_replaced_dataset_keeps_new_real_values(real_rasters, recorded_profile):+ import rasterio++ lat, lon = recorded_profile["positions"][0]+ with samplers([real_rasters[0]]) as (fast, original):+ exact_height(fast.sample(lat, lon), original.sample(lat, lon))+ close(fast)+ close(original)+ fast.rasters = [rasterio.open(real_rasters[1])]+ original.rasters = [rasterio.open(real_rasters[1])]+ for a, b in recorded_profile["positions"][:8]:+ exact_height(fast.sample(a, b), original.sample(a, b))+++def test_real_pixel_nodata_metadata_and_constant(real_rasters, recorded_profile, tmp_path):+ import rasterio++ # Change only nodata metadata on a disposable copy of the real raster.+ # Every observed pixel value stays unchanged.+ copied = tmp_path / "nodata-metadata.tif"+ shutil.copyfile(real_rasters[0], copied)+ lat, lon = recorded_profile["positions"][0]+ reference = terrain.Terrain([real_rasters[0]])+ try:+ observed_height = reference.sample(lat, lon).item()+ finally:+ close(reference)+ with rasterio.open(copied, "r+", IGNORE_COG_LAYOUT_BREAK="YES") as writer:+ writer.nodata = observed_height+ with samplers([copied]) as (fast, original):+ for _ in range(2):+ with pytest.raises(ValueError) as expected:+ original.sample(lat, lon)+ with pytest.raises(ValueError) as actual:+ fast.sample(lat, lon)+ assert str(actual.value) == str(expected.value)+ assert fast._pixel_cache+ assert all(np.ma.getmaskarray(value).all() for value in fast._pixel_cache.values())+ with samplers([copied], constant_m=observed_height) as (fast, original):+ for _ in range(2):+ exact_height(fast.sample(lat, lon), original.sample(lat, lon))+ assert fast.sample(lat, lon).item() == observed_height+ with samplers([real_rasters[1], copied]) as (fast, original):+ exact_height(fast.sample(lat, lon), original.sample(lat, lon))+++def encoded(value):+ def scalar(item):+ return item.tolist() if isinstance(item, np.ndarray) else item.item()+ return json.dumps(value, sort_keys=True, separators=(",", ":"), allow_nan=True, default=scalar)+++def test_real_complete_profile_keeps_all_fields_and_custom_dispatch(+ real_rasters, recorded_profile, monkeypatch):+ source = os.environ.get("DOPPLERGEIST_REAL_CPA_FIXTURE")+ if not source:+ pytest.skip("Set DOPPLERGEIST_REAL_CPA_FIXTURE to the restored real-index fixture")+ diagnostic = json.loads(Path(source).read_text())+ candidate = recorded_profile["candidate"]+ index = FlightIndex(diagnostic["real_index"])+ assert index.report["input_hash"] == diagnostic["index_input_hash"]+ tracks = {track.id: track for track in index.lookup(candidate["flight_ids"])}+ assert set(tracks) == set(candidate["flight_ids"])+ events, measurements = matching.prepare_events(recorded_profile["events"], c=343., max_distance_m=20000.)+ options = {"radius_m": 500., "recording_start_window_s": recorded_profile["recording_start_window_s"], "c": 343.}+ refiner = matching.refine_candidate+ calls = []++ def later(*args, **kwargs):+ assert len(args) == 5+ assert set(kwargs) == {"radius_m", "clock_radius_s", "altitude_offsets_m", "crs", "c", "recording_start_window_s"}+ calls.append("later")+ return refiner(*args, **kwargs)++ def first(*args, **kwargs):+ calls.append("first")+ assert len(args) == 5+ assert not any(key.startswith("_") for key in kwargs)+ monkeypatch.setattr(matching, "refine_candidate", later)+ return refiner(*args, **kwargs)++ with samplers([real_rasters[0]], geoid_path=real_rasters[1]) as (fast, original):+ actual = matching._cache_ridge_fits(matching.profile_candidate)(+ deepcopy(candidate), tracks, events, measurements, fast, **options)+ assert len(actual["sensitivity"]["profiles"]) == recorded_profile["expected_profile_count"]+ assert fast._pixel_cache and fast.geoid._pixel_cache+ # This public wrapper forces the existing unshared-transform path and+ # changes global dispatch after the nominal call, using real solves.+ monkeypatch.setattr(matching, "refine_candidate", first)+ expected = matching._cache_ridge_fits(matching.profile_candidate)(+ deepcopy(candidate), tracks, events, measurements, original, **options)+ assert encoded(actual) == encoded(expected)+ assert calls == ["first"] + ["later"] * 43