Skip to content

Python tool for aircraft Doppler audio geolocation using historical ADS-B flight data (Source-available)

6.6 KB
Raw Blame
"""Loading-budget checks on archived aircraft observations.

Receiver coordinates are calculation controls, not microphone-location truth.
No audio or aircraft trajectory is generated by these tests.
"""
from dataclasses import replace
import json
from pathlib import Path

import numpy as np
import pandas as pd
import pytest

from dopplergeist.data_access import DataUnavailable, FlightIndex
from dopplergeist.geometry import ecef
from dopplergeist.tiled_search import SearchBudget, _tracks, _tracks_for_points


class QueryProbe:
    def __init__(self, index):
        self.index = index
        self.queries = self.yielded = 0

    def query(self, bounds, window):
        self.queries += 1
        for track in self.index.query(bounds, window):
            self.yielded += 1
            yield track


class NoTerrain:
    def sample(self, *args):
        raise AssertionError("This query must not request terrain")


@pytest.fixture
def real_query(tmp_path):
    root = Path(__file__).resolve().parents[1]
    observations = root / "research/trajectory-motion/frozen/canonical-observations.json"
    frame = pd.DataFrame(json.loads(observations.read_text()))
    frame = frame.loc[frame.typecode.isin(["C172", "H500"])].copy()
    bounds = [-180., -90., 180., 90.]
    window = [float(frame.time_s.min()), float(frame.time_s.max())]
    coverage = {"bounds": bounds, "time_range_s": window, "all_aircraft": False,
                "source_note": "Archived real observations; incomplete excerpt"}
    built = FlightIndex.build(tmp_path / "real.sqlite", [frame], sources=[], coverage=coverage)
    index = FlightIndex(built.path, track_cache_bytes=0)
    complete = list(index.query(bounds, window))
    if len(complete) < 4:
        pytest.skip("non-jet observations do not provide enough distinct tracks for this test")
    workloads = json.loads((root / "tests/data/real-search-workloads.json").read_text())
    far = pd.DataFrame([workloads["cases"]["previous-fit"]["point"]])
    track = complete[0]
    midpoint = len(track.time) // 2
    near = pd.DataFrame([{"point_id": 0, "lat": track.lat[midpoint],
                          "lon": track.lon[midpoint], "elev_m": 0.}])
    return index, bounds, window, complete, near, far


def assert_track_arrays_equal(got, expected):
    assert [track.id for track in got] == [track.id for track in expected]
    for actual, prior in zip(got, expected):
        for name in ("time", "lat", "lon", "altitude", "xyz"):
            np.testing.assert_array_equal(getattr(actual, name), getattr(prior, name))
        np.testing.assert_array_equal(actual.spline.c, prior.spline.c)
        np.testing.assert_array_equal(actual.derivative.c, prior.derivative.c)
        assert actual.typecode == prior.typecode
        assert actual.altitude_basis == prior.altitude_basis


@pytest.mark.parametrize("limiting_field", ["max_tracks_per_tile", "max_track_samples_per_tile"])
def test_overloaded_query_reads_each_real_segment_once(real_query, limiting_field):
    index, bounds, window, complete, points, _ = real_query
    observers = ecef(points.lat.to_numpy(), points.lon.to_numpy(), points.elev_m.to_numpy())
    generous = SearchBudget(max_tracks_per_tile=1000, max_track_samples_per_tile=1000000)
    expected = _tracks([index], bounds, window, generous, observers=observers, radius=20000.)
    assert 0 < len(expected) < len(complete)
    limit = len(expected) if limiting_field == "max_tracks_per_tile" else sum(len(t.time) for t in expected)
    budget = replace(generous, **{limiting_field: limit})
    with pytest.raises(DataUnavailable, match="Tile track/sample memory budget exceeded"):
        _tracks([index], bounds, window, budget)
    probe = QueryProbe(index)
    got, returned_points = _tracks_for_points([probe], bounds, window, budget,
        points, NoTerrain(), 20000., 343.)
    assert_track_arrays_equal(got, expected)
    assert returned_points is points
    assert probe.queries == 1
    assert probe.yielded == len(complete)


@pytest.mark.parametrize("empty", [False, True])
def test_ordinary_and_empty_queries_do_not_sample_terrain(real_query, empty):
    index, bounds, window, complete, _, far = real_query
    if empty:
        window = [window[0] - 100., window[0] - 50.]
    points = far.drop(columns="elev_m")
    probe = QueryProbe(index)
    tracks, returned_points = _tracks_for_points([probe], bounds, window, SearchBudget(),
        points, NoTerrain(), 20000., 343.)
    assert returned_points is points and "elev_m" not in points
    assert len(tracks) == (0 if empty else len(complete))
    assert probe.queries == 1


def test_overload_preserves_duplicates_and_bounded_scan(real_query):
    index, bounds, window, complete, _, points = real_query
    observers = ecef(points.lat.to_numpy(), points.lon.to_numpy(), points.elev_m.to_numpy())
    budget = SearchBudget(max_tracks_per_tile=1)
    assert not _tracks([index], bounds, window, SearchBudget(), observers=observers, radius=20000.)
    probe = QueryProbe(index)
    retained, _ = _tracks_for_points([probe, probe], bounds, window, budget,
        points, NoTerrain(), 20000., 343.)
    assert not retained
    assert probe.queries == 2 and probe.yielded == 2 * len(complete)
    probe = QueryProbe(index)
    with pytest.raises(DataUnavailable, match="Tile track/sample memory budget exceeded"):
        _tracks_for_points([probe] * 21, bounds, window, budget,
            points, NoTerrain(), 20000., 343.)
    assert probe.yielded == 21  # The inherited 20x scan budget remains inclusive.


def test_retained_budget_failure_is_not_hidden_by_sieve(real_query):
    index, bounds, window, complete, points, _ = real_query
    probe = QueryProbe(index)
    budget = SearchBudget(max_tracks_per_tile=1)
    with pytest.raises(DataUnavailable, match="Tile track/sample memory budget exceeded"):
        _tracks_for_points([probe], bounds, window, budget, points, NoTerrain(), 10000000., 343.)
    assert probe.queries == 1
    assert probe.yielded <= len(complete)


def test_pruned_prefix_still_detects_conflicting_real_geometry(real_query):
    index, bounds, window, complete, _, points = real_query

    class ConflictingIndex:
        def query(self, bounds, window):
            for track in index.query(bounds, window):
                if track.id == complete[1].id:
                    # An ID collision between two actual observed trajectories
                    # must still fail after the earlier geometry was pruned.
                    track.id = complete[0].id
                    yield track

    with pytest.raises(DataUnavailable, match="Conflicting flight segment identity"):
        _tracks_for_points([index, ConflictingIndex()], bounds, window,
            SearchBudget(max_tracks_per_tile=1), points, NoTerrain(), 20000., 343.)