Improve Frequency and Observable support (#331)

gwbres · web-flow · commit a97521dcf12c · 2025-03-30T13:07:14.000+02:00
Signed-off-by: Guillaume W. Bres &lt;guillaume.bressaix@gmail.com&gt;
diff --git a/src/carrier.rs b/src/carrier.rs
@@ -168,32 +168,61 @@ impl std::str::FromStr for Carrier {
 }
 
 impl Carrier {
-    /// Returns frequency associated to this channel in MHz
+    /// Returns [Carrier] frequency in Hz with 1kHz accuracy.
     pub fn frequency(&self) -> f64 {
         self.frequency_mega_hz() * 1.0E6
     }
 
+    /// Returns [Carrier] frequency in MHz with 1kHz accuracy.
     pub fn frequency_mega_hz(&self) -> f64 {
         match self {
-            Self::L1 | Self::E1 | Self::B1c | Self::B1a => 1575.42_f64,
-            Self::L2 => 1227.60_f64,
-            Self::L5 | Self::E5a | Self::B2a => 1176.45_f64,
-            Self::L6 => 1176.45_f64,
-            Self::E6 => 1278.75_f64,
+            Self::L1 | Self::E1 | Self::B1c | Self::B1a => 1575.420_f64,
+            Self::L2 => 1227.600_f64,
+            Self::L5 | Self::E5a | Self::B2a => 1176.450_f64,
+            Self::L6 => 1176.450_f64,
+            Self::E6 => 1278.750_f64,
             Self::E5b | Self::B2 | Self::B2b => 1207.140_f64,
             Self::E5a5b | Self::B2a2b => 1191.795_f64,
             Self::B1 => 1561.098_f64,
-            Self::B3 | Self::B3a => 1268.52_f64,
+            Self::B3 | Self::B3a => 1268.520_f64,
             Self::S => 2492.028_f64,
             Self::G1a => 1600.995_f64,
-            Self::G1(None) => 1602.0_f64,
-            Self::G1(Some(c)) => 1602.0_f64 + (*c as f64 * 9.0 / 16.0),
-            Self::G2a => 1248.06_f64,
-            Self::G2(None) => 1246.06_f64,
-            Self::G2(Some(c)) => 1246.06_f64 + (*c as f64 * 7.0 / 16.0),
+            Self::G1(None) => 1602.000_f64,
+            Self::G1(Some(c)) => 1602.000_f64 + (*c as f64 * 9.0 / 16.0),
+            Self::G2a => 1248.060_f64,
+            Self::G2(None) => 1246.060_f64,
+            Self::G2(Some(c)) => 1246.060_f64 + (*c as f64 * 7.0 / 16.0),
             Self::G3 => 1202.025_f64,
-            Self::S1 => 2036.25,
-            Self::U2 => 401.25,
+            Self::S1 => 2036.250,
+            Self::U2 => 401.250,
+        }
+    }
+
+    /// Builds [Constellation] [Carrier] frequency from value expressed in MHz.
+    /// This requires a 1kHz accuracy over provided value.
+    pub fn from_frequency_mega_hz(freq_mhz: f64) -> Result<Self, Error> {
+        if freq_mhz.is_sign_negative() {
+            return Err(Error::InvalidFrequency);
+        }
+
+        let freq_khz = (freq_mhz * 1.0E3) as u32;
+
+        match freq_khz {
+            1575_420 => Ok(Self::L1),
+            1227_600 => Ok(Self::L2),
+            1176_450 => Ok(Self::L5),
+            1207_140 => Ok(Self::E5b),
+            1191_795 => Ok(Self::E5a5b),
+            1278_750 => Ok(Self::E6),
+            1561_098 => Ok(Self::B1),
+            1268_520 => Ok(Self::B3),
+            2492_028 => Ok(Self::S),
+            1602_000 => Ok(Self::G1(None)),
+            1600_995 => Ok(Self::G1a),
+            1246_000 => Ok(Self::G2(None)),
+            1248_060 => Ok(Self::G2a),
+            1202_025 => Ok(Self::G3),
+            _ => Err(Error::UnknownFrequency),
         }
     }
 
diff --git a/src/error.rs b/src/error.rs
@@ -188,6 +188,10 @@ pub enum FormattingError {
 /// General error (processing, analysis..)
 #[derive(Debug)]
 pub enum Error {
+    /// Invalid frequency
+    InvalidFrequency,
+    /// Unknown frequency
+    UnknownFrequency,
     /// Non supported GPS [Observable]
     UnknownGPSObservable,
     /// Non supported Galileo [Observable]
@@ -204,4 +208,20 @@ pub enum Error {
     UnknownSBASObservable,
     /// Non supported DORIS [Observable]
     UnknownDORISObservable,
+    /// Unknown GPS Frequency
+    UnknownGPSFrequency,
+    /// Unknown Galileo Frequency
+    UnknownGalileoFrequency,
+    /// Unknown QZSS Frequency
+    UnknownQzssFrequency,
+    /// Unknown Glonass Frequency
+    UnknownGlonassFrequency,
+    /// Unknown BDS Frequency
+    UnknownBDSFrequency,
+    /// Unknown IRNSS Frequency
+    UnknownIRNSSFrequency,
+    /// Unknown SBAS Frequency
+    UnknownSBASFrequency,
+    /// Unknown DORIS Frequency
+    UnknownDORISFrequency,
 }
diff --git a/src/observable.rs b/src/observable.rs
@@ -118,12 +118,145 @@ impl Observable {
         }
     }
 
-    /// Tries to reconstruct a [Carrier] signal from this [Observable].
-    /// This will work if our database knows this [Self::code].
-    pub fn carrier(&self, c: Constellation) -> Result<Carrier, Error> {
+    /// Tries to convert into [Carrier] frequency.
+    pub fn to_carrier(&self, c: Constellation) -> Result<Carrier, Error> {
         Carrier::from_observable(c, self)
     }
 
+    /// Tries to create a Pseudo Range [Observable] from
+    /// provided signal frequency in MHz and provided [Constellation].
+    /// This requires a 1kHz accuracy on given frequency.
+    pub fn from_pseudo_range_frequency_mega_hz(
+        constellation: Constellation,
+        freq_mhz: f64,
+    ) -> Result<Self, Error> {
+        let carrier = Carrier::from_frequency_mega_hz(freq_mhz)?;
+
+        match constellation {
+            Constellation::GPS => match carrier {
+                Carrier::L1 => return Ok(Self::PseudoRange("C1C".to_string())),
+                Carrier::L2 => return Ok(Self::PseudoRange("C2C".to_string())),
+                Carrier::L5 => return Ok(Self::PseudoRange("C5X".to_string())),
+                _ => return Err(Error::UnknownGPSFrequency),
+            },
+            Constellation::Galileo => match carrier {
+                Carrier::L1 => return Ok(Self::PseudoRange("C1C".to_string())),
+                Carrier::L5 => return Ok(Self::PseudoRange("C5X".to_string())),
+                Carrier::E6 => return Ok(Self::PseudoRange("C6X".to_string())),
+                Carrier::E5b => return Ok(Self::PseudoRange("C7X".to_string())),
+                Carrier::E5a5b => return Ok(Self::PseudoRange("C8X".to_string())),
+                _ => return Err(Error::UnknownGalileoFrequency),
+            },
+            Constellation::QZSS => match carrier {
+                Carrier::L1 => return Ok(Self::PseudoRange("C1C".to_string())),
+                Carrier::L2 => return Ok(Self::PseudoRange("C2X".to_string())),
+                Carrier::L5 => return Ok(Self::PseudoRange("C5X".to_string())),
+                Carrier::E6 => return Ok(Self::PseudoRange("C6X".to_string())),
+                _ => return Err(Error::UnknownQzssFrequency),
+            },
+            Constellation::BeiDou => match carrier {
+                Carrier::B1 => return Ok(Self::PseudoRange("C2X".to_string())),
+                Carrier::L1 => return Ok(Self::PseudoRange("C1X".to_string())),
+                Carrier::L5 => return Ok(Self::PseudoRange("C5X".to_string())),
+                Carrier::E5b => return Ok(Self::PseudoRange("C7X".to_string())),
+                Carrier::E5a5b => return Ok(Self::PseudoRange("C8X".to_string())),
+                Carrier::B3 => return Ok(Self::PseudoRange("C6X".to_string())),
+                _ => return Err(Error::UnknownBDSFrequency),
+            },
+            Constellation::Glonass => match carrier {
+                Carrier::G1(_) => return Ok(Self::PseudoRange("C1C".to_string())),
+                Carrier::G2(_) => return Ok(Self::PseudoRange("C2X".to_string())),
+                Carrier::G3 => return Ok(Self::PseudoRange("C3X".to_string())),
+                Carrier::G1a => return Ok(Self::PseudoRange("C4X".to_string())),
+                Carrier::G2a => return Ok(Self::PseudoRange("C6X".to_string())),
+                _ => return Err(Error::UnknownGlonassFrequency),
+            },
+            Constellation::IRNSS => match carrier {
+                Carrier::L5 => return Ok(Self::PseudoRange("C5X".to_string())),
+                Carrier::S => return Ok(Self::PseudoRange("C9X".to_string())),
+                _ => return Err(Error::UnknownIRNSSFrequency),
+            },
+            _ => {},
+        }
+
+        if constellation.is_sbas() {
+            match carrier {
+                Carrier::L1 => Ok(Self::PseudoRange("C1C".to_string())),
+                Carrier::L5 => Ok(Self::PseudoRange("C5X".to_string())),
+                _ => Err(Error::UnknownSBASFrequency),
+            }
+        } else {
+            Err(Error::UnknownFrequency)
+        }
+    }
+
+    /// Tries to create a Phase Range [Observable] from
+    /// provided signal frequency in MHz and provided [Constellation].
+    /// This requires a 1kHz accuracy on given frequency.
+    pub fn from_phase_range_frequency_mega_hz(
+        constellation: Constellation,
+        freq_mhz: f64,
+    ) -> Result<Self, Error> {
+        let carrier = Carrier::from_frequency_mega_hz(freq_mhz)?;
+
+        match constellation {
+            Constellation::GPS => match carrier {
+                Carrier::L1 => return Ok(Self::PhaseRange("L1C".to_string())),
+                Carrier::L2 => return Ok(Self::PhaseRange("L2C".to_string())),
+                Carrier::L5 => return Ok(Self::PhaseRange("L5X".to_string())),
+                _ => return Err(Error::UnknownGPSFrequency),
+            },
+            Constellation::Galileo => match carrier {
+                Carrier::L1 => return Ok(Self::PhaseRange("L1C".to_string())),
+                Carrier::L5 => return Ok(Self::PhaseRange("L5X".to_string())),
+                Carrier::E6 => return Ok(Self::PhaseRange("L6X".to_string())),
+                Carrier::E5b => return Ok(Self::PhaseRange("L7X".to_string())),
+                Carrier::E5a5b => return Ok(Self::PhaseRange("L8X".to_string())),
+                _ => return Err(Error::UnknownGalileoFrequency),
+            },
+            Constellation::QZSS => match carrier {
+                Carrier::L1 => return Ok(Self::PhaseRange("L1C".to_string())),
+                Carrier::L2 => return Ok(Self::PhaseRange("L2X".to_string())),
+                Carrier::L5 => return Ok(Self::PhaseRange("L5X".to_string())),
+                Carrier::E6 => return Ok(Self::PhaseRange("L6X".to_string())),
+                _ => return Err(Error::UnknownQzssFrequency),
+            },
+            Constellation::BeiDou => match carrier {
+                Carrier::B1 => return Ok(Self::PhaseRange("L2X".to_string())),
+                Carrier::L1 => return Ok(Self::PhaseRange("L1X".to_string())),
+                Carrier::L5 => return Ok(Self::PhaseRange("L5X".to_string())),
+                Carrier::E5b => return Ok(Self::PhaseRange("L7X".to_string())),
+                Carrier::E5a5b => return Ok(Self::PhaseRange("L8X".to_string())),
+                Carrier::B3 => return Ok(Self::PhaseRange("L6X".to_string())),
+                _ => return Err(Error::UnknownBDSFrequency),
+            },
+            Constellation::Glonass => match carrier {
+                Carrier::G1(_) => return Ok(Self::PhaseRange("L1C".to_string())),
+                Carrier::G2(_) => return Ok(Self::PhaseRange("L2X".to_string())),
+                Carrier::G3 => return Ok(Self::PhaseRange("L3X".to_string())),
+                Carrier::G1a => return Ok(Self::PhaseRange("L4X".to_string())),
+                Carrier::G2a => return Ok(Self::PhaseRange("L6X".to_string())),
+                _ => return Err(Error::UnknownGlonassFrequency),
+            },
+            Constellation::IRNSS => match carrier {
+                Carrier::L5 => return Ok(Self::PhaseRange("L5X".to_string())),
+                Carrier::S => return Ok(Self::PhaseRange("L9X".to_string())),
+                _ => return Err(Error::UnknownIRNSSFrequency),
+            },
+            _ => {},
+        }
+
+        if constellation.is_sbas() {
+            match carrier {
+                Carrier::L1 => Ok(Self::PhaseRange("L1C".to_string())),
+                Carrier::L5 => Ok(Self::PhaseRange("L5X".to_string())),
+                _ => Err(Error::UnknownSBASFrequency),
+            }
+        } else {
+            Err(Error::UnknownFrequency)
+        }
+    }
+
     /// Returns the code length (repetition period), expressed in seconds,
     /// of self: a valid Pseudo Range observable. This is not intended to be used
     /// on phase observables, although they are also determined from PRN codes.
@@ -313,7 +446,7 @@ impl Observable {
     /// used in signal combinations
     pub(crate) fn is_l1_pivot(&self, constellation: Constellation) -> bool {
         if self.is_phase_range_observable() || self.is_pseudo_range_observable() {
-            if let Ok(carrier) = self.carrier(constellation) {
+            if let Ok(carrier) = self.to_carrier(constellation) {
                 matches!(
                     carrier,
                     Carrier::L1
diff --git a/src/observation/parsing.rs b/src/observation/parsing.rs
@@ -384,11 +384,6 @@ fn parse_signals_v2(
                     Ok(unsigned) => {
                         lli = LliFlags::from_bits(unsigned);
                     },
-                    #[cfg(feature = "log")]
-                    Err(e) => {
-                        //error!("parse_sig(v2) - lli: {}", e);
-                    },
-                    #[cfg(not(feature = "log"))]
                     Err(_) => {},
                 }
             }
diff --git a/src/observation/rinex/feature.rs b/src/observation/rinex/feature.rs
@@ -312,7 +312,7 @@ impl Rinex {
 
                 let is_l1_pivot = v.observable.is_l1_pivot(v.sv.constellation);
 
-                let carrier = v.observable.carrier(v.sv.constellation);
+                let carrier = v.observable.to_carrier(v.sv.constellation);
                 if carrier.is_err() {
                     continue;
                 }
@@ -437,7 +437,7 @@ impl Rinex {
         for (k, v) in self.signal_observations_iter() {
             let is_ph = v.observable.is_phase_range_observable();
             let is_pr = v.observable.is_pseudo_range_observable();
-            let carrier = v.observable.carrier(v.sv.constellation);
+            let carrier = v.observable.to_carrier(v.sv.constellation);
 
             if !is_ph && !is_pr || carrier.is_err() {
                 continue;
diff --git a/src/observation/signal.rs b/src/observation/signal.rs
@@ -86,8 +86,8 @@ impl SignalObservation {
 
         let both_phase = phase_1 && phase_2;
 
-        let carrier_1 = self.observable.carrier(self.sv.constellation);
-        let carrier_2 = rhs.observable.carrier(self.sv.constellation);
+        let carrier_1 = self.observable.to_carrier(self.sv.constellation);
+        let carrier_2 = rhs.observable.to_carrier(self.sv.constellation);
 
         let both_ok = carrier_1.is_ok() && carrier_2.is_ok();
 

Original file line number	Diff line number	Diff line change
`@@ -384,11 +384,6 @@ fn parse_signals_v2(`
`384`	`384`	`Ok(unsigned) => {`
`385`	`385`	`lli = LliFlags::from_bits(unsigned);`
`386`	`386`	`},`
`387`		`- #[cfg(feature = "log")]`
`388`		`- Err(e) => {`
`389`		`- //error!("parse_sig(v2) - lli: {}", e);`
`390`		`- },`
`391`		`- #[cfg(not(feature = "log"))]`
`392`	`387`	`Err(_) => {},`
`393`	`388`	`}`
`394`	`389`	`}`