spelling, linting, and general cleanup

jbrodovsky · jbrodovsky · commit 04136fdc2e7b · 2025-09-10T11:06:17.000-04:00
diff --git a/core/src/messages.rs b/core/src/messages.rs
@@ -27,7 +27,7 @@ use crate::sim::TestDataRecord;
 ///
 /// ## Usage
 /// - `PassThrough` → GNSS data is delivered at its native logging rate.
-/// - `FixedInterval` → Downsample the GNSS stream to a constant interval,
+/// - `FixedInterval` → Down-sample the GNSS stream to a constant interval,
 ///   simulating jamming that allows only low-rate fixes.
 /// - `DutyCycle` → Alternate between ON and OFF windows of fixed length,
 ///   simulating periodic outages.
@@ -49,13 +49,14 @@ use crate::sim::TestDataRecord;
 /// // Alternate 5 s ON, 15 s OFF, starting in ON state at t=0
 /// let sched = GnssScheduler::DutyCycle { on_s: 5.0, off_s: 15.0, start_phase_s: 0.0 };
 /// ```
-#[derive(Clone, Debug, Serialize, Deserialize)]
+#[derive(Clone, Debug, Default, Serialize, Deserialize)]
 #[serde(tag = "kind", rename_all = "snake_case")]
 pub enum GnssScheduler {
     /// Pass every GNSS fix through to the filter with no rate reduction.
     ///
     /// Useful as a baseline when you want to test only fault injection without
     /// simulating outages or reduced update rates.
+    #[default]
     PassThrough,
     /// Emit GNSS measurements at a fixed interval, discarding those in between.
     ///
@@ -160,7 +161,7 @@ mod serialization_tests {
 ///
 /// - `None`: deliver the fix unchanged.
 /// - `Degraded`: add AR(1)-correlated noise to position and velocity, and
-///   inflate the advertised covariance. Simulates low-SNR or multipath conditions.
+///   inflate the advertised covariance. Simulates low-SNR or multi-path conditions.
 /// - `SlowBias`: apply a slowly drifting offset in N/E position and velocity.
 ///   Simulates soft spoofing where the trajectory is nudged gradually away
 ///   from truth.
@@ -216,7 +217,7 @@ pub enum GnssFaultModel {
     None,
 
     /// (2) Degraded accuracy: AR(1)-correlated noise on position and velocity,
-    /// plus inflated advertised covariance. Models low-SNR or multipath cases.
+    /// plus inflated advertised covariance. Models low-SNR or multi-path cases.
     Degraded {
         /// AR(1) correlation coefficient for position error (close to 1.0).
         rho_pos: f64,
@@ -840,7 +841,20 @@ fn apply_fault(
                 vel_std_mps,
             );
             for m in models {
-                // out = apply_fault(m, st, t, dt, out.0, out.1, out.2, out.3, out.4, out.5, out.6);
+                out = apply_fault(
+                    m,
+                    st,
+                    t,
+                    dt,
+                    out.0,
+                    out.1,
+                    out.2,
+                    out.3,
+                    out.4,
+                    out.5,
+                    vert_std_m,
+                    out.6,
+                );
             }
             out
         }
@@ -872,7 +886,7 @@ fn apply_fault(
 ///
 /// # Returns
 /// A `EventStream` containing an interleaved sequence of IMU and (optionally
-/// downsampled/corrupted) GNSS events, ordered by `elapsed_s`.
+/// down-sampled/corrupted) GNSS events, ordered by `elapsed_s`.
 ///
 /// # Scheduling semantics
 /// - [`GnssScheduler::PassThrough`]: emit a GNSS event at every record step.
@@ -933,15 +947,15 @@ pub fn build_event_stream(records: &[TestDataRecord], cfg: &GnssDegradationConfi
     let mut next_emit_time = match cfg.scheduler {
         GnssScheduler::PassThrough => 0.0,
         GnssScheduler::FixedInterval {
-            interval_s,
             phase_s,
+            ..
         } => phase_s,
         GnssScheduler::DutyCycle { start_phase_s, .. } => start_phase_s,
     };
     let mut duty_on = true;
 
     for w in records_with_elapsed.windows(2) {
-        let (t0, r0) = (&w[0].0, &w[0].1);
+        let (t0, _) = (&w[0].0, &w[0].1);
         let (t1, r1) = (&w[1].0, &w[1].1);
         let dt = t1 - t0;
 
diff --git a/core/src/sim.rs b/core/src/sim.rs
@@ -19,18 +19,13 @@ use std::io::{self};
 use std::path::Path;
 
 use anyhow::{Result, bail};
-use chrono::{DateTime, Datelike, Duration, Utc};
+use chrono::{DateTime, Duration, Utc};
 use nalgebra::{DMatrix, DVector, Vector3};
 use serde::{Deserialize, Serialize};
-use world_magnetic_model::GeomagneticField;
-use world_magnetic_model::time::{Date, Month};
-use world_magnetic_model::uom::si::angle::radian;
-use world_magnetic_model::uom::si::f32::{Angle, Length};
-use world_magnetic_model::uom::si::length::meter;
 
 use crate::earth::METERS_TO_DEGREES;
 use crate::filter::{
-    GPSPositionAndVelocityMeasurement, RelativeAltitudeMeasurement, StrapdownParams, UKF,
+    StrapdownParams, UKF,
 };
 use crate::messages::{Event, EventStream};
 use crate::{IMUData, StrapdownState, forward};
@@ -409,18 +404,18 @@ impl From<(&DateTime<Utc>, &DVector<f64>, &DMatrix<f64>)> for NavigationResult {
             "Covariance matrix must be 15x15"
         );
         let covariance = DVector::from_vec(covariance.diagonal().iter().map(|&x| x).collect());
-        let wmm_date: Date = Date::from_calendar_date(
-            timestamp.year(),
-            Month::try_from(timestamp.month() as u8).unwrap(),
-            timestamp.day() as u8,
-        )
-        .expect("Invalid date for world magnetic model");
-        let magnetic_field = GeomagneticField::new(
-            Length::new::<meter>(state[2] as f32),
-            Angle::new::<radian>(state[0] as f32),
-            Angle::new::<radian>(state[1] as f32),
-            wmm_date,
-        );
+        // let wmm_date: Date = Date::from_calendar_date(
+        //     timestamp.year(),
+        //     Month::try_from(timestamp.month() as u8).unwrap(),
+        //     timestamp.day() as u8,
+        // )
+        // .expect("Invalid date for world magnetic model");
+        // let magnetic_field = GeomagneticField::new(
+        //     Length::new::<meter>(state[2] as f32),
+        //     Angle::new::<radian>(state[0] as f32),
+        //     Angle::new::<radian>(state[1] as f32),
+        //     wmm_date,
+        // );
         NavigationResult {
             timestamp: *timestamp,
             latitude: state[0].to_degrees(),
@@ -517,41 +512,33 @@ impl From<(&DateTime<Utc>, &UKF)> for NavigationResult {
 /// # Arguments
 /// - `timestamp`: The timestamp of the navigation solution.
 /// - `state`: A reference to the StrapdownState instance containing the navigation state.
-/// - `imu_data`: An IMUData struct containing the IMU measurements.
-/// - `magnetic_vector`: Magnetic field strength measurement in micro teslas (body frame x, y, z).
-/// - `pressure`: Pressure in millibars.
+///
 /// # Returns
 /// A NavigationResult struct containing the navigation solution.
 impl
     From<(
         &DateTime<Utc>,
         &StrapdownState,
-        &IMUData,
-        &Vector3<f64>,
-        &f64,
     )> for NavigationResult
 {
     fn from(
-        (timestamp, state, imu_data, magnetic_vector, pressure): (
+        (timestamp, state): (
             &DateTime<Utc>,
-            &StrapdownState,
-            &IMUData,
-            &Vector3<f64>,
-            &f64,
+            &StrapdownState
         ),
     ) -> Self {
-        let wmm_date: Date = Date::from_calendar_date(
-            timestamp.year(),
-            Month::try_from(timestamp.month() as u8).unwrap(),
-            timestamp.day() as u8,
-        )
-        .expect("Invalid date for world magnetic model");
-        let magnetic_field = GeomagneticField::new(
-            Length::new::<meter>(state.altitude as f32),
-            Angle::new::<radian>(state.latitude as f32),
-            Angle::new::<radian>(state.longitude as f32),
-            wmm_date,
-        );
+        //let wmm_date: Date = Date::from_calendar_date(
+        //    timestamp.year(),
+        //    Month::try_from(timestamp.month() as u8).unwrap(),
+        //    timestamp.day() as u8,
+        //)
+        //.expect("Invalid date for world magnetic model");
+        //let magnetic_field = GeomagneticField::new(
+        //    Length::new::<meter>(state.altitude as f32),
+        //    Angle::new::<radian>(state.latitude as f32),
+        //    Angle::new::<radian>(state.longitude as f32),
+        //    wmm_date,
+        //);
         NavigationResult {
             timestamp: timestamp.clone(),
             latitude: state.latitude.to_degrees(),
diff --git a/geonav/src/lib.rs b/geonav/src/lib.rs
@@ -10,8 +10,6 @@ use std::path::PathBuf;
 
 use nalgebra;
 use nalgebra::{DMatrix, DVector, Vector3};
-use rand::Rng;
-use statrs::distribution::{Continuous, Normal};
 use strapdown::IMUData;
 use strapdown::earth::METERS_TO_DEGREES;
 use strapdown::filter::{
@@ -40,28 +38,28 @@ pub enum ReliefResolution {
     ThreeSeconds,
     OneSecond,
 }
-impl ReliefResolution {
-    /// Convert the resolution to a string. This can be used for calling the GMT library
-    fn as_str(&self) -> &'static str {
-        match self {
-            ReliefResolution::OneDegree => "01d",
-            ReliefResolution::ThirtyMinutes => "30m",
-            ReliefResolution::TwentyMinutes => "20m",
-            ReliefResolution::FifteenMinutes => "15m",
-            ReliefResolution::TenMinutes => "10m",
-            ReliefResolution::SixMinutes => "06m",
-            ReliefResolution::FiveMinutes => "05m",
-            ReliefResolution::FourMinutes => "04m",
-            ReliefResolution::ThreeMinutes => "03m",
-            ReliefResolution::TwoMinutes => "02m",
-            ReliefResolution::OneMinute => "01m",
-            ReliefResolution::ThirtySeconds => "30s",
-            ReliefResolution::FifteenSeconds => "15s",
-            ReliefResolution::ThreeSeconds => "03s",
-            ReliefResolution::OneSecond => "01s",
-        }
-    }
-}
+// impl ReliefResolution {
+//     /// Convert the resolution to a string. This can be used for calling the GMT library
+//     fn as_str(&self) -> &'static str {
+//         match self {
+//             ReliefResolution::OneDegree => "01d",
+//             ReliefResolution::ThirtyMinutes => "30m",
+//             ReliefResolution::TwentyMinutes => "20m",
+//             ReliefResolution::FifteenMinutes => "15m",
+//             ReliefResolution::TenMinutes => "10m",
+//             ReliefResolution::SixMinutes => "06m",
+//             ReliefResolution::FiveMinutes => "05m",
+//             ReliefResolution::FourMinutes => "04m",
+//             ReliefResolution::ThreeMinutes => "03m",
+//             ReliefResolution::TwoMinutes => "02m",
+//             ReliefResolution::OneMinute => "01m",
+//             ReliefResolution::ThirtySeconds => "30s",
+//             ReliefResolution::FifteenSeconds => "15s",
+//             ReliefResolution::ThreeSeconds => "03s",
+//             ReliefResolution::OneSecond => "01s",
+//         }
+//     }
+// }
 /// Resolution values for gravity maps
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub enum GravityResolution {
@@ -77,24 +75,24 @@ pub enum GravityResolution {
     TwoMinutes,
     OneMinute,
 }
-impl GravityResolution {
-    /// Convert the resolution to a string. This can be used for calling the GMT library
-    fn as_str(&self) -> &'static str {
-        match self {
-            GravityResolution::OneDegree => "01d",
-            GravityResolution::ThirtyMinutes => "30m",
-            GravityResolution::TwentyMinutes => "20m",
-            GravityResolution::FifteenMinutes => "15m",
-            GravityResolution::TenMinutes => "10m",
-            GravityResolution::SixMinutes => "06m",
-            GravityResolution::FiveMinutes => "05m",
-            GravityResolution::FourMinutes => "04m",
-            GravityResolution::ThreeMinutes => "03m",
-            GravityResolution::TwoMinutes => "02m",
-            GravityResolution::OneMinute => "01m",
-        }
-    }
-}
+// impl GravityResolution {
+//     /// Convert the resolution to a string. This can be used for calling the GMT library
+//     fn as_str(&self) -> &'static str {
+//         match self {
+//             GravityResolution::OneDegree => "01d",
+//             GravityResolution::ThirtyMinutes => "30m",
+//             GravityResolution::TwentyMinutes => "20m",
+//             GravityResolution::FifteenMinutes => "15m",
+//             GravityResolution::TenMinutes => "10m",
+//             GravityResolution::SixMinutes => "06m",
+//             GravityResolution::FiveMinutes => "05m",
+//             GravityResolution::FourMinutes => "04m",
+//             GravityResolution::ThreeMinutes => "03m",
+//             GravityResolution::TwoMinutes => "02m",
+//             GravityResolution::OneMinute => "01m",
+//         }
+//     }
+// }
 /// Resolution values for magnetic maps
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub enum MagneticResolution {
@@ -109,23 +107,23 @@ pub enum MagneticResolution {
     ThreeMinutes,
     TwoMinutes,
 }
-impl MagneticResolution {
-    /// Convert the resolution to a string. This can be used for calling the GMT library
-    fn as_str(&self) -> &'static str {
-        match self {
-            MagneticResolution::OneDegree => "01d",
-            MagneticResolution::ThirtyMinutes => "30m",
-            MagneticResolution::TwentyMinutes => "20m",
-            MagneticResolution::FifteenMinutes => "15m",
-            MagneticResolution::TenMinutes => "10m",
-            MagneticResolution::SixMinutes => "06m",
-            MagneticResolution::FiveMinutes => "05m",
-            MagneticResolution::FourMinutes => "04m",
-            MagneticResolution::ThreeMinutes => "03m",
-            MagneticResolution::TwoMinutes => "02m",
-        }
-    }
-}
+// impl MagneticResolution {
+//     /// Convert the resolution to a string. This can be used for calling the GMT library
+//     fn as_str(&self) -> &'static str {
+//         match self {
+//             MagneticResolution::OneDegree => "01d",
+//             MagneticResolution::ThirtyMinutes => "30m",
+//             MagneticResolution::TwentyMinutes => "20m",
+//             MagneticResolution::FifteenMinutes => "15m",
+//             MagneticResolution::TenMinutes => "10m",
+//             MagneticResolution::SixMinutes => "06m",
+//             MagneticResolution::FiveMinutes => "05m",
+//             MagneticResolution::FourMinutes => "04m",
+//             MagneticResolution::ThreeMinutes => "03m",
+//             MagneticResolution::TwoMinutes => "02m",
+//         }
+//     }
+// }
 /// Enum for the different types of maps. A GeoMap is defined by its measurement type and resolution.
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub enum GeophysicalMeasurementType {
@@ -369,7 +367,7 @@ impl GeoMap {
         let w22: f64 = ((lon - lon1) * (lat - lat1)) / ((lon2 - lon1) * (lat2 - lat1));
         Some(w11 * q11 + w12 * q12 + w21 * q21 + w22 * q22)
     }
-    // TODO: #95 Implement direct GMT interface using syscalls
+    // TODO: #95 Implement direct GMT interface using system shell calls
 }
 //================= Map Information ========================================================================
 
@@ -387,7 +385,7 @@ pub struct GeophysicalMeasurement<'a> {
 ///
 /// The geophysical feedback model is different from traditional measurement models in that it needs to relate
 /// a scalar (or vector) measurement to the position states. We can somewhat do this via a map, but the scalar
-/// values on the map are not neccessarily unique. This means that we cannot directly use the measurement to
+/// values on the map are not necessarily unique. This means that we cannot directly use the measurement to
 /// provide feedback and instead must use it to weight sigma points that do contain position information.
 ///
 /// Working hypothesis: we can treat the UKF as a hybrid KF/PF where the sigma point / particles can be weighted
@@ -642,7 +640,7 @@ pub fn run_geophysical_navigation(
                         + record.grav_z.powf(2.0))
                     .sqrt()
                         - state[15];
-                    let geo_measurement = GeophysicalMeasurement {
+                    let _geo_measurement = GeophysicalMeasurement {
                         map: &geo_map,
                         noise_std: measurement_standard_deviation,
                         measurement: freeair,
@@ -656,7 +654,7 @@ pub fn run_geophysical_navigation(
                         (record.mag_x.powf(2.0) + record.mag_y.powf(2.0) + record.mag_z.powf(2.0))
                             .sqrt()
                             - state[15];
-                    let geo_measurement = GeophysicalMeasurement {
+                    let _geo_measurement = GeophysicalMeasurement {
                         map: &geo_map,
                         noise_std: measurement_standard_deviation,
                         measurement: mag_anom,
diff --git a/sim/src/main.rs b/sim/src/main.rs
@@ -6,7 +6,7 @@ use strapdown::messages::{
     GnssDegradationConfig, GnssFaultModel, GnssScheduler, build_event_stream,
 };
 use strapdown::sim::{
-    NavigationResult, TestDataRecord, closed_loop, dead_reckoning, initialize_ukf,
+    NavigationResult, TestDataRecord, closed_loop, initialize_ukf,
 };
 
 const LONG_ABOUT: &str = "STRAPDOWN: A simulation and analysis tool for strapdown inertial navigation systems.
