Orbit determination constant biases + measurement ambiguity and moduli

Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "nyx-space"
 build = "build.rs"
-version = "2.0.0"
+version = "2.1.0"
 edition = "2021"
 authors = ["Christopher Rabotin <[email protected]>"]
 description = "A high-fidelity space mission toolkit, with orbit propagation, estimation and some systems engineering"

README.md

@@ -62,6 +62,12 @@ For Python projects, get started by installing the library via `pip`: `pip insta
 
 Nyx is provided under the [AGPLv3 License](./LICENSE). By using this software, you assume responsibility for adhering to the license. Refer to [the pricing page](https://nyxspace.com/pricing/?utm_source=readme-price) for an FAQ on the AGPLv3 license. Notably, any software that incorporates, links to, or depends on Nyx must also be released under the AGPLv3 license, even if you distribute an unmodified version of Nyx.
 
+# Versioning
+
+Nyx mostly adheres to SemVer. New patch versions should be rare. Updated dependencies trigger a new minor version. _However_ new fields in structures and new behavior may also be added with minor releases, but the public facing initializers and functions should not significantly change (but may still change).
+
+Major releases are for dramatic changes.
+
 
 [cratesio-image]: https://img.shields.io/crates/v/nyx-space.svg
 [cratesio]: https://crates.io/crates/nyx-space

data/tests/config/high-prec-network.yaml

@@ -1,7 +1,9 @@
 range_noise_model:
   tau: 12 h 159 ms
   process_noise: 5.0e-3 # 5 m
+  constant: 0
 
 doppler_noise_model:
   tau: 11 h 59 min
   process_noise: 50.0e-6 # 5 cm/s
+  constant: 0

data/tests/config/many_ground_stations.yaml

@@ -10,10 +10,12 @@
       bias:
         tau: 24 h
         process_noise: 5.0e-3 # 5 m
+        constant: 0
     doppler_km_s:
       bias:
         tau: 24 h
         process_noise: 50.0e-6 # 5 cm/s
+        constant: 0
   light_time_correction: false
   latitude_deg: 2.3522
   longitude_deg: 48.8566
@@ -37,10 +39,12 @@
       bias:
         tau: 24 h
         process_noise: 5.0e-3 # 5 m
+        constant: 0
     doppler_km_s:
       bias:
         tau: 24 h
         process_noise: 50.0e-6 # 5 cm/s
+        constant: 0
   light_time_correction: false
   measurement_types:
     - range_km

data/tests/config/one_ground_station.yaml

@@ -13,10 +13,12 @@ stochastic_noises:
     bias:
       tau: 24 h
       process_noise: 5.0e-3 # 5 m
+      constant: 0
   doppler_km_s:
     bias:
       tau: 24 h
       process_noise: 50.0e-6 # 5 cm/s
+      constant: 0
 light_time_correction: false
 measurement_types:
     - range_km

src/dynamics/guidance/ruggiero.rs

@@ -17,6 +17,7 @@
 */
 
 use anise::prelude::Almanac;
+use serde::{Deserialize, Serialize};
 use snafu::ResultExt;
 
 use super::{
@@ -32,7 +33,7 @@ use std::fmt;
 use std::sync::Arc;
 
 /// Ruggiero defines the closed loop guidance law from IEPC 2011-102
-#[derive(Copy, Clone, Default)]
+#[derive(Copy, Clone, Default, Serialize, Deserialize)]
 pub struct Ruggiero {
     /// Stores the objectives
     pub objectives: [Option<Objective>; 5],

src/lib.rs

@@ -41,7 +41,7 @@ pub mod cosmic;
 /// Utility functions shared by different modules, and which may be useful to engineers.
 pub mod utils;
 
-mod errors;
+pub mod errors;
 /// Nyx will (almost) never panic and functions which may fail will return an error.
 pub use self::errors::NyxError;
 

src/mc/dispersion.rs

@@ -17,10 +17,11 @@
 */
 
 use crate::md::StateParameter;
+use serde::{Deserialize, Serialize};
 use typed_builder::TypedBuilder;
 
 /// A dispersions configuration, allows specifying min/max bounds (by default, they are not set)
-#[derive(Copy, Clone, TypedBuilder)]
+#[derive(Copy, Clone, TypedBuilder, Serialize, Deserialize)]
 pub struct StateDispersion {
     pub param: StateParameter,
     #[builder(default, setter(strip_option))]

src/md/events/details.rs

@@ -25,12 +25,13 @@ use crate::md::prelude::{Interpolatable, Traj};
 use crate::md::EventEvaluator;
 use crate::time::Duration;
 use core::fmt;
+use serde::{Deserialize, Serialize};
 use std::sync::Arc;
 
 /// Enumerates the possible edges of an event in a trajectory.
 ///
 /// `EventEdge` is used to describe the nature of a trajectory event, particularly in terms of its temporal dynamics relative to a specified condition or threshold. This enum helps in distinguishing whether the event is occurring at a rising edge, a falling edge, or if the edge is unclear due to insufficient data or ambiguous conditions.
-#[derive(Copy, Clone, Debug, PartialEq)]
+#[derive(Copy, Clone, Debug, PartialEq, Serialize, Deserialize)]
 pub enum EventEdge {
     /// Represents a rising edge of the event. This indicates that the event is transitioning from a lower to a higher evaluation of the event. For example, in the context of elevation, a rising edge would indicate an increase in elevation from a lower angle.
     Rising,
@@ -73,14 +74,14 @@ where
 {
     /// Generates detailed information about an event at a specific epoch in a trajectory.
     ///
-    /// This takes an `Epoch` as an input and returns a `Result<Self, NyxError>`.
+    /// This takes an `Epoch` as an input and returns a `Result<Self, EventError>`.
     /// It is designed to determine the state of a trajectory at a given epoch, evaluate the specific event at that state, and ascertain the nature of the event (rising, falling, or unclear).
     /// The initialization intelligently determines the edge type of the event by comparing the event's value at the current, previous, and next epochs.
     /// It ensures robust event characterization in trajectories.
     ///
     /// # Returns
     /// - `Ok(EventDetails<S>)` if the state at the given epoch can be determined and the event details are successfully evaluated.
-    /// - `Err(NyxError)` if there is an error in retrieving the state at the specified epoch.
+    /// - `Err(EventError)` if there is an error in retrieving the state at the specified epoch.
     ///
     pub fn new<E: EventEvaluator<S>>(
         state: S,

src/md/events/mod.rs

@@ -27,6 +27,7 @@
 use crate::State;
 use anise::prelude::{Almanac, Frame};
 use anise::structure::planetocentric::ellipsoid::Ellipsoid;
+use serde::{Deserialize, Serialize};
 
 use std::default::Default;
 use std::fmt;
@@ -59,15 +60,14 @@
 }
 
 /// Defines a state parameter event finder
-#[derive(Clone, Debug)]
-
+#[derive(Copy, Clone, Debug, Serialize, Deserialize)]
 pub struct Event {
     /// The state parameter
     pub parameter: StateParameter,
     /// The desired self.desired_value, must be in the same units as the state parameter
     pub desired_value: f64,
-    /// The time precision after which the solver will report that it cannot find any more precise
-    pub epoch_precision: Unit,
+    /// The duration precision after which the solver will report that it cannot find any more precise
+    pub epoch_precision: Duration,
     /// The precision on the desired value
     pub value_precision: f64,
     /// An optional frame in which to search this -- it IS recommended to convert the whole trajectory instead of searching in a given frame!
@@ -133,12 +133,12 @@
         parameter: StateParameter,
         desired_value: f64,
         value_precision: f64,
-        epoch_precision: Unit,
+        unit_precision: Unit,
     ) -> Self {
         Self {
             parameter,
             desired_value,
-            epoch_precision,
+            epoch_precision: 1 * unit_precision,
             value_precision,
             obs_frame: None,
         }
@@ -166,7 +166,7 @@
         Self {
             parameter,
             desired_value,
-            epoch_precision: Unit::Millisecond,
+            epoch_precision: Unit::Millisecond * 1,
             value_precision: 1e-3,
             obs_frame: Some(target_frame),
         }
@@ -179,7 +179,7 @@
             parameter: StateParameter::Periapsis,
             desired_value: 0.0,
             value_precision: 1e-3,
-            epoch_precision: Unit::Second,
+            epoch_precision: Unit::Second * 1,
             obs_frame: None,
         }
     }

src/md/objective.rs

@@ -18,10 +18,11 @@
 
 use super::StateParameter;
 use crate::{errors::StateError, Spacecraft, State};
+use serde::{Deserialize, Serialize};
 use std::fmt;
 
 /// Defines a state parameter event finder
-#[derive(Copy, Clone, Debug)]
+#[derive(Copy, Clone, Debug, Serialize, Deserialize)]
 pub struct Objective {
     /// The state parameter to target
     pub parameter: StateParameter,

src/od/ground_station/trk_device.rs

@@ -174,4 +174,20 @@ impl TrackingDevice<Spacecraft> for GroundStation {
             })?
             .covariance(epoch))
     }
+
+    fn measurement_bias(&self, msr_type: MeasurementType, _epoch: Epoch) -> Result<f64, ODError> {
+        let stochastics = self.stochastic_noises.as_ref().unwrap();
+
+        if let Some(gm) = stochastics
+            .get(&msr_type)
+            .ok_or(ODError::NoiseNotConfigured {
+                kind: format!("{msr_type:?}"),
+            })?
+            .bias
+        {
+            Ok(gm.constant)
+        } else {
+            Ok(0.0)
+        }
+    }
 }

src/od/msr/measurement.rs

@@ -23,7 +23,10 @@
 use std::fmt;
 
 /// A type-agnostic simultaneous measurement storage structure. Allows storing any number of simultaneous measurement of a given taker.
-#[derive(Clone, Debug, PartialEq)]
+///
+/// Note that two measurements are considered equal if the tracker and epoch match exactly, and if both have the same measurement types,
+/// and those measurements are equal to within 1e-10 (this allows for some leeway in TDM producers).
+#[derive(Clone, Debug)]
 pub struct Measurement {
     /// Tracker alias which made this measurement
     pub tracker: String,
@@ -58,6 +61,7 @@
     where
         DefaultAllocator: Allocator<S>,
     {
+        // Consider adding a modulo modifier here, any bias should be configured by each ground station.
         let mut obs = OVector::zeros();
         for (i, t) in types.iter().enumerate() {
             if let Some(msr_value) = self.data.get(t) {
@@ -91,3 +95,17 @@
         write!(f, "{} measured {} on {}", self.tracker, msrs, self.epoch)
     }
 }
+
+impl PartialEq for Measurement {
+    fn eq(&self, other: &Self) -> bool {
+        self.tracker == other.tracker
+            && self.epoch == other.epoch
+            && self.data.iter().all(|(key, &value)| {
+                if let Some(&other_value) = other.data.get(key) {
+                    (value - other_value).abs() < 1e-12
+                } else {
+                    false
+                }
+            })
+    }
+}