Changeset 11087 in ntrip for trunk/BNC/src/ssrQc.cpp

Timestamp:

Oct 16, 2026, 10:19:51 AM (3 weeks ago)

Author:

stuerze

Message:

Bias check is added in ssrQC, refernce signals are configurable now

File:

• trunk/BNC/src/ssrQc.cpp (modified) (8 diffs)

trunk/BNC/src/ssrQc.cpp

@@ -42 +42 @@
 
 #include "ssrQc.h"
+#include "ssrRefSig.h"
+#include "combination/bncbiassnx.h"
 #include "bnccore.h"
 #include "bncutils.h"
@@ -126 +128 @@
 
   connect(this, SIGNAL(newMessage(QByteArray,bool)), BNC_CORE, SLOT(slotMessage(const QByteArray,bool)));
+  for (const QString& err : t_ssrRefSig::init()) {
+    emit newMessage(("SSR QC: " + err).toLatin1(), true);
+  }
+  // reference code biases from a Bias SINEX file (optional)
+  _bsxRef = 0;
+  bncSettings settings;
+  QString bsxFile = settings.value("ssrQcBiasFile").toString();
+  expandEnvVar(bsxFile);
+  if (!bsxFile.isEmpty()) {
+    _bsxRef = new bncBiasSnx(true);
+    if (_bsxRef->readFile(bsxFile) == success) {
+      _bsxName = QFileInfo(bsxFile).fileName();
+    }
+    else {
+      emit newMessage(("SSR QC: wrong Bias SINEX file " + bsxFile).toLatin1(), true);
+      delete _bsxRef;
+      _bsxRef = 0;
+    }
+  }
   connect(BNC_CORE, SIGNAL(newOrbCorrections(QList<t_orbCorr>)),
           this, SLOT(slotNewOrbCorrections(QList<t_orbCorr>)), Qt::DirectConnection);
@@ -183 +204 @@
            << " completeness w.r.t. healthy broadcast ephemerides," << endl
            << "IOD matching, code and phase bias signals, yaw angle, code biases of the reference signals, clock jumps > "
-           << MAX_CLK_JUMP << " m, largest orbit corrections" << endl;
+           << MAX_CLK_JUMP << " m, largest orbit corrections" << endl
+           << "Reference signals of the clocks: " << t_ssrRefSig::currentString().toStdString() << endl;
     }
     _outs[staID]     = out;
@@ -199 +221 @@
     delete out;
   }
+  delete _bsxRef;
 }
 
@@ -207 +230 @@
 }
 
-// Reference signals (IGS conventions, as in the combination)
+// Reference signals of the clocks (as in the combination, option ssrRefSignals)
 ////////////////////////////////////////////////////////////////////////////
 bool t_ssrQc::refSignals(char sys, QString& sig1, QString& sig2,
                          t_frequency::type& frq1, t_frequency::type& frq2) {
-  switch (sys) {
-    case 'G': sig1 = "1W"; sig2 = "2W"; frq1 = t_frequency::G1; frq2 = t_frequency::G2; return true;
-    case 'R': sig1 = "1P"; sig2 = "2P"; frq1 = t_frequency::R1; frq2 = t_frequency::R2; return true;
-    case 'E': sig1 = "1C"; sig2 = "5Q"; frq1 = t_frequency::E1; frq2 = t_frequency::E5; return true;
-    case 'C': sig1 = "2I"; sig2 = "6I"; frq1 = t_frequency::C2; frq2 = t_frequency::C6; return true;
-    case 'J': sig1 = "1C"; sig2 = "2L"; frq1 = t_frequency::J1; frq2 = t_frequency::J2; return true;
-  }
-  return false;
+  t_ssrRefSig::t_pair pair;
+  if (!t_ssrRefSig::get(sys, pair)) {
+    return false;
+  }
+  sig1 = QString::fromStdString(pair.sig1());
+  sig2 = QString::fromStdString(pair.sig2());
+  frq1 = pair.frq1;
+  frq2 = pair.frq2;
+  return true;
 }
 
@@ -376 +400 @@
       _codeSignals[staSys].insert(sig);
       values[sig] = frqBias._value;
+    }
+    if (!values.isEmpty()) {
+      _cbLast[QString::fromStdString(bias._staID)][prn] = values;
     }
     t_satStat& stat = _satStat[QString::fromStdString(bias._staID) + ' ' + prn];
@@ -425 +452 @@
     if (yawProvided) {
       stat.numYaw++;
+    }
+  }
+}
+
+// Reference DCBs (bias(base) - bias(signal)) of a satellite: median of the
+// other ACs (one vote per AC, own AC left out, combinations not voting) or
+// the selected reference stream, or from the Bias SINEX file
+////////////////////////////////////////////////////////////////////////////
+bool t_ssrQc::refDcbs(const QString& staID, const QString& prn, const QString& base, bool fromFile,
+                      QMap<QString, double>& dcbs, const QString& onlyAC, QMap<QString, int>* numVotes) {
+  dcbs.clear();
+  if (numVotes) {
+    numVotes->clear();
+  }
+  if (fromFile) {
+    if (!_bsxRef) {
+      return false;
+    }
+    char sys = prn[0].toLatin1();
+    t_ssrRefSig::t_pair pair;
+    if (!t_ssrRefSig::get(sys, pair)) {
+      return false;
+    }
+    // the DCBs do not depend on the coefficients (as long as they add up to 1)
+    double f1 = t_CST::freq(pair.frq1, 0.0);
+    double f2 = t_CST::freq(pair.frq2, 0.0);
+    double aIF1 =  f1 * f1 / (f1 * f1 - f2 * f2);
+    double aIF2 = -f2 * f2 / (f1 * f1 - f2 * f2);
+    t_satCodeBias satCodeBias;
+    _bsxRef->determineSsrSatCodeBiases(prn, aIF1, aIF2, satCodeBias);
+    QMap<QString, double> osb;
+    for (const t_frqCodeBias& bb : satCodeBias._bias) {
+      osb[QString::fromStdString(bb._rnxType2ch)] = bb._value;
+    }
+    if (!osb.contains(base)) {
+      return false;
+    }
+    for (auto it = osb.constBegin(); it != osb.constEnd(); ++it) {
+      if (it.key() != base) {
+        dcbs[it.key()] = osb[base] - it.value();
+      }
+    }
+    return !dcbs.isEmpty();
+  }
+
+  // per AC: DCBs of its streams
+  QMap<QString, QMap<QString, QVector<double> > > acDcbs;  // AC, signal
+  for (auto itS = _cbLast.constBegin(); itS != _cbLast.constEnd(); ++itS) {
+    const QString& sta = itS.key();
+    if (sta == staID) {
+      continue;
+    }
+    if (_reference == "CONSENSUS") {
+      if (!votes(sta) || acOf(sta) == acOf(staID) || (!onlyAC.isEmpty() && acOf(sta) != onlyAC)) {
+        continue;
+      }
+    }
+    else if (sta != _reference) {
+      continue;
+    }
+    if (!itS.value().contains(prn)) {
+      continue;
+    }
+    const QMap<QString, double>& bb = itS.value()[prn];
+    if (!bb.contains(base)) {
+      continue;
+    }
+    for (auto it = bb.constBegin(); it != bb.constEnd(); ++it) {
+      if (it.key() != base) {
+        acDcbs[acOf(sta)][it.key()].append(bb[base] - it.value());
+      }
+    }
+  }
+  QMap<QString, QVector<double> > votesPerSig;
+  for (auto itA = acDcbs.constBegin(); itA != acDcbs.constEnd(); ++itA) {
+    for (auto it = itA.value().constBegin(); it != itA.value().constEnd(); ++it) {
+      votesPerSig[it.key()].append(median(it.value()));
+    }
+  }
+  for (auto it = votesPerSig.constBegin(); it != votesPerSig.constEnd(); ++it) {
+    dcbs[it.key()] = median(it.value());
+    if (numVotes) {
+      (*numVotes)[it.key()] = it.value().size();
+    }
+  }
+  return !dcbs.isEmpty();
+}
+
+// Code bias check: the DCBs of the stream (relative to the first reference
+// signal, otherwise to another common signal) compared with a reference;
+// DCBs do not depend on the clock datum. A sign opposite to the reference
+// for most DCBs indicates the SINEX instead of the SSR sign convention.
+// References: the Bias SINEX file, the selected reference stream, or each
+// other AC separately (a median of two ACs cannot decide which one is wrong)
+////////////////////////////////////////////////////////////////////////////
+void t_ssrQc::compareCodeBiases(const QString& staID, char sys, QStringList& lines) {
+  const double MIN_DCB  = 0.3;   // [m] DCBs used for the sign check
+  const double MIN_DEV  = 0.5;   // [m] deviating DCBs: > max(MIN_DEV, DEV_FACTOR x median)
+  const int    MIN_VOTE = 3;     // ACs needed for a consensus DCB (deviating satellites)
+  if (!_cbLast.contains(staID)) {
+    return;
+  }
+  t_ssrRefSig::t_pair pair;
+  if (!t_ssrRefSig::get(sys, pair)) {
+    return;
+  }
+  const QString ref1 = QString::fromStdString(pair.sig1());
+
+  class t_cmp {
+   public:
+    unsigned numSat = 0, numSign = 0, numOpp = 0;
+    double   sumSqr = 0.0;
+    QVector<double> absDiffs;
+    QMap<QString, QPair<QString, double> > maxDiff;   // PRN: signal, difference
+    QSet<QString> bases;
+    bool opposite() const {return numSign >= 5 && numOpp > numSign / 2;}
+    double rms() const {return absDiffs.isEmpty() ? 0.0 : sqrt(sumSqr / absDiffs.size());}
+  };
+  // mode 0: file, 1: reference stream or median of the other ACs, 2: one other AC
+  auto compare = [&](int mode, const QString& onlyAC) {
+    t_cmp cc;
+    for (auto itP = _cbLast[staID].constBegin(); itP != _cbLast[staID].constEnd(); ++itP) {
+      const QString& prn = itP.key();
+      if (prn[0].toLatin1() != sys) {
+        continue;
+      }
+      const QMap<QString, double>& bb = itP.value();
+      QStringList candidates = QStringList() << ref1 << bb.keys();
+      QMap<QString, double> dcbs;
+      QMap<QString, int>    numVotes;
+      QString base;
+      for (const QString& cand : candidates) {
+        if (bb.contains(cand) && refDcbs(staID, prn, cand, mode == 0, dcbs, onlyAC, &numVotes)) {
+          base = cand;
+          break;
+        }
+      }
+      if (base.isEmpty()) {
+        continue;
+      }
+      bool used = false;
+      for (auto it = dcbs.constBegin(); it != dcbs.constEnd(); ++it) {
+        if (!bb.contains(it.key())) {
+          continue;
+        }
+        if (mode == 1 && _reference == "CONSENSUS" && numVotes.value(it.key()) < MIN_VOTE) {
+          continue;
+        }
+        double dcb  = bb[base] - bb[it.key()];
+        double diff = dcb - it.value();
+        used = true;
+        cc.sumSqr += diff * diff;
+        cc.absDiffs.append(fabs(diff));
+        if (fabs(diff) > fabs(cc.maxDiff.value(prn).second)) {
+          cc.maxDiff[prn] = qMakePair("C" + it.key(), diff);
+        }
+        if (fabs(it.value()) >= MIN_DCB) {
+          cc.numSign++;
+          if (dcb * it.value() < 0.0) {
+            cc.numOpp++;
+          }
+        }
+      }
+      if (used) {
+        cc.numSat++;
+        cc.bases.insert("C" + base);
+      }
+    }
+    return cc;
+  };
+  auto baseStr = [](const t_cmp& cc) {
+    QStringList ll = cc.bases.values();
+    ll.sort();
+    return ll.join("/");
+  };
+  auto deviating = [&](const t_cmp& cc, const QString& refName) {
+    if (cc.absDiffs.isEmpty() || cc.opposite()) {
+      return;
+    }
+    double limit = std::max(MIN_DEV, DEV_FACTOR * median(cc.absDiffs));
+    QStringList devs;
+    for (auto it = cc.maxDiff.constBegin(); it != cc.maxDiff.constEnd(); ++it) {
+      if (fabs(it.value().second) > limit) {
+        devs << QString("%1(%2 %3)").arg(it.key()).arg(it.value().first).arg(it.value().second, 0, 'f', 2);
+      }
+    }
+    if (!devs.isEmpty()) {
+      lines << QString("satellites with DCBs deviating from %1 [m]: %2").arg(refName).arg(devs.join(" "));
+    }
+  };
+
+  // Bias SINEX file or the selected reference stream
+  for (int mode = 0; mode < 2; mode++) {
+    if ((mode == 0 && !_bsxRef) || (mode == 1 && _reference == "CONSENSUS")) {
+      continue;
+    }
+    QString refName = (mode == 0) ? QString("Bias SINEX file %1").arg(_bsxName) : _reference;
+    t_cmp cc = compare(mode, QString());
+    if (cc.absDiffs.isEmpty()) {
+      continue;
+    }
+    lines << QString("code biases compared with %1 (DCBs to %2, %3 satellites, %4 DCBs): RMS of the differences "
+                     "%5 m, opposite sign for %6 of %7 DCBs (|DCB| >= %8 m)")
+             .arg(refName).arg(baseStr(cc)).arg(cc.numSat).arg(cc.absDiffs.size())
+             .arg(cc.rms(), 0, 'f', 3).arg(cc.numOpp).arg(cc.numSign).arg(MIN_DCB, 0, 'f', 1);
+    if (cc.opposite()) {
+      lines << QString("code biases with the opposite sign of %1 for %2 of %3 DCBs - "
+                       "SINEX sign convention instead of the SSR one?").arg(refName).arg(cc.numOpp).arg(cc.numSign);
+    }
+    deviating(cc, refName);
+  }
+
+  // Each other AC separately, and the median of the other ACs for deviating satellites
+  if (_reference == "CONSENSUS") {
+    QSet<QString> acs;
+    for (auto itS = _cbLast.constBegin(); itS != _cbLast.constEnd(); ++itS) {
+      if (itS.key() != staID && votes(itS.key()) && acOf(itS.key()) != acOf(staID)) {
+        acs.insert(acOf(itS.key()));
+      }
+    }
+    QStringList acList = acs.values();
+    acList.sort();
+    QStringList items;
+    QStringList oppACs;
+    int numACs = 0;
+    QSet<QString> bases;
+    for (const QString& ac : acList) {
+      t_cmp cc = compare(2, ac);
+      if (cc.absDiffs.isEmpty()) {
+        continue;
+      }
+      numACs++;
+      bases.unite(cc.bases);
+      items << QString("%1 RMS %2 m, opposite sign %3/%4").arg(ac).arg(cc.rms(), 0, 'f', 2)
+                                                         .arg(cc.numOpp).arg(cc.numSign);
+      if (cc.opposite()) {
+        oppACs << ac;
+      }
+    }
+    if (numACs > 0) {
+      QStringList ll = bases.values();
+      ll.sort();
+      lines << QString("code biases compared with the other ACs (DCBs to %1): %2").arg(ll.join("/")).arg(items.join("; "));
+      if (numACs >= 2 && oppACs.size() > numACs / 2) {
+        lines << QString("code biases with the opposite sign of %1 of %2 other ACs (%3) - "
+                         "SINEX sign convention instead of the SSR one?")
+                 .arg(oppACs.size()).arg(numACs).arg(oppACs.join(" "));
+      }
+      deviating(compare(1, QString()), QString("the median of the other ACs (at least %1 ACs)").arg(MIN_VOTE));
     }
   }
@@ -865 +1141 @@
         }
       }
+      compareCodeBiases(staID, sys, lines);
       if (_phaseSignals.contains(staSys)) {
         QStringList sigs = _phaseSignals[staSys].values();