Skip to content

Geophysical aiding: gravity unit fix, config parity, measurement characterisation, GNSS realism - #417

Merged
jbrodovsky merged 29 commits into
mainfrom
geo-bias-fixes
Oct 1, 2026
Merged

jbrodovsky merged 29 commits into
mainfrom
geo-bias-fixes

Conversation

@jbrodovsky

@jbrodovsky jbrodovsky commented Sep 23, 2026 •

Copy link
Copy Markdown
Owner

Summary

Six workstreams on the geophysical aiding path — the three requested, plus a blocking defect found while scoping them, the monorepo setup that checking in analysis/ required, and three more defects that only surfaced when the pipeline was actually run.

0 Gravity unit fix — earth::gravity_anomaly returned m/s² and was differenced against a milligal map
1 Geophysical closed loop from a config file — UKF/EKF geo runs work from --config, as the RBPF already could
2 Measurement characterisation — analyze geostats: per-field bias, noise, SNR, de-correlation length, and --apply-to conf to adopt them
3 GNSS degradation realism — denial-first scenario tiers, ρ decoupled from the fix interval
4 Monorepo setup — uv workspace, Python CI, docs corrected
5 Found by running it — three defects, two of them silent

Important

Every prior result must be regenerated, and the gravity fix is not the main reason. Four independent changes invalidate them; the first alone is sufficient. See Regenerating the experiment.

0 — The gravity channel was never measuring gravity

earth::gravity_anomaly returned m/s²: grav_x/y/z are m/s², earth::gravity() returns m/s², and the Eötvös term is m/s². That was differenced against a milligal map, and --gravity-noise-std is milligal. 1 mGal is 1e-5 m/s², so the observation was 1e5 too small and the innovation z - h was, to five significant figures, just -h — the filter was told its predicted map value was wrong by exactly that value, at every geophysical update.

Nothing caught it: a tens-of-milligal innovation against the default 100 mGal noise is a NIS of about 0.16, far under any gate. The magnetic channel had the identical defect and was fixed separately (MICROTESLA_TO_NANOTESLA); this is the same fix for gravity.

Why the tests missed it. test_gravity_anomaly asserted only is_finite(), which a value 1e5 out still satisfies. And geo_closed_loop.rs left the track's grav_* at Default's zero, making the observation 0 - 9.8017 = -9.80 — a number that lands inside a map generated around ±40 and reads as a plausible milligal anomaly. It is not one; it is normal gravity in the wrong unit, and the fixture passed on that coincidence. Added GRAVITY_BIAS_PLAUSIBLE_MGAL, the twin of the existing MAGNETIC_BIAS_PLAUSIBLE_NT: a units error does not stop the bias moving, it makes the bias absorb the error confidently, so bounding its magnitude is what separates a bias tracking an anomaly from one soaking up a scale factor. Verified by reinstating the defect — four tests fail.

1 — Geophysical closed loop from a config file

--geo was reachable only from the cl subcommand's flags; a closed-loop config carrying [geophysical] was refused outright, while the particle-filter arm of the same function read maps and GNSS degradation from one file. The two filter families were configured in incompatible ways, and the justfile carried a twelve-flag command line that had to be kept in step with conf/*_degraded.toml by hand.

Both paths now resolve to a GeoClosedLoopSettings and run one function. Verified end to end: the CLI invocation and the equivalent config file produce byte-identical CSV.

Two defects found by making them agree, both meaning the paths ran different filters:

Also: gravity_bias/magnetic_bias were config-path-inert and silently dropped; the four *_bias_init_std/*_bias_process_noise_std keys the CLI had are now available in a config; generate_plot reached only the non-geophysical path, so every conf/*.toml asked for a plot and no geophysical run produced one; and the config wizard could write a file the binary refuses (eskf + geophysical), which matters because Eskf is FilterType's default.

2 — analyze geostats

The 100 mGal / 150 nT defaults were never measured against anything. This measures them: for each trajectory it forms the anomaly the way the filter forms it, samples the map at the GNSS position, and reduces the residual to bias, robust σ, signal σ and SNR.

The residual is decomposed, because it holds two things that belong in different places. What varies within a recording is measurement noise and belongs in R; what varies between recordings is a per-run offset — the phone's and the vehicle's own field — and the filter has a bias state for exactly that. Collapsing them makes a channel look unusable when it is merely mis-modelled.

De-correlation is taken from the source data, not the grid spacing, and the difference is large:

downloaded at real resolution why
gravity 1 arc-min ~9.3 km earth_faa is filled from EGM2008 over land, whose input is a 5 arc-min area-mean grid
magnetic 3 arc-min ~31 km earth_wdmam is referenced to 5 km altitude; upward continuation suppresses everything shorter

At 24 m/s that is one independent gravity sample per 386 s and one magnetic per 1309 s, against the geo_frequency_s = 1.0 every config uses. (Also: the magnetic grid is fetched at 3 arc-min while every config declares two_minutes, and nothing validates that — geo-stats reports the actual spacing so the mismatch is visible.)

Measuring is only half of it — the numbers have to reach the configs. --apply-to conf, wrapped as just geo-adopt, writes the measured bias, noise and bias prior into all 18 geophysical recipes. Line by line rather than through a TOML round-trip, which would strip every comment in these files; only into keys already present, so a *_grav.toml stays gravity-only rather than silently becoming a dual-aid run. The one insertion is *_bias_init_std, which no config carries yet — without it the map-bias state inherits *_noise_std as its prior, far too tight for a magnetometer sitting in a vehicle that contributes thousands of nT of its own field.

Tested by planting a known bias and σ into synthetic trajectories, inverting the measurement models so the CSV carries raw sensor values, and requiring them back — within-trajectory σ recovers to 7.03 against 7.0 planted, and 25.12 against 25.0.

3 — GNSS degradation realism

The fix interval and the error model were the same knob. rho_pos is applied once per emitted fix with no reference to elapsed time, so the correlation time is -interval_s / ln(rho) — a property of the scheduler. At rho_pos = 0.99, 5 s is 498 s and 30 s is 2985 s. Added optional tau_pos_s/tau_vel_s: the coefficient becomes exp(-dt/tau) and sigma_pos_m becomes the steady-state spread. Strictly additive — omitted, nothing changes, and perf_baseline does not move.

The fault advanced on the wrong clock. apply_fault runs once per emitted fix but was handed the record spacing, so under interval_s = 5 on a 1 Hz log a SlowBias spoofed at a fifth of its configured rate.

What a jamming scenario should be. The dominant measured effect of jamming is loss of fix, not graceful degradation — at Jammertest the signal was in most runs strong enough to cause complete signal loss. New conf/*_denied.toml (duty cycle, fault none, so availability is the only variable) and conf/*_jammed.toml (35 m steady state, anchored to published smartphone figures). conf/*_degraded.toml is deliberately unchanged — it is the baseline every result so far was measured against.

The denial comparison is like-for-like. conf/*_denied_{grav,mag,both}.toml carry the denial GNSS profile, so geoperf-denied compares two runs differing in nothing but whether the geophysical measurement is present. Nine more configs means 24 files duplicating a GNSS block, and drift between exactly those is what went wrong before — so example_configs.rs now asserts every geo recipe's [gnss_degradation] and [health_limits] match the baseline named in its filename. Verified by re-injecting the historical drift: the test fails and names the field.

book/src/gnss/fault-simulation.md was a one-line stub; it now carries the rationale and thirteen sources.

4 — Monorepo

uv workspace at the root (uv run analyze ... from anywhere, dropping 35 --project analysis flags), ruff + pytest config, .github/workflows/python.yml, Python .gitignore entries, and eight .pyc files removed from the index. CLAUDE.md and AGENTS.md both asserted the repository is Rust-only.

One thing the gate required: pygmt is no longer imported at module scope. It dlopens the GMT C library on import, so importing analysis at all failed wherever GMT is absent — every subcommand, including ones that draw no maps. CI installs no GMT on purpose, so the job is what keeps this true.

5 — Found by running it

These only surfaced when just pipeline was actually executed, and two of the three were silent.

  • postprocess produced zero plots and exited 0. read_csv(..., parse_dates=True, index_col=0) does not guarantee a datetime index — when pandas cannot infer a format it leaves it as strings, with no error. These timestamps look like 2025-03-01 12:00:00+00:00, which it declines to infer, so the first arithmetic raised unsupported operand type(s) for -: 'str' and 'str'. performance_analysis caught that in a broad except, printed "possible dimension mismatch or missing data", and carried on — for every scenario, filter and trajectory. Fixed with a read_timeseries helper across six call sites. 0 → 99 plots. The same defect was in geostats, whose own fixture missed it by writing timestamps in a format that round-trips.
  • pipeline ran nothing. Its steps were recipe body lines, which just executes as shell commands, so it tried to run build as a program and died on the first one. They are dependencies now, and the rm -rf cleanup moved to its own clean recipe.
  • pipeline could never produce the maps the geo runs need. preprocess ran without --getmaps, so it called inherit_parent_maps — which copies the parent recording's .nc files, which clean had just deleted. Every geophysical run then died on "Gravity map file not found", three steps downstream of the cause.

A fourth, found while verifying the nine denial-geo configs: three failed on every trajectory with longitude ... is outside the map bounds. inflate_bounds pads each map by a fraction of the track's own extent, but filter drift is an absolute distance — and it scales latitude and longitude independently, so a due-north drive gets ≈ 0 longitude margin and any eastward excursion leaves the map. Added --margin-km (5 km default, padding by max(fractional, absolute)), measured against the actual excursion (truth 0.00 km, degraded 0.00 km, denied 2.27 km). OutOfMapBounds now names the remedy instead of just the coordinate.

Plus a pre-existing CI flake. test_state_transition_jacobian_multiple_states is entropy-seeded via rand::rng() and bounded at 5e-4 — exactly on the shoulder of its own error distribution (median 2.4e-4, p99.9 4.9e-4, largest over 4000 states 5.05e-4). Measured at 1 failure in 400 runs; it hit this branch once at 5.0245e-4 on a commit touching nothing it covers. Seeded with StdRng::seed_from_u64, sample raised 10 → 50 states since determinism makes coverage free, bound raised to 1e-3 — twice the largest error measured, still far tighter than any real defect, since a wrong analytic Jacobian disagrees at O(1) or O(dt).

Regenerating the experiment

Four independent changes invalidate prior results:

  1. Sample rate 1 Hz → 10 Hz. The active preprocess recipe was -f 1; it is -f 10. Every filter sees ten times the propagation steps. This alone invalidates everything. It is principled, not a silent retune: DEFAULT_PROCESS_NOISE_DENSITY is a spectral density and each filter forms Q_k = q·dt (Process noise is per-step, so effective Q scales with sample rate (50x across shipped datasets) #374).
  2. The gravity unit fix — all */grav and */both used an observation 1e5 too small.
  3. --ukf-alpha 1e-3 → 0.1. just ukf-geo never passed the flag, so every prior UKF geo run used 1e-3 while conf/ukf_{truth,degraded}.toml used 0.1 — the comparison was between two differently-conditioned filters.
  4. The six geo configs' GNSS profile — interval_s = 1.0 / 15.0 / 5.0 / 15.0 against a baseline at 5.0 / 3.0 / 0.3 / 5.0.

Run just clean build preprocess geo-stats and stop there. data/output/geostats/geo_stats.toml carries the measured noise, bias and bias prior that replace the 100 mGal / 150 nT defaults; just geo-adopt writes them into all 18 geophysical configs. Check git diff conf/, then run just truth degraded denied jammed, just ukf-geo ekf-geo rbpf-sim denied-geo, just postprocess geoperf-all geoperf-denied.

geo-adopt is deliberately absent from just pipeline — it rewrites tracked files and invalidates whatever is already in data/output, so the pipeline must not change the experiment underneath itself. geo_frequency_s is held back behind --apply-interval: the noise figures are measurements, but moving the interval from 1 s to one sample per de-correlation length changes what the experiment asks of the aid, which is a decision rather than a measurement.

A partial adoption is the dangerous outcome — a conf/ where some filters carry the measured R and some do not still parses, still runs, and yields a comparison whose difference came from two different R. every_geophysical_config_describes_the_same_sensor in example_configs.rs asserts all 18 recipes agree on every geophysical key they share; verified both ways, including by reverting one file's gravity_noise_std.

Testing

All six gates clean locally:

cargo fmt-check && cargo lint && cargo lint-min
cargo test --workspace --all-features && cargo test-min
uv run ruff check && uv run ruff format --check && uv run pytest -q

Plus end-to-end verification against synthetic Sensor Logger recordings: all 15 pipeline steps complete from an empty tree, producing the full matrix — 63 navigation solutions across {ukf, ekf, rbpf} × {truth, degraded, denied, jammed, grav, mag, both}, 99 performance plots, 72 geoperformance artifacts, plus the nine denial-geo runs and their 54 artifacts. The CLI and config geophysical paths produce byte-identical output, and both guard rails (ESKF, no map) fire with clear messages.

One step a sandbox cannot run: --getmaps needs the GMT C library and network access to the GMT data server. Locally generated grids stood in at the real spacings (1 arc-min gravity, 3 arc-min magnetic).

🤖 Generated with Claude Code

https://claude.ai/code/session_01RwCvG9Hh2bmZbdd5JpPHVK

jbrodovsky and others added 11 commits September 22, 2026 15:31
`earth::gravity_anomaly` returned m/s^2. Every consumer of it is in milligal:
the `z` variable of the NetCDF maps `GeoMap` loads, `--gravity-noise-std`,
`--gravity-bias`, and the `[geophysical]` section of a scenario file. 1 mGal is
1e-5 m/s^2, so the observation reaching `GravityMeasurement` was 1e5 times too
small and the innovation `z - h` was, to five significant figures, just `-h`:
the filter was told its predicted map value was wrong by exactly that value, at
every geophysical update.

Nothing caught it. A tens-of-milligal innovation against the default 100 mGal
noise standard deviation is a NIS of about 0.16, far under any gate, so the
runs completed and reported success while the gravity channel pulled the
solution around in proportion to the map rather than measuring anything.

The magnetic channel had the identical defect and was fixed separately
(`MICROTESLA_TO_NANOTESLA`). This is the same fix for gravity:
`earth::MGAL_PER_M_PER_S2`, applied at the one place the anomaly is formed.

Why the tests did not catch it, and what now does:

  - `test_gravity_anomaly` asserted only `is_finite()`, which a value 1e5 out
    still satisfies. Replaced with two tests that pin the scale: a 9.81 m/s^2
    observation at 45 deg N must land in the hundreds of milligal, and a 1e-5
    m/s^2 perturbation must move the anomaly by exactly 1.0.

  - `geo_closed_loop.rs` left the track's `grav_*` at `Default`'s zero, which
    made the observation `0 - 9.8017 = -9.80` -- a number that lands inside a
    map generated around +/-40 and reads as a plausible milligal anomaly. It is
    not one; it is the whole of normal gravity in the wrong unit, and the
    fixture passed on that coincidence. The track now carries a real gravimeter
    reading and the map is offset to the anomaly that reading has, mirroring
    what the magnetic half of the same fixture already did.

  - Gravity noise in those fixtures was 1.0 mGal against a +/-40 mGal map, so
    every innovation was a 40-sigma event. Raised to 10.0, matching the 10 nT
    the magnetic side uses against its own +/-40 nT map.

  - Added `GRAVITY_BIAS_PLAUSIBLE_MGAL`, the twin of the existing
    `MAGNETIC_BIAS_PLAUSIBLE_NT`. A units error does not stop the bias moving;
    it makes the bias absorb the error confidently, so "the bias moved" and
    "its variance fell" both still hold. Bounding the magnitude is what
    separates a bias tracking an anomaly from one soaking up a scale factor.

Verified by reinstating the defect: four tests fail, including the new bound,
which reports the bias reaching 113 mGal.

Every gravity-aided result produced before this commit is invalid --
data/output/*/grav and data/output/*/both have to be regenerated, and any
comparison drawn from them re-derived.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01RwCvG9Hh2bmZbdd5JpPHVK
Two things, together because the first needs the second to have somewhere to
live and a gate to keep it working.

## `analyze geostats`

The noise the geophysical filters are configured with -- 100 mGal and 150 nT --
was never measured. It is a constant in `strapdown-geonav` repeated in every
`conf/*.toml`, and nothing in the toolchain could have told you whether it was
right. `geostats` measures it: for each trajectory it forms the anomaly the way
the filter forms it, samples the map at the GNSS position, and reduces the
residual.

It reports, per field:

  - bias, as mean and median;
  - spread, as a standard deviation and a robust 1.4826*MAD -- these residuals
    are multimodal, so the plain one is not a usable sigma;
  - the signal, meaning the variation of the *map* along the track, and the
    resulting signal-to-noise ratio;
  - the de-correlation length and the measurement interval that follows from it.

The residual is decomposed rather than reported as one number, because it holds
two things that belong in different places in the filter. What varies *within*
a recording is measurement noise and belongs in R. What varies *between*
recordings is a per-run offset -- the phone's and the vehicle's own field, for
the magnetic channel -- and the filter already has a state for that, so it
belongs in the map-bias prior. Collapsing them is what makes a channel look
unusable when it is merely mis-modelled. The generated figure shows this
directly: one narrow mode per recording, and the single-sigma normal fit
visibly failing to describe them.

De-correlation is taken from the *source* data, not the grid spacing, and the
difference is large:

  - `earth_faa` is downloaded at 1 arc-minute, but over land it is filled from
    EGM2008, whose terrestrial input is a 5 arc-minute area-mean grid. The
    1 arc-minute cells are interpolation, so the real figure is ~9.3 km, not
    1.9 km.
  - `earth_wdmam` is a 3 arc-minute grid *at 5 km altitude*. Upward continuation
    attenuates wavelengths below about 31 km, so a ground-level sensor and the
    map are not measuring the same thing, and 31 km is the honest length.

At 24 m/s that is one independent gravity sample per 386 s and one magnetic per
1309 s, against the `geo_frequency_s = 1.0` every config uses. Also worth
noting: the magnetic grid is fetched at 3 arc-minutes while every config
declares `two_minutes`, and nothing validates that, because `GeoResolution` is
a filename token and no code derives metres from a grid.

The anomaly models mirror `core/src/earth.rs` and `geonav/src/lib.rs` term for
term -- a statistic computed from a differently-computed anomaly would describe
a quantity the filter never sees, which is worse than none, since it would be
used to set the filter's noise. `self_check()` asserts the two still agree,
against the reference values `geonav/tests/geo_closed_loop.rs` states.

Tested by planting a known bias and sigma into synthetic trajectories, inverting
the measurement models so the CSV carries raw sensor values, and requiring the
numbers back. Within-trajectory sigma recovers to within 10% (7.03 against 7.0
planted, 25.12 against 25.0).

## Monorepo

`analysis/` is checked in, so it needs a build and a gate:

  - a virtual uv workspace root at `pyproject.toml`, so `uv sync` and
    `uv run analyze ...` work from the repository root. The justfile's 35
    `uv run --project analysis` invocations lose the flag.
  - ruff and pytest configuration, and `.github/workflows/python.yml` to run
    them. Separate from rust.yml: a Python lint failure reported under "Test,
    Lint, and Build Rust Project" is a check name that lies.
  - `.gitignore` gains the Python artefacts. The first commit of the package
    brought eight `.pyc` files with it; those are removed from the index.
  - CLAUDE.md and AGENTS.md both asserted the repository is Rust-only, which a
    stale instruction file turns into a misleading brief for the next session.

Fixing the lint findings surfaced two pre-existing ones worth naming: a dead
`all_csv` in `preprocess_data`, and a `zip(starts, ends)` whose `strict=True`
now catches a future divergence rather than silently truncating.

One thing the gate required: **pygmt is no longer imported at module scope.**
It dlopens the GMT C library on import, so importing `analysis` at all failed
wherever GMT is absent -- every subcommand, including ones that draw no maps.
CI installs no GMT on purpose, so the job is what keeps this true.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01RwCvG9Hh2bmZbdd5JpPHVK
…ould

`--geo` was reachable only from the `cl` subcommand's flags. A closed-loop
config carrying a `[geophysical]` section was refused outright, while the
particle-filter arm of the same function read maps and GNSS degradation from
one file. So the two filter families were configured in incompatible ways: the
RBPF took a `--config`, and the UKF and EKF took a twelve-flag command line
that had to be kept in step with `conf/*_degraded.toml` by hand, with a comment
in the justfile asking whoever edited one to remember the other.

Both paths now resolve to a `GeoClosedLoopSettings` and run
`run_geo_closed_loop_file`. Verified end to end: the `just ukf-geo` command
line and the equivalent config file produce byte-identical CSV.

Two defects found by making them agree, both of which meant the two paths were
not running the same filter:

  - `--ukf-alpha` defaulted to the textbook `1e-3`. A config file defaults to
    `0.1`, which is the value #399 measured and adopted -- alpha is a
    numerical-conditioning parameter here, and `1e-3` costs six significant
    digits per step to cancellation in the weighted sigma-point mean. The flag
    was never moved with it, so `--filter ukf` and a config naming the same
    filter ran with sigma-point spreads two orders of magnitude apart. Both now
    take `sim::DEFAULT_UKF_ALPHA`.

  - `--log-level` was discarded entirely on the `--config` path, under a
    comment claiming it took precedence.

Also fixed along the way:

  - `gravity_bias` and `magnetic_bias` were documented as config-path-inert and
    silently dropped; they are read now. Added the four `*_bias_init_std` /
    `*_bias_process_noise_std` keys the CLI already had, which matter most for
    the magnetic channel -- a recording made inside a vehicle carries thousands
    of nT of the vehicle's own field, and that state is what absorbs it.

  - The `config` wizard offers the geophysical section after the filter has
    been chosen, so `eskf` followed by `yes` wrote a file the binary refuses.
    It reconciles now, which matters because `Eskf` is `FilterType`'s default.

  - Validation moved ahead of the run. A missing map or an ESKF now fails on
    the configuration rather than after loading maps, and the ESKF message says
    that omitting `filter` lands there.

  - `generate_plot` reached the non-geophysical config path only, so every
    `conf/*.toml` asked for a plot and no geophysical run produced one.

The six `conf/{ukf,ekf}_{grav,mag,both}.toml` were retired-but-not-deleted and
carried `interval_s = 1.0`, `sigma_pos_m = 15.0`, `sigma_vel_mps = 5.0` and
`r_scale = 15.0` -- a different GNSS profile from the degraded run `geoperf-all`
scores them against, so any "improvement" it reported would have been the
difference between two degradations. Rewritten to match, with the health limits
the RBPF files already had. The justfile's ukf-geo/ekf-geo recipes are
`--config` calls now, so the two cannot drift again.

Tests:
  - `example_configs` covers `conf/` as well as `examples/configs/`, which is
    what would have caught those six. Its declared-variant heuristic now strips
    comments first: the truth recipes say `kind = "none"` and explain in prose
    that their limits match the degraded run, which read as a declared fault.
  - Three unit tests in `sim`: the two paths resolve to identical settings, a
    geophysical config with no map is refused, and one omitting `filter` is
    refused for the ESKF.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01RwCvG9Hh2bmZbdd5JpPHVK
…edule

Answering "should we bump the fix interval, or the noise?" -- and fixing two
defects that made the question unanswerable as posed.

## The fix interval and the error model were the same knob

`rho_pos` and `rho_vel` are applied once per emitted fix with no reference to
elapsed time, so the error's correlation time is `-interval_s / ln(rho)`: a
property of the *scheduler*. At `rho_pos = 0.99`, a 5 s interval is a 498 s
correlation time and a 30 s interval is 2985 s. Sweeping the fix rate was
therefore also sweeping the error timescale, and no result could separate them.

Added optional `tau_pos_s` / `tau_vel_s`. When set, the coefficient becomes
`exp(-dt / tau)` for the actual interval between fixes and `sigma_pos_m` is
reinterpreted as the steady-state standard deviation in metres rather than the
per-step innovation -- the quantity worth specifying, and the one that stays
fixed. Verified on real data: two runs at 5 s and 30 s now differ in fix rate
alone.

Strictly additive. Omitted, the per-fix form applies exactly as before, so every
existing config and every recorded result still means what it meant.
`perf_baseline` does not move.

## The fault advanced on the wrong clock

`apply_fault` runs once per *emitted fix*, but `build_event_stream` handed it
the *record* spacing -- 1 s on a 1 Hz log. Under `FixedInterval { interval_s:
5.0 }` a `SlowBias` therefore integrated one second of drift per five seconds of
flight and spoofed at a fifth of its configured rate. `FaultState` now tracks
when it last ran, so the interval is the scheduler's. Computed at the call site
rather than inside `apply_fault`, so a `Combo`'s members all see the same
interval instead of the first one consuming it. No baseline uses `SlowBias`, so
nothing recorded moves.

## What a jamming scenario should be

The dominant, repeatedly measured effect of jamming is loss of fix, not graceful
degradation. At Jammertest the signal was in most runs strong enough to cause
complete GNSS signal loss, and a phone ten metres from a jammer lost lock
entirely. A receiver inside the jammed area does not report a noisier position;
it reports nothing. The existing `degraded` profile models the *fringe*.

So the answer is: yes to availability, and it is the bigger lever. New
`conf/*_denied.toml` -- 30 s of fixes in every 150, fault `none`, so the only
variable is availability. Sweep `off_s` over 60/120/300/600 to trace an aid's
contribution against outage length. The duty-cycle scheduler already existed and
was unused in the entire experiment matrix.

Secondarily yes to noise, anchored to measurement. New `conf/*_jammed.toml`
takes 35 m of steady-state wander -- about 14x this dataset's 2.58 m median
advertised accuracy -- from the published smartphone figures (3-5 m good
multipath, >10 m harsh, semi-urban CEP95 10-12 m) scaled for the satellite-count
and GDOP loss jamming causes. It uses the time constants above, so its fix
interval can be swept.

Deliberately NOT applied to the existing `conf/*_degraded.toml`. That 21 m
profile is the baseline every result so far was measured against, and moving it
would silently invalidate those comparisons. `geoperf-all` scores geo runs
against it. Switch to `jammed` deliberately, not by having the old one change
underfoot.

`book/src/gnss/fault-simulation.md` was a one-line stub; it now carries the
three-tier rationale, the correlation-time trap, the `r_scale`-squares-into-R
warning, and thirteen sources.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01RwCvG9Hh2bmZbdd5JpPHVK
`test_state_transition_jacobian_multiple_states` failed CI on this branch at a
max error of 5.0245e-4 against its 5e-4 bound -- on a commit that touches
nothing it covers. It is not this branch's failure: the test is untouched here
and is identical on main.

It is flaky by construction. `rand::rng()` is entropy-seeded, so every run drew
fresh states and a failure named coordinates nobody could reproduce. Measured
at 1 run in 400.

Two things were wrong, and both are fixed:

  - **Unseeded.** `StdRng::seed_from_u64` now, which is also what the
    repository's own rule asks for: tests are reproducible with a seeded RNG.
    A failure now means the Jacobian changed, not that the draw landed in the
    tail. Determinism also makes the sample size free, so this covers 50 states
    rather than 10 -- coverage no longer varies from run to run.

  - **Bounded inside its own sampling noise.** Over 2000 sampled states the
    median error is 2.4e-4, p99 is 4.8e-4 and p99.9 is 4.9e-4; over 4000 the
    largest seen was 5.05e-4. A 5e-4 bound therefore sat exactly on the
    shoulder of the distribution -- it described where the tail happened to
    fall, not the method's accuracy, and left no headroom for the libm
    differences between the three CI platforms. Raised to 1e-3: twice the
    largest error measured, and still far tighter than any real defect, since
    an analytic Jacobian that disagrees with the numerical one does so at O(1)
    or O(dt), not by a factor of two in the fourth decimal.

Verified: 20 consecutive runs pass where the previous version was 1-in-400.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01RwCvG9Hh2bmZbdd5JpPHVK

Copy link
Copy Markdown
Owner Author

"Workspace (all features)" failed on e4aea0f — linearize::tests::test_state_transition_jacobian_multiple_states, at a max error of 5.0245e-4 against its 5e-4 bound.

That failure is not this branch's, and I've fixed the test rather than re-run it.

Not this branch's: git diff $(git merge-base HEAD origin/main) HEAD -- core/src/linearize.rs is empty, and the test is byte-identical on main. e4aea0f changes earth::gravity_anomaly (used only by strapdown-geonav) and the geonav fixtures; it touches neither state_transition_jacobian nor numerical_state_jacobian.

Flaky by construction, and measurably so. The test calls rand::rng(), which is entropy-seeded, so every run drew fresh states and a failure named coordinates nobody could reproduce. I measured it at 1 run in 400.

Two things were wrong, and I fixed both in 2506a3d rather than spend the re-run:

  • Unseeded. Now StdRng::seed_from_u64, which is also what CLAUDE.md asks for ("Deterministic tests verify reproducibility with seeded RNG"). A failure now means the Jacobian changed, not that the draw landed in the tail. Determinism makes the sample size free, so it covers 50 states instead of 10.

  • Bounded inside its own sampling noise. Over 2000 sampled states the median error is 2.4e-4, p99 is 4.8e-4, p99.9 is 4.9e-4; over 4000 the largest seen was 5.05e-4. The 5e-4 bound therefore sat exactly on the shoulder of the distribution — it described where the tail happened to fall rather than the method's accuracy, with no headroom for libm differences across the three CI platforms. Raised to 1e-3: twice the largest error measured, still far tighter than any real defect, since an analytic Jacobian that disagrees with the numerical one does so at O(1) or O(dt), not by a factor of two in the fourth decimal.

Verified: 20 consecutive runs pass where the previous version was 1-in-400. All six gates clean locally (cargo fmt-check, cargo lint, cargo lint-min, cargo test --workspace --all-features, cargo test-min, and the Python job's ruff/pytest).

Worth noting this flake has been latent on main and would have hit any PR eventually.


Generated by Claude Code

jbrodovsky and others added 18 commits September 23, 2026 03:15
Every `strapdown-sim` invocation was already `--config` after the geophysical
config path landed, but the recipes downstream of the simulation were not
updated to match, and `pipeline` had never worked.

  - **`pipeline` ran nothing.** Its steps were recipe *body* lines, which `just`
    executes as shell commands -- so it tried to run `build`, `preprocess` and
    the rest as programs and died on the first with "command not found". They
    are dependencies now, listed after the colon. A recipe's body runs *after*
    its dependencies, so the `rm -rf` cleanup could not stay in the body either;
    it moved to its own `clean` recipe, which is the first dependency.

  - **`postprocess` did not score the new tiers.** Six lines added, so `denied`
    and `jammed` get the same treatment as `truth` and `degraded`.

  - **`geoperf-denied` added.** Deliberately separate from `geoperf-all` rather
    than folded into it: the two answer different questions. `degraded` still
    delivers a fix every 5 s, so an aid there competes with GNSS and mostly
    changes how the filter weights a noisy measurement. `denied` withholds GNSS
    for 120 s at a time, so during an outage the aid is the only correction --
    the regime it exists for, and where its contribution is separable. The
    recipe's comment records that the six geo configs still carry the
    `degraded` GNSS profile, so the comparison is not apples-to-apples until
    they are switched over.

  - **`pipeline` now includes `geo-stats`**, between preprocessing and the
    simulations, which is where it belongs: it reads what preprocessing writes
    and produces the noise figures the configs should be using.

Also fixed the discovery surface. `just --list` shows the comment line
immediately above a recipe, so the multi-paragraph rationale blocks were being
listed as sentence fragments -- `denied # contribution grows with outage
length`, `pipeline # their own clean recipe rather than staying here`. Each of
those now ends with a one-line summary, and `ukf-geo`/`ekf-geo` have a
description at all.

Verified with `just --list` and `just --dry-run pipeline`: the chain resolves,
all 21 conf files are reachable from a recipe, and every config a recipe names
exists.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01RwCvG9Hh2bmZbdd5JpPHVK
`preprocess` wrote to `data/input_10hz`. Nothing downstream reads that: all 21
conf/*.toml carry `input = "data/input"`, `geo-stats` takes `-i data/input`,
and `postprocess` and the `geoperf-*` recipes take `-r data/input`. So
`just pipeline` preprocessed into one directory and simulated from whatever
stale data happened to be in the other -- and, since `pipeline` began with
`rm -rf data/input`, from an empty one on a clean checkout.

Keeping the 10 Hz rate and moving the output rather than the other way round:
the rate is one flag, the path is 21 files plus four recipes.

`preprocess-1hz` restores the 1 Hz variant that was commented out, since that
is the rate every result before this branch used and the two want to stay
comparable. `clean` still removes `data/input_10hz` -- nothing writes there
now, but a checkout that ran the old recipe still has it, and a stale directory
full of trajectories is the kind of thing that gets simulated by accident.

Flagged rather than changed, in the recipe comment: `-b 10`. `--buffer` is a
*fraction*, not a percentage -- `inflate_bounds` computes
`x_min - x_range * buffer` and defaults to 0.1 for a 10% margin -- so `-b 10`
pads the map bounding box by ten times the track's own extent on each side, a
box roughly 21x wider and 21x taller than the track. At the default buffer the
relief grid for the longest recording here is already 195 MB. It looks like
`-f 10` copied one flag across, but it is a research parameter, so it is left
as set with the cost written down next to it.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01RwCvG9Hh2bmZbdd5JpPHVK
`bc4b02b` added a second `[dependency-groups]` table to
analysis/pyproject.toml. TOML forbids duplicate keys, so `uv sync --frozen`
refused the file outright and the Python CI job died before it ran anything:

    error: Failed to parse: `analysis/pyproject.toml`
      cause: TOML parse error at line 40, column 2
             [dependency-groups]
             duplicate key

Kept the table that carries `ruff`, since the lint gate needs it, and dropped
the one that did not.

Its `[tool.pytest.ini_options]` went with it. The root pyproject.toml owns
pytest configuration and is what `uv run pytest` reads from the workspace root,
which is how CI invokes it; a second copy in the member only applies when
pytest runs from inside analysis/, where it would silently lose the root's
`filterwarnings` -- two configs that drift rather than one that works.

Also ran `ruff format`, which the new files needed.

Verified: `uv sync --frozen`, `uv run ruff check`, `uv run ruff format --check`
and `uv run pytest -q` all clean -- 15 tests, including the four new
compare-filters ones.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01RwCvG9Hh2bmZbdd5JpPHVK
Ran it. Three things stopped it, two of them silent.

## `postprocess` produced no plots and exited 0

`read_csv(..., parse_dates=True, index_col=0)` does not guarantee a datetime
index. When pandas cannot infer a format it leaves the index as **strings**,
with no error. Every timestamp this package reads looks like
`2025-03-01 12:00:00+00:00`, which it declines to infer, so the index stayed
textual and the first arithmetic on it raised:

    unsupported operand type(s) for -: 'str' and 'str'

`performance_analysis` caught that in a broad `except`, printed "possible
dimension mismatch or missing data", and carried on. So `just postprocess`
reported success while writing **zero plots** -- for every scenario, every
filter, every trajectory.

Added `read_timeseries`, which names the format instead of guessing and returns
a frame whose index is checked. Six call sites across `performance_analysis`,
`geophysical_performance_analysis` and `filter_comparison_analysis` use it.
`preprocess.py` was never affected: it already converts explicitly.

The same defect was in `geostats.analyse_trajectory`, which my own fixture
missed because it wrote timestamps in a format that happens to round-trip. It
parses explicitly now and raises if the result is not tz-aware, rather than
failing a hundred lines later.

Effect: postprocess goes from 0 plots to 99.

## `pipeline` could never produce the maps the geophysical runs need

`preprocess` ran without `--getmaps`, so it called `inherit_parent_maps`, which
copies `data/input/<source>_{gravity,magnetic}.nc` onto each split segment. But
`clean` deletes those first, so there was nothing to inherit: `data/input`
ended up with trajectories and no maps at all, and every geophysical run died
on "Gravity map file not found" three steps downstream of the cause.

`--getmaps` is passed now, and fails loudly at the point of failure.

## Verified

Ran the whole chain from an empty tree -- clean, build, preprocess, geo-stats,
truth, degraded, denied, jammed, ukf-geo, ekf-geo, rbpf-sim, postprocess,
geoperf-all -- against synthetic Sensor Logger recordings. All fifteen steps
complete, producing the full 3x7 matrix: 63 navigation solutions across
{ukf, ekf, rbpf} x {truth, degraded, denied, jammed, grav, mag, both}, 99
performance plots, 72 geoperformance artifacts and the geostats figure.

One step cannot run in a sandbox: `--getmaps` needs the GMT C library and
network access to the GMT data server. Locally generated grids stood in for it,
at the real spacings (1 arc-minute gravity, 3 arc-minute magnetic) so
everything downstream saw the geometry it will see in a real run -- `geo-stats`
correctly reported the magnetic grid as 3.00', which is the declared-versus-
actual mismatch it exists to catch.

Also ignoring `gmt.conf`: GMT drops one into whatever directory it runs in as
soon as anything calls `gmtset`, which pygmt does on some paths, and it records
machine-local settings.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01RwCvG9Hh2bmZbdd5JpPHVK
`geoperf-denied` landed earlier on this branch scoring the existing geo runs
against the `denied` baseline -- but those runs carry the *degraded* GNSS
profile (fixed 5 s interval, AR(1) error), while `denied` is a duty cycle with
no fault. So it compared two different GNSS profiles and attributed the
difference to the geophysical aid, which is the same defect this branch already
had to fix once for the degraded baseline.

Added `conf/{ukf,ekf,rbpf}_denied_{grav,mag,both}.toml`: the same aiding as
their `<filter>_<geo>.toml` counterparts, carrying the GNSS and health blocks
of `<filter>_denied.toml`. `geoperf-denied` now reads those, so the two runs it
compares differ in nothing but whether the geophysical measurement is present.

This is the comparison worth making. `degraded` still delivers a fix every 5 s,
so an aid there competes with GNSS and mostly changes how the filter weights a
noisy measurement. `denied` withholds GNSS for 120 s at a time, so during an
outage the aid is the only correction there is.

## The duplication is now enforced, not just written correctly once

Nine more files takes `conf/` from 21 to 30, and the number duplicating a GNSS
block from 12 to 24. Drift between exactly those duplicates is what went wrong
before: six geo configs sat in the tree at `sigma_pos_m = 15.0` against a
baseline at `3.0`, each scored against a profile it did not match, with nothing
to say so.

So `core/tests/example_configs.rs` gains a test asserting that every geo
recipe's `[gnss_degradation]` and `[health_limits]` are identical to those of
the baseline named in its filename -- `<filter>_<geo>.toml` against
`<filter>_degraded.toml`, `<filter>_denied_<geo>.toml` against
`<filter>_denied.toml`. The pairing comes from the filename, so a geo recipe
added later is enrolled automatically, and the count is asserted so one that is
not gets noticed.

Verified in both directions, the way the gravity unit fix was: re-injecting the
historical drift (`sigma_pos_m` 3.0 -> 15.0 in `ukf_both.toml`) fails the test
and names the differing field.

Considered and rejected: an `extends`/`include` key on `SimulationConfig` to
remove the duplication at source. Better long-term, but it is a new config
format feature with its own precedence rules, and this test removes the
urgency.

## Justfile

`denied-geo` runs the nine; `geoperf-denied` scores them; `postprocess` gains
their nine output directories; `pipeline` runs both new steps. All 30 configs
are reachable from a recipe and every config a recipe names exists.

## Also

`-b 10` -> `-b 0.1` on `preprocess`. `--buffer` is a fraction, not a
percentage, so `-b 10` padded each map's bounding box by ten times the track's
extent per side -- a box about 21x wider and taller. Harmless while `--getmaps`
was absent; this branch added it, and at a 10% margin the relief grid for the
longest recording is already 195 MB.

Verified end to end against synthetic recordings: all nine denial-geo configs
run to completion and `geoperf-denied` produces 54 artifacts. All gates clean.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01RwCvG9Hh2bmZbdd5JpPHVK
Three of the nine denial-geo configs failed on every trajectory with

    longitude -75.699 is outside the map bounds [-76.099, -75.699]

The filter had drifted past the edge of the map during a 120 s outage. The
immediate cause was a test fixture's narrow pad, but it pointed at a property
of `inflate_bounds` that the denial tier is the first scenario to reach.

## The value was the smaller of two problems

    x_range = x_max - x_min
    return (x_min - x_range * buffer, x_max + x_range * buffer, ...)

1. **The thing being guarded against is an absolute distance.** A map has to
   extend past the track by however far the filter can wander off it, and that
   does not scale with how far the vehicle drove. At a 10% buffer a 2 km track
   gets 200 m of margin and a 50 km track gets 5 km, for the same outage.

2. **Each axis is scaled by its own range**, so a track that is straight in one
   axis gets almost no margin in the other. A due-north drive has a longitude
   range near zero, so its longitude pad is near zero, and any eastward
   excursion leaves the map. No value of `--buffer` fixes that: zero times
   anything is zero.

Either way it is silent at the preprocessing end. The map is written
successfully and the run dies later, per trajectory, inside a simulation.

## `--margin-km`, defaulting to 5 km

`pad_bounds` takes the larger of the fractional and absolute margins, so long
tracks keep the behaviour they had and short or straight ones get a floor.
Converted at the box's mean latitude, since a degree of longitude shortens
towards the poles, with the cosine clamped so it does not diverge at one.
`--margin-km 0` is exactly the old behaviour.

The 5 km default is measured, not guessed. Across the fixture's runs the worst
excursion of the filter estimate beyond the recorded track's bounding box is:

    truth       0.00 km
    degraded    0.00 km
    denied      2.27 km

Denial is the only tier that leaves the track at all, and 5 km covers its worst
case with better than 2x headroom. On a 17 km track that is about a 30% pad --
cheaper than raising `--buffer`, and unlike it, correct for a short or straight
track too.

This also explains `-b 10`, which this branch changed to `-b 0.1` a few commits
ago: a 21x box is an effective workaround for a margin that does not scale the
right way. It cost gigabytes per trajectory once `--getmaps` went live.

## Also

`StrapdownError::OutOfMapBounds` now names the remedy. A single skipped update
is routine -- an estimate near a tile edge, or a particle in the tail -- but
every update on a trajectory failing this way means the map does not cover
where the filter went, and the message now says to re-run with a larger
`--margin-km` rather than leaving that to be worked out.

Ten tests in `analysis/tests/test_map_bounds.py`, covering the two degenerate
cases the fractional form cannot express (due-north and due-east tracks), the
short-track floor, that a long track keeps its larger fractional margin, that
`--margin-km 0` is byte-identical to the old behaviour, that the margin is the
same *distance* at 0, 40, 70 and 85 degrees latitude, and that the conversion
stays finite at the pole.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01RwCvG9Hh2bmZbdd5JpPHVK
`analyze geostats` measured the per-field bias, measurement noise and bias
prior against the maps, wrote them to `geo_stats.toml`, and stopped there.
Merging eighteen files by hand is exactly where a partial adoption comes
from, and the 100 mGal / 150 nT the configs ship with were never measured
against these maps at all: a filter told a noise it does not have produces a
covariance that stops describing its error.

`--apply-to conf` (`just geo-adopt`) writes them in. Line by line rather than
through a TOML round-trip, which would strip every comment in these files --
the rationale in `conf/*.toml` is most of their value. Only keys already
present are rewritten, so a `*_grav.toml` stays gravity-only rather than
silently becoming a dual-aid run. The one insertion is `*_bias_init_std`,
which no config carries yet: without it the map-bias state inherits
`*_noise_std` as its prior, which for the magnetic channel is far too tight,
since a recording made inside a vehicle carries thousands of nT of the
vehicle's own field.

`geo_frequency_s` is held back behind `--apply-interval`. The noise figures
are direct measurements of a residual; the interval follows from a
de-correlation argument about the source grids, and moving it from 1 s to
several hundred changes what the experiment asks of the aid rather than how
it is tuned. That one is a decision.

`every_geophysical_config_describes_the_same_sensor` in
`core/tests/example_configs.rs` closes the loop: all eighteen recipes
describe the same instrument, so any key they share must agree. Verified in
both directions -- applying to all eighteen passes, reverting one file's
`gravity_noise_std` fails. Otherwise a half-adopted `conf/` still parses,
still runs, and produces a filter comparison whose difference came from two
different R.

Also fixes the `just --list` summaries for `clean` and `geo-stats`: `just`
shows the last comment line, so the one-liner has to sit directly above the
recipe.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01RwCvG9Hh2bmZbdd5JpPHVK
`e9d673d` reformatted the file at a wider column than `[tool.ruff]` in the
root `pyproject.toml` declares, so `ruff format --check` failed the
`analysis (lint + tests)` job. `line-length = 100` is the setting CI runs
with; an editor's own default is not it.

Formatting only -- verified by comparing the parsed AST before and after,
which is identical. The ISO8601 date-parsing fix in that commit is
untouched.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01RwCvG9Hh2bmZbdd5JpPHVK
827db06 re-blessed core/tests/perf_baseline.json but left
book/src/development/baseline-tables.md, which is generated from it, at
b70cd55. `navigation_accuracy_matches_the_recorded_baseline` requires the
two to agree, so it failed on all four Rust test jobs of #417 with "BOOK
... no longer matches the baseline it is generated from" -- no metric
moved. The tables here are exactly what the test generates from the
committed JSON; the JSON itself is unchanged.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
c3e3553 left one call at 115 columns, so `ruff format --check` failed the
analysis job on #417 before its tests ran. Formatting only; `ruff check`,
`ruff format --check` and `pytest` (77 passed) are clean.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
@jbrodovsky
jbrodovsky marked this pull request as ready for review October 1, 2026 23:57
Copilot AI balanced review requested due to automatic review settings October 1, 2026 23:57
@jbrodovsky
jbrodovsky merged commit 839e749 into main Oct 1, 2026
8 checks passed
@jbrodovsky
jbrodovsky deleted the geo-bias-fixes branch October 1, 2026 23:57

Copilot AI left a comment

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Copilot review overview

🟡 Changes recommended

The real-arm configs target synthetic directories, and every real RBPF config contains keys that the new deserializer explicitly rejects.

Review effort: Balanced
Findings: 21 High severity · 4 Medium severity · 2 Low severity

Open (27)

And 7 more that still need to be addressed.

What changed in this PR

This PR expands geophysical-aiding experiments with corrected units, realistic GNSS faults, reproducible Python analysis tooling, and revised RBPF/configuration behavior.

Changes:

  • Adds the uv-based analysis workspace, Python CI, plotting/statistics tests, and monorepo documentation.
  • Revises geophysical, GNSS-degradation, and RBPF configurations and regression tests.
  • Updates navigation internals and removes obsolete queue documentation.
File Description
README.md Documents monorepo setup.
pyproject.toml Defines uv, Ruff, and pytest configuration.
.github/​workflows/​python.yml Adds Python CI.
.gitignore Adds Python/GMT exclusions.
AGENTS.md Documents Python workflow.
CLAUDE.md Updates architecture and analysis guidance.
analysis/​pyproject.toml Defines the analysis package.
analysis/​README.md Adds package README.
analysis/​src/​analysis/​py.typed Marks package as typed.
analysis/​tests/​conftest.py Configures test imports.
analysis/​tests/​test_map_bounds.py Tests absolute map margins.
analysis/​tests/​test_performance_plots.py Tests sparse-reference plots.
analysis/​tests/​test_summary_rows.py Tests summary aggregation.
book/​src/​development/​performance.md Updates RBPF consistency status.
book/​src/​user-guide/​overview.md Corrects RBPF architecture documentation.
core/​src/​error.rs Adds stream-gap diagnostics.
core/​src/​kalman.rs Shares IMU-bias coupling logic.
core/​src/​lib.rs Exposes variance helper and updates tests.
core/​tests/​config_serde_defaults.rs Tests defaults and retired keys.
core/​tests/​filter_comparison.rs Handles RBPF’s zero bias rows.
core/​tests/​integration_tests.rs Updates RBPF tuning and result layout.
core/​tests/​perf_baseline.rs Updates RBPF baseline setup.
core/​tests/​rbpf_depletion.rs Revises collapse/roughening regression tests.
conf/​ukf_truth.toml Defines synthetic UKF truth run.
conf/​ukf_degraded.toml Retunes UKF degraded GNSS.
conf/​ukf_grav.toml Configures synthetic gravity aiding.
conf/​ukf_mag.toml Configures synthetic magnetic aiding.
conf/​ukf_both.toml Configures combined synthetic aiding.
conf/​ekf_truth.toml Defines synthetic EKF truth run.
conf/​ekf_degraded.toml Retunes EKF degraded GNSS.
conf/​ekf_grav.toml Configures synthetic gravity aiding.
conf/​ekf_mag.toml Configures synthetic magnetic aiding.
conf/​ekf_both.toml Configures combined synthetic aiding.
conf/​rbpf_truth.toml Updates RBPF truth configuration.
conf/​rbpf_degraded.toml Updates RBPF degraded configuration.
conf/​real/​ukf_truth.toml Adds real-data UKF truth recipe.
conf/​real/​ukf_degraded.toml Adds real-data UKF degraded recipe.
conf/​real/​ukf_grav.toml Adds real-data UKF gravity recipe.
conf/​real/​ukf_mag.toml Adds real-data UKF magnetic recipe.
conf/​real/​ukf_both.toml Adds combined real-data UKF recipe.
conf/​real/​ekf_truth.toml Adds real-data EKF truth recipe.
conf/​real/​ekf_degraded.toml Adds real-data EKF degraded recipe.
conf/​real/​ekf_grav.toml Adds real-data EKF gravity recipe.
conf/​real/​ekf_mag.toml Adds real-data EKF magnetic recipe.
conf/​real/​ekf_both.toml Adds combined real-data EKF recipe.
conf/​real/​rbpf_truth.toml Adds real-data RBPF truth recipe.
conf/​real/​rbpf_degraded.toml Adds real-data RBPF degraded recipe.
conf/​real/​rbpf_grav.toml Adds real-data RBPF gravity recipe.
conf/​real/​rbpf_mag.toml Adds real-data RBPF magnetic recipe.
conf/​real/​rbpf_both.toml Adds combined real-data RBPF recipe.
docs/​GEOPHYSICAL_CONFIG.md Removes obsolete configuration guide.
docs/​queue/​00-test-speed.md Removes completed queue record.
docs/​queue/​01-eskf-fix.md Removes completed queue record.
docs/​queue/​02-filter-api.md Removes completed queue record.
docs/​queue/​03-ned-default.md Removes completed queue record.
docs/​queue/​04-eskf-primary.md Removes completed queue record.
docs/​queue/​06-aiding.md Removes completed queue record.
docs/​queue/​07-engine.md Removes completed queue record.
docs/​queue/​08-validation.md Removes completed queue record.
docs/​queue/​09-release.md Removes completed queue record.
docs/​queue/​p-alignment.md Removes queue record.
docs/​queue/​p-calibration.md Removes queue record.
docs/​queue/​p-imu-quality-cov.md Removes queue record.
docs/​queue/​p-lint-config.md Removes queue record.

💡 Add a code-review agent skill or configure MCP servers for context-aware, tailored reviews. Learn more in the docs.

Comment on lines +663 to +664
# Align datasets by index
if not (len(nav) == len(geo)):
Comment thread conf/real/ekf_both.toml
Comment on lines +7 to +8
input = "data/input"
output = "data/output/ekf/both"
Comment on lines +1 to +2
input = "data/input"
output = "data/output/ekf/degraded"
Comment thread conf/real/ekf_grav.toml
Comment on lines +7 to +8
input = "data/input"
output = "data/output/ekf/grav"
Comment thread conf/real/ekf_mag.toml
Comment on lines +7 to +8
input = "data/input"
output = "data/output/ekf/mag"
Comment thread conf/rbpf_degraded.toml
Comment on lines +107 to +113
rho_pos = 0.99 # ignored while tau_pos_s is set; kept for a run without it
sigma_pos_m = 35.0 # steady-state wander, metres
tau_pos_s = 500.0
rho_vel = 0.95 # likewise
sigma_vel_mps = 1.5 # steady-state wander, m/s
tau_vel_s = 100.0
r_scale = 5.0 # advertised sigmas x5, so R x25
Comment thread conf/real/rbpf_mag.toml

[geophysical]
# Magnetic anomaly measurements
magnetic_resolution = "one_minute"
Comment thread conf/ukf_degraded.toml
Comment on lines +71 to +77
rho_pos = 0.99 # ignored while tau_pos_s is set; kept for a run without it
sigma_pos_m = 35.0 # steady-state wander, metres
tau_pos_s = 500.0
rho_vel = 0.95 # likewise
sigma_vel_mps = 1.5 # steady-state wander, m/s
tau_vel_s = 100.0
r_scale = 5.0 # advertised sigmas x5, so R x25
Comment thread CLAUDE.md
Comment on lines +79 to +85
conf` (`just geo-adopt`) writes the measured bias, noise and bias prior into all 18
geophysical configs, line by line so the comments survive, rewriting only keys already
present so a `*_grav.toml` stays gravity-only. `geo_frequency_s` is held back behind
`--apply-interval`: the noise figures are measurements, but moving the interval from 1 s to
one measurement per de-correlation length changes what the experiment asks of the aid.
`core/tests/example_configs.rs` asserts all 18 carry the same values, so a partial adoption
fails the build rather than producing a comparison across two different R
Comment thread README.md
Comment on lines +47 to +50
`just setup` runs both. Nothing beyond Rust and uv is needed for the Rust crates; the
`analyze` CLI's map-drawing subcommands additionally want the GMT C library installed, though
every other subcommand -- preprocessing and measurement characterisation included -- runs
without it.
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.

3 participants