Changeset 5883 in ntrip for trunk/BNC/src/PPP

Timestamp:

Aug 8, 2014, 3:51:27 PM (11 years ago)

Author:

mervart

Message:

 

Location:

trunk/BNC/src/PPP

Files:

• pppRun.cpp (moved) (moved from trunk/BNC/src/PPP/pppRunRealTime.cpp ) (10 diffs)
• pppRun.h (moved) (moved from trunk/BNC/src/PPP/pppRunRealTime.h ) (3 diffs)
• pppRunPostProc.cpp (deleted)
• pppRunPostProc.h (deleted)
• pppThread.cpp (modified) (3 diffs)
• pppThread.h (modified) (2 diffs)

trunk/BNC/src/PPP/pppRun.cpp

@@ -28 +28 @@
  * -------------------------------------------------------------------------
  *
- * Class:      t_pppRunRealTime
+ * Class:      t_pppRun
  *
  * Purpose:    Single Real-Time PPP Client
@@ -46 +46 @@
 #include <map>
 
-#include "pppRunRealTime.h"
+#include "pppRun.h"
 #include "bnccore.h"
 #include "bncephuser.h"
+#include "rinex/rnxobsfile.h"
+#include "rinex/rnxnavfile.h"
+#include "rinex/corrfile.h"
 
 using namespace BNC_PPP;
@@ -55 +58 @@
 // Constructor
 ////////////////////////////////////////////////////////////////////////////
-t_pppRunRealTime::t_pppRunRealTime(const t_pppOptions* opt) {
+t_pppRun::t_pppRun(const t_pppOptions* opt) {
+
   _opt = opt;
+
   connect(this, SIGNAL(newMessage(QByteArray,bool)), 
           BNC_CORE, SLOT(slotMessage(const QByteArray,bool)));
+
+  connect(this, SIGNAL(newPosition(bncTime, QVector<double>)),
+          BNC_CORE, SIGNAL(newPosition(bncTime, QVector<double>)));
+
+  for (unsigned iPrn = 0; iPrn <= t_prn::MAXPRN; iPrn++) {
+    _lastOrbCorrIOD[iPrn]   = -1;
+    _lastClkCorrValue[iPrn] = 0.0;
+  }
+
+  _pppClient = new t_pppClient(_opt);
+
   if (_opt->_realTime) {
     connect(BNC_CORE->caster(), SIGNAL(newObs(QByteArray, QList<t_obs>)),
@@ -74 +90 @@
     connect(BNC_CORE, SIGNAL(newCorrections(QStringList)),
             this, SLOT(slotNewCorrections(QStringList)));
-
-    connect(this, SIGNAL(newPosition(bncTime, QVector<double>)),
-            BNC_CORE, SIGNAL(newPosition(bncTime, QVector<double>)));
-
-    for (unsigned iPrn = 0; iPrn <= t_prn::MAXPRN; iPrn++) {
-      _lastOrbCorrIOD[iPrn]   = -1;
-      _lastClkCorrValue[iPrn] = 0.0;
-    }
-
-    _pppClient = new t_pppClient(_opt);
   }
   else {
-    throw t_except("t_pppRunRealTime: post-processing not yet implemented");
+    processFiles();
   }
 }
@@ -92 +98 @@
 // Destructor
 ////////////////////////////////////////////////////////////////////////////
-t_pppRunRealTime::~t_pppRunRealTime() {
+t_pppRun::~t_pppRun() {
 }
 
 // 
 ////////////////////////////////////////////////////////////////////////////
-void t_pppRunRealTime::slotNewEphGPS(gpsephemeris gpseph) {
+void t_pppRun::slotNewEphGPS(gpsephemeris gpseph) {
   QMutexLocker locker(&_mutex);
   t_ephGPS eph;
@@ -106 +112 @@
 // 
 ////////////////////////////////////////////////////////////////////////////
-void t_pppRunRealTime::slotNewEphGlonass(glonassephemeris gloeph) {
+void t_pppRun::slotNewEphGlonass(glonassephemeris gloeph) {
   QMutexLocker locker(&_mutex);
   t_ephGlo eph;
@@ -115 +121 @@
 // 
 ////////////////////////////////////////////////////////////////////////////
-void t_pppRunRealTime::slotNewEphGalileo(galileoephemeris galeph) {
+void t_pppRun::slotNewEphGalileo(galileoephemeris galeph) {
   QMutexLocker locker(&_mutex);
   t_ephGal eph;
@@ -124 +130 @@
 //
 ////////////////////////////////////////////////////////////////////////////
-void t_pppRunRealTime::slotNewObs(QByteArray staID, QList<t_obs> obsList) {
+void t_pppRun::slotNewObs(QByteArray staID, QList<t_obs> obsList) {
   QMutexLocker locker(&_mutex);
 
@@ -222 +228 @@
 // 
 ////////////////////////////////////////////////////////////////////////////
-void t_pppRunRealTime::slotNewCorrections(QStringList corrList) {
+void t_pppRun::slotNewCorrections(QStringList corrList) {
   QMutexLocker locker(&_mutex);
 
@@ -330 +336 @@
   }
 }
+
+
+// 
+////////////////////////////////////////////////////////////////////////////
+void t_pppRun::processFiles() {
+
+  try {
+    _rnxObsFile = new t_rnxObsFile(_opt->obsFileName, t_rnxObsFile::input);
+  }
+  catch (...) {
+    delete _rnxObsFile; _rnxObsFile = 0;
+    emit finished();
+    return;
+  }
+
+  _rnxNavFile = new t_rnxNavFile(_opt->navFileName, t_rnxNavFile::input);
+  _pppClient  = new bncPPPclient("POST", _opt, false);
+
+  if (!_opt->corrFileName.isEmpty()) {
+    _corrFile = new t_corrFile(_opt->corrFileName);
+    connect(_corrFile, SIGNAL(newCorrections(QStringList)),
+            _pppClient, SLOT(slotNewCorrections(QStringList)));
+  }
+
+  // Read/Process Observations
+  // -------------------------
+  int   nEpo = 0;
+  const t_rnxObsFile::t_rnxEpo* epo = 0;
+  while ( (epo = _rnxObsFile->nextEpoch()) != 0 ) {
+    ++nEpo;
+
+    if (_maxSpeed != 0) {
+      QMutexLocker locker(&_mutex);
+      if (_speed < _maxSpeed) {
+        double sleepTime = 0.02 * _maxSpeed / _speed;
+        msleep(sleepTime*1.e3);
+      }
+    }
+
+    // Get Corrections
+    // ---------------
+    if (_corrFile) {
+      _corrFile->syncRead(epo->tt);
+    }
+
+    // Get Ephemerides
+    // ----------------
+    t_eph* eph = 0;
+    const QMap<QString, int>* corrIODs = _corrFile ? &_corrFile->corrIODs() : 0;
+    while ( (eph = _rnxNavFile->getNextEph(epo->tt, corrIODs)) != 0 ) {
+      if (_pppClient->putNewEph(eph) != success) {
+        delete eph; eph = 0;
+      }
+    }
+
+    for (unsigned iObs = 0; iObs < epo->rnxSat.size(); iObs++) {
+
+      if (_isToBeDeleted) {
+        QThread::exit(0);
+        return;
+      }
+
+      const t_rnxObsFile::t_rnxSat& rnxSat = epo->rnxSat[iObs];
+    
+      t_obs obs;
+      t_rnxObsFile::setObsFromRnx(_rnxObsFile, epo, rnxSat, obs);
+
+      _pppClient->putNewObs(obs);
+    }
+    if (nEpo % 10 == 0) {
+      emit progress(nEpo);
+    }
+  }
+
+  if (BNC_CORE->mode() != t_bncCore::interactive) {
+    qApp->exit(0);
+  }
+  else {
+    emit finished();
+    deleteLater();
+  }
+}
+
+//  
+////////////////////////////////////////////////////////////////////////////
+void t_pppRun::slotSetSpeed(int speed) {
+  QMutexLocker locker(&_mutex);
+  _speed = speed;
+}

trunk/BNC/src/PPP/pppRun.h

@@ -1 @@
-#ifndef PPPRUNREALTIME_H
-#define PPPRUNREALTIME_H
+#ifndef PPPRUN_H
+#define PPPRUN_H
 
 #include <deque>
@@ -10 +10 @@
 #include "pppClient.h"
 
+class t_rnxObsFile;
+class t_rnxNavFile;
+class t_corrFile;
+
 namespace BNC_PPP {
 
-class t_pppRunRealTime : public QObject {
+class t_pppRun : public QObject {
  Q_OBJECT
  public:
-  t_pppRunRealTime(const t_pppOptions* opt);
-  ~t_pppRunRealTime();
+  t_pppRun(const t_pppOptions* opt);
+  ~t_pppRun();
+
+  void processFiles();
 
  signals:
@@ -50 +56 @@
   double                 _lastClkCorrValue[t_prn::MAXPRN+1];
   bncTime                _lastClkCorrTime;
+
+  t_rnxObsFile* _rnxObsFile;
+  t_rnxNavFile* _rnxNavFile;
+  t_corrFile*   _corrFile;
+  int           _maxSpeed;
+  int           _speed;
 };
 

trunk/BNC/src/PPP/pppThread.cpp

@@ -56 +56 @@
 ////////////////////////////////////////////////////////////////////////////
 t_pppThread::t_pppThread(const t_pppOptions* opt) : QThread(0) {
-  _opt            = opt;
-  _pppRunRealTime = 0;
+  _opt    = opt;
+  _pppRun = 0;
+
   connect(this, SIGNAL(finished()), this, SLOT(deleteLater()));
 
@@ -67 +68 @@
 ////////////////////////////////////////////////////////////////////////////
 t_pppThread::~t_pppThread() {
-  delete _pppRunRealTime;
+  delete _pppRun;
 }
 
@@ -74 +75 @@
 void t_pppThread::run() {
   try {
-    _pppRunRealTime = new t_pppRunRealTime(_opt);
-    QThread::exec();
+    _pppRun = new t_pppRun(_opt);
+    if (_opt->_realTime) {
+      QThread::exec();
+    }
+    else {
+      _ppRun->processFiles();
+    }
   }
   catch (t_except exc) {
-    _pppRunRealTime = 0;
+    _pppRun = 0;
     emit newMessage(QByteArray(exc.what().c_str()), true);
   }

trunk/BNC/src/PPP/pppThread.h

@@ -9 +9 @@
 #include "pppOptions.h"
 #include "pppClient.h"
-#include "pppRunRealTime.h"
+#include "pppRun.h"
 
 namespace BNC_PPP {
@@ -25 +25 @@
  private:
   const t_pppOptions* _opt;
-  t_pppRunRealTime*   _pppRunRealTime;
+  t_pppRun*           _pppRun;
 };