NAV (V2, V3, Partial V4) formatting (#328)

* Navgation (ephemeris) frames formatting
* NAV (V2) validated
* NAV (V3) validated
* Ionospheric terms validated

---------

Signed-off-by: Guillaume W. Bres <[email protected]>

Author: gwbres

data

@@ -173,6 +173,8 @@ pub enum FormattingError {
     OutputError(#[from] IoError),
     #[error("missing constellation information")]
     NoConstellationDefinition,
+    #[error("missing navigation standard specs")]
+    MissingNavigationStandards,
     #[error("undefined observables")]
     UndefinedObservables,
     #[error("missing observable definition")]

src/error.rs

@@ -1,5 +1,7 @@
 //! RINEX header formatting
 
+use gnss::constellation;
+
 use crate::{
     fmt_comment, fmt_rinex,
     header::Header,
@@ -14,6 +16,8 @@ impl Header {
     pub fn format<W: Write>(&self, w: &mut BufWriter<W>) -> Result<(), FormattingError> {
         const NUM_GLO_CHANNELS_PER_LINE: usize = 8;
 
+        let major = self.version.major;
+
         if let Some(obs) = &self.obs {
             if let Some(crinex) = &obs.crinex {
                 crinex.format(w)?;
@@ -92,6 +96,21 @@ impl Header {
             )?;
         }
 
+        // KB model
+        for (index, (constellation, model)) in self.ionod_corrections.iter().enumerate() {
+            if let Some(kb) = model.as_klobuchar() {
+                if major == 2 && index == 0 {
+                    kb.format_v2_header(w)?;
+                } else if major == 3 {
+                    kb.format_v3_header(w, *constellation)?;
+                }
+            } else if let Some(ng) = model.as_nequick_g() {
+                if major == 3 {
+                    ng.format_header(w, constellation)?;
+                }
+            }
+        }
+
         //TODO
         // things that could be nice to squeeze in:
         // [+] SBAS detail (detailed vehicle identity)

src/header/formatting.rs

@@ -95,11 +95,12 @@ use flate2::{read::GzDecoder, write::GzEncoder, Compression as GzCompression};
 #[cfg(feature = "clock")]
 use std::collections::BTreeMap;
 
-use epoch::epoch_decompose;
-use hatanaka::CRINEX;
-use observable::Observable;
-
-use production::{DataSource, DetailedProductionAttributes, ProductionAttributes, FFU, PPU};
+use crate::{
+    epoch::epoch_decompose,
+    hatanaka::CRINEX,
+    observable::Observable,
+    production::{DataSource, DetailedProductionAttributes, ProductionAttributes, FFU, PPU},
+};
 
 /// Package to include all basic structures
 pub mod prelude {

src/lib.rs

@@ -0,0 +1,126 @@
+//! Ephemeris message formatting
+use crate::{
+    navigation::{
+        formatting::NavFormatter, orbits::closest_nav_standards, Ephemeris, NavMessageType,
+    },
+    prelude::{Constellation, SV},
+    FormattingError, Version,
+};
+
+use std::io::{BufWriter, Write};
+
+impl Ephemeris {
+    /// Formats [Ephemeris] according to RINEX standards
+    pub(crate) fn format<W: Write>(
+        &self,
+        w: &mut BufWriter<W>,
+        sv: SV,
+        version: Version,
+        msgtype: NavMessageType,
+    ) -> Result<(), FormattingError> {
+        let sv_constellation = if sv.constellation.is_sbas() {
+            Constellation::SBAS
+        } else {
+            sv.constellation
+        };
+
+        // retrieve standard specs
+        let standard_specs = match closest_nav_standards(sv_constellation, version, msgtype) {
+            Some(specs) => specs,
+            None => {
+                return Err(FormattingError::MissingNavigationStandards);
+            },
+        };
+
+        // starts with (clock_bias, drift, rate)
+        // epoch has already been buffered
+        write!(
+            w,
+            "{}{}{}",
+            NavFormatter::new(self.clock_bias),
+            NavFormatter::new(self.clock_drift),
+            NavFormatter::new(self.clock_drift_rate),
+        )?;
+
+        // following standard specs
+        let data_fields = &standard_specs.items;
+        for i in 0..data_fields.len() {
+            if let Some(value) = self.get_orbit_f64(data_fields[i].0) {
+                if i % 4 == 0 {
+                    write!(w, "\n   {}", NavFormatter::new(value))?;
+                } else {
+                    write!(w, "{}", NavFormatter::new(value))?;
+                }
+            } else {
+                if i % 4 == 0 {
+                    write!(w, "\n   {}", NavFormatter::new(0.0))?;
+                } else {
+                    write!(w, "{}", NavFormatter::new(0.0))?;
+                }
+            }
+        }
+
+        write!(w, "\n")?;
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod test {
+
+    use crate::navigation::{Ephemeris, NavMessageType, OrbitItem};
+    use crate::prelude::{Version, SV};
+
+    use std::io::BufWriter;
+    use std::str::FromStr;
+
+    use crate::tests::formatting::Utf8Buffer;
+
+    #[test]
+    fn test_value_formatter() {}
+
+    #[test]
+    fn ephemeris_formatting() {
+        let g01 = SV::from_str("G01").unwrap();
+        let version = Version::from_str("2.0").unwrap();
+        let msgtype = NavMessageType::LNAV;
+
+        let ephemeris = Ephemeris {
+            clock_bias: -1.0e-4,
+            clock_drift: -2.0e-11,
+            clock_drift_rate: 0.0,
+            orbits: [
+                ("iode".to_string(), OrbitItem::F64(1.0)),
+                ("crs".to_string(), OrbitItem::F64(2.0)),
+                ("deltaN".to_string(), OrbitItem::F64(3.0)),
+                ("4".to_string(), OrbitItem::F64(4.0)),
+                ("cuc".to_string(), OrbitItem::F64(5.0)),
+            ]
+            .into_iter()
+            .collect(),
+        };
+
+        let utf8 = Utf8Buffer::new(1024);
+        let mut writer = BufWriter::new(utf8);
+
+        ephemeris
+            .format(&mut writer, g01, version, msgtype)
+            .unwrap();
+
+        let inner = writer.into_inner().unwrap();
+
+        let utf8 = inner.to_ascii_utf8();
+
+        assert_eq!(
+            utf8,
+            "-1.000000000000E-04-2.000000000000E-11 0.000000000000E+00
+    1.000000000000E+00 2.000000000000E+00 3.000000000000E+00 0.000000000000E+00
+    5.000000000000E+00 0.000000000000E+00 0.000000000000E+00 0.000000000000E+00
+    0.000000000000E+00 0.000000000000E+00 0.000000000000E+00 0.000000000000E+00
+    0.000000000000E+00 0.000000000000E+00 0.000000000000E+00 0.000000000000E+00
+    0.000000000000E+00 0.000000000000E+00 0.000000000000E+00 0.000000000000E+00
+    0.000000000000E+00 0.000000000000E+00 0.000000000000E+00 0.000000000000E+00
+    0.000000000000E+00 0.000000000000E+00\n"
+        );
+    }
+}

src/navigation/ephemeris/formatting.rs

@@ -1,3 +1,4 @@
+mod formatting;
 mod parsing;
 
 #[cfg(feature = "log")]