Changeset 11041 in ntrip for trunk

Timestamp:

Sep 22, 2026, 4:08:55 PM (6 hours ago)

Author:

stuerze

Message:

updates regarding RTCM-SSR

Location:

trunk/BNC/src

Files:

• PPP/pppClient.cpp (modified) (1 diff)
• PPP/pppClient.h (modified) (1 diff)
• PPP/pppObsPool.cpp (modified) (3 diffs)
• PPP/pppObsPool.h (modified) (3 diffs)
• PPP/pppSatObs.cpp (modified) (5 diffs)
• PPP/pppSatObs.h (modified) (2 diffs)
• RTCM3/RTCM3coDecoder.cpp (modified) (1 diff)
• RTCM3/clock_and_orbit/clock_orbit.h (modified) (1 diff)
• RTCM3/clock_and_orbit/clock_orbit_igs.cpp (modified) (1 diff)
• RTCM3/clock_and_orbit/clock_orbit_igs.h (modified) (1 diff)
• RTCM3/clock_and_orbit/clock_orbit_rtcm.cpp (modified) (1 diff)
• RTCM3/clock_and_orbit/clock_orbit_rtcm.h (modified) (1 diff)
• RTCM3/clock_and_orbit/clock_orbit_rtcm_new.cpp (modified) (1 diff)
• RTCM3/clock_and_orbit/clock_orbit_rtcm_new.h (modified) (1 diff)
• pppRun.cpp (modified) (3 diffs)
• pppRun.h (modified) (1 diff)
• satObs.cpp (modified) (2 diffs)
• satObs.h (modified) (1 diff)

trunk/BNC/src/PPP/pppClient.cpp

@@ -157 +157 @@
     }
     _obsPool->putCodeBias(newBias);
+  }
+}
+
+//
+//////////////////////////////////////////////////////////////////////////////
+void t_pppClient::putSatAntennas(const vector<t_satAntenna*>& satAntennas) {
+  if (OPT->_logMode == t_pppOptions::normal && satAntennas.size() > 0) {
+    LOG << "satAntennas    " << string(satAntennas[0]->_time) << ' ' << satAntennas.size() << endl;
+  }
+  for (unsigned ii = 0; ii < satAntennas.size(); ii++) {
+    _obsPool->putSatAntenna(new t_satAntenna(*satAntennas[ii]));
   }
 }

trunk/BNC/src/PPP/pppClient.h

@@ -33 +33 @@
   void putCodeBiases(const std::vector<t_satCodeBias*>& biases);
   void putPhaseBiases(const std::vector<t_satPhaseBias*>& biases);
+  void putSatAntennas(const std::vector<t_satAntenna*>& satAntennas);
   void processEpoch(const std::vector<t_satObs*>& satObs, t_output* output);
 

trunk/BNC/src/PPP/pppObsPool.cpp

@@ -51 +51 @@
     _satPhaseBiases[ii] = 0;
   }
+  for (unsigned ii = 0; ii <= t_prn::MAXPRN; ii++) {
+    _satAntennas[ii] = 0;
+  }
   _vTec = 0;
   _metaData = 0;
@@ -63 +66 @@
   for (unsigned ii = 0; ii <= t_prn::MAXPRN; ii++) {
     delete _satPhaseBiases[ii];
+  }
+  for (unsigned ii = 0; ii <= t_prn::MAXPRN; ii++) {
+    delete _satAntennas[ii];
   }
   delete _vTec;
@@ -110 +116 @@
     LOG << endl;
   }
+}
+
+//
+/////////////////////////////////////////////////////////////////////////////
+void t_pppObsPool::putSatAntenna(t_satAntenna* satAntenna) {
+  int iPrn = satAntenna->_prn.toInt();
+  delete _satAntennas[iPrn];
+  _satAntennas[iPrn] = satAntenna;
 }
 

trunk/BNC/src/PPP/pppObsPool.h

@@ -32 +32 @@
   void putCodeBias(t_satCodeBias* satCodeBias);
   void putPhaseBias(t_satPhaseBias* satPhaseBias);
+  void putSatAntenna(t_satAntenna* satAntenna);
   void putTec(t_vTec* _vTec);
   void putMetaData(t_metaData* metaData);
@@ -45 +46 @@
   const t_satPhaseBias* satPhaseBias(const t_prn& prn) const {
     return _satPhaseBiases[prn.toInt()];
+  }
+  const t_satAntenna* satAntenna(const t_prn& prn) const {
+    return _satAntennas[prn.toInt()];
   }
   const t_vTec* vTec() const {return _vTec;}
@@ -61 +65 @@
   t_satCodeBias*           _satCodeBiases[t_prn::MAXPRN+1];
   t_satPhaseBias*          _satPhaseBiases[t_prn::MAXPRN+1];
+  t_satAntenna*            _satAntennas[t_prn::MAXPRN+1];
   t_vTec*                  _vTec;
   t_metaData*              _metaData;

trunk/BNC/src/PPP/pppSatObs.cpp

@@ -400 +400 @@
 
 
+// A system's Satellite Antenna message is only trustworthy once the
+// provider has confirmed it via Metadata: SatelliteAntennaIOD (DF+010) must
+// be non-zero, and must match the Data IOD (DF+069) of a Metadata entry for
+// model-correction type 1 (satellite antenna PCV) or type 2 (GDV) - either
+// entry matching is sufficient. Metadata carries this IOD once globally, not
+// per system (DF+010 is GNSS-specific, DF+069 is not), so the same Metadata
+// entries are reused as the trust anchor for every system's check - the
+// provider is relied on to keep DF+010 synchronized with DF+069 across all
+// systems for this to work.
+////////////////////////////////////////////////////////////////////////////
+static bool ssrSatAntennaTrusted(const t_satAntenna* satAntenna) {
+  if (!satAntenna || satAntenna->_satelliteAntennaIOD == 0) {
+    return false;
+  }
+  const t_metaData* metaData = PPP_CLIENT->obsPool()->metaData();
+  if (!metaData) {
+    return false;
+  }
+  for (unsigned ii = 0; ii < metaData->_entries.size(); ii++) {
+    const t_metaDataEntry& entry = metaData->_entries[ii];
+    if ((entry._typeIndicator == 1 || entry._typeIndicator == 2) && // PCV or GDV
+        entry._dataIODIndicator &&
+        entry._dataIOD == satAntenna->_satelliteAntennaIOD) {
+      return true;
+    }
+  }
+  return false;
+}
+
+// Satellite antenna correction (offset + nadir-angle-dependent PCV) from a
+// live SSR Satellite Antenna message, in the same additive sense as
+// bncAntex::satCorr(). Returns false (corr untouched) if no trusted SSR data
+// is available for this PRN/frequency (see ssrSatAntennaTrusted), so the
+// caller falls back to the static ANTEX file.
+////////////////////////////////////////////////////////////////////////////
+static bool ssrSatAntennaCorr(const t_satAntenna* satAntenna, const string& frqStr,
+                               double elTx, double& corr) {
+  if (!satAntenna) {
+    return false;
+  }
+  for (unsigned ii = 0; ii < satAntenna->_freq.size(); ii++) {
+    const t_frqAntenna& frq = satAntenna->_freq[ii];
+    if (frq._frqType != frqStr) {
+      continue;
+    }
+    corr = 0.0;
+    if (frq._nadirCorrectionIndicator) {
+      corr += frq._nadirCorrection;
+    }
+    if (!frq._nadirAngleCorrection.empty()) {
+      // 1-degree bins starting at nadir (0 deg), per RTCM-SSR spec
+      double nadirDeg = 90.0 - elTx * 180.0 / M_PI;
+      int    idx      = int(nadirDeg + 0.5);
+      if (idx < 0) {
+        idx = 0;
+      }
+      else if (idx >= (int)frq._nadirAngleCorrection.size()) {
+        idx = (int)frq._nadirAngleCorrection.size() - 1;
+      }
+      corr += frq._nadirAngleCorrection[idx];
+    }
+    return true;
+  }
+  return false;
+}
+
 //
 ////////////////////////////////////////////////////////////////////////////
@@ -476 +542 @@
   // -------------------------------------------
   if (PPP_CLIENT->antex()) {
+    const t_satAntenna* satAntenna = PPP_CLIENT->obsPool()->satAntenna(_prn);
+    if (!ssrSatAntennaTrusted(satAntenna)) {
+      satAntenna = 0; // untrusted (IOD zero, or not confirmed via Metadata) - fall back to ANTEX
+    }
     for (unsigned ii = 0; ii < t_frequency::max; ii++) {
       t_frequency::type frqType = static_cast<t_frequency::type>(ii);
@@ -482 +552 @@
       bool found;
       QString prn(_prn.toString().c_str());
-      _model._antPCO[ii]  = PPP_CLIENT->antex()->rcvCorr(station->antName(), frqType, _model._eleSat, _model._azSat, found);
-      _model._antPCO[ii] += PPP_CLIENT->antex()->satCorr(prn, frqType, _model._elTx, _model._azTx, found);
-      if (OPT->_isAPC && found) {
-        // the PCOs as given in the satellite antenna correction for all frequencies
-        // have to be reduced by the PCO of the respective reference frequency
-        if      (_prn.system() == 'G') {
-          _model._antPCO[ii] -= PPP_CLIENT->antex()->satCorr(prn, t_frequency::G1, _model._elTx, _model._azTx, found);
+      _model._antPCO[ii] = PPP_CLIENT->antex()->rcvCorr(station->antName(), frqType, _model._eleSat, _model._azSat, found);
+
+      // Prefer a live, trusted SSR Satellite Antenna correction over the
+      // static ANTEX file when available for this satellite/frequency,
+      // mirroring how SSR orbit/clock corrections already take precedence
+      // over broadcast ephemerides elsewhere in this codebase. Unlike
+      // ANTEX's satCorr() (a single geometric PCO/PCV value shared by code
+      // and phase alike), the SSR message's DF+011/DF+012 indicators say
+      // explicitly which observable(s) the correction applies to, so it is
+      // routed into the dedicated phase-only/code-only fields instead of
+      // the shared _antPCO - both may fire for the same ssrCorr value if
+      // both indicators are set.
+      double ssrCorr;
+      if (ssrSatAntennaCorr(satAntenna, frqStr, _model._elTx, ssrCorr)) {
+        if (satAntenna->_phaseCenterInfoInd) {
+          _model._antPCV[ii] += ssrCorr;
         }
-        else if (_prn.system() == 'R') {
-          _model._antPCO[ii] -= PPP_CLIENT->antex()->satCorr(prn, t_frequency::R1, _model._elTx, _model._azTx, found);
+        if (satAntenna->_groupDelayInfoInd) {
+          _model._antGDV[ii] += ssrCorr;
         }
-        else if (_prn.system() == 'E') {
-          _model._antPCO[ii] -= PPP_CLIENT->antex()->satCorr(prn, t_frequency::E1, _model._elTx, _model._azTx, found);
-        }
-        else if (_prn.system() == 'C') {
-          _model._antPCO[ii] -= PPP_CLIENT->antex()->satCorr(prn, t_frequency::C2, _model._elTx, _model._azTx, found);
+      }
+      else {
+        _model._antPCO[ii] += PPP_CLIENT->antex()->satCorr(prn, frqType, _model._elTx, _model._azTx, found);
+        if (OPT->_isAPC && found) {
+          // the PCOs as given in the satellite antenna correction for all frequencies
+          // have to be reduced by the PCO of the respective reference frequency
+          if      (_prn.system() == 'G') {
+            _model._antPCO[ii] -= PPP_CLIENT->antex()->satCorr(prn, t_frequency::G1, _model._elTx, _model._azTx, found);
+          }
+          else if (_prn.system() == 'R') {
+            _model._antPCO[ii] -= PPP_CLIENT->antex()->satCorr(prn, t_frequency::R1, _model._elTx, _model._azTx, found);
+          }
+          else if (_prn.system() == 'E') {
+            _model._antPCO[ii] -= PPP_CLIENT->antex()->satCorr(prn, t_frequency::E1, _model._elTx, _model._azTx, found);
+          }
+          else if (_prn.system() == 'C') {
+            _model._antPCO[ii] -= PPP_CLIENT->antex()->satCorr(prn, t_frequency::C2, _model._elTx, _model._azTx, found);
+          }
         }
       }
@@ -645 +737 @@
       if (_prn.system() == frqStr[0]) {
       LOG << "PCO           : " << frqStr << setw(12) << setprecision(3) << _model._antPCO[iFreq]       << endl
+          << "SSR PCV       : " << frqStr << setw(12) << setprecision(3) << _model._antPCV[iFreq]       << endl
+          << "SSR GDV       : " << frqStr << setw(12) << setprecision(3) << _model._antGDV[iFreq]       << endl
           << "BIAS CODE     : " << frqStr << setw(12) << setprecision(3) << _model._codeBias[iFreq]     << "\t(" << _obs[iFreq]->trkChar() << ") " << endl
           << "BIAS PHASE    : " << frqStr << setw(12) << setprecision(3) << _model._phaseBias[iFreq]    << "\t(" << _obs[iFreq]->trkChar() << ") " << endl
@@ -704 +798 @@
     for (it = codeCoeff.begin(); it != codeCoeff.end(); it++) {
       t_frequency::type tFreq = it->first;
-      dispPart += it->second * (_model._antPCO[tFreq] - _model._codeBias[tFreq]);
+      dispPart += it->second * (_model._antPCO[tFreq] + _model._antGDV[tFreq] - _model._codeBias[tFreq]);
     }
     for (it = phaseCoeff.begin(); it != phaseCoeff.end(); it++) {
       t_frequency::type tFreq = it->first;
-      dispPart += it->second * (_model._antPCO[tFreq] - _model._phaseBias[tFreq] +
+      dispPart += it->second * (_model._antPCO[tFreq] + _model._antPCV[tFreq] - _model._phaseBias[tFreq] +
                                 _model._windUp * t_CST::lambda(tFreq, _channel));
     }

trunk/BNC/src/PPP/pppSatObs.h

@@ -109 +109 @@
         for (unsigned ii = 0; ii < t_frequency::max; ii++) {
           _antPCO[ii]        = 0.0;
+          _antPCV[ii]        = 0.0;
+          _antGDV[ii]        = 0.0;
           _codeBias[ii]      = 0.0;
           _phaseBias[ii]     = 0.0;
@@ -130 +132 @@
       double _windUp;
       double _rel;
-      double _antPCO[t_frequency::max];
+      double _antPCO[t_frequency::max]; // ANTEX-sourced, shared code+phase (geometric PCO/PCV)
+      double _antPCV[t_frequency::max]; // SSR-sourced, phaserange only (DF+011 Phase Center indicator)
+      double _antGDV[t_frequency::max]; // SSR-sourced, pseudorange only (DF+012 Group Delay indicator)
       double _codeBias[t_frequency::max];
       double _phaseBias[t_frequency::max];

trunk/BNC/src/RTCM3/RTCM3coDecoder.cpp

@@ -702 +702 @@
           }
           t_frqAntenna frqAntenna;
-          frqAntenna._freqIndex                = f;
+          frqAntenna._frqType = _ssrCorr->antFreqIndexToStr(si.sysChar, f);
+          if (frqAntenna._frqType.empty()) {
+            continue; // reserved/unmapped DF+018 bit position
+          }
           frqAntenna._nadirCorrectionIndicator = satPart.Freq[f].NadirCorrectionIndicator;
           frqAntenna._nadirCorrection          = satPart.Freq[f].NadirCorrection;

trunk/BNC/src/RTCM3/clock_and_orbit/clock_orbit.h

@@ -516 +516 @@
   virtual std::string codeTypeToRnxType(char system, CodeType type) = 0;
   virtual CodeType rnxTypeToCodeType(char system, std::string type) = 0;
+  /* DF+018 GNSS Frequency Mask bit position (0-based) -> t_frequency::type
+     label (e.g. "G1", "R2", "E7"), per system. Returns "" for a reserved/
+     unmapped bit position. */
+  virtual std::string antFreqIndexToStr(char system, unsigned int freqIndex) = 0;
 
 

trunk/BNC/src/RTCM3/clock_and_orbit/clock_orbit_igs.cpp

@@ -937 +937 @@
 }
 
+//
+////////////////////////////////////////////////////////////////////////////
+std::string SsrCorrIgs::antFreqIndexToStr(char, unsigned int) {
+  // This format does not decode Satellite Antenna message content; only
+  // present to satisfy SsrCorr's interface.
+  return "";
+}
+

trunk/BNC/src/RTCM3/clock_and_orbit/clock_orbit_igs.h

@@ -219 +219 @@
    std::string metaTypeToStr(unsigned int ind);
    std::string codeTypeToRnxType(char system, CodeType type);
+   std::string antFreqIndexToStr(char system, unsigned int freqIndex);
    SsrCorr::CodeType rnxTypeToCodeType(char system, std::string type);
 

trunk/BNC/src/RTCM3/clock_and_orbit/clock_orbit_rtcm.cpp

@@ -1391 +1391 @@
 }
 
+//
+////////////////////////////////////////////////////////////////////////////
+std::string SsrCorrRtcm::antFreqIndexToStr(char, unsigned int) {
+  // Satellite Antenna messages are not defined in (old) RTCM-SSR; only
+  // present to satisfy SsrCorr's interface.
+  return "";
+}
+

trunk/BNC/src/RTCM3/clock_and_orbit/clock_orbit_rtcm.h

@@ -218 +218 @@
   std::string metaTypeToStr(unsigned int ind);
   std::string codeTypeToRnxType(char system, CodeType type);
+  std::string antFreqIndexToStr(char system, unsigned int freqIndex);
   SsrCorr::CodeType rnxTypeToCodeType(char system, std::string type);
 

trunk/BNC/src/RTCM3/clock_and_orbit/clock_orbit_rtcm_new.cpp

@@ -1410 +1410 @@
   return "reserved!";
 }
+
+//
+////////////////////////////////////////////////////////////////////////////
+std::string SsrCorrRtcmNew::antFreqIndexToStr(char system, unsigned int freqIndex) {
+  switch (system) {
+  case 'G':
+    if (freqIndex == 0) return "G1";
+    if (freqIndex == 1) return "G2";
+    if (freqIndex == 2) return "G5";
+    break;
+  case 'R':
+    if (freqIndex == 0) return "R1";
+    if (freqIndex == 1) return "R2";
+    break;
+  case 'E':
+    if (freqIndex == 0) return "E1";
+    if (freqIndex == 1) return "E6";
+    if (freqIndex == 2) return "E7";
+    if (freqIndex == 3) return "E8";
+    if (freqIndex == 4) return "E5";
+    break;
+  case 'J':
+    if (freqIndex == 0) return "J1";
+    if (freqIndex == 1) return "J6";
+    if (freqIndex == 2) return "J2";
+    if (freqIndex == 3) return "J5";
+    break;
+  case 'C':
+    if (freqIndex == 0) return "C2"; // B1
+    if (freqIndex == 1) return "C6"; // B3
+    if (freqIndex == 2) return "C7"; // B2
+    if (freqIndex == 3) return "C5"; // B2a
+    if (freqIndex == 4) return "C7"; // B2b (same t_frequency::type as B2)
+    if (freqIndex == 5) return "C1"; // B1C
+    break;
+  }
+  return ""; // reserved / unmapped bit position
+}

trunk/BNC/src/RTCM3/clock_and_orbit/clock_orbit_rtcm_new.h

@@ -273 +273 @@
   std::string codeTypeToRnxType(char system, CodeType type);
   SsrCorr::CodeType rnxTypeToCodeType(char system, std::string type);
+  std::string antFreqIndexToStr(char system, unsigned int freqIndex);
 
   size_t MakeClockOrbit(const struct ClockOrbit *co, ClockOrbitType type, int moremessagesfollow, char *buffer, size_t size);

trunk/BNC/src/pppRun.cpp

@@ -119 +119 @@
     connect(BNC_CORE, SIGNAL(newPhaseBiases(QList<t_satPhaseBias>)),
             this, SLOT(slotNewPhaseBiases(QList<t_satPhaseBias>)),conType);
+
+    connect(BNC_CORE, SIGNAL(newSatAntennas(QList<t_satAntenna>)),
+            this, SLOT(slotNewSatAntennas(QList<t_satAntenna>)),conType);
 
     connect(BNC_CMB, SIGNAL(newOrbCorrections(QList<t_orbCorr>)),
@@ -567 +570 @@
 //
 ////////////////////////////////////////////////////////////////////////////
+void t_pppRun::slotNewSatAntennas(QList<t_satAntenna> satAntennas) {
+  if (satAntennas.size() == 0) {
+    return;
+  }
+
+  if (_opt->_realTime) {
+    if (_opt->_corrMount.empty() && _opt->_biasMount.empty()) {
+      return;
+    }
+    if      (!_opt->_biasMount.empty()) {
+      if (_opt->_biasMount != satAntennas[0]._staID) {
+        return;
+      }
+    }
+    else if (!_opt->_corrMount.empty()) {
+      if (_opt->_corrMount != satAntennas[0]._staID) {
+        return;
+      }
+    }
+  }
+  vector<t_satAntenna*> antennas;
+  for (int ii = 0; ii < satAntennas.size(); ii++) {
+    antennas.push_back(new t_satAntenna(satAntennas[ii]));
+  }
+
+  _pppClient->putSatAntennas(antennas);
+
+  for (unsigned ii = 0; ii < antennas.size(); ii++) {
+    delete antennas[ii];
+  }
+}
+
+//
+////////////////////////////////////////////////////////////////////////////
 void t_pppRun::slotNewPhaseBiases(QList<t_satPhaseBias> phaseBiases) {
   if (phaseBiases.size() == 0) {
@@ -630 +667 @@
       connect(_corrFile, SIGNAL(newPhaseBiases(QList<t_satPhaseBias>)), this, SLOT(slotNewPhaseBiases(QList<t_satPhaseBias>)));
     }
+    connect(_corrFile, SIGNAL(newSatAntennas(QList<t_satAntenna>)), this, SLOT(slotNewSatAntennas(QList<t_satAntenna>)));
     if (_opt->_ionoFile.empty()) {
       connect(_corrFile, SIGNAL(newTec(t_vTec)), this, SLOT(slotNewTec(t_vTec)));

trunk/BNC/src/pppRun.h

@@ -46 +46 @@
   void slotNewCodeBiases(QList<t_satCodeBias> codeBiases);
   void slotNewPhaseBiases(QList<t_satPhaseBias> phaseBiases);
+  void slotNewSatAntennas(QList<t_satAntenna> satAntennas);
   void slotNewObs(QByteArray staID, QList<t_satObs> obsList);
   void slotSetSpeed(int speed);

trunk/BNC/src/satObs.cpp

@@ -521 +521 @@
     for (unsigned ii = 0; ii < satAntenna._freq.size(); ii++) {
       const t_frqAntenna& frqAntenna = satAntenna._freq[ii];
-      *out << "   " << frqAntenna._freqIndex << ' '
+      *out << "   " << frqAntenna._frqType << ' '
         << frqAntenna._nadirCorrectionIndicator << ' '
         << setw(10) << setprecision(4) << frqAntenna._nadirCorrection;
@@ -573 +573 @@
     for (int jj = 0; jj < numFreq; jj++) {
       t_frqAntenna frqAntenna;
-      in >> frqAntenna._freqIndex >> frqAntenna._nadirCorrectionIndicator >> frqAntenna._nadirCorrection;
+      in >> frqAntenna._frqType >> frqAntenna._nadirCorrectionIndicator >> frqAntenna._nadirCorrection;
       for (unsigned kk = 0; kk < numAngles; kk++) {
         double val;

trunk/BNC/src/satObs.h

@@ -283 +283 @@
  public:
   t_frqAntenna() {
-    _freqIndex                = 0;
     _nadirCorrectionIndicator = false;
     _nadirCorrection          = 0.0;
   }
-  unsigned int        _freqIndex; // 0 .. ANT_MAXFREQUENCIES-1, DF+018 bit position
+  std::string         _frqType; // t_frequency::type label, e.g. "G1", "R2", "E7"
   bool                _nadirCorrectionIndicator;
   double              _nadirCorrection;      // m, only valid if _nadirCorrectionIndicator