Update user profile: this is a runtime, not a config (#78)

* Update user profile: this is a runtime, not a config

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

---------

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

Author: gwbres

.github/workflows/rust.yml

@@ -45,18 +45,12 @@ jobs:
 
     - name: Config documentation
       run: |
-        cargo test generate_static_cpp_preset --all-features
-        echo "Static CPP" >> $GITHUB_STEP_SUMMARY
-        echo "==========" >> $GITHUB_STEP_SUMMARY
-        python3 tools/jsonmd.py static_cpp.json >> $GITHUB_STEP_SUMMARY 
-        rm static_cpp.json
+        cargo test generate_default_preset --all-features
+        echo "Default Preset" >> $GITHUB_STEP_SUMMARY
+        echo "==============" >> $GITHUB_STEP_SUMMARY
+        python3 tools/jsonmd.py default.json >> $GITHUB_STEP_SUMMARY 
+        rm default.json
         
-        cargo test generate_static_ppp_preset --all-features
-        echo "Static PPP" >> $GITHUB_STEP_SUMMARY
-        echo "==========" >> $GITHUB_STEP_SUMMARY
-        python3 tools/jsonmd.py static_ppp.json >> $GITHUB_STEP_SUMMARY 
-        rm static_ppp.json
-
   publish:
     name: Publish Library
     runs-on: ubuntu-latest

.gitignore

@@ -18,3 +18,5 @@ Cargo.lock
 *.patch
 *.rs~
 *.cache
+
+default.json

src/cfg/mod.rs

@@ -41,7 +41,7 @@ const fn max_iono_bias() -> f64 {
 }
 
 const fn min_sv_elev() -> Option<f64> {
-    Some(10.0)
+    Some(12.5)
 }
 
 const fn default_code_smoothing() -> usize {
@@ -80,10 +80,6 @@ pub struct Config {
     #[cfg_attr(feature = "serde", serde(default))]
     pub method: Method,
 
-    /// [Profile] defines the type of application.
-    #[cfg_attr(feature = "serde", serde(default))]
-    pub user: User,
-
     /// Select a prefered signal.
     /// When defined, this signal will strictly be used in the navigation process.
     /// When undefined, the algorithm will prefer the best SNR available, and the
@@ -179,7 +175,6 @@ impl Default for Config {
         Self {
             timescale: default_timescale(),
             method: Method::default(),
-            user: User::default(),
             solver: SolverOpts::default(),
             int_delay: Default::default(),
             modeling: Modeling::default(),
@@ -200,46 +195,6 @@ impl Default for Config {
 }
 
 impl Config {
-    /// Returns [Config] for static PPP positioning, with desired [Method].
-    /// You can then customize [Self] as you will.
-    pub fn static_preset(method: Method) -> Self {
-        let mut s = Self::default();
-
-        s.method = method;
-        s.user.profile = None;
-
-        // consider that static applications can afford stringent criterias
-        s.solver.max_gdop = 3.0;
-        s.max_tropo_bias = 15.0;
-        s
-    }
-
-    /// Returns [Config] for dynamic PPP positioning, with desired [Method]
-    /// and rover [Profile]. You can then customize [Self] as you will.
-    pub fn dynamic_preset(method: Method, profile: Profile) -> Self {
-        let mut s = Self::default();
-
-        s.method = method;
-        s.user.profile = Some(profile);
-
-        s.solver.max_gdop = 5.0;
-        s.max_tropo_bias = 15.0;
-        s
-    }
-
-    /// Returns [Config] for static RTK positioning, with desired [Method],
-    /// Remote site coordinates expressed in meters ECEF.
-    /// You can then customize [Self] as you will.
-    pub fn static_rtk_preset(method: Method) -> Self {
-        Self::static_preset(method) // strictly identical
-    }
-
-    /// Returns [Config] for dynamic RTK positioning, with desired [Method],
-    /// rover [Profile].
-    pub fn dynamic_rtk_preset(method: Method, profile: Profile) -> Self {
-        Self::dynamic_preset(method, profile)
-    }
-
     /// Returns new [Config] with desired navigation [Method]
     pub fn with_navigation_method(&self, method: Method) -> Self {
         let mut s = self.clone();
@@ -264,18 +219,10 @@ mod test {
     use std::io::Write;
 
     #[test]
-    fn generate_static_cpp_preset() {
-        let cfg = Config::static_preset(Method::CPP);
-        let string = serde_json::to_string_pretty(&cfg).unwrap();
-        let mut fd = std::fs::File::create("static_cpp.json").unwrap();
-        write!(fd, "{}", string).unwrap();
-    }
-
-    #[test]
-    fn generate_static_ppp_preset() {
-        let cfg = Config::static_preset(Method::PPP);
+    fn generate_default_preset() {
+        let cfg = Config::default();
         let string = serde_json::to_string_pretty(&cfg).unwrap();
-        let mut fd = std::fs::File::create("static_ppp.json").unwrap();
+        let mut fd = std::fs::File::create("default.json").unwrap();
         write!(fd, "{}", string).unwrap();
     }
 }

src/cfg/user.rs

@@ -9,25 +9,36 @@ const fn default_clock_sigma() -> f64 {
 }
 
 /// Default user [Profile]
-const fn default_user_profile() -> Option<Profile> {
-    Some(Profile::Pedestrian)
+const fn default_user_profile() -> Profile {
+    Profile::Pedestrian
 }
 
-/// Receiver [Profile], which is application dependent.
-/// [Profile::Static] is our default value: any roaming application needs to customize its profile.
+/// Receiver [Profile], which is application dependent.  
+/// Operating under incorrect parametrization ([Profile] not matching your use case),
+/// will not prohibit obtaining results. It's just that they could be improved
+/// by adapting your profile to your use case correctly.
 #[derive(Default, Debug, Clone, Copy, PartialEq)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub enum Profile {
-    /// [Profile::Pedestrian]: < 10 km/h very low velocity
+    /// [Profile::Static] applies to user applications where
+    /// the receiver antenna is held static at all times.
+    /// This is not our prefered mode, because this apply to particular use cases.
+    Static,
+
+    /// [Profile::Pedestrian]: < 10 km/h very low velocity.
+    /// This is our default mode.
     #[cfg_attr(feature = "serde", serde(alias = "pedestrian", alias = "Pedestrian"))]
     #[default]
     Pedestrian,
+
     /// [Profile::Car]: < 100 km/h slow velocity
     #[cfg_attr(feature = "serde", serde(alias = "car", alias = "Car"))]
     Car,
+
     /// [Profile::Airplane]: < 1000 km/h high velocity
     #[cfg_attr(feature = "serde", serde(alias = "airplane", alias = "airplane"))]
     Airplane,
+
     /// [Profile::Rocket]: > 1000 km/h ultra high velocity
     #[cfg_attr(feature = "serde", serde(alias = "rocket", alias = "rocket"))]
     Rocket,
@@ -39,6 +50,7 @@ impl std::str::FromStr for Profile {
         let s = s.to_lowercase();
         let trimmed = s.trim();
         match trimmed {
+            "static" => Ok(Self::Static),
             "pedestrian" => Ok(Self::Pedestrian),
             "car" => Ok(Self::Car),
             "airplane" => Ok(Self::Airplane),
@@ -51,6 +63,7 @@ impl std::str::FromStr for Profile {
 impl std::fmt::Display for Profile {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
+            Self::Static => write!(f, "Static"),
             Self::Pedestrian => write!(f, "Pedestrian"),
             Self::Car => write!(f, "car"),
             Self::Airplane => write!(f, "airplane"),
@@ -65,9 +78,8 @@ impl std::fmt::Display for Profile {
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub struct User {
     /// Custom user [Profile] which is application dependent.
-    /// This is disregarded by solvers dedicated to static applications.
     #[cfg_attr(feature = "serde", serde(default))]
-    pub profile: Option<Profile>,
+    pub profile: Profile,
 
     /// Receiver clock prediction perturbation (instantaneous bias) in seconds.
     /// Standard values are:
@@ -88,12 +100,7 @@ pub struct User {
 
 impl std::fmt::Display for User {
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
-        if let Some(profile) = self.profile {
-            write!(f, "Profile=\"{}\" ", profile)?;
-        } else {
-            write!(f, "Profile=Static ")?;
-        }
-
+        write!(f, "Profile=\"{}\" ", self.profile)?;
         write!(f, "clock-sigma={}s", self.clock_sigma_s)
     }
 }

src/navigation/mod.rs

@@ -126,13 +126,11 @@ where
             }
         }
 
+        // TODO: improve this model
         q_k[(0, 0)] = 1.0;
         q_k[(1, 1)] = 1.0;
         q_k[(2, 2)] = 1.0;
 
-        q_k[(Self::clock_index(), Self::clock_index())] =
-            (cfg.user.clock_sigma_s * SPEED_OF_LIGHT_M_S).powi(2);
-
         Self {
             f_k,
             q_k,
@@ -156,11 +154,18 @@ where
     }
 
     /// Reset [Navigation] filter.
+    ///
+    /// To this day, it has not been demonstrated that this
+    /// operation is needed by any real-world application, even
+    /// real-time processing. But anyways.. this exists.
+    ///
+    /// After reset, the [Navigation] solver is in the same state as deployment,
+    /// ready to consume a first measurement.
     pub fn reset(&mut self) {
         self.clear();
         self.kalman.reset();
 
-        if let Some(postfit) = &mut self.postfit {
+        if self.postfit.is_some() {
             self.postfit = None;
         }
 
@@ -177,7 +182,7 @@ where
     /// Iterates mutable [Navigation] filter.
     /// ## Input
     /// - t: sampling [Epoch]
-    /// - user: [User]
+    /// - user: [User] profile
     /// - past_state: past [State]
     /// - candidates: proposed [Candidate]s
     /// - size: number of proposed [Cadndidate]s
@@ -195,18 +200,8 @@ where
     ) -> Result<(), Error> {
         self.clear();
 
-        if self.cfg.user != user {
-            // profile update
-            if user.profile != self.cfg.user.profile {
-                if let Some(profile) = user.profile {
-                    info!("{}: switching to {} profile", t, profile);
-                    self.cfg.user.profile = Some(profile);
-                }
-            }
-
-            self.q_k[(Self::clock_index(), Self::clock_index())] =
-                (user.clock_sigma_s * SPEED_OF_LIGHT_M_S).powi(2);
-        }
+        self.q_k[(Self::clock_index(), Self::clock_index())] =
+            (user.clock_sigma_s * SPEED_OF_LIGHT_M_S).powi(2);
 
         if !self.kalman.initialized {
             self.kf_initialization(t, past_state, candidates, size, rtk_base, bias)?;