Changeset 10034 in ntrip for trunk/BNC/src/PPP/pppClient.cpp

Timestamp:

Apr 21, 2023, 11:48:24 AM (12 months ago)

Author:

stuerze

Message:

 

File:

• trunk/BNC/src/PPP/pppClient.cpp (modified) (14 diffs)

trunk/BNC/src/PPP/pppClient.cpp

@@ -20 +20 @@
 #include <iomanip>
 #include <cmath>
+#include <stdlib.h>
 #include <string.h>
 #include <stdexcept>
@@ -54 +55 @@
   _obsPool  = new t_pppObsPool();
   _staRover = new t_pppStation();
-  _filter   = new t_pppFilter(_obsPool);
+  _filter   = new t_pppFilter();
   _tides    = new t_tides();
   _antex    = 0;
@@ -65 +66 @@
     }
   }
-
-  if (_opt->_refSatRequired) {
-    for (unsigned iSys = 0; iSys < _opt->systems().size(); iSys++) {
-      char sys = _opt->systems()[iSys];
-      _refSatMap[sys] = new t_pppRefSat();
-    }
-  }
-
+  _offGlo = 0.0;
+  _offGal = 0.0;
+  _offBds = 0.0;
   CLIENTS.setLocalData(this);  // CLIENTS takes ownership over "this"
 }
@@ -81 +77 @@
   delete _log;
   delete _opt;
-  delete _filter;
   delete _ephPool;
   delete _obsPool;
@@ -88 +83 @@
     delete _antex;
   }
+  delete _filter;
   delete _tides;
   clearObs();
-  QMapIterator<char, t_pppRefSat*> it(_refSatMap);
-  while (it.hasNext()) {
-    it.next();
-    delete it.value();
-  }
-  _refSatMap.clear();
 }
 
@@ -165 +155 @@
   // -------
   epoTime.reset();
-  clearObs();
+  //clearObs();
 
   // Create vector of valid observations
@@ -218 +208 @@
     while (it != obsVector.end()) {
       t_pppSatObs* satObs = *it;
-      char sys = satObs->prn().system();
-      t_pppRefSat* refSat = _refSatMap[sys];
-      double stecRef = refSat->stecValue();
-      if (stecRef && !satObs->isReference()) {
-        pseudoObsIono = true;
-        satObs->setPseudoObsIono(t_frequency::G1, stecRef);
-      }
+      pseudoObsIono = satObs->setPseudoObsIono(t_frequency::G1);
       it++;
     }
   }
-
-/*
-  vector<t_pppSatObs*>::iterator it = obsVector.begin();
+  /*vector<t_pppSatObs*>::iterator it = obsVector.begin();
       while (it != obsVector.end()) {
         t_pppSatObs* satObs = *it;
         satObs->printObsMinusComputed();
         it++;
-      }
-*/
+      }*/
+
   return pseudoObsIono;
 }
@@ -330 +312 @@
     }
     if (maxRes < BLUNDER) {
-      if (print && _numEpoProcessing == 1) {
+      if (print) {
         LOG.setf(ios::fixed);
         LOG << "\nPPP of Epoch ";
@@ -354 +336 @@
   return success;
 }
-
+// Compute A Priori Glonass Receiver Clock Offset
+//////////////////////////////////////////////////////////////////////////////
+double t_pppClient::cmpOffGlo(vector<t_pppSatObs*>& obsVector) {
+
+  t_lc::type tLC   = t_lc::dummy;
+  double     offGlo = 0.0;
+
+  if (OPT->useSystem('R')) {
+
+    while (obsVector.size() > 0) {
+      offGlo = 0.0;
+      double   maxRes      = 0.0;
+      int      maxResIndex = -1;
+      t_prn    maxResPrn;
+      unsigned nObs        = 0;
+      for (unsigned ii = 0; ii < obsVector.size(); ii++) {
+        t_pppSatObs* satObs = obsVector.at(ii);
+        if (satObs->prn().system() == 'R') {
+          if (tLC == t_lc::dummy) {
+            tLC = satObs->isValid(t_lc::cIF) ? t_lc::cIF : t_lc::c1;
+          }
+          if (satObs->isValid(tLC) && (!satObs->modelSet() || satObs->eleSat() >= OPT->_minEle)) {
+            double ll = satObs->obsValue(tLC) - satObs->cmpValue(tLC);
+            ++nObs;
+            offGlo += ll;
+            if (fabs(ll) > fabs(maxRes)) {
+              maxRes      = ll;
+              maxResIndex = ii;
+              maxResPrn   = satObs->prn();
+            }
+          }
+        }
+      }
+
+      if (nObs > 0) {
+        offGlo = offGlo / nObs;
+      }
+      else {
+        offGlo = 0.0;
+      }
+
+      if (fabs(maxRes) > 1000.0) {
+        LOG << "t_pppClient::cmpOffGlo outlier " << maxResPrn.toString() << " " << maxRes << endl;
+        obsVector.erase(obsVector.begin() + maxResIndex);
+      }
+      else {
+        break;
+      }
+    }
+  }
+
+  return offGlo;
+}
+
+// Compute A Priori Galileo Receiver Clock Offset
+//////////////////////////////////////////////////////////////////////////////
+double t_pppClient::cmpOffGal(vector<t_pppSatObs*>& obsVector) {
+
+  t_lc::type tLC   = t_lc::dummy;
+  double     offGal = 0.0;
+
+  if (OPT->useSystem('E')) {
+
+    while (obsVector.size() > 0) {
+      offGal = 0.0;
+      double   maxRes      = 0.0;
+      int      maxResIndex = -1;
+      t_prn    maxResPrn;
+      unsigned nObs        = 0;
+      for (unsigned ii = 0; ii < obsVector.size(); ii++) {
+        t_pppSatObs* satObs = obsVector.at(ii);
+        if (satObs->prn().system() == 'E') {
+          if (tLC == t_lc::dummy) {
+            tLC = satObs->isValid(t_lc::cIF) ? t_lc::cIF : t_lc::c1;
+          }
+          if (satObs->isValid(tLC) && (!satObs->modelSet() || satObs->eleSat() >= OPT->_minEle)) {
+            double ll = satObs->obsValue(tLC) - satObs->cmpValue(tLC);
+            ++nObs;
+            offGal += ll;
+            if (fabs(ll) > fabs(maxRes)) {
+              maxRes      = ll;
+              maxResIndex = ii;
+              maxResPrn   = satObs->prn();
+            }
+          }
+        }
+      }
+
+      if (nObs > 0) {
+        offGal = offGal / nObs;
+      }
+      else {
+        offGal = 0.0;
+      }
+
+      if (fabs(maxRes) > 1000.0) {
+        LOG << "t_pppClient::cmpOffGal outlier " << maxResPrn.toString() << " " << maxRes << endl;
+        obsVector.erase(obsVector.begin() + maxResIndex);
+      }
+      else {
+        break;
+      }
+    }
+  }
+
+  return offGal;
+}
+
+
+// Compute A Priori BDS Receiver Clock Offset
+//////////////////////////////////////////////////////////////////////////////
+double t_pppClient::cmpOffBds(vector<t_pppSatObs*>& obsVector) {
+
+  t_lc::type tLC   = t_lc::dummy;
+  double     offBds = 0.0;
+
+  if (_opt->useSystem('C')) {
+    while (obsVector.size() > 0) {
+      offBds = 0.0;
+      double   maxRes      = 0.0;
+      int      maxResIndex = -1;
+      t_prn    maxResPrn;
+      unsigned nObs        = 0;
+      for (unsigned ii = 0; ii < obsVector.size(); ii++) {
+        const t_pppSatObs* satObs = obsVector.at(ii);
+        if (satObs->prn().system() == 'C') {
+          if (tLC == t_lc::dummy) {
+            tLC = satObs->isValid(t_lc::cIF) ? t_lc::cIF : t_lc::c1;
+          }
+          if (satObs->isValid(tLC) && (!satObs->modelSet() || satObs->eleSat() >= _opt->_minEle)) {
+            double ll = satObs->obsValue(tLC) - satObs->cmpValue(tLC);
+            ++nObs;
+            offBds += ll;
+            if (fabs(ll) > fabs(maxRes)) {
+              maxRes      = ll;
+              maxResIndex = ii;
+              maxResPrn   = satObs->prn();
+            }
+          }
+        }
+      }
+
+      if (nObs > 0) {
+        offBds = offBds / nObs;
+      }
+      else {
+        offBds = 0.0;
+      }
+
+      if (fabs(maxRes) >  1000.0) {
+        LOG << "t_pppClient::cmpOffBds outlier " << maxResPrn.toString() << " " << maxRes << endl;
+        delete obsVector.at(maxResIndex);
+        obsVector.erase(obsVector.begin() + maxResIndex);
+      }
+      else {
+        break;
+      }
+    }
+  }
+  return offBds;
+}
 //
 //////////////////////////////////////////////////////////////////////////////
@@ -403 +545 @@
   else {
     _output->_error = true;
-    if (OPT->_obsModelType == OPT->DCMcodeBias ||
-        OPT->_obsModelType == OPT->DCMphaseBias) {
-      if (ind == 1 || ind == 6 || ind > 7) {
-        reset();
-      }
-      //else {_filter->restoreState(ind);}
-    }
-  }
+  }
+
   _output->_log = _log->str();
   delete _log; _log = new ostringstream();
@@ -426 +562 @@
   station->setAntName(_opt->_antNameRover);
   station->setEpochTime(time);
+
   if (_opt->xyzAprRoverSet()) {
     station->setXyzApr(_opt->_xyzAprRover);
@@ -472 +609 @@
   try {
     initOutput(output);
-    bool epochReProcessing = false;
-    _numEpoProcessing = 0;
-    if (!_historicalRefSats.isEmpty()) {
-      _historicalRefSats.clear();
-    }
-
-    do {
-      if ((_numEpoProcessing++) > 30) {
-        LOG << "t_pppClient::processEpoch:  _numEpoProcessing > 30" << endl;
-        return finish(failure,12);
-      }
-
-      if (_obsPool->refSatChanged()) {
-        if(_filter->datumTransformation(_refSatMap) != success) {
-          LOG << "t_pppFilter::datumTransformation() != success" << endl;
-          return finish(failure,1);
-        }
-        else {
-          LOG << "t_pppFilter::datumTransformation() == success" << endl;
-          _filter->rememberState(1);
-        }
-      }
-
-      // Prepare Observations of the Rover
-      // ---------------------------------
-      if (prepareObs(satObs, _obsRover, _epoTimeRover) != success) {
-        return finish(failure,2);
-      }
-
-      for (int iter = 1; iter <= 2; iter++) {
-        ColumnVector xyzc(4); xyzc = 0.0;
-        bool print = (iter == 2);
-        if (cmpBancroft(_epoTimeRover, _obsRover, xyzc, print) != success) {
-          return finish(failure,3);
-        }
-
-        if (cmpModel(_staRover, xyzc, _obsRover) != success) {
-          return finish(failure,4);
-        }
-      }
-      // use observations only if satellite code biases are available
-      // ------------------------------------------------------------
-      if (!_opt->_corrMount.empty() &&
-          (OPT->_obsModelType == OPT->DCMcodeBias ||
-           OPT->_obsModelType == OPT->DCMphaseBias)) {
+
+    // Prepare Observations of the Rover
+    // ---------------------------------
+    if (prepareObs(satObs, _obsRover, _epoTimeRover) != success) {
+      return finish(failure, 1);
+    }
+
+    for (int iter = 1; iter <= 2; iter++) {
+      ColumnVector xyzc(4); xyzc = 0.0;
+      bool print = (iter == 2);
+      if (cmpBancroft(_epoTimeRover, _obsRover, xyzc, print) != success) {
+        return finish(failure, 2);
+      }
+       if (cmpModel(_staRover, xyzc, _obsRover) != success) {
+        return finish(failure, 3);
+      }
+    }
+    // use observations only if satellite code biases are available
+    /* ------------------------------------------------------------
+    if (!_opt->_corrMount.empty() {
         useObsWithCodeBiasesOnly(_obsRover);
-      }
-
-      if (int(_obsRover.size()) < _opt->_minObs) {
-        LOG << "t_pppClient::processEpoch not enough observations" << endl;
-        return finish(failure,5);
-      }
-
-      if (_opt->_refSatRequired) {
-        if (handleRefSatellites(_obsRover) != success) {
-          return finish(failure,6);
-        }
-        if (_obsPool->refSatChanged()) {
-          epochReProcessing = true;
-          continue;
-        }
-      }
-
-      // Prepare Pseudo Observations of the Rover
-      // ----------------------------------------
-      _pseudoObsIono = preparePseudoObs(_obsRover);
-
-      // Store last epoch of data
-      // ------------------------
-      _obsPool->putEpoch(_epoTimeRover, _obsRover, _pseudoObsIono, _refSatMap);
-#ifdef BNC_DEBUG_PPP
-      LOG << "PUT EPOCH t_pppClient::processEpoch " << _epoTimeRover.timestr().c_str() << endl;
-#endif
-
-      // Process Epoch in Filter
-      // -----------------------
-      if (_filter->processEpoch(_numEpoProcessing) != success) {
-        LOG << "filter->processEpoch() != success" << endl;
-        return finish(failure,7);
-      }
-
-      // Epoch re-processing required?
-      // -----------------------------
-      if (_obsPool->refSatChangeRequired() && //SLIP
-          _opt->_obsModelType  != t_pppOptions::UncombPPP) {
-        LOG << "pppClient: _obsPool->refSatChangeRequired() " << endl;
-        epochReProcessing = true;
-#ifdef BNC_DEBUG_PPP
-        LOG <<  "DELETE EPOCH" << endl;
-#endif
-        _obsPool->deleteLastEpoch();
-        _filter->restoreState(0);
-        setHistoricalRefSats();
-      }
-      else {
-         epochReProcessing = false;
-         if (OPT->_obsModelType == OPT->DCMcodeBias ||
-             OPT->_obsModelType == OPT->DCMphaseBias) {
-           _filter->rememberState(0);
-         }
-      }
-    } while (epochReProcessing);
-
+    }*/
+
+    if (int(_obsRover.size()) < _opt->_minObs) {
+      LOG << "t_pppClient::processEpoch not enough observations" << endl;
+      return finish(failure, 4);
+    }
+    
+      _offGlo = cmpOffGlo(_obsRover);
+      _offGal = cmpOffGal(_obsRover);
+      _offBds = cmpOffBds(_obsRover);
+      
+    // Prepare Pseudo Observations of the Rover
+    // ----------------------------------------
+    _pseudoObsIono = preparePseudoObs(_obsRover);
+
+    // Store last epoch of data
+    // ------------------------
+    _obsPool->putEpoch(_epoTimeRover, _obsRover, _pseudoObsIono);
+
+    // Process Epoch in Filter
+    // -----------------------
+    if (_filter->processEpoch(_obsPool) != success) {
+      LOG << "filter->processEpoch() != success" << endl;
+      return finish(failure, 5);
+    }
   }
   catch (Exception& exc) {
     LOG << exc.what() << endl;
-    return finish(failure,8);
+    return finish(failure, 6);
   }
   catch (t_except msg) {
     LOG << msg.what() << endl;
-    return finish(failure,9);
+    return finish(failure, 7);
   }
   catch (const char* msg) {
     LOG << msg << endl;
-    return finish(failure,10);
+    return finish(failure, 8);
   }
   catch (...) {
     LOG << "unknown exception" << endl;
-    return finish(failure,11);
-  }
-  return finish(success,0);
+    return finish(failure, 9);
+  }
+  return finish(success, 0);
 }
 
@@ -684 +764 @@
 //
 //////////////////////////////////////////////////////////////////////////////
-void t_pppClient::setRefSatellites(std::vector<t_pppSatObs*>& obsVector) {
-  // reference satellite definition per system
-  for (unsigned iSys = 0; iSys < _opt->systems().size(); iSys++) {
-    t_irc  refSatReDefinition = success;
-    char sys = _opt->systems()[iSys];
-    bool refSatDefined = false;
-    t_pppRefSat* refSat = _refSatMap[sys];
-    for (unsigned ii = 0; ii < obsVector.size(); ii++) {
-      t_pppSatObs* satObs = obsVector.at(ii);
-      if (satObs->eleSat() < _opt->_minEle) {
-        continue;
-      }
-      // reference satellite is unchanged
-      // ================================
-      if (     !_obsPool->refSatChangeRequired(sys) && refSat->prn() == satObs->prn()) {
-        refSatDefined = true;
-        obsVector[ii]->setAsReference();
-      }
-      // reference satellite has changed
-      // ===============================
-      else if ( _obsPool->refSatChangeRequired(sys) && refSat->prn() != satObs->prn()) {
-        if (satObs->prn().system() == sys) {
-          if (!_historicalRefSats[sys].contains(satObs->prn())) {
-            refSatDefined = true;
-            obsVector[ii]->setAsReference();
-            refSat->setPrn(satObs->prn());
-          }
-          else if ( _historicalRefSats[sys].contains(satObs->prn())) {
-            refSatReDefinition = failure;
-          }
-        }
-      }
-      if (refSatDefined) {
-        if (OPT->_pseudoObsIono) {
-          refSat->setStecValue(satObs->getIonoCodeDelay(t_frequency::G1));
-        }
-        break;
-      }
-    }
-
-    // all available satellites were already tried to use
-    if ((!refSatDefined) && (refSatReDefinition == failure)) {
-      refSat->setPrn(t_prn(sys, 99));
-      _obsPool->setRefSatChangeRequired(sys, false);
-      return;
-    }
-
-    // reference satellite has to be initialized
-    // =========================================
-    if (!refSatDefined) {
-      for (unsigned ii = 0; ii < obsVector.size(); ii++) {
-        t_pppSatObs* satObs = obsVector.at(ii);
-        if (satObs->eleSat() < _opt->_minEle) {
-          continue;
-        }
-        if (satObs->prn().system() == sys &&
-            !_historicalRefSats[sys].contains(satObs->prn())) {
-          obsVector[ii]->setAsReference();
-          refSat->setPrn(satObs->prn());
-          if (OPT->_pseudoObsIono) {
-            refSat->setStecValue(satObs->getIonoCodeDelay(t_frequency::G1));
-          }
-          refSatDefined = true;
-          break;
-        }
-      }
-    }
-
-    // no observations for that system
-    // ===============================
-    if (!refSatDefined) {
-      refSat->setPrn(t_prn());
-    }
-    _obsPool->setRefSatChangeRequired(sys, false); // done or impossible
-  }
-
-  return;
-}
-
-//
-//////////////////////////////////////////////////////////////////////////////
-t_irc t_pppClient::handleRefSatellites(std::vector<t_pppSatObs*>& obsVector) {
-
-  // set refSats in current epoch
-  // ============================
-  setRefSatellites(obsVector); // current epoch
-  LOG.setf(ios::fixed);
-  t_pppObsPool::t_epoch* epoch = _obsPool->lastEpoch();
-  const QMap<char, t_pppRefSat*>& refSatMapLastEpoch = epoch->refSatMap();
-
-  QMapIterator<char, t_pppRefSat*> it(_refSatMap);
-  while (it.hasNext()) {
-    it.next();
-    char  sys = it.key();
-    t_prn prn = it.value()->prn();
-    t_prn refSatLastEpochPrn = t_prn();
-    if (epoch) {
-      refSatLastEpochPrn =  refSatMapLastEpoch[sys]->prn();
-    }
-    if      (prn.number() ==  0) { // no obs for that system available
-      continue;
-    }
-    else if (prn.number() == 99) { // refSat re-definition not possible
-      LOG << " => refSat re-definition impossible: " << sys << endl;
-      return failure;
-    }
-    QString str;
-    if (prn == refSatLastEpochPrn || refSatLastEpochPrn == t_prn() )  {
-      _obsPool->setRefSatChanged(sys, false);
-      str = " SET   ";
-    }
-    else {
-      _obsPool->setRefSatChanged(sys, true);
-      str = " RESET ";
-    }
-    LOG << string(_epoTimeRover) <<  str.toStdString() << " REFSAT  " << sys << ": " << prn.toString() << endl;
-  }
-  return success;
-}
-
-void t_pppClient::setHistoricalRefSats() {
-  QMapIterator<char, t_pppRefSat*> it(_refSatMap);
-  while (it.hasNext()) {
-    it.next();
-    t_prn prn = it.value()->prn();
-    char sys = prn.system();
-    if (_obsPool->refSatChangeRequired(sys)) {
-      _historicalRefSats[sys].append(prn);
-    }
-  }
-}
-
-//
-//////////////////////////////////////////////////////////////////////////////
-void t_pppClient::reset() {LOG << "t_pppClient::reset()" << endl;
+void t_pppClient::reset() {cout << "t_pppClient::reset()" << endl;
 
   // to delete old orbit and clock corrections
@@ -830 +776 @@
   // to delete all parameters
   delete _filter;
-  _filter   = new t_pppFilter(_obsPool);
-
-}
+  _filter   = new t_pppFilter();
+
+}