Improve surveying and allow BRDC navigation

README.md

@@ -20,19 +20,19 @@ You can also open a [Discussion](https://github.com/georust/rinex/discussions) o
 
 - Fast
   - Parse and render reports in a few seconds 
-  - Resolve PVT solutions as well
+  - Perform precise Geodetic surveys in a few seconds
 - Open sources
   - Read and access all the code
   - All examples based on Open data 
-- Efficient seamless compression / decompression
-  - Hatanaka (OBS_RINEX) and Gzip are built in
+- All modern GNSS constellations, codes and signals
+  - Surveying with GPS, Galileo, BeiDou and QZSS
+- Time scales: GPST, QZSST, BDT, GST, UTC, TAI
+- Efficient seamless compression and decompression
 - RINEX V4 full support
 - All RINEX formats supported (see following table)
-- High Precision Clock RINEX products
-- High Precision Orbital (SP3) products [SP3](https://docs.rs/sp3/1.0.7/sp3/)
-- DORIS (special RINEX) by ESA
-- All modern GNSS constellations, codes and signals
-- Time scales: GPST, BDT, GST, UTC
+- High Precision Clock RINEX products (for PPP)
+- High Precision Orbital [SP3 for PPP](https://docs.rs/sp3/1.0.7/sp3/)
+- DORIS (special RINEX)
 - Several pre-processing algorithms:
   - [File merging](https://github.com/georust/rinex/wiki/file-merging)
   - [Time binning](https://github.com/georust/rinex/wiki/time-binning)
@@ -45,11 +45,8 @@ You can also open a [Discussion](https://github.com/georust/rinex/discussions) o
 
 ## Disadvantages :warning:
 
-- QZSST is not supported until next release
-- PPP is work in progress
-- Navigation is only available in Galileo and GPS mode.  
-QZSST comes next.   
-BDS and IRNSS will either come at the same time or shortly after.
+- Navigation is currently not feasible with Glonass and IRNSS
+- Differential navigation (SBAS, DGNSS or RTK) is not support yet
 - Our applications do not accept BINEX or other proprietary formats
 - File production might lack some features, mostly because we're currently focused on data processing
 

rinex-cli/Cargo.toml

@@ -30,20 +30,20 @@ map_3d = "0.1.5"
 colorous = "1.0"
 horrorshow = "0.8"
 clap = { version = "4.4.13", features = ["derive", "color"] }
-hifitime = { version = "3.9.0", features = ["serde", "std"] }
-gnss-rs = { version = "2.1.3" , features = ["serde"] }
+hifitime = { git = "https://github.com/nyx-space/hifitime.git", branch = "master", features = ["serde", "std"] }
+gnss-rs = { git = "https://github.com/rtk-rs/gnss", branch = "main", features = ["serde"] }
 rinex = { path = "../rinex", version = "=0.16.1", features = ["full"] }
 plotly = { git = "https://github.com/plotly/plotly.rs", branch = "main" }
 rinex-qc = { path = "../rinex-qc", version = "=0.1.14", features = ["serde"] } 
 sp3 = { path = "../sp3", version = "=1.0.8",  features = ["serde", "flate2"] }
 serde = { version = "1.0", default-features = false, features = ["derive"] }
 
-
 # solver
-gnss-rtk = { version = "0.4.5", features = ["serde"] }
+# gnss-rtk = { version = "0.4.5", features = ["serde"] }
 # gnss-rtk = { path = "../../rtk-rs/gnss-rtk", features = ["serde"] }
-# gnss-rtk = { git = "https://github.com/rtk-rs/gnss-rtk", branch = "main", features = ["serde"] }
+gnss-rtk = { git = "https://github.com/rtk-rs/gnss-rtk", branch = "main", features = ["serde"] }
 
 # cggtts
-cggtts = { version = "4.1.4", features = ["serde", "scheduler"] }
+# cggtts = { version = "4.1.4", features = ["serde", "scheduler"] }
 # cggtts = { path = "../../cggtts/cggtts", features = ["serde", "scheduler"] }
+cggtts = { git = "https://github.com/gwbres/cggtts", branch = "dev", features = ["serde", "scheduler"] }

rinex-cli/config/rtk/gpst_cpp_basic.json

@@ -1,5 +1,5 @@
 {
-    "method": "CodePPP",
+    "method": "CPP",
     "timescale": "GPST",
     "interp_order": 17,
     "min_sv_elevation": 5.0,

rinex-cli/config/rtk/gpst_cpp_kf.json

@@ -1,5 +1,5 @@
 {
-    "method": "CodePPP",
+    "method": "CPP",
     "timescale": "GPST",
     "interp_order": 17,
     "min_sv_elev": 5.0,

rinex-cli/src/graph/mod.rs

@@ -515,6 +515,7 @@ fn gnss_combination_plot(matches: &ArgMatches) -> bool {
 /* Returns True if Navigation plot is to be generated */
 fn navigation_plot(matches: &ArgMatches) -> bool {
     matches.get_flag("skyplot")
+        || matches.get_flag("orbit")
         || matches.get_flag("orbit-residual")
         || matches.get_flag("sv-clock")
 }

rinex-cli/src/positioning/cggtts/mod.rs

@@ -10,9 +10,6 @@ use gnss::prelude::{Constellation, SV};
 
 use rinex::{carrier::Carrier, prelude::Observable};
 
-use super::cast_rtk_carrier;
-use super::interp::TimeInterpolator;
-
 use rtk::prelude::{
     Candidate,
     Duration,
@@ -30,9 +27,16 @@ use cggtts::{
     track::{FitData, GlonassChannel, SVTracker, Scheduler},
 };
 
-use crate::cli::Context;
-use crate::positioning::{
-    bd_model, kb_model, ng_model, tropo_components, Error as PositioningError,
+use crate::{
+    cli::Context,
+    positioning::{
+        bd_model,
+        cast_rtk_carrier,
+        kb_model,
+        ng_model, //tropo_components,
+        Error as PositioningError,
+        Time,
+    },
 };
 
 // fn reset_sv_tracker(sv: SV, trackers: &mut HashMap<(SV, Observable), SVTracker>) {
@@ -61,7 +65,7 @@ use crate::positioning::{
 pub fn resolve<I>(
     ctx: &Context,
     mut solver: Solver<I>,
-    rx_lat_ddeg: f64,
+    // rx_lat_ddeg: f64,
     matches: &ArgMatches,
 ) -> Result<Vec<Track>, PositioningError>
 where
@@ -83,26 +87,13 @@ where
     // infaillible, at this point
     let obs_data = ctx.data.observation().unwrap();
     let nav_data = ctx.data.brdc_navigation().unwrap();
-
-    let clk_data = ctx.data.clock();
-    let meteo_data = ctx.data.meteo();
-
-    let sp3_has_clock = ctx.data.sp3_has_clock();
-    if clk_data.is_none() && sp3_has_clock {
-        if let Some(sp3) = ctx.data.sp3() {
-            warn!("Using clock states defined in SP3 file - CLK product should be prefered");
-            if sp3.epoch_interval >= Duration::from_seconds(300.0) {
-                warn!("Interpolating clock states from low sample rate SP3 will most likely introduce errors");
-            }
-        }
-    }
+    // let meteo_data = ctx.data.meteo(); //TODO
 
     let dominant_sampling_period = obs_data
         .dominant_sample_rate()
         .expect("RNX2CGGTTS requires steady GNSS observations");
 
-    let mut interp = TimeInterpolator::from_ctx(ctx);
-    debug!("Clock interpolator created");
+    let mut time = Time::from_ctx(ctx);
 
     // CGGTTS specifics
     let mut tracks = Vec::<Track>::new();
@@ -120,8 +111,8 @@ where
             continue;
         }
 
-        // Nearest TROPO
-        let zwd_zdd = tropo_components(meteo_data, *t, rx_lat_ddeg);
+        // Nearest TROPO: TODO
+        // let zwd_zdd = tropo_components(meteo_data, *t, rx_lat_ddeg);
 
         for (sv, observations) in vehicles {
             let sv_eph = nav_data.sv_ephemeris(*sv, *t);
@@ -134,7 +125,7 @@ where
 
             // determine TOE
             let (_toe, sv_eph) = sv_eph.unwrap();
-            let clock_corr = match interp.next_at(*t, *sv) {
+            let clock_corr = match time.next_at(*t, *sv) {
                 Some(dt) => dt,
                 None => {
                     error!("{:?} ({}) - failed to determine clock correction", *t, *sv);
@@ -150,8 +141,8 @@ where
             };
 
             let tropo_bias = TroposphereBias {
-                total: None, //TODO
-                zwd_zdd,
+                total: None,   //TODO
+                zwd_zdd: None, // TODO
             };
 
             // tries to form a candidate for each signal
@@ -177,8 +168,8 @@ where
 
                     // attach one phase, if need be
                     match solver.cfg.method {
-                        Method::SPP => {},     // nothing to do
-                        Method::CodePPP => {}, // nothing to do
+                        Method::SPP => {}, // nothing to do
+                        Method::CPP => {}, // nothing to do
                         Method::PPP => {
                             // try to attach phase data
                             // let to_match =
@@ -220,7 +211,7 @@ where
                 // complete if need be
                 match solver.cfg.method {
                     Method::SPP => {}, // nothing to do
-                    Method::CodePPP => {
+                    Method::CPP => {
                         // Attach secondary PR
                         for (second_obs, second_data) in observations {
                             let rhs_carrier =

rinex-cli/src/positioning/interp/mod.rs → rinex-cli/src/positioning/interp.rs

@@ -1,38 +1,31 @@
-mod orbit;
-pub use orbit::Interpolator as OrbitInterpolator;
-
-mod time;
-pub use time::Interpolator as TimeInterpolator;
-
 use rinex::prelude::{Duration, Epoch};
 
-/// Interpolators internal buffer.
-/// Both interpolators, whether it be Temporal or Position, both work on 3D values represented as f64 double precision.
-pub trait Buffer {
+/// Interpolator buffer Trait.
+pub trait Buffer<T> {
     /// Memory allocation
     fn malloc(size: usize) -> Self;
     /// Return current number of symbols
     fn len(&self) -> usize;
     /// Return symbol by index
-    fn get(&self, index: usize) -> Option<&(Epoch, (f64, f64, f64))>;
+    fn get(&self, index: usize) -> Option<&(Epoch, T)>;
     /// Clear all symbols
     fn clear(&mut self);
     /// New new symbol
-    fn push(&mut self, x_j: (Epoch, (f64, f64, f64)));
+    fn push(&mut self, x_j: (Epoch, T));
     /// Returns internal symbols
-    fn snapshot(&self) -> &[(Epoch, (f64, f64, f64))];
+    fn snapshot(&self) -> &[(Epoch, T)];
     /// Returns true if an interpolation of this order is feasible @ t
     fn feasible(&self, order: usize, t: Epoch) -> bool;
     /// Returns direct output in rare cases where Interpolation is not needed.
     /// This avoids introduction extra bias in the measurement, due to the interpolation process.
-    fn direct_output(&self, t: Epoch) -> Option<&(f64, f64, f64)> {
+    fn direct_output(&self, t: Epoch) -> Option<&T> {
         self.snapshot()
             .iter()
             .filter_map(|(k, v)| if *k == t { Some(v) } else { None })
             .reduce(|k, _| k)
     }
     /// Returns mutable internal symbols
-    fn snapshot_mut(&mut self) -> &mut [(Epoch, (f64, f64, f64))];
+    fn snapshot_mut(&mut self) -> &mut [(Epoch, T)];
     /// Returns latest interval
     fn last_dt(&self) -> Option<(Epoch, Duration)> {
         if self.len() > 1 {
@@ -44,10 +37,9 @@ pub trait Buffer {
         }
     }
     /// Streams data in, in chronological order with gap intolerance.
-    fn fill(&mut self, x_j: (Epoch, (f64, f64, f64))) {
+    fn fill(&mut self, x_j: (Epoch, T)) {
         if let Some((last, dt)) = self.last_dt() {
             if (x_j.0 - last).to_seconds().is_sign_positive() {
-                // NB Should we make gap tolerance more flexible ?
                 if (x_j.0 - last) > dt {
                     warn!("{} - {} gap detected - buffer reset", x_j.0, x_j.0 - last);
                     self.clear();