Changeset 5810 in ntrip

Timestamp:

Aug 6, 2014, 11:34:36 AM (10 years ago)

Author:

mervart

Message:

 

Location:

trunk/BNC/src/PPP

Files:

• pppClient.cpp (modified) (3 diffs)
• pppClient.h (modified) (5 diffs)
• pppEphPool.cpp (modified) (11 diffs)
• pppEphPool.h (modified) (2 diffs)
• pppFilter.cpp (modified) (15 diffs)
• pppFilter.h (modified) (3 diffs)
• pppMain.cpp (modified) (4 diffs)
• pppMain.h (modified) (2 diffs)
• pppObsPool.cpp (modified) (7 diffs)
• pppObsPool.h (modified) (2 diffs)
• pppOptions.cpp (modified) (11 diffs)
• pppOptions.h (modified) (2 diffs)
• pppParlist.cpp (modified) (21 diffs)
• pppParlist.h (modified) (6 diffs)
• pppSatBias.cpp (modified) (1 diff)
• pppSatBias.h (modified) (1 diff)
• pppStation.cpp (modified) (7 diffs)
• pppStation.h (modified) (2 diffs)
• pppThread.cpp (modified) (6 diffs)
• pppThread.h (modified) (4 diffs)
• pppWidgets.cpp (modified) (1 diff)
• satobs.cpp (modified) (2 diffs)
• satobs.h (modified) (3 diffs)

trunk/BNC/src/PPP/pppClient.cpp

@@ -49 +49 @@
 
 #include "pppClient.h"
-#include "ephpool.h"
-#include "obspool.h"
-#include "satbias.h"
+#include "pppEphPool.h"
+#include "pppObsPool.h"
+#include "pppSatBias.h"
 #include "bncconst.h"
 #include "bncutils.h"
-#include "station.h"
+#include "pppStation.h"
 #include "bncantex.h"
-#include "filter.h"
+#include "pppFilter.h"
 
 using namespace BNC;
@@ -73 +73 @@
 // Constructor
 //////////////////////////////////////////////////////////////////////////////
-t_pppClient::t_pppClient(const t_options* opt) {
+t_pppClient::t_pppClient(const t_pppOptions* opt) {
   _output   = 0;
-  _opt      = new t_options(*opt);
+  _opt      = new t_pppOptions(*opt);
   _log      = new ostringstream();
-  _ephPool  = new t_ephPool();
-  _obsPool  = new t_obsPool();
-  _staRover = new t_station();
-  _filter   = new t_filter();
+  _ephPool  = new t_pppEphPool();
+  _obsPool  = new t_pppObsPool();
+  _staRover = new t_pppStation();
+  _filter   = new t_pppFilter();
   _tides    = new t_tides();
 
@@ -359 +359 @@
 // 
 //////////////////////////////////////////////////////////////////////////////
-t_irc t_pppClient::cmpModel(t_station* station, const ColumnVector& xyzc,
+t_irc t_pppClient::cmpModel(t_pppStation* station, const ColumnVector& xyzc,
                                vector<t_satObs*>& obsVector) {
 

trunk/BNC/src/PPP/pppClient.h

@@ -4 +4 @@
 #include <sstream>
 #include <vector>
-#include "ppp.h"
+#include "pppInclude.h"
 #include "ephemeris.h"
-#include "options.h"
+#include "pppOptions.h"
 #include "pppModel.h"
 
@@ -13 +13 @@
 namespace BNC {
 
-class t_ephPool;
-class t_obsPool;
+class t_pppEphPool;
+class t_pppObsPool;
 class t_satObs;
-class t_station;
-class t_filter;
+class t_pppStation;
+class t_pppFilter;
 
 class t_pppClient {
  public:
-  t_pppClient(const t_options* opt);                                                      
+  t_pppClient(const t_pppOptions* opt);                                                      
   ~t_pppClient();                                                     
 
@@ -30 +30 @@
   void processEpoch(const std::vector<t_pppSatObs*>& pppSatObs, t_output* output);
 
-  const t_ephPool* ephPool() const {return _ephPool;}
-  const t_obsPool* obsPool() const {return _obsPool;}
+  const t_pppEphPool* ephPool() const {return _ephPool;}
+  const t_pppObsPool* obsPool() const {return _obsPool;}
   const bncAntex*  antex() const {return _antex;}
-  const t_station* staRover() const {return _staRover;}
+  const t_pppStation* staRover() const {return _staRover;}
   double           offGG() const {return _offGG;}
 
   std::ostringstream& log() {return *_log;}
-  const t_options*    opt() const {return _opt;}
+  const t_pppOptions*    opt() const {return _opt;}
 
   static void bancroft(const Matrix& BBpass, ColumnVector& pos);
@@ -49 +49 @@
   t_irc prepareObs(const std::vector<t_pppSatObs*>& pppSatObs,
                    std::vector<t_satObs*>& obsVector, bncTime& epoTime);
-  t_irc cmpModel(t_station* station, const ColumnVector& xyzc,
+  t_irc cmpModel(t_pppStation* station, const ColumnVector& xyzc,
                  std::vector<t_satObs*>& obsVector);
   t_irc cmpBancroft(const bncTime& epoTime, std::vector<t_satObs*>& obsVector, 
@@ -56 +56 @@
 
   t_output*              _output;
-  t_ephPool*             _ephPool;
-  t_obsPool*             _obsPool;
+  t_pppEphPool*             _ephPool;
+  t_pppObsPool*             _obsPool;
   bncTime                _epoTimeRover;
-  t_station*             _staRover;
+  t_pppStation*             _staRover;
   bncAntex*              _antex;
-  t_filter*              _filter;
+  t_pppFilter*              _filter;
   double                 _offGG;
   std::vector<t_satObs*> _obsRover;
   std::ostringstream*    _log; 
-  t_options*             _opt; 
+  t_pppOptions*             _opt; 
   t_tides*               _tides;
 };

trunk/BNC/src/PPP/pppEphPool.cpp

@@ -40 +40 @@
 
 #include <iostream>
-#include "ephpool.h"
-#include "ppp.h"
+#include "pppEphPool.h"
+#include "pppInclude.h"
 #include "pppClient.h"
 
@@ -49 +49 @@
 //
 /////////////////////////////////////////////////////////////////////////////
-void t_ephPool::putEphemeris(t_eph* eph) {
+void t_pppEphPool::putEphemeris(t_eph* eph) {
   if (eph && eph->ok()) {
     _satEphPool[eph->prn().toInt()].putEphemeris(_maxQueueSize, eph);
@@ -60 +60 @@
 //
 /////////////////////////////////////////////////////////////////////////////
-void t_ephPool::putOrbCorrection(t_orbCorr* corr) {
+void t_pppEphPool::putOrbCorrection(t_orbCorr* corr) {
   if (corr) {
     _satEphPool[corr->prn().toInt()].putOrbCorrection(corr);
@@ -68 +68 @@
 //
 /////////////////////////////////////////////////////////////////////////////
-void t_ephPool::putClkCorrection(t_clkCorr* corr) {
+void t_pppEphPool::putClkCorrection(t_clkCorr* corr) {
   if (corr) {
     _satEphPool[corr->prn().toInt()].putClkCorrection(corr);
@@ -76 +76 @@
 //
 /////////////////////////////////////////////////////////////////////////////
-t_irc t_ephPool::getCrd(const t_prn& prn, const bncTime& tt, 
+t_irc t_pppEphPool::getCrd(const t_prn& prn, const bncTime& tt, 
                              ColumnVector& xc, ColumnVector& vv) const {
   return _satEphPool[prn.toInt()].getCrd(tt, xc, vv);
@@ -83 +83 @@
 //
 /////////////////////////////////////////////////////////////////////////////
-int t_ephPool::getChannel(const t_prn& prn) const {
+int t_pppEphPool::getChannel(const t_prn& prn) const {
   return _satEphPool[prn.toInt()].getChannel();
 }
@@ -89 +89 @@
 //
 /////////////////////////////////////////////////////////////////////////////
-void t_ephPool::t_satEphPool::putEphemeris(unsigned maxQueueSize, t_eph* eph) {
+void t_pppEphPool::t_satEphPool::putEphemeris(unsigned maxQueueSize, t_eph* eph) {
   if (_ephs.empty() || eph->isNewerThan(_ephs.front())) {
     _ephs.push_front(eph);
@@ -104 +104 @@
 //
 /////////////////////////////////////////////////////////////////////////////
-void t_ephPool::t_satEphPool::putOrbCorrection(t_orbCorr* corr) {
+void t_pppEphPool::t_satEphPool::putOrbCorrection(t_orbCorr* corr) {
   for (unsigned ii = 0; ii < _ephs.size(); ii++) {
     t_eph* eph = _ephs[ii];
@@ -117 +117 @@
 //
 /////////////////////////////////////////////////////////////////////////////
-void t_ephPool::t_satEphPool::putClkCorrection(t_clkCorr* corr) {
+void t_pppEphPool::t_satEphPool::putClkCorrection(t_clkCorr* corr) {
   for (unsigned ii = 0; ii < _ephs.size(); ii++) {
     t_eph* eph = _ephs[ii];
@@ -129 +129 @@
 //
 /////////////////////////////////////////////////////////////////////////////
-t_irc t_ephPool::t_satEphPool::getCrd(const bncTime& tt, ColumnVector& xc,
+t_irc t_pppEphPool::t_satEphPool::getCrd(const bncTime& tt, ColumnVector& xc,
                                            ColumnVector& vv) const {
   for (unsigned ii = 0; ii < _ephs.size(); ii++) {
@@ -149 +149 @@
 //
 /////////////////////////////////////////////////////////////////////////////
-int t_ephPool::t_satEphPool::getChannel() const {
+int t_pppEphPool::t_satEphPool::getChannel() const {
   if (_ephs.size() > 0) {
     return _ephs[0]->slotNum();

trunk/BNC/src/PPP/pppEphPool.h

@@ -3 +3 @@
 
 #include <deque>
-#include "ppp.h"
+#include "pppInclude.h"
 #include "bnctime.h"
 #include "ephemeris.h"
@@ -9 +9 @@
 namespace BNC {
 
-class t_ephPool {
+class t_pppEphPool {
  public:
-  t_ephPool(unsigned maxQueueSize = 3) {
+  t_pppEphPool(unsigned maxQueueSize = 3) {
     _maxQueueSize = maxQueueSize;
   }
-  ~t_ephPool() {}; 
+  ~t_pppEphPool() {}; 
 
   void putEphemeris(t_eph* eph);

trunk/BNC/src/PPP/pppFilter.cpp

@@ -6 +6 @@
 #include <newmatap.h>
 
-#include "filter.h"
+#include "pppFilter.h"
 #include "bncutils.h"
-#include "parlist.h"
-#include "obspool.h"
-#include "station.h"
+#include "pppParlist.h"
+#include "pppObsPool.h"
+#include "pppStation.h"
 #include "pppClient.h"
 
@@ -18 +18 @@
 // Constructor
 ////////////////////////////////////////////////////////////////////////////
-t_filter::t_filter() {
+t_pppFilter::t_pppFilter() {
   _parlist = 0;
 }
@@ -24 +24 @@
 // Destructor
 ////////////////////////////////////////////////////////////////////////////
-t_filter::~t_filter() {
+t_pppFilter::~t_pppFilter() {
   delete _parlist;
 }
@@ -30 +30 @@
 // Process Single Epoch
 ////////////////////////////////////////////////////////////////////////////
-t_irc t_filter::processEpoch(t_obsPool* obsPool) {
+t_irc t_pppFilter::processEpoch(t_pppObsPool* obsPool) {
 
   _numSat     = 0;
 
   if (!_parlist) {
-    _parlist = new t_parlist();
+    _parlist = new t_pppParlist();
   }
 
   // Vector of all Observations
   // --------------------------
-  t_obsPool::t_epoch* epoch = obsPool->lastEpoch();
+  t_pppObsPool::t_epoch* epoch = obsPool->lastEpoch();
   if (!epoch) {
     return failure;
@@ -76 +76 @@
   // --------------
   _parlist->set(_epoTime, ambLCs, obsVector);
-  const vector<t_param*>& params = _parlist->params();
+  const vector<t_pppParam*>& params = _parlist->params();
 
   // Status Vector, Variance-Covariance Matrix
@@ -88 +88 @@
   
   for (unsigned ii = 0; ii < params.size(); ii++) {
-    const t_param* par1 = params[ii];
+    const t_pppParam* par1 = params[ii];
 
     _x0[ii] = par1->x0();
@@ -100 +100 @@
       _xFlt[ii]     = xFltOld[iOld];
       for (unsigned jj = 0; jj < ii; jj++) {
-        const t_param* par2 = params[jj];
+        const t_pppParam* par2 = params[jj];
         int            jOld = par2->indexOld();
         if (jOld >= 0) {
@@ -127 +127 @@
 // Process Selected LCs
 ////////////////////////////////////////////////////////////////////////////
-t_irc t_filter::processLC(const vector<t_lc::type>& LCs, 
+t_irc t_pppFilter::processLC(const vector<t_lc::type>& LCs, 
                                vector<t_satObs*>& obsVector) {
 
@@ -141 +141 @@
   SymmetricMatrix         QSav       = _QFlt;
   string                  epoTimeStr = string(_epoTime);
-  const vector<t_param*>& params     = _parlist->params();
+  const vector<t_pppParam*>& params     = _parlist->params();
   unsigned                maxObs     = obsVector.size() * LCs.size();
     
@@ -172 +172 @@
           usedTypes.push_back(tLC);
           for (unsigned iPar = 0; iPar < params.size(); iPar++) {
-            const t_param* par = params[iPar];
+            const t_pppParam* par = params[iPar];
             AA[iObs][iPar] = par->partial(_epoTime, obs, tLC);
           }
@@ -238 +238 @@
     if (maxOutlierIndex > -1) {
       t_satObs* obs = usedObs[maxOutlierIndex];
-      t_param* par = 0;
+      t_pppParam* par = 0;
       LOG << epoTimeStr << " Outlier " << t_lc::toString(maxOutlierLC) << ' ' 
           << obs->prn().toString()                        << ' ' 
           << setw(8) << setprecision(4) << maxOutlier << endl;
       for (unsigned iPar = 0; iPar < params.size(); iPar++) {
-        t_param* hlp = params[iPar];
-        if (hlp->type() == t_param::amb && hlp->prn()  == obs->prn() && 
+        t_pppParam* hlp = params[iPar];
+        if (hlp->type() == t_pppParam::amb && hlp->prn()  == obs->prn() && 
             hlp->tLC()  == usedTypes[maxOutlierIndex]) {
           par = hlp;
@@ -289 +289 @@
 // Cycle-Slip Detection
 ////////////////////////////////////////////////////////////////////////////
-t_irc t_filter::detectCycleSlips(const vector<t_lc::type>& LCs, 
+t_irc t_pppFilter::detectCycleSlips(const vector<t_lc::type>& LCs, 
                                       const vector<t_satObs*>& obsVector) {
 
   const double            SLIP       = 20.0;  // slip threshold
   string                  epoTimeStr = string(_epoTime);
-  const vector<t_param*>& params     = _parlist->params();
+  const vector<t_pppParam*>& params     = _parlist->params();
 
   for (unsigned ii = 0; ii < LCs.size(); ii++) {
@@ -336 +336 @@
           ColumnVector AA(params.size());
           for (unsigned iPar = 0; iPar < params.size(); iPar++) {
-            const t_param* par = params[iPar];
+            const t_pppParam* par = params[iPar];
             AA[iPar] = par->partial(_epoTime, obs, tLC);
           }
@@ -358 +358 @@
 // Reset Ambiguity Parameter (cycle slip)
 ////////////////////////////////////////////////////////////////////////////
-t_irc t_filter::resetAmb(t_prn prn, const vector<t_satObs*>& obsVector,
+t_irc t_pppFilter::resetAmb(t_prn prn, const vector<t_satObs*>& obsVector,
                          SymmetricMatrix* QSav, ColumnVector* xSav) {
   t_irc irc = failure;
-  vector<t_param*>& params = _parlist->params();
+  vector<t_pppParam*>& params = _parlist->params();
   for (unsigned iPar = 0; iPar < params.size(); iPar++) {
-    t_param* par = params[iPar];
-    if (par->type() == t_param::amb && par->prn() == prn) {
+    t_pppParam* par = params[iPar];
+    if (par->type() == t_pppParam::amb && par->prn() == prn) {
       int ind = par->indexNew();
       t_lc::type tLC = par->tLC();
       LOG << string(_epoTime) << " RESET " << par->toString() << endl;
-      delete par; par = new t_param(t_param::amb, prn, tLC, &obsVector);
+      delete par; par = new t_pppParam(t_pppParam::amb, prn, tLC, &obsVector);
       par->setIndex(ind);
       params[iPar] = par;
@@ -395 +395 @@
 // Compute various DOP Values
 ////////////////////////////////////////////////////////////////////////////
-void t_filter::cmpDOP(const std::vector<t_lc::type>& LCs, const Matrix& AA) {
+void t_pppFilter::cmpDOP(const std::vector<t_lc::type>& LCs, const Matrix& AA) {
 
   _dop.reset();

trunk/BNC/src/PPP/pppFilter.h

@@ -4 +4 @@
 #include <vector>
 #include <newmat.h>
-#include "ppp.h"
-#include "parlist.h"
+#include "pppInclude.h"
+#include "pppParlist.h"
 #include "bnctime.h"
 #include "t_prn.h"
@@ -11 +11 @@
 namespace BNC {
 
-class t_parlist;
-class t_obsPool;
+class t_pppParlist;
+class t_pppObsPool;
 class t_satObs;
 
-class t_filter {
+class t_pppFilter {
  public:
-  t_filter();
-  ~t_filter();
+  t_pppFilter();
+  ~t_pppFilter();
 
-  t_irc processEpoch(t_obsPool* obsPool);
+  t_irc processEpoch(t_pppObsPool* obsPool);
 
   const ColumnVector&    x() const {return _xFlt;}
@@ -61 +61 @@
 
   bncTime         _epoTime;
-  t_parlist*      _parlist;
+  t_pppParlist*      _parlist;
   SymmetricMatrix _QFlt;
   ColumnVector    _xFlt;

trunk/BNC/src/PPP/pppMain.cpp

@@ -70 +70 @@
     readOptions();
 
-    QListIterator<t_options*> iOpt(_options);
+    QListIterator<t_pppOptions*> iOpt(_options);
     while (iOpt.hasNext()) {
-      const t_options* opt = iOpt.next();
-      t_pppThread* pppThread = new t_pppThread(opt);
-      pppThread->start();
-      _pppThreads << pppThread;
+      const t_pppOptions* opt = iOpt.next();
+      t_pppInclude.hread* pppInclude.hread = new t_pppInclude.hread(opt);
+      pppInclude.hread->start();
+      _pppInclude.hreads << pppInclude.hread;
       _running = true;
     }
@@ -92 +92 @@
   }
 
-  QListIterator<t_pppThread*> it(_pppThreads);
+  QListIterator<t_pppInclude.hread*> it(_pppInclude.hreads);
   while (it.hasNext()) {
-    t_pppThread* pppThread = it.next();
-    pppThread->exit();
-  }
-  _pppThreads.clear();
-
-  QListIterator<t_options*> iOpt(_options);
+    t_pppInclude.hread* pppInclude.hread = it.next();
+    pppInclude.hread->exit();
+  }
+  _pppInclude.hreads.clear();
+
+  QListIterator<t_pppOptions*> iOpt(_options);
   while (iOpt.hasNext()) {
     delete iOpt.next();
@@ -112 +112 @@
 void t_pppMain::readOptions() {
 
-  QListIterator<t_options*> iOpt(_options);
+  QListIterator<t_pppOptions*> iOpt(_options);
   while (iOpt.hasNext()) {
     delete iOpt.next();
@@ -143 +143 @@
     }
 
-    t_options* opt = new t_options();
+    t_pppOptions* opt = new t_pppOptions();
 
     opt->_realTime    = realTime;

trunk/BNC/src/PPP/pppMain.h

@@ -3 +3 @@
 
 #include <QtCore>
-#include "options.h"
-#include "pppThread.h"
+#include "pppOptions.h"
+#include "pppInclude.hread.h"
 
 namespace BNC {
@@ -18 +18 @@
   void readOptions();
 
-  QList<t_options*>   _options;
-  QList<t_pppThread*> _pppThreads;
+  QList<t_pppOptions*>   _options;
+  QList<t_pppInclude.hread*> _pppInclude.hreads;
   QString             _logFile;
   QString             _nmeaFile;

trunk/BNC/src/PPP/pppObsPool.cpp

@@ -39 +39 @@
  * -----------------------------------------------------------------------*/
 
-#include "obspool.h"
+#include "pppObsPool.h"
 
 using namespace BNC;
@@ -46 +46 @@
 // Constructor
 /////////////////////////////////////////////////////////////////////////////
-t_obsPool::t_epoch::t_epoch(const bncTime& epoTime, vector<t_satObs*>& obsVector) {
+t_pppObsPool::t_epoch::t_epoch(const bncTime& epoTime, vector<t_satObs*>& obsVector) {
   _epoTime   = epoTime;
   for (unsigned ii = 0; ii < obsVector.size(); ii++) {
@@ -56 +56 @@
 // Destructor
 /////////////////////////////////////////////////////////////////////////////
-t_obsPool::t_epoch::~t_epoch() {
+t_pppObsPool::t_epoch::~t_epoch() {
   for (unsigned ii = 0; ii < _obsVector.size(); ii++) {
     delete _obsVector[ii];
@@ -64 +64 @@
 // Constructor
 /////////////////////////////////////////////////////////////////////////////
-t_obsPool::t_obsPool() {
+t_pppObsPool::t_pppObsPool() {
   for (unsigned ii = 0; ii <= t_prn::MAXPRN; ii++) {
     _satBiases[ii] = 0;
@@ -72 +72 @@
 // Destructor
 /////////////////////////////////////////////////////////////////////////////
-t_obsPool::~t_obsPool() {
+t_pppObsPool::~t_pppObsPool() {
   for (unsigned ii = 0; ii <= t_prn::MAXPRN; ii++) {
     delete _satBiases[ii];
@@ -84 +84 @@
 //
 /////////////////////////////////////////////////////////////////////////////
-void t_obsPool::putBiases(t_satBias* satBias) {
+void t_pppObsPool::putBiases(t_satBias* satBias) {
   int iPrn = satBias->prn().toInt();
   delete _satBiases[iPrn];
@@ -92 +92 @@
 //
 /////////////////////////////////////////////////////////////////////////////
-void t_obsPool::putEpoch(const bncTime& epoTime, vector<t_satObs*>& obsVector) {
+void t_pppObsPool::putEpoch(const bncTime& epoTime, vector<t_satObs*>& obsVector) {
   const unsigned MAXSIZE = 2;
   _epochs.push_back(new t_epoch(epoTime, obsVector));

trunk/BNC/src/PPP/pppObsPool.h

@@ -5 +5 @@
 #include <deque>
 #include "satobs.h"
-#include "satbias.h"
+#include "pppSatBias.h"
 #include "bnctime.h"
 
 namespace BNC {
 
-class t_obsPool {
+class t_pppObsPool {
  public: 
 
@@ -25 +25 @@
   };
 
-  t_obsPool();
-  ~t_obsPool();
+  t_pppObsPool();
+  ~t_pppObsPool();
   void putBiases(t_satBias* satBias);
 

trunk/BNC/src/PPP/pppOptions.cpp

@@ -27 +27 @@
  * -------------------------------------------------------------------------
  *
- * Class:      t_options
+ * Class:      t_pppOptions
  *
  * Purpose:    Options for PPP client
@@ -40 +40 @@
 
 #include <newmatio.h>
-#include "options.h"
+#include "pppOptions.h"
 
 using namespace BNC;
@@ -47 +47 @@
 // Constructor
 //////////////////////////////////////////////////////////////////////////////
-t_options::t_options() {
+t_pppOptions::t_pppOptions() {
   _xyzAprRover.ReSize(3); _xyzAprRover = 0.0;
   _ellAprRover.ReSize(3); _ellAprRover = 0.0;
@@ -55 +55 @@
 // Destructor
 //////////////////////////////////////////////////////////////////////////////
-t_options::~t_options() {
+t_pppOptions::~t_pppOptions() {
 }
 
 // 
 //////////////////////////////////////////////////////////////////////////////
-bool t_options::dualFreqRequired() const {
+bool t_pppOptions::dualFreqRequired() const {
   return true;
 }
@@ -66 +66 @@
 // 
 //////////////////////////////////////////////////////////////////////////////
-bool t_options::biasRequired() const {
+bool t_pppOptions::biasRequired() const {
   return false;
 }
@@ -72 +72 @@
 // 
 //////////////////////////////////////////////////////////////////////////////
-bool t_options::corrRequired() const {
+bool t_pppOptions::corrRequired() const {
   return false;
 }
@@ -78 +78 @@
 // 
 //////////////////////////////////////////////////////////////////////////////
-bool t_options::useGlonass() const  {
+bool t_pppOptions::useGlonass() const  {
   return (_lcGLONASS.size() > 0);
 }
@@ -84 +84 @@
 // 
 //////////////////////////////////////////////////////////////////////////////
-bool t_options::xyzAprRoverSet() const {
+bool t_pppOptions::xyzAprRoverSet() const {
   return (_xyzAprRover[0] != 0.0 || _xyzAprRover[1] != 0.0 || _xyzAprRover[2] != 0.0);
 }
@@ -90 +90 @@
 // 
 //////////////////////////////////////////////////////////////////////////////
-bool t_options::estTropo() const  {
+bool t_pppOptions::estTropo() const  {
   return (_sigTropo > 0.0 || _noiseTropo > 0.0);
 }
@@ -96 +96 @@
 // 
 //////////////////////////////////////////////////////////////////////////////
-vector<t_lc::type> t_options::LCs() const {
+vector<t_lc::type> t_pppOptions::LCs() const {
 
   vector<t_lc::type> allLCs = _lcGPS;
@@ -131 +131 @@
 // 
 //////////////////////////////////////////////////////////////////////////////
-double t_options::maxRes(t_lc::type /* tLC */) const {
+double t_pppOptions::maxRes(t_lc::type /* tLC */) const {
   return _maxResC1;
 }

trunk/BNC/src/PPP/pppOptions.h

@@ -5 +5 @@
 #include <vector>
 #include <newmat.h>
-#include "ppp.h"
+#include "pppInclude.h"
 
 namespace BNC {
 
-class t_options {
+class t_pppOptions {
  public:
   class t_optBias {
@@ -18 +18 @@
   };
 
-  t_options();
-  ~t_options();
+  t_pppOptions();
+  ~t_pppOptions();
   bool dualFreqRequired() const;
   bool biasRequired() const;

trunk/BNC/src/PPP/pppParlist.cpp

@@ -5 +5 @@
 #include <algorithm>
 #include <newmatio.h>
-#include "parlist.h"
+#include "pppParlist.h"
 #include "satobs.h"
 
-#include "station.h"
+#include "pppStation.h"
 #include "bncutils.h"
 #include "bncconst.h"
@@ -18 +18 @@
 // Constructor
 ////////////////////////////////////////////////////////////////////////////
-t_param::t_param(e_type type, const t_prn& prn, t_lc::type tLC,
+t_pppParam::t_pppParam(e_type type, const t_prn& prn, t_lc::type tLC,
                  const vector<t_satObs*>* obsVector) {
 
@@ -84 +84 @@
 // Destructor
 ////////////////////////////////////////////////////////////////////////////
-t_param::~t_param() {
+t_pppParam::~t_pppParam() {
   delete _ambInfo;
 }
@@ -90 +90 @@
 // 
 ////////////////////////////////////////////////////////////////////////////
-double t_param::partial(const bncTime& /* epoTime */, const t_satObs* obs, 
+double t_pppParam::partial(const bncTime& /* epoTime */, const t_satObs* obs, 
                         const t_lc::type& tLC) const {
 
@@ -99 +99 @@
   }
 
-  const t_station* sta  = PPP_CLIENT->staRover();
+  const t_pppStation* sta  = PPP_CLIENT->staRover();
   ColumnVector     rhoV = sta->xyzApr() - obs->xc().Rows(1,3);
 
@@ -149 +149 @@
 // 
 ////////////////////////////////////////////////////////////////////////////
-string t_param::toString() const {
+string t_pppParam::toString() const {
   stringstream ss;
   switch (_type) {
@@ -182 +182 @@
 // Constructor
 ////////////////////////////////////////////////////////////////////////////
-t_parlist::t_parlist() {
+t_pppParlist::t_pppParlist() {
 }
 
 // Destructor
 ////////////////////////////////////////////////////////////////////////////
-t_parlist::~t_parlist() {
+t_pppParlist::~t_pppParlist() {
   for (unsigned ii = 0; ii < _params.size(); ii++) {
     delete _params[ii];
@@ -195 +195 @@
 // 
 ////////////////////////////////////////////////////////////////////////////
-t_irc t_parlist::set(const bncTime& epoTime, const vector<t_lc::type>& ambLCs, 
+t_irc t_pppParlist::set(const bncTime& epoTime, const vector<t_lc::type>& ambLCs, 
                      const vector<t_satObs*>& obsVector) {
 
   // Remove some Parameters
   // ----------------------
-  vector<t_param*>::iterator it = _params.begin();
+  vector<t_pppParam*>::iterator it = _params.begin();
   while (it != _params.end()) {
-    t_param* par = *it;
+    t_pppParam* par = *it;
 
     bool remove = false;
@@ -210 +210 @@
     }
 
-    else if (par->type() == t_param::amb) {
+    else if (par->type() == t_pppParam::amb) {
       if (par->lastObsTime().valid() && (epoTime - par->lastObsTime() > 120.0)) {
         remove = true;
@@ -216 +216 @@
     }
 
-    else if (par->type() == t_param::amb) {
+    else if (par->type() == t_pppParam::amb) {
       if (par->lastObsTime().valid() && (epoTime - par->lastObsTime() > 3600.0)) {
         remove = true;
@@ -234 +234 @@
   // ------------------------------------------
   for (unsigned ii = 0; ii < _params.size(); ii++) {
-    t_param* par = _params[ii];
+    t_pppParam* par = _params[ii];
     if (par->prn() == 0) {
       par->setLastObsTime(epoTime);
@@ -257 +257 @@
   // Required Set of Parameters
   // --------------------------
-  vector<t_param*> required;
+  vector<t_pppParam*> required;
 
   // Coordinates
   // -----------
-  required.push_back(new t_param(t_param::crdX, t_prn(), t_lc::dummy));
-  required.push_back(new t_param(t_param::crdY, t_prn(), t_lc::dummy));
-  required.push_back(new t_param(t_param::crdZ, t_prn(), t_lc::dummy));
+  required.push_back(new t_pppParam(t_pppParam::crdX, t_prn(), t_lc::dummy));
+  required.push_back(new t_pppParam(t_pppParam::crdY, t_prn(), t_lc::dummy));
+  required.push_back(new t_pppParam(t_pppParam::crdZ, t_prn(), t_lc::dummy));
 
   // Receiver Clock
   // --------------
-  required.push_back(new t_param(t_param::clkR, t_prn(), t_lc::dummy));
+  required.push_back(new t_pppParam(t_pppParam::clkR, t_prn(), t_lc::dummy));
 
   // GPS-Glonass Clock Offset
   // ------------------------
   if (OPT->useGlonass()) {
-    required.push_back(new t_param(t_param::offGG, t_prn(), t_lc::dummy));
+    required.push_back(new t_pppParam(t_pppParam::offGG, t_prn(), t_lc::dummy));
   }
 
@@ -278 +278 @@
   // ---------------
   for (unsigned ii = 0; ii < OPT->_estBias.size(); ii++) {
-    const t_options::t_optBias& optBias = OPT->_estBias[ii];
-    required.push_back(new t_param(t_param::bias, t_prn(optBias._system, 1), optBias._tLC));
+    const t_pppOptions::t_optBias& optBias = OPT->_estBias[ii];
+    required.push_back(new t_pppParam(t_pppParam::bias, t_prn(optBias._system, 1), optBias._tLC));
   }
 
@@ -285 +285 @@
   // -----------
   if (OPT->estTropo()) {
-    required.push_back(new t_param(t_param::trp, t_prn(), t_lc::dummy));
+    required.push_back(new t_pppParam(t_pppParam::trp, t_prn(), t_lc::dummy));
   }
 
@@ -294 +294 @@
     for (unsigned jj = 0; jj < obsVector.size(); jj++) {
       const t_satObs* satObs = obsVector[jj];
-      required.push_back(new t_param(t_param::amb, satObs->prn(), tLC, &obsVector));
+      required.push_back(new t_pppParam(t_pppParam::amb, satObs->prn(), tLC, &obsVector));
     }
   }
@@ -301 +301 @@
   // --------------------------------------------
   for (unsigned ii = 0; ii < required.size(); ii++) {
-    t_param* parReq = required[ii];
+    t_pppParam* parReq = required[ii];
 
     bool found = false;
     for (unsigned jj = 0; jj < _params.size(); jj++) {
-      t_param* parOld = _params[jj];
+      t_pppParam* parOld = _params[jj];
       if (parOld->isEqual(parReq)) {
         found = true;
@@ -321 +321 @@
   // Set Parameter Indices
   // ---------------------
-  sort(_params.begin(), _params.end(), t_param::sortFunction);
+  sort(_params.begin(), _params.end(), t_pppParam::sortFunction);
 
   for (unsigned ii = 0; ii < _params.size(); ii++) {
-    t_param* par = _params[ii];
+    t_pppParam* par = _params[ii];
     par->setIndex(ii);
     for (unsigned jj = 0; jj < obsVector.size(); jj++) {
@@ -340 +340 @@
 // 
 ////////////////////////////////////////////////////////////////////////////
-void t_parlist::printResult(const bncTime& epoTime, const SymmetricMatrix& QQ,
+void t_pppParlist::printResult(const bncTime& epoTime, const SymmetricMatrix& QQ,
                             const ColumnVector& xx, double ambFixRate) const {
 
@@ -347 +347 @@
   LOG << endl;
 
-  t_param* parX = 0;
-  t_param* parY = 0;
-  t_param* parZ = 0;
+  t_pppParam* parX = 0;
+  t_pppParam* parY = 0;
+  t_pppParam* parZ = 0;
   for (unsigned ii = 0; ii < _params.size(); ii++) {
-    t_param* par = _params[ii];
-    if      (par->type() == t_param::crdX) {
+    t_pppParam* par = _params[ii];
+    if      (par->type() == t_pppParam::crdX) {
       parX = par;
     }
-    else if (par->type() == t_param::crdY) {
+    else if (par->type() == t_pppParam::crdY) {
       parY = par;
     }
-    else if (par->type() == t_param::crdZ) {
+    else if (par->type() == t_pppParam::crdZ) {
       parZ = par;
     }
@@ -367 +367 @@
           << showpos << setw(10) << setprecision(4) << xx[ind] << noshowpos << " +- "
           << setw(8)  << setprecision(4) << sqrt(QQ[ind][ind]);
-      if (par->type() == t_param::amb) {
+      if (par->type() == t_pppParam::amb) {
         LOG << " el = " << setw(6) << setprecision(2) << par->ambEleSat() * 180.0 / M_PI
             << " epo = " << setw(4) << par->ambNumEpo();
@@ -376 +376 @@
   
   if (parX && parY && parZ) {
-    const t_station* sta = PPP_CLIENT->staRover();
+    const t_pppStation* sta = PPP_CLIENT->staRover();
 
     ColumnVector xyz(3);

trunk/BNC/src/PPP/pppParlist.h

@@ -4 +4 @@
 #include <vector>
 #include <string>
-#include "ppp.h"
+#include "pppInclude.h"
 #include "t_prn.h"
 #include "bnctime.h"
@@ -12 +12 @@
 class t_satObs;
 
-class t_param {
+class t_pppParam {
  public:
   enum e_type {crdX, crdY, crdZ, clkR, amb, offGG, trp, bias};
 
-  t_param(e_type type, const t_prn& prn, t_lc::type tLC,
+  t_pppParam(e_type type, const t_prn& prn, t_lc::type tLC,
           const std::vector<t_satObs*>* obsVector = 0);
 
-  ~t_param();
+  ~t_pppParam();
   e_type type() const {return _type;}
   double x0()  const {return _x0;}
@@ -25 +25 @@
                  const t_lc::type& tLC) const;
   bool   epoSpec() const {return _epoSpec;}
-  bool   isEqual(const t_param* par2) const {
+  bool   isEqual(const t_pppParam* par2) const {
     return (_type == par2->_type && _prn == par2->_prn && _tLC == par2->_tLC);
   }
@@ -52 +52 @@
   void     stepAmbNumEpo()             {if (_ambInfo) _ambInfo->_numEpo += 1;}
 
-  static bool sortFunction(const t_param* p1, const t_param* p2) {
+  static bool sortFunction(const t_pppParam* p1, const t_pppParam* p2) {
     if      (p1->_type != p2->_type) {
       return p1->_type < p2->_type;
@@ -92 +92 @@
 };
 
-class t_parlist {
+class t_pppParlist {
  public:
-  t_parlist();
-  ~t_parlist();
+  t_pppParlist();
+  ~t_pppParlist();
 
   t_irc set(const bncTime& epoTime, const std::vector<t_lc::type>& ambLCs,
@@ -101 +101 @@
 
   unsigned nPar() const {return _params.size();}
-  const std::vector<t_param*>& params() const {return _params;}
-  std::vector<t_param*>& params() {return _params;}
+  const std::vector<t_pppParam*>& params() const {return _params;}
+  std::vector<t_pppParam*>& params() {return _params;}
   void printResult(const bncTime& epoTime, const SymmetricMatrix& QQ, 
                    const ColumnVector& xx, double ambFixRate) const;
  private:
-  std::vector<t_param*> _params;
+  std::vector<t_pppParam*> _params;
 };
 

trunk/BNC/src/PPP/pppSatBias.cpp

@@ -39 +39 @@
  * -----------------------------------------------------------------------*/
 
-#include "satbias.h"
+#include "pppSatBias.h"
 
 using namespace BNC;

trunk/BNC/src/PPP/pppSatBias.h

@@ -3 +3 @@
 
 #include <map>
-#include "ppp.h"
+#include "pppInclude.h"
 #include "bnctime.h"
 

trunk/BNC/src/PPP/pppStation.cpp

@@ -27 +27 @@
  * -------------------------------------------------------------------------
  *
- * Class:      t_station
+ * Class:      t_pppStation
  *
  * Purpose:    Processed station
@@ -39 +39 @@
  * -----------------------------------------------------------------------*/
 
-#include "station.h"
+#include "pppStation.h"
 #include "bncutils.h"
 #include "pppModel.h"
@@ -48 +48 @@
 // Constructor
 //////////////////////////////////////////////////////////////////////////////
-t_station::t_station() {
+t_pppStation::t_pppStation() {
   _windUp    = new t_windUp();
 }
@@ -54 +54 @@
 // Destructor
 //////////////////////////////////////////////////////////////////////////////
-t_station::~t_station() {
+t_pppStation::~t_pppStation() {
   delete _windUp;
 }
@@ -60 +60 @@
 // 
 //////////////////////////////////////////////////////////////////////////////
-void t_station::setXyzApr(const ColumnVector& xyzApr) {
+void t_pppStation::setXyzApr(const ColumnVector& xyzApr) {
   _xyzApr = xyzApr;
   _ellApr.ReSize(3);
@@ -68 +68 @@
 // 
 //////////////////////////////////////////////////////////////////////////////
-void t_station::setNeuEcc(const ColumnVector& neuEcc) {
+void t_pppStation::setNeuEcc(const ColumnVector& neuEcc) {
   _neuEcc = neuEcc;
   _xyzEcc.ReSize(3);
@@ -76 +76 @@
 // 
 //////////////////////////////////////////////////////////////////////////////
-double t_station::windUp(const bncTime& time, t_prn prn, 
+double t_pppStation::windUp(const bncTime& time, t_prn prn, 
                          const ColumnVector& rSat) const {
   return _windUp->value(time, _xyzApr, prn, rSat);

trunk/BNC/src/PPP/pppStation.h

@@ -4 +4 @@
 #include <string>
 #include <newmat.h>
-#include "ppp.h"
+#include "pppInclude.h"
 #include "bnctime.h"
 
@@ -11 +11 @@
 class t_windUp;
 
-class t_station {
+class t_pppStation {
  public:
-  t_station();
-  ~t_station();
+  t_pppStation();
+  ~t_pppStation();
   void setName(std::string name) {_name = name;}
   void setAntName(std::string antName) {_antName = antName;}

trunk/BNC/src/PPP/pppThread.cpp

@@ -28 +28 @@
  * -------------------------------------------------------------------------
  *
- * Class:      t_pppThread, t_pppRun
+ * Class:      t_pppInclude.hread, t_pppRun
  *
  * Purpose:    Single PPP Client (running in its own thread)
@@ -46 +46 @@
 #include <map>
 
-#include "pppThread.h"
+#include "pppInclude.hread.h"
 #include "bnccore.h"
 
@@ -54 +54 @@
 // Constructor
 ////////////////////////////////////////////////////////////////////////////
-t_pppThread::t_pppThread(const t_options* opt) : QThread(0) {
+t_pppInclude.hread::t_pppInclude.hread(const t_pppOptions* opt) : QThread(0) {
   _opt   = opt;
   _pppRun = 0;
@@ -65 +65 @@
 // Destructor
 ////////////////////////////////////////////////////////////////////////////
-t_pppThread::~t_pppThread() {
+t_pppInclude.hread::~t_pppInclude.hread() {
   delete _pppRun;
 }
@@ -71 +71 @@
 // Run (virtual)
 ////////////////////////////////////////////////////////////////////////////
-void t_pppThread::run() {
+void t_pppInclude.hread::run() {
   try {
     _pppRun = new t_pppRun(_opt);
@@ -84 +84 @@
 // Constructor
 ////////////////////////////////////////////////////////////////////////////
-t_pppRun::t_pppRun(const t_options* opt) {
+t_pppRun::t_pppRun(const t_pppOptions* opt) {
   _opt = opt;
   connect(this, SIGNAL(newMessage(QByteArray,bool)), 

trunk/BNC/src/PPP/pppThread.h

@@ -7 +7 @@
 
 #include "GPSDecoder.h"
-#include "options.h"
+#include "pppOptions.h"
 #include "pppClient.h"
 
@@ -27 +27 @@
  Q_OBJECT
  public:
-  t_pppRun(const t_options* opt);
+  t_pppRun(const t_pppOptions* opt);
   ~t_pppRun();
 
@@ -42 +42 @@
  private:
   QMutex                    _mutex;
-  const t_options*          _opt;
+  const t_pppOptions*          _opt;
   t_pppClient*              _pppClient;
   std::deque<t_pppEpoData*> _pppEpochs;
 };
 
-class t_pppThread : public QThread {
+class t_pppInclude.hread : public QThread {
  Q_OBJECT
  public:
-  t_pppThread(const t_options* opt);
-  ~t_pppThread();
+  t_pppInclude.hread(const t_pppOptions* opt);
+  ~t_pppInclude.hread();
   virtual void run();
 
@@ -58 +58 @@
 
  private:
-  const t_options* _opt;
+  const t_pppOptions* _opt;
   t_pppRun*        _pppRun;
 };

trunk/BNC/src/PPP/pppWidgets.cpp

@@ -41 +41 @@
 #include <iostream>
 
-#include "PPP/pppwidgets.h"
+#include "PPP/pppWidgets.h"
 #include "qtfilechooser.h"
 #include "bncsettings.h"

trunk/BNC/src/PPP/satobs.cpp

@@ -45 +45 @@
 #include "satobs.h"
 #include "bncconst.h"
-#include "ephpool.h"
-#include "station.h"
+#include "pppEphPool.h"
+#include "pppStation.h"
 #include "bncutils.h"
 #include "bncantex.h"
-#include "obspool.h"
+#include "pppObsPool.h"
 #include "pppClient.h"
 
@@ -174 +174 @@
 // 
 ////////////////////////////////////////////////////////////////////////////
-t_irc t_satObs::cmpModel(const t_station* station) {
+t_irc t_satObs::cmpModel(const t_pppStation* station) {
 
   // Reset all model values

trunk/BNC/src/PPP/satobs.h

@@ -5 +5 @@
 #include <map>
 #include <newmat.h>
-#include "ppp.h"
+#include "pppInclude.h"
 #include "bnctime.h"
 
@@ -12 +12 @@
 typedef std::string t_obsType;
 
-class t_station;
+class t_pppStation;
 
 class t_satObs {
@@ -23 +23 @@
   const ColumnVector& xc() const {return _xcSat;}
   const bncTime&      time() const {return _time;}
-  t_irc               cmpModel(const t_station* station);
+  t_irc               cmpModel(const t_pppStation* station);
   double              obsValue(t_lc::type tLC) const;
   double              cmpValue(t_lc::type tLC) const;