linted and formatted

Author: jbrodovsky

core/src/kalman.rs

@@ -3345,7 +3345,7 @@ mod tests {
         for _ in 0..20 {
             let imu_data = IMUData {
                 accel: Vector3::new(0.0, 0.0, earth::gravity(&0.0, &0.0)) + true_accel_bias,
-                gyro: true_gyro_bias.clone(),
+                gyro: true_gyro_bias,
             };
             eskf.predict(&imu_data, 0.1);
 

core/src/lib.rs

@@ -993,9 +993,9 @@ pub(crate) fn calculate_constant_velocity_acceleration(
 
     // For constant velocity: specific_force + gravity - r*(transport_rate + 2*rotation_rate)*velocity = 0
     // Therefore: specific_force = r*(transport_rate + 2*rotation_rate)*velocity - gravity
-    let specific_force = r * (transport_rate + 2.0 * rotation_rate) * target_velocity - gravity;
+    
 
-    specific_force
+    r * (transport_rate + 2.0 * rotation_rate) * target_velocity - gravity
 }
 
 /// Helper function to generate IMU data and GPS measurements for a given scenario
@@ -1607,7 +1607,7 @@ mod tests {
             longitude: 0.0_f64.to_radians(), // Already in radians
             altitude: 1000.0,
             velocity_north: 0.0,
-            velocity_east: vel.clone(), // 10 m/s eastward
+            velocity_east: vel, // 10 m/s eastward
             velocity_vertical: 0.0,
             attitude: Rotation3::identity(),
             is_enu: true,

core/src/linearize.rs

@@ -1064,7 +1064,7 @@ mod tests {
         let x0: Vec<f64> = state.into();
 
         // Evaluate nominal dynamics
-        let mut state_nominal = state.clone();
+        let mut state_nominal = *state;
         crate::forward(
             &mut state_nominal,
             crate::IMUData {

core/src/messages.rs

@@ -409,7 +409,6 @@ impl GnssDegradationConfig {
 /// };
 /// let gnss_event = Event::Measurement { meas: Box::new(gnss_meas), elapsed_s: 2.0 };
 /// ```
-
 pub enum Event {
     /// IMU prediction step.
     ///
@@ -1208,8 +1207,8 @@ mod tests {
         let original_lon = -122.0;
 
         let mut all_same = true;
-        let mut prev_lat = None;
-        let mut prev_lon = None;
+        let mut prev_lat: Option<f64> = None;
+        let mut prev_lon: Option<f64> = None;
 
         for event in &gnss_events {
             if let Event::Measurement { meas, .. } = event {
@@ -1223,17 +1222,15 @@ mod tests {
 
                 // Check if positions vary between measurements
                 if let Some(prev_lat) = prev_lat
-                    && (meas.latitude - prev_lat as f64).abs() > 1e-10
-                {
-                    all_same = false;
-                }
+                    && (meas.latitude - prev_lat).abs() > 1e-10 {
+                        all_same = false;
+                    }
                 prev_lat = Some(meas.latitude);
 
-                if let Some(prev_lon) = prev_lon {
-                    if (meas.longitude - prev_lon as f64).abs() > 1e-10 {
+                if let Some(prev_lon) = prev_lon
+                    && (meas.longitude - prev_lon).abs() > 1e-10 {
                         all_same = false;
                     }
-                }
                 prev_lon = Some(meas.longitude);
             }
         }
@@ -1284,14 +1281,13 @@ mod tests {
         // Find GNSS events and group by time
         let mut gnss_by_time: Vec<(f64, &GPSPositionAndVelocityMeasurement)> = Vec::new();
         for event in &events.events {
-            if let Event::Measurement { meas, elapsed_s } = event {
-                if let Some(gps) = meas
+            if let Event::Measurement { meas, elapsed_s } = event
+                && let Some(gps) = meas
                     .as_any()
                     .downcast_ref::<GPSPositionAndVelocityMeasurement>()
                 {
                     gnss_by_time.push((*elapsed_s, gps));
                 }
-            }
         }
         gnss_by_time.sort_by(|a, b| a.0.partial_cmp(&b.0).unwrap());
 
@@ -1301,7 +1297,7 @@ mod tests {
 
         // Check measurements before, during, and after hijack
         for (time, meas) in gnss_by_time {
-            if time < 1.0 - 1e-6 || time > 2.0 + 1e-6 {
+            if !(1.0 - 1e-6..=2.0 + 1e-6).contains(&time) {
                 // Before hijack or after hijack: positions should be near original
                 assert!((meas.latitude - original_lat).abs() < 1e-6);
                 assert!((meas.longitude - original_lon).abs() < 1e-6);
@@ -1327,7 +1323,7 @@ mod tests {
 
         // This should at least not crash
         let events = build_event_stream(&records, &config);
-        assert!(events.events.len() > 0);
+        assert!(!events.events.is_empty());
     }
 
     #[test]
@@ -1369,7 +1365,7 @@ mod tests {
 
         let events = build_event_stream(&records, &config);
         // Should have events
-        assert!(events.events.len() > 0);
+        assert!(!events.events.is_empty());
 
         // Check that some GNSS measurements exist
         let gnss_count = events
@@ -1397,7 +1393,7 @@ mod tests {
 
         let events = build_event_stream(&records, &config);
         // Should have events
-        assert!(events.events.len() > 0);
+        assert!(!events.events.is_empty());
 
         // Check that some GNSS measurements exist
         let gnss_count = events
@@ -1493,7 +1489,7 @@ mod tests {
         let events = build_event_stream(&records, &config);
 
         // Should have events even with NaN accuracies
-        assert!(events.events.len() > 0);
+        assert!(!events.events.is_empty());
 
         // Check that GNSS measurements were created
         let gnss_count = events
@@ -1520,7 +1516,7 @@ mod tests {
 
         let events = build_event_stream(&records, &config);
         // Should have events
-        assert!(events.events.len() > 0);
+        assert!(!events.events.is_empty());
     }
 }
 #[cfg(test)]

core/src/particle.rs

@@ -35,7 +35,6 @@
 
 use std::any::Any;
 
-
 use nalgebra::DVector;
 use rand::prelude::*;
 
@@ -354,9 +353,9 @@ pub trait ParticleFilter {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::measurements::GPSPositionMeasurement;
-    use crate::{IMUData, StrapdownState, earth, generate_scenario_data};
-    use nalgebra::Rotation3;
+    
+    
+    
 
     // ============= Tests for standalone resampling functions ==================
 

core/src/sim.rs

@@ -3544,7 +3544,7 @@ mod tests {
         let timestamp = chrono::Utc::now();
         let nav = NavigationResult::from((
             &timestamp,
-            &state_vector.into(),
+            &state_vector,
             &DMatrix::from_diagonal(&DVector::from_element(15, 0.0)), // dummy covariance
         ));
         assert_eq!(nav.latitude, (1.0_f64).to_degrees());

sim/src/common.rs

@@ -5,12 +5,9 @@
 //! - Path validation and file discovery
 //! - User input prompts
 
-use log::error;
-use rayon::prelude::*;
 use std::error::Error;
 use std::io;
 use std::path::{Path, PathBuf};
-use std::sync::Mutex;
 
 /// Initialize the logger with the specified configuration.
 ///
@@ -135,69 +132,6 @@ pub fn validate_output_path(output: &Path) -> Result<(), Box<dyn Error>> {
     Ok(())
 }
 
-/// Process multiple files with optional parallel execution.
-///
-/// # Arguments
-/// * `csv_files` - Vector of CSV files to process
-/// * `parallel` - Whether to process files in parallel
-/// * `processor` - Function to process each file, returns Result
-///
-/// # Errors
-/// Returns an error if any files fail to process (after all attempts).
-pub fn process_files<F>(
-    csv_files: &[PathBuf],
-    parallel: bool,
-    processor: F,
-) -> Result<(), Box<dyn Error>>
-where
-    F: Fn(&Path) -> Result<(), Box<dyn Error>> + Send + Sync,
-{
-    let is_multiple = csv_files.len() > 1;
-
-    if parallel && is_multiple {
-        // Parallel processing
-        let errors = Mutex::new(Vec::new());
-
-        csv_files.par_iter().for_each(|input_file| {
-            if let Err(e) = processor(input_file) {
-                error!("Error processing {}: {}", input_file.display(), e);
-                errors
-                    .lock()
-                    .expect("Failed to acquire lock on error collection")
-                    .push((input_file.clone(), e.to_string()));
-            }
-        });
-
-        let errors = errors
-            .into_inner()
-            .expect("Failed to extract errors from mutex");
-        if !errors.is_empty() {
-            error!("{} file(s) failed to process", errors.len());
-            for (file, err) in &errors {
-                error!("  {}: {}", file.display(), err);
-            }
-            return Err(format!("{} file(s) failed to process", errors.len()).into());
-        }
-    } else {
-        // Sequential processing
-        let mut failures = 0usize;
-        for input_file in csv_files {
-            if let Err(e) = processor(input_file) {
-                if !is_multiple {
-                    return Err(e);
-                }
-                failures += 1;
-                error!("Error processing {}: {}", input_file.display(), e);
-            }
-        }
-        if failures > 0 {
-            error!("{} file(s) failed to process", failures);
-        }
-    }
-
-    Ok(())
-}
-
 // ============================================================================
 // User Input Utilities
 // ============================================================================

sim/src/main.rs

@@ -40,9 +40,9 @@ use strapdown::rbpf::{RaoBlackwellizedParticleFilter, RbpfConfig};
 // Geophysical navigation imports (feature-gated)
 #[cfg(feature = "geonav")]
 use geonav::{
-    GeoMap, GeophysicalMeasurementType, GravityMeasurement, GravityResolution,
-    MagneticAnomalyMeasurement, MagneticResolution, build_event_stream as geo_build_event_stream,
-    geo_closed_loop_ekf, geo_closed_loop_ukf,
+    GeoMap, GeophysicalAnomalyMeasurementModel, GeophysicalMeasurementType, GravityMeasurement,
+    GravityResolution, MagneticAnomalyMeasurement, MagneticResolution,
+    build_event_stream as geo_build_event_stream, geo_closed_loop_ekf, geo_closed_loop_ukf,
 };
 #[cfg(feature = "geonav")]
 use std::rc::Rc;
@@ -504,7 +504,7 @@ fn process_file(
             let pf_cfg = config
                 .particle_filter
                 .clone()
-                .unwrap_or_else(strapdown::sim::ParticleFilterConfig::default);
+                .unwrap_or_default();
             let mut rbpf = RaoBlackwellizedParticleFilter::new(
                 nominal,
                 RbpfConfig {
@@ -519,7 +519,7 @@ fn process_file(
             let mut results = Vec::with_capacity(event_stream.events.len());
             let mut last_ts: Option<chrono::DateTime<chrono::Utc>> = None;
 
-            for (idx, event) in event_stream.events.into_iter().enumerate() {
+            for event in event_stream.events.into_iter() {
                 let elapsed_s = match &event {
                     Event::Imu { elapsed_s, .. } => *elapsed_s,
                     Event::Measurement { elapsed_s, .. } => *elapsed_s,
@@ -1343,7 +1343,7 @@ fn run_particle_filter(args: &ParticleFilterSimArgs) -> Result<(), Box<dyn Error
         let mut results = Vec::with_capacity(event_stream.events.len());
         let mut last_ts: Option<chrono::DateTime<chrono::Utc>> = None;
 
-        for (idx, event) in event_stream.events.into_iter().enumerate() {
+        for event in event_stream.events.into_iter() {
             let elapsed_s = match &event {
                 Event::Imu { elapsed_s, .. } => *elapsed_s,
                 Event::Measurement { elapsed_s, .. } => *elapsed_s,