Python tool for aircraft Doppler audio geolocation using historical ADS-B flight data (Source-available)
Python acoustic-geolocationads-baircraft-trackingairplaneaudio-forensicsdoppler-effectdoppler-shiftgeolocationosintsignal-processing
"""Replay the three historical failed scale-fixture tiles, without audio truth.
Compare preserved scores with a per-track oracle on the unchanged canonical
index. This is a fault-isolation regression, not a localization benchmark.
"""
import argparse
import json
from pathlib import Path
import subprocess
import time
import numpy as np
from dopplergeist.audio import Spectrum
from dopplergeist.data_access import FlightIndex, sha256, write_json
from dopplergeist.geometry import AcousticSupportError
from dopplergeist.search import cpa_table, pair_candidates, score_candidate
from dopplergeist.terrain import Terrain
from dopplergeist.tiled_search import SearchBudget, _expanded_bounds, _record_support, _score, _tracks, grid_tiles, merge_candidates, tile_points
def signature(rows):
return [(r["flight_ids"], r["x"], r["y"], r["score"], r["recording_start_time_s"],
r["pass_emission_times_s"]) for r in rows]
def main():
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument("index")
parser.add_argument("output")
parser.add_argument("--manifest", default="evidence/w2-data-scale-20261102/scale-v2-manifest.json")
args = parser.parse_args()
output = Path(args.output)
output.mkdir(parents=True, exist_ok=False)
config = json.loads(Path(args.manifest).read_text())["configuration"]
index = FlightIndex(args.index)
assert sha256(index.path) == config["indexes"][0]["file_sha256"], "Require the unchanged historical index"
assert index.report["input_hash"] == config["indexes"][0]["input_hash"]
budget = SearchBudget(**config["budget"])
event, = config["events"]
t = np.linspace(event["start_s"], event["end_s"], 41)
ridge = 120 * (1 - .12 * np.tanh((t - event["cpa_receive_s"]) / 12))
spec = Spectrum(t, np.array([80., 160.]), np.zeros((2, len(t))), np.zeros((2, len(t))))
measurements = [(spec, ridge, np.ones(len(t)), {})]
radius, began, reports = event["slant_range_m"][1], time.monotonic(), []
selected = {"5_13", "9_9", "7_15"}
for name, cells in grid_tiles(config["bounds"], budget.spacing_m, budget.tile_cells):
if name not in selected:
continue
points = tile_points(cells, budget.spacing_m, config["bounds"], Terrain(constant_m=0), config["crs"])
tracks = _tracks([index], _expanded_bounds(cells, budget.spacing_m, radius, config["crs"]), config["time_range_s"], budget)
ranked, counts = _score(points, tracks, [event], measurements, budget, config["scoring"], {})
summary = dict(unsupported_cpa_track_evaluations=0, unclassified_score_candidates=0,
evaluated_trials=0, rejected_trials=0, unknown_trials=0, unreported_trial_envelopes=0)
_record_support(output, f"coarse:{name}", counts, summary)
# Independently enumerate/score each track. A failure cannot interrupt
# unrelated tracks in this oracle; retain every finite result before k.
reference, failures, source_failures, nonfinite = [], [], [], 0
lookup = {p.point_id: p for p in points.itertuples()}
for track in tracks:
try:
table = cpa_table([track], points, radius, config["scoring"].get("c", 343.), budget.cpa_step_s)
except AcousticSupportError as error:
source_failures.append({"flight_id": track.id, "reason": error.reason,
"emission_intervals_s": error.emission_intervals_s,
"receive_intervals_s": error.receive_intervals_s})
continue
candidates, _ = pair_candidates(table, [event], time_origin=config["scoring"]["time_origin"], time_tolerance_s=5.)
for candidate in candidates:
try:
row = score_candidate(candidate, lookup[candidate["point_id"]], {track.id: track},
[event], measurements, **config["scoring"])
except AcousticSupportError as error:
failures.append({"flight_id": track.id, "point_id": int(candidate["point_id"]), "reason": error.reason})
continue
if np.isfinite(row["score"]):
row["pass_emission_times_s"] = [float(p["emission_time"]) for p in candidate["passes"]]
reference.append(row)
else:
nonfinite += 1
kept = merge_candidates(reference, budget.top_k)
assert signature(ranked) == signature(kept), f"Clean candidate change at {name}"
assert counts["unclassified_score_candidates"] == len(failures) + nonfinite
assert len(counts["unsupported_cpa_tracks"]) == len(source_failures)
assert (failures or source_failures) and ranked, "Each historical failure tile must preserve valid diagnostics"
report = {"tile": name, "tracks": len(tracks), "points": len(points), "finite_oracle_rows": len(reference),
"retained_rows": len(ranked), "typed_candidate_failures": failures, "nonfinite_oracle_rows": nonfinite,
"unsupported_cpa_sources": source_failures,
"model_support_complete": False, "model_support": summary, "clean_scores_equal_oracle": True,
"ranked": ranked}
write_json(output / f"tile-{name}.json", report)
reports.append({k: v for k, v in report.items() if k != "ranked"})
print(json.dumps({k: v for k, v in report.items() if k not in ("ranked", "typed_candidate_failures", "unsupported_cpa_sources")}), flush=True)
assert {r["tile"] for r in reports} == selected
root = Path(__file__).resolve().parents[1]
write_json(output / "report.json", {"scope": "Historical three failed analytic-ridge scale tiles; no localization truth",
"source_commit": subprocess.check_output(["git", "rev-parse", "HEAD"], cwd=root, text=True).strip(),
"index_sha256": sha256(index.path), "index_input_hash": index.report["input_hash"],
"old_manifest_sha256": sha256(args.manifest), "code_sha256": {p.name: sha256(p) for p in (root / "src/dopplergeist").glob("*.py")},
"runner_sha256": sha256(__file__), "elapsed_s": time.monotonic()-began, "tiles": reports,
"limitations": ["Diagnostic tiles were selected from preserved historical model failures, not recorder truth.",
"Same legacy derivatives/altitudes and constant ground; no raw normalization repair.",
"This does not certify continuous motion, complete national coverage or geolocation accuracy."]})
if __name__ == "__main__":
main()