Develop (#30)

* Improving Tropo and Iono interfaces
---------

Signed-off-by: Guillaume W. Bres <guillaume.bressaix@gmail.com>

Author: gwbres

.gitignore

@@ -16,3 +16,4 @@ Cargo.lock
 *.swp
 *.swo
 *.patch
+*.rs~

examples/spp/main.rs

@@ -2,8 +2,8 @@
 // This is simply here to demonstrate how to operate the API, and does not generate actual results.
 use gnss_rtk::prelude::{
     BaseStation as RTKBaseStation, Candidate, Carrier, ClockCorrection, Config, Duration, Epoch,
-    Error, InvalidationCause, IonosphereBias, Method, Observation, OrbitalState,
-    OrbitalStateProvider, Solver, TroposphereBias, SV,
+    Error, InvalidationCause, IonoComponents, Method, Observation, OrbitalState,
+    OrbitalStateProvider, Solver, TropoComponents, SV,
 };
 
 // Orbit source example
@@ -73,6 +73,10 @@ impl MyDataSource {
                         doppler: None,
                         ambiguity: None,
                     }],
+                    // Provide more information if you can
+                    IonoComponents::Unknown,
+                    // Provide more information if you can
+                    TropoComponents::Unknown,
                 ),
                 // Create all as many candidates as possible.
                 // It's better to have more than needed, it leaves us more possibility in the election process.
@@ -112,14 +116,7 @@ pub fn main() {
 
     // Browse your data source (This is an Example)
     while let Some((epoch, candidates)) = source.next() {
-        // External bias sources are not very well supported yet.
-        // We recommend you use the internal modeling.
-        // This is done by specifying you simply have no knowledge
-        // of the external biases:
-        let ionod = IonosphereBias::default(); // Unknown
-        let tropod = TroposphereBias::default(); // Unknown
-
-        match solver.resolve(epoch, &candidates, &ionod, &tropod) {
+        match solver.resolve(epoch, &candidates) {
             Ok((_epoch, solution)) => {
                 // A solution was successfully resolved for this Epoch.
                 // The position is expressed as absolute ECEF [m].

src/bias/iono.rs

@@ -1,22 +1,23 @@
-use crate::bias::RuntimeParam;
-use crate::prelude::TimeScale;
-use map_3d::deg2rad;
+use crate::{bias::RuntimeParams, prelude::TimeScale};
 use std::f64::consts::PI;
 
-/// Ionospheric Components to attach
-/// any resolution attempt. Fill as much as you can.
-/// If this structure is empty, you should then provide observations
-/// on at least two carrier signals so the solver can estimate this bias.
-#[derive(Default)]
-pub struct IonosphereBias {
-    /// Klobuchar Model to apply
-    pub kb_model: Option<KbModel>,
-    /// Nequick-G model to apply
-    pub ng_model: Option<NgModel>,
-    /// BDGIM model to apply
-    pub bd_model: Option<BdModel>,
-    /// Slan Total Electron Density estimate
-    pub stec_meas: Option<f64>,
+#[cfg(feature = "serde")]
+use serde::{Deserialize, Serialize};
+
+/// Ionopheric delay components to attach to any attempt.
+#[derive(Default, Clone, Copy)]
+pub enum IonoComponents {
+    /// Unknown
+    #[default]
+    Unknown,
+    /// Provide a [KbModel]
+    KbModel(KbModel),
+    /// Provide a [NgModel]
+    NgModel(NgModel),
+    /// Provide a [BdModel]
+    BdModel(BdModel),
+    /// Provide Slant Total Electron Density [TECu]
+    Stec(f64),
 }
 
 /// Klobuchar Model
@@ -31,30 +32,29 @@ pub struct KbModel {
 }
 
 impl KbModel {
-    pub(crate) fn bias(&self, rtm: &RuntimeParam) -> Option<f64> {
+    pub(crate) fn value(&self, rtm: &RuntimeParams) -> f64 {
         const PHI_P: f64 = 78.3;
         const R_EARTH: f64 = 6378.0;
         const LAMBDA_P: f64 = 291.0;
         const L1_F: f64 = 1575.42E6;
 
-        let (lat_ddeg, lon_ddeg, _) = rtm.apriori_geo;
-
+        let (phi_u, lambda_u) = rtm.apriori_rad;
         let fract = R_EARTH / (R_EARTH + self.h_km);
-        let (elev, azim) = (deg2rad(rtm.elevation), deg2rad(rtm.azimuth));
-        let (phi_u, lambda_u) = (deg2rad(lat_ddeg), deg2rad(lon_ddeg));
+        let (elev_rad, azim_rad) = (rtm.elevation_rad, rtm.azimuth_rad);
 
-        let t_gps = rtm
+        let t_gpst = rtm
             .t
             .to_duration_in_time_scale(TimeScale::GPST)
             .to_seconds();
-        let psi = PI / 2.0 - elev - (fract * elev.cos()).asin();
-        let phi_i = (phi_u.sin() * psi.cos() + phi_u.cos() * psi.sin() * azim.cos()).asin();
-        let lambda_i = lambda_u + azim.sin() * psi / phi_i.cos();
+
+        let psi = PI / 2.0 - elev_rad - (fract * elev_rad.cos()).asin();
+        let phi_i = (phi_u.sin() * psi.cos() + phi_u.cos() * psi.sin() * azim_rad.cos()).asin();
+        let lambda_i = lambda_u + azim_rad.sin() * psi / phi_i.cos();
         let phi_m = (phi_i.sin() * PHI_P.sin()
             + phi_i.cos() * PHI_P.cos() * (lambda_i - LAMBDA_P).cos())
         .asin();
 
-        let mut t_s = 43.2E3 * lambda_i / PI + t_gps;
+        let mut t_s = 43.2E3 * lambda_i / PI + t_gpst;
         if t_s > 86.4E3 {
             t_s -= 86.4E3;
         } else if t_s < 0.0 {
@@ -78,60 +78,89 @@ impl KbModel {
         }
 
         let x_i = 2.0 * PI * (t_s - 50400.0) / p_i;
-        let f = 1.0 / ((1.0 - fract * elev.cos()).powi(2)).sqrt();
+        let f = 1.0 / ((1.0 - fract * elev_rad.cos()).powi(2)).sqrt();
         let i_1 = match x_i < PI / 2.0 {
             true => 5.0 * 10E-9 + a_i * x_i.cos(),
             false => f * 5.0 * 10E-9,
         };
 
-        Some(i_1 * (L1_F / rtm.frequency).powi(2))
+        i_1 * (L1_F / rtm.frequency).powi(2)
     }
 }
 
-/// Nequick-G Model
+/// Nequick-G Model: is not supported yet.
 #[derive(Clone, Copy, Default, Debug)]
 pub struct NgModel {
     /// alpha coefficients
     pub a: (f64, f64, f64),
 }
 
 impl NgModel {
-    pub(crate) fn bias(&self, _rtm: &RuntimeParam) -> Option<f64> {
+    pub(crate) fn value(&self, _rtm: &RuntimeParams) -> f64 {
         //let phi = deg2rad(rtm.apriori_geo.0);
         //let mu = inclination / phi.cos().sqrt();
-        None //TODO
+        0.0
     }
 }
 
-/// BDGIM Model
+/// BDGIM Model: is not supported yet.
 #[derive(Clone, Copy, Default, Debug)]
 pub struct BdModel {
     /// Alpha coefficients in TECu
     pub alpha: (f64, f64, f64, f64, f64, f64, f64, f64, f64),
 }
 
 impl BdModel {
-    pub(crate) fn bias(&self, _rtm: &RuntimeParam) -> Option<f64> {
+    pub(crate) fn value(&self, _rtm: &RuntimeParams) -> f64 {
         //let phi = deg2rad(rtm.apriori_geo.0);
         //let mu = inclination / phi.cos().sqrt();
-        None //TODO
+        0.0
+    }
+}
+
+impl IonoComponents {
+    pub(crate) fn value(&self, rtm: &RuntimeParams) -> f64 {
+        match self {
+            Self::Unknown => 0.0,
+            Self::KbModel(model) => model.value(rtm),
+            Self::NgModel(model) => model.value(rtm),
+            Self::BdModel(model) => model.value(rtm),
+            Self::Stec(stec) => 0.0, //TODO
+        }
+    }
+}
+
+/// Modeled (estimated) or measured bias
+#[derive(Debug, Copy, Clone)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+pub enum IonosphereBias {
+    /// Measured bias in [m]
+    Measured(f64),
+    /// Modelled bias in [m]
+    Modeled(f64),
+}
+
+impl Default for IonosphereBias {
+    /// Builds a Default "Modeled" Bias with 0 value
+    fn default() -> Self {
+        Self::Modeled(0.0)
     }
 }
 
 impl IonosphereBias {
-    pub(crate) fn bias(&self, rtm: &RuntimeParam) -> Option<f64> {
-        if let Some(_stec) = self.stec_meas {
-            // TODO
-            // let alpha = 40.3 * 10E16 / frequency / frequency;
-            None
-        } else if let Some(kb) = self.kb_model {
-            kb.bias(rtm)
-        } else if let Some(ng) = self.ng_model {
-            ng.bias(rtm)
-        } else if let Some(bd) = self.bd_model {
-            bd.bias(rtm)
-        } else {
-            None
+    /// Returns Bias value in [m]
+    pub fn value(&self) -> f64 {
+        match self {
+            Self::Measured(bias) => *bias,
+            Self::Modeled(bias) => *bias,
         }
     }
+    /// Builds a measured bias in [m]
+    pub(crate) fn measured(meas_m: f64) -> Self {
+        Self::Measured(meas_m)
+    }
+    /// Builds a modeled bias in [m]
+    pub(crate) fn modeled(model_m: f64) -> Self {
+        Self::Modeled(model_m)
+    }
 }

src/bias/mod.rs

@@ -1,58 +1,18 @@
 use crate::prelude::Epoch;
 
 pub(crate) mod tropo;
-pub use tropo::{TropoModel, TroposphereBias};
+pub use tropo::{TropoComponents, TropoModel};
 
 pub(crate) mod iono;
-pub use iono::{BdModel, IonosphereBias, KbModel, NgModel};
+pub use iono::{BdModel, IonoComponents, IonosphereBias, KbModel, NgModel};
 
-#[cfg(feature = "serde")]
-use serde::{Deserialize, Serialize};
-
-/// Modeled (estimated) or measured bias
-#[derive(Debug, Copy, Clone, Default)]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-pub struct Bias {
-    /// Measured delay [meters of delay]
-    pub measured: Option<f64>,
-    /// Modeled delay [meters of delay]
-    pub modeled: Option<f64>,
-}
-
-impl Bias {
-    /// Bias value
-    pub fn value(&self) -> Option<f64> {
-        if self.measured.is_none() {
-            self.modeled
-        } else {
-            self.measured
-        }
-    }
-    /// Builds a measured Time Delay from a measurement in [s]
-    pub fn measured(measurement: f64) -> Self {
-        Self {
-            measured: Some(measurement),
-            modeled: None,
-        }
-    }
-    /// Builds a modeled Time Delay from a model in [s]
-    pub fn modeled(model: f64) -> Self {
-        Self {
-            modeled: Some(model),
-            measured: None,
-        }
-    }
-}
-
-pub(crate) struct RuntimeParam {
+pub(crate) struct RuntimeParams {
     pub t: Epoch,
-    // elevation in [°]
-    pub elevation: f64,
-    // azimmuth in [°]
-    pub azimuth: f64,
-    // Apriori geodetic coordinates with latitude
-    // expressed as meters above sea level
-    pub apriori_geo: (f64, f64, f64),
-    // signal frequency
     pub frequency: f64,
+    pub azimuth_deg: f64,
+    pub elevation_deg: f64,
+    pub azimuth_rad: f64,
+    pub elevation_rad: f64,
+    pub apriori_geo: (f64, f64, f64),
+    pub apriori_rad: (f64, f64),
 }