Changeset 5810 in ntrip


Ignore:
Timestamp:
Aug 6, 2014, 11:34:36 AM (8 years ago)
Author:
mervart
Message:
 
Location:
trunk/BNC/src/PPP
Files:
23 edited

Legend:

Unmodified
Added
Removed
  • trunk/BNC/src/PPP/pppClient.cpp

    r5802 r5810  
    4949
    5050#include "pppClient.h"
    51 #include "ephpool.h"
    52 #include "obspool.h"
    53 #include "satbias.h"
     51#include "pppEphPool.h"
     52#include "pppObsPool.h"
     53#include "pppSatBias.h"
    5454#include "bncconst.h"
    5555#include "bncutils.h"
    56 #include "station.h"
     56#include "pppStation.h"
    5757#include "bncantex.h"
    58 #include "filter.h"
     58#include "pppFilter.h"
    5959
    6060using namespace BNC;
     
    7373// Constructor
    7474//////////////////////////////////////////////////////////////////////////////
    75 t_pppClient::t_pppClient(const t_options* opt) {
     75t_pppClient::t_pppClient(const t_pppOptions* opt) {
    7676  _output   = 0;
    77   _opt      = new t_options(*opt);
     77  _opt      = new t_pppOptions(*opt);
    7878  _log      = new ostringstream();
    79   _ephPool  = new t_ephPool();
    80   _obsPool  = new t_obsPool();
    81   _staRover = new t_station();
    82   _filter   = new t_filter();
     79  _ephPool  = new t_pppEphPool();
     80  _obsPool  = new t_pppObsPool();
     81  _staRover = new t_pppStation();
     82  _filter   = new t_pppFilter();
    8383  _tides    = new t_tides();
    8484
     
    359359//
    360360//////////////////////////////////////////////////////////////////////////////
    361 t_irc t_pppClient::cmpModel(t_station* station, const ColumnVector& xyzc,
     361t_irc t_pppClient::cmpModel(t_pppStation* station, const ColumnVector& xyzc,
    362362                               vector<t_satObs*>& obsVector) {
    363363
  • trunk/BNC/src/PPP/pppClient.h

    r5802 r5810  
    44#include <sstream>
    55#include <vector>
    6 #include "ppp.h"
     6#include "pppInclude.h"
    77#include "ephemeris.h"
    8 #include "options.h"
     8#include "pppOptions.h"
    99#include "pppModel.h"
    1010
     
    1313namespace BNC {
    1414
    15 class t_ephPool;
    16 class t_obsPool;
     15class t_pppEphPool;
     16class t_pppObsPool;
    1717class t_satObs;
    18 class t_station;
    19 class t_filter;
     18class t_pppStation;
     19class t_pppFilter;
    2020
    2121class t_pppClient {
    2222 public:
    23   t_pppClient(const t_options* opt);                                                     
     23  t_pppClient(const t_pppOptions* opt);                                                     
    2424  ~t_pppClient();                                                     
    2525
     
    3030  void processEpoch(const std::vector<t_pppSatObs*>& pppSatObs, t_output* output);
    3131
    32   const t_ephPool* ephPool() const {return _ephPool;}
    33   const t_obsPool* obsPool() const {return _obsPool;}
     32  const t_pppEphPool* ephPool() const {return _ephPool;}
     33  const t_pppObsPool* obsPool() const {return _obsPool;}
    3434  const bncAntex*  antex() const {return _antex;}
    35   const t_station* staRover() const {return _staRover;}
     35  const t_pppStation* staRover() const {return _staRover;}
    3636  double           offGG() const {return _offGG;}
    3737
    3838  std::ostringstream& log() {return *_log;}
    39   const t_options*    opt() const {return _opt;}
     39  const t_pppOptions*    opt() const {return _opt;}
    4040
    4141  static void bancroft(const Matrix& BBpass, ColumnVector& pos);
     
    4949  t_irc prepareObs(const std::vector<t_pppSatObs*>& pppSatObs,
    5050                   std::vector<t_satObs*>& obsVector, bncTime& epoTime);
    51   t_irc cmpModel(t_station* station, const ColumnVector& xyzc,
     51  t_irc cmpModel(t_pppStation* station, const ColumnVector& xyzc,
    5252                 std::vector<t_satObs*>& obsVector);
    5353  t_irc cmpBancroft(const bncTime& epoTime, std::vector<t_satObs*>& obsVector,
     
    5656
    5757  t_output*              _output;
    58   t_ephPool*             _ephPool;
    59   t_obsPool*             _obsPool;
     58  t_pppEphPool*             _ephPool;
     59  t_pppObsPool*             _obsPool;
    6060  bncTime                _epoTimeRover;
    61   t_station*             _staRover;
     61  t_pppStation*             _staRover;
    6262  bncAntex*              _antex;
    63   t_filter*              _filter;
     63  t_pppFilter*              _filter;
    6464  double                 _offGG;
    6565  std::vector<t_satObs*> _obsRover;
    6666  std::ostringstream*    _log;
    67   t_options*             _opt;
     67  t_pppOptions*             _opt;
    6868  t_tides*               _tides;
    6969};
  • trunk/BNC/src/PPP/pppEphPool.cpp

    r5809 r5810  
    4040
    4141#include <iostream>
    42 #include "ephpool.h"
    43 #include "ppp.h"
     42#include "pppEphPool.h"
     43#include "pppInclude.h"
    4444#include "pppClient.h"
    4545
     
    4949//
    5050/////////////////////////////////////////////////////////////////////////////
    51 void t_ephPool::putEphemeris(t_eph* eph) {
     51void t_pppEphPool::putEphemeris(t_eph* eph) {
    5252  if (eph && eph->ok()) {
    5353    _satEphPool[eph->prn().toInt()].putEphemeris(_maxQueueSize, eph);
     
    6060//
    6161/////////////////////////////////////////////////////////////////////////////
    62 void t_ephPool::putOrbCorrection(t_orbCorr* corr) {
     62void t_pppEphPool::putOrbCorrection(t_orbCorr* corr) {
    6363  if (corr) {
    6464    _satEphPool[corr->prn().toInt()].putOrbCorrection(corr);
     
    6868//
    6969/////////////////////////////////////////////////////////////////////////////
    70 void t_ephPool::putClkCorrection(t_clkCorr* corr) {
     70void t_pppEphPool::putClkCorrection(t_clkCorr* corr) {
    7171  if (corr) {
    7272    _satEphPool[corr->prn().toInt()].putClkCorrection(corr);
     
    7676//
    7777/////////////////////////////////////////////////////////////////////////////
    78 t_irc t_ephPool::getCrd(const t_prn& prn, const bncTime& tt,
     78t_irc t_pppEphPool::getCrd(const t_prn& prn, const bncTime& tt,
    7979                             ColumnVector& xc, ColumnVector& vv) const {
    8080  return _satEphPool[prn.toInt()].getCrd(tt, xc, vv);
     
    8383//
    8484/////////////////////////////////////////////////////////////////////////////
    85 int t_ephPool::getChannel(const t_prn& prn) const {
     85int t_pppEphPool::getChannel(const t_prn& prn) const {
    8686  return _satEphPool[prn.toInt()].getChannel();
    8787}
     
    8989//
    9090/////////////////////////////////////////////////////////////////////////////
    91 void t_ephPool::t_satEphPool::putEphemeris(unsigned maxQueueSize, t_eph* eph) {
     91void t_pppEphPool::t_satEphPool::putEphemeris(unsigned maxQueueSize, t_eph* eph) {
    9292  if (_ephs.empty() || eph->isNewerThan(_ephs.front())) {
    9393    _ephs.push_front(eph);
     
    104104//
    105105/////////////////////////////////////////////////////////////////////////////
    106 void t_ephPool::t_satEphPool::putOrbCorrection(t_orbCorr* corr) {
     106void t_pppEphPool::t_satEphPool::putOrbCorrection(t_orbCorr* corr) {
    107107  for (unsigned ii = 0; ii < _ephs.size(); ii++) {
    108108    t_eph* eph = _ephs[ii];
     
    117117//
    118118/////////////////////////////////////////////////////////////////////////////
    119 void t_ephPool::t_satEphPool::putClkCorrection(t_clkCorr* corr) {
     119void t_pppEphPool::t_satEphPool::putClkCorrection(t_clkCorr* corr) {
    120120  for (unsigned ii = 0; ii < _ephs.size(); ii++) {
    121121    t_eph* eph = _ephs[ii];
     
    129129//
    130130/////////////////////////////////////////////////////////////////////////////
    131 t_irc t_ephPool::t_satEphPool::getCrd(const bncTime& tt, ColumnVector& xc,
     131t_irc t_pppEphPool::t_satEphPool::getCrd(const bncTime& tt, ColumnVector& xc,
    132132                                           ColumnVector& vv) const {
    133133  for (unsigned ii = 0; ii < _ephs.size(); ii++) {
     
    149149//
    150150/////////////////////////////////////////////////////////////////////////////
    151 int t_ephPool::t_satEphPool::getChannel() const {
     151int t_pppEphPool::t_satEphPool::getChannel() const {
    152152  if (_ephs.size() > 0) {
    153153    return _ephs[0]->slotNum();
  • trunk/BNC/src/PPP/pppEphPool.h

    r5809 r5810  
    33
    44#include <deque>
    5 #include "ppp.h"
     5#include "pppInclude.h"
    66#include "bnctime.h"
    77#include "ephemeris.h"
     
    99namespace BNC {
    1010
    11 class t_ephPool {
     11class t_pppEphPool {
    1212 public:
    13   t_ephPool(unsigned maxQueueSize = 3) {
     13  t_pppEphPool(unsigned maxQueueSize = 3) {
    1414    _maxQueueSize = maxQueueSize;
    1515  }
    16   ~t_ephPool() {};
     16  ~t_pppEphPool() {};
    1717
    1818  void putEphemeris(t_eph* eph);
  • trunk/BNC/src/PPP/pppFilter.cpp

    r5809 r5810  
    66#include <newmatap.h>
    77
    8 #include "filter.h"
     8#include "pppFilter.h"
    99#include "bncutils.h"
    10 #include "parlist.h"
    11 #include "obspool.h"
    12 #include "station.h"
     10#include "pppParlist.h"
     11#include "pppObsPool.h"
     12#include "pppStation.h"
    1313#include "pppClient.h"
    1414
     
    1818// Constructor
    1919////////////////////////////////////////////////////////////////////////////
    20 t_filter::t_filter() {
     20t_pppFilter::t_pppFilter() {
    2121  _parlist = 0;
    2222}
     
    2424// Destructor
    2525////////////////////////////////////////////////////////////////////////////
    26 t_filter::~t_filter() {
     26t_pppFilter::~t_pppFilter() {
    2727  delete _parlist;
    2828}
     
    3030// Process Single Epoch
    3131////////////////////////////////////////////////////////////////////////////
    32 t_irc t_filter::processEpoch(t_obsPool* obsPool) {
     32t_irc t_pppFilter::processEpoch(t_pppObsPool* obsPool) {
    3333
    3434  _numSat     = 0;
    3535
    3636  if (!_parlist) {
    37     _parlist = new t_parlist();
     37    _parlist = new t_pppParlist();
    3838  }
    3939
    4040  // Vector of all Observations
    4141  // --------------------------
    42   t_obsPool::t_epoch* epoch = obsPool->lastEpoch();
     42  t_pppObsPool::t_epoch* epoch = obsPool->lastEpoch();
    4343  if (!epoch) {
    4444    return failure;
     
    7676  // --------------
    7777  _parlist->set(_epoTime, ambLCs, obsVector);
    78   const vector<t_param*>& params = _parlist->params();
     78  const vector<t_pppParam*>& params = _parlist->params();
    7979
    8080  // Status Vector, Variance-Covariance Matrix
     
    8888 
    8989  for (unsigned ii = 0; ii < params.size(); ii++) {
    90     const t_param* par1 = params[ii];
     90    const t_pppParam* par1 = params[ii];
    9191
    9292    _x0[ii] = par1->x0();
     
    100100      _xFlt[ii]     = xFltOld[iOld];
    101101      for (unsigned jj = 0; jj < ii; jj++) {
    102         const t_param* par2 = params[jj];
     102        const t_pppParam* par2 = params[jj];
    103103        int            jOld = par2->indexOld();
    104104        if (jOld >= 0) {
     
    127127// Process Selected LCs
    128128////////////////////////////////////////////////////////////////////////////
    129 t_irc t_filter::processLC(const vector<t_lc::type>& LCs,
     129t_irc t_pppFilter::processLC(const vector<t_lc::type>& LCs,
    130130                               vector<t_satObs*>& obsVector) {
    131131
     
    141141  SymmetricMatrix         QSav       = _QFlt;
    142142  string                  epoTimeStr = string(_epoTime);
    143   const vector<t_param*>& params     = _parlist->params();
     143  const vector<t_pppParam*>& params     = _parlist->params();
    144144  unsigned                maxObs     = obsVector.size() * LCs.size();
    145145   
     
    172172          usedTypes.push_back(tLC);
    173173          for (unsigned iPar = 0; iPar < params.size(); iPar++) {
    174             const t_param* par = params[iPar];
     174            const t_pppParam* par = params[iPar];
    175175            AA[iObs][iPar] = par->partial(_epoTime, obs, tLC);
    176176          }
     
    238238    if (maxOutlierIndex > -1) {
    239239      t_satObs* obs = usedObs[maxOutlierIndex];
    240       t_param* par = 0;
     240      t_pppParam* par = 0;
    241241      LOG << epoTimeStr << " Outlier " << t_lc::toString(maxOutlierLC) << ' '
    242242          << obs->prn().toString()                        << ' '
    243243          << setw(8) << setprecision(4) << maxOutlier << endl;
    244244      for (unsigned iPar = 0; iPar < params.size(); iPar++) {
    245         t_param* hlp = params[iPar];
    246         if (hlp->type() == t_param::amb && hlp->prn()  == obs->prn() &&
     245        t_pppParam* hlp = params[iPar];
     246        if (hlp->type() == t_pppParam::amb && hlp->prn()  == obs->prn() &&
    247247            hlp->tLC()  == usedTypes[maxOutlierIndex]) {
    248248          par = hlp;
     
    289289// Cycle-Slip Detection
    290290////////////////////////////////////////////////////////////////////////////
    291 t_irc t_filter::detectCycleSlips(const vector<t_lc::type>& LCs,
     291t_irc t_pppFilter::detectCycleSlips(const vector<t_lc::type>& LCs,
    292292                                      const vector<t_satObs*>& obsVector) {
    293293
    294294  const double            SLIP       = 20.0;  // slip threshold
    295295  string                  epoTimeStr = string(_epoTime);
    296   const vector<t_param*>& params     = _parlist->params();
     296  const vector<t_pppParam*>& params     = _parlist->params();
    297297
    298298  for (unsigned ii = 0; ii < LCs.size(); ii++) {
     
    336336          ColumnVector AA(params.size());
    337337          for (unsigned iPar = 0; iPar < params.size(); iPar++) {
    338             const t_param* par = params[iPar];
     338            const t_pppParam* par = params[iPar];
    339339            AA[iPar] = par->partial(_epoTime, obs, tLC);
    340340          }
     
    358358// Reset Ambiguity Parameter (cycle slip)
    359359////////////////////////////////////////////////////////////////////////////
    360 t_irc t_filter::resetAmb(t_prn prn, const vector<t_satObs*>& obsVector,
     360t_irc t_pppFilter::resetAmb(t_prn prn, const vector<t_satObs*>& obsVector,
    361361                         SymmetricMatrix* QSav, ColumnVector* xSav) {
    362362  t_irc irc = failure;
    363   vector<t_param*>& params = _parlist->params();
     363  vector<t_pppParam*>& params = _parlist->params();
    364364  for (unsigned iPar = 0; iPar < params.size(); iPar++) {
    365     t_param* par = params[iPar];
    366     if (par->type() == t_param::amb && par->prn() == prn) {
     365    t_pppParam* par = params[iPar];
     366    if (par->type() == t_pppParam::amb && par->prn() == prn) {
    367367      int ind = par->indexNew();
    368368      t_lc::type tLC = par->tLC();
    369369      LOG << string(_epoTime) << " RESET " << par->toString() << endl;
    370       delete par; par = new t_param(t_param::amb, prn, tLC, &obsVector);
     370      delete par; par = new t_pppParam(t_pppParam::amb, prn, tLC, &obsVector);
    371371      par->setIndex(ind);
    372372      params[iPar] = par;
     
    395395// Compute various DOP Values
    396396////////////////////////////////////////////////////////////////////////////
    397 void t_filter::cmpDOP(const std::vector<t_lc::type>& LCs, const Matrix& AA) {
     397void t_pppFilter::cmpDOP(const std::vector<t_lc::type>& LCs, const Matrix& AA) {
    398398
    399399  _dop.reset();
  • trunk/BNC/src/PPP/pppFilter.h

    r5809 r5810  
    44#include <vector>
    55#include <newmat.h>
    6 #include "ppp.h"
    7 #include "parlist.h"
     6#include "pppInclude.h"
     7#include "pppParlist.h"
    88#include "bnctime.h"
    99#include "t_prn.h"
     
    1111namespace BNC {
    1212
    13 class t_parlist;
    14 class t_obsPool;
     13class t_pppParlist;
     14class t_pppObsPool;
    1515class t_satObs;
    1616
    17 class t_filter {
     17class t_pppFilter {
    1818 public:
    19   t_filter();
    20   ~t_filter();
     19  t_pppFilter();
     20  ~t_pppFilter();
    2121
    22   t_irc processEpoch(t_obsPool* obsPool);
     22  t_irc processEpoch(t_pppObsPool* obsPool);
    2323
    2424  const ColumnVector&    x() const {return _xFlt;}
     
    6161
    6262  bncTime         _epoTime;
    63   t_parlist*      _parlist;
     63  t_pppParlist*      _parlist;
    6464  SymmetricMatrix _QFlt;
    6565  ColumnVector    _xFlt;
  • trunk/BNC/src/PPP/pppMain.cpp

    r5795 r5810  
    7070    readOptions();
    7171
    72     QListIterator<t_options*> iOpt(_options);
     72    QListIterator<t_pppOptions*> iOpt(_options);
    7373    while (iOpt.hasNext()) {
    74       const t_options* opt = iOpt.next();
    75       t_pppThread* pppThread = new t_pppThread(opt);
    76       pppThread->start();
    77       _pppThreads << pppThread;
     74      const t_pppOptions* opt = iOpt.next();
     75      t_pppInclude.hread* pppInclude.hread = new t_pppInclude.hread(opt);
     76      pppInclude.hread->start();
     77      _pppInclude.hreads << pppInclude.hread;
    7878      _running = true;
    7979    }
     
    9292  }
    9393
    94   QListIterator<t_pppThread*> it(_pppThreads);
     94  QListIterator<t_pppInclude.hread*> it(_pppInclude.hreads);
    9595  while (it.hasNext()) {
    96     t_pppThread* pppThread = it.next();
    97     pppThread->exit();
    98   }
    99   _pppThreads.clear();
    100 
    101   QListIterator<t_options*> iOpt(_options);
     96    t_pppInclude.hread* pppInclude.hread = it.next();
     97    pppInclude.hread->exit();
     98  }
     99  _pppInclude.hreads.clear();
     100
     101  QListIterator<t_pppOptions*> iOpt(_options);
    102102  while (iOpt.hasNext()) {
    103103    delete iOpt.next();
     
    112112void t_pppMain::readOptions() {
    113113
    114   QListIterator<t_options*> iOpt(_options);
     114  QListIterator<t_pppOptions*> iOpt(_options);
    115115  while (iOpt.hasNext()) {
    116116    delete iOpt.next();
     
    143143    }
    144144
    145     t_options* opt = new t_options();
     145    t_pppOptions* opt = new t_pppOptions();
    146146
    147147    opt->_realTime    = realTime;
  • trunk/BNC/src/PPP/pppMain.h

    r5736 r5810  
    33
    44#include <QtCore>
    5 #include "options.h"
    6 #include "pppThread.h"
     5#include "pppOptions.h"
     6#include "pppInclude.hread.h"
    77
    88namespace BNC {
     
    1818  void readOptions();
    1919
    20   QList<t_options*>   _options;
    21   QList<t_pppThread*> _pppThreads;
     20  QList<t_pppOptions*>   _options;
     21  QList<t_pppInclude.hread*> _pppInclude.hreads;
    2222  QString             _logFile;
    2323  QString             _nmeaFile;
  • trunk/BNC/src/PPP/pppObsPool.cpp

    r5809 r5810  
    3939 * -----------------------------------------------------------------------*/
    4040
    41 #include "obspool.h"
     41#include "pppObsPool.h"
    4242
    4343using namespace BNC;
     
    4646// Constructor
    4747/////////////////////////////////////////////////////////////////////////////
    48 t_obsPool::t_epoch::t_epoch(const bncTime& epoTime, vector<t_satObs*>& obsVector) {
     48t_pppObsPool::t_epoch::t_epoch(const bncTime& epoTime, vector<t_satObs*>& obsVector) {
    4949  _epoTime   = epoTime;
    5050  for (unsigned ii = 0; ii < obsVector.size(); ii++) {
     
    5656// Destructor
    5757/////////////////////////////////////////////////////////////////////////////
    58 t_obsPool::t_epoch::~t_epoch() {
     58t_pppObsPool::t_epoch::~t_epoch() {
    5959  for (unsigned ii = 0; ii < _obsVector.size(); ii++) {
    6060    delete _obsVector[ii];
     
    6464// Constructor
    6565/////////////////////////////////////////////////////////////////////////////
    66 t_obsPool::t_obsPool() {
     66t_pppObsPool::t_pppObsPool() {
    6767  for (unsigned ii = 0; ii <= t_prn::MAXPRN; ii++) {
    6868    _satBiases[ii] = 0;
     
    7272// Destructor
    7373/////////////////////////////////////////////////////////////////////////////
    74 t_obsPool::~t_obsPool() {
     74t_pppObsPool::~t_pppObsPool() {
    7575  for (unsigned ii = 0; ii <= t_prn::MAXPRN; ii++) {
    7676    delete _satBiases[ii];
     
    8484//
    8585/////////////////////////////////////////////////////////////////////////////
    86 void t_obsPool::putBiases(t_satBias* satBias) {
     86void t_pppObsPool::putBiases(t_satBias* satBias) {
    8787  int iPrn = satBias->prn().toInt();
    8888  delete _satBiases[iPrn];
     
    9292//
    9393/////////////////////////////////////////////////////////////////////////////
    94 void t_obsPool::putEpoch(const bncTime& epoTime, vector<t_satObs*>& obsVector) {
     94void t_pppObsPool::putEpoch(const bncTime& epoTime, vector<t_satObs*>& obsVector) {
    9595  const unsigned MAXSIZE = 2;
    9696  _epochs.push_back(new t_epoch(epoTime, obsVector));
  • trunk/BNC/src/PPP/pppObsPool.h

    r5809 r5810  
    55#include <deque>
    66#include "satobs.h"
    7 #include "satbias.h"
     7#include "pppSatBias.h"
    88#include "bnctime.h"
    99
    1010namespace BNC {
    1111
    12 class t_obsPool {
     12class t_pppObsPool {
    1313 public:
    1414
     
    2525  };
    2626
    27   t_obsPool();
    28   ~t_obsPool();
     27  t_pppObsPool();
     28  ~t_pppObsPool();
    2929  void putBiases(t_satBias* satBias);
    3030
  • trunk/BNC/src/PPP/pppOptions.cpp

    r5809 r5810  
    2727 * -------------------------------------------------------------------------
    2828 *
    29  * Class:      t_options
     29 * Class:      t_pppOptions
    3030 *
    3131 * Purpose:    Options for PPP client
     
    4040
    4141#include <newmatio.h>
    42 #include "options.h"
     42#include "pppOptions.h"
    4343
    4444using namespace BNC;
     
    4747// Constructor
    4848//////////////////////////////////////////////////////////////////////////////
    49 t_options::t_options() {
     49t_pppOptions::t_pppOptions() {
    5050  _xyzAprRover.ReSize(3); _xyzAprRover = 0.0;
    5151  _ellAprRover.ReSize(3); _ellAprRover = 0.0;
     
    5555// Destructor
    5656//////////////////////////////////////////////////////////////////////////////
    57 t_options::~t_options() {
     57t_pppOptions::~t_pppOptions() {
    5858}
    5959
    6060//
    6161//////////////////////////////////////////////////////////////////////////////
    62 bool t_options::dualFreqRequired() const {
     62bool t_pppOptions::dualFreqRequired() const {
    6363  return true;
    6464}
     
    6666//
    6767//////////////////////////////////////////////////////////////////////////////
    68 bool t_options::biasRequired() const {
     68bool t_pppOptions::biasRequired() const {
    6969  return false;
    7070}
     
    7272//
    7373//////////////////////////////////////////////////////////////////////////////
    74 bool t_options::corrRequired() const {
     74bool t_pppOptions::corrRequired() const {
    7575  return false;
    7676}
     
    7878//
    7979//////////////////////////////////////////////////////////////////////////////
    80 bool t_options::useGlonass() const  {
     80bool t_pppOptions::useGlonass() const  {
    8181  return (_lcGLONASS.size() > 0);
    8282}
     
    8484//
    8585//////////////////////////////////////////////////////////////////////////////
    86 bool t_options::xyzAprRoverSet() const {
     86bool t_pppOptions::xyzAprRoverSet() const {
    8787  return (_xyzAprRover[0] != 0.0 || _xyzAprRover[1] != 0.0 || _xyzAprRover[2] != 0.0);
    8888}
     
    9090//
    9191//////////////////////////////////////////////////////////////////////////////
    92 bool t_options::estTropo() const  {
     92bool t_pppOptions::estTropo() const  {
    9393  return (_sigTropo > 0.0 || _noiseTropo > 0.0);
    9494}
     
    9696//
    9797//////////////////////////////////////////////////////////////////////////////
    98 vector<t_lc::type> t_options::LCs() const {
     98vector<t_lc::type> t_pppOptions::LCs() const {
    9999
    100100  vector<t_lc::type> allLCs = _lcGPS;
     
    131131//
    132132//////////////////////////////////////////////////////////////////////////////
    133 double t_options::maxRes(t_lc::type /* tLC */) const {
     133double t_pppOptions::maxRes(t_lc::type /* tLC */) const {
    134134  return _maxResC1;
    135135}
  • trunk/BNC/src/PPP/pppOptions.h

    r5809 r5810  
    55#include <vector>
    66#include <newmat.h>
    7 #include "ppp.h"
     7#include "pppInclude.h"
    88
    99namespace BNC {
    1010
    11 class t_options {
     11class t_pppOptions {
    1212 public:
    1313  class t_optBias {
     
    1818  };
    1919
    20   t_options();
    21   ~t_options();
     20  t_pppOptions();
     21  ~t_pppOptions();
    2222  bool dualFreqRequired() const;
    2323  bool biasRequired() const;
  • trunk/BNC/src/PPP/pppParlist.cpp

    r5809 r5810  
    55#include <algorithm>
    66#include <newmatio.h>
    7 #include "parlist.h"
     7#include "pppParlist.h"
    88#include "satobs.h"
    99
    10 #include "station.h"
     10#include "pppStation.h"
    1111#include "bncutils.h"
    1212#include "bncconst.h"
     
    1818// Constructor
    1919////////////////////////////////////////////////////////////////////////////
    20 t_param::t_param(e_type type, const t_prn& prn, t_lc::type tLC,
     20t_pppParam::t_pppParam(e_type type, const t_prn& prn, t_lc::type tLC,
    2121                 const vector<t_satObs*>* obsVector) {
    2222
     
    8484// Destructor
    8585////////////////////////////////////////////////////////////////////////////
    86 t_param::~t_param() {
     86t_pppParam::~t_pppParam() {
    8787  delete _ambInfo;
    8888}
     
    9090//
    9191////////////////////////////////////////////////////////////////////////////
    92 double t_param::partial(const bncTime& /* epoTime */, const t_satObs* obs,
     92double t_pppParam::partial(const bncTime& /* epoTime */, const t_satObs* obs,
    9393                        const t_lc::type& tLC) const {
    9494
     
    9999  }
    100100
    101   const t_station* sta  = PPP_CLIENT->staRover();
     101  const t_pppStation* sta  = PPP_CLIENT->staRover();
    102102  ColumnVector     rhoV = sta->xyzApr() - obs->xc().Rows(1,3);
    103103
     
    149149//
    150150////////////////////////////////////////////////////////////////////////////
    151 string t_param::toString() const {
     151string t_pppParam::toString() const {
    152152  stringstream ss;
    153153  switch (_type) {
     
    182182// Constructor
    183183////////////////////////////////////////////////////////////////////////////
    184 t_parlist::t_parlist() {
     184t_pppParlist::t_pppParlist() {
    185185}
    186186
    187187// Destructor
    188188////////////////////////////////////////////////////////////////////////////
    189 t_parlist::~t_parlist() {
     189t_pppParlist::~t_pppParlist() {
    190190  for (unsigned ii = 0; ii < _params.size(); ii++) {
    191191    delete _params[ii];
     
    195195//
    196196////////////////////////////////////////////////////////////////////////////
    197 t_irc t_parlist::set(const bncTime& epoTime, const vector<t_lc::type>& ambLCs,
     197t_irc t_pppParlist::set(const bncTime& epoTime, const vector<t_lc::type>& ambLCs,
    198198                     const vector<t_satObs*>& obsVector) {
    199199
    200200  // Remove some Parameters
    201201  // ----------------------
    202   vector<t_param*>::iterator it = _params.begin();
     202  vector<t_pppParam*>::iterator it = _params.begin();
    203203  while (it != _params.end()) {
    204     t_param* par = *it;
     204    t_pppParam* par = *it;
    205205
    206206    bool remove = false;
     
    210210    }
    211211
    212     else if (par->type() == t_param::amb) {
     212    else if (par->type() == t_pppParam::amb) {
    213213      if (par->lastObsTime().valid() && (epoTime - par->lastObsTime() > 120.0)) {
    214214        remove = true;
     
    216216    }
    217217
    218     else if (par->type() == t_param::amb) {
     218    else if (par->type() == t_pppParam::amb) {
    219219      if (par->lastObsTime().valid() && (epoTime - par->lastObsTime() > 3600.0)) {
    220220        remove = true;
     
    234234  // ------------------------------------------
    235235  for (unsigned ii = 0; ii < _params.size(); ii++) {
    236     t_param* par = _params[ii];
     236    t_pppParam* par = _params[ii];
    237237    if (par->prn() == 0) {
    238238      par->setLastObsTime(epoTime);
     
    257257  // Required Set of Parameters
    258258  // --------------------------
    259   vector<t_param*> required;
     259  vector<t_pppParam*> required;
    260260
    261261  // Coordinates
    262262  // -----------
    263   required.push_back(new t_param(t_param::crdX, t_prn(), t_lc::dummy));
    264   required.push_back(new t_param(t_param::crdY, t_prn(), t_lc::dummy));
    265   required.push_back(new t_param(t_param::crdZ, t_prn(), t_lc::dummy));
     263  required.push_back(new t_pppParam(t_pppParam::crdX, t_prn(), t_lc::dummy));
     264  required.push_back(new t_pppParam(t_pppParam::crdY, t_prn(), t_lc::dummy));
     265  required.push_back(new t_pppParam(t_pppParam::crdZ, t_prn(), t_lc::dummy));
    266266
    267267  // Receiver Clock
    268268  // --------------
    269   required.push_back(new t_param(t_param::clkR, t_prn(), t_lc::dummy));
     269  required.push_back(new t_pppParam(t_pppParam::clkR, t_prn(), t_lc::dummy));
    270270
    271271  // GPS-Glonass Clock Offset
    272272  // ------------------------
    273273  if (OPT->useGlonass()) {
    274     required.push_back(new t_param(t_param::offGG, t_prn(), t_lc::dummy));
     274    required.push_back(new t_pppParam(t_pppParam::offGG, t_prn(), t_lc::dummy));
    275275  }
    276276
     
    278278  // ---------------
    279279  for (unsigned ii = 0; ii < OPT->_estBias.size(); ii++) {
    280     const t_options::t_optBias& optBias = OPT->_estBias[ii];
    281     required.push_back(new t_param(t_param::bias, t_prn(optBias._system, 1), optBias._tLC));
     280    const t_pppOptions::t_optBias& optBias = OPT->_estBias[ii];
     281    required.push_back(new t_pppParam(t_pppParam::bias, t_prn(optBias._system, 1), optBias._tLC));
    282282  }
    283283
     
    285285  // -----------
    286286  if (OPT->estTropo()) {
    287     required.push_back(new t_param(t_param::trp, t_prn(), t_lc::dummy));
     287    required.push_back(new t_pppParam(t_pppParam::trp, t_prn(), t_lc::dummy));
    288288  }
    289289
     
    294294    for (unsigned jj = 0; jj < obsVector.size(); jj++) {
    295295      const t_satObs* satObs = obsVector[jj];
    296       required.push_back(new t_param(t_param::amb, satObs->prn(), tLC, &obsVector));
     296      required.push_back(new t_pppParam(t_pppParam::amb, satObs->prn(), tLC, &obsVector));
    297297    }
    298298  }
     
    301301  // --------------------------------------------
    302302  for (unsigned ii = 0; ii < required.size(); ii++) {
    303     t_param* parReq = required[ii];
     303    t_pppParam* parReq = required[ii];
    304304
    305305    bool found = false;
    306306    for (unsigned jj = 0; jj < _params.size(); jj++) {
    307       t_param* parOld = _params[jj];
     307      t_pppParam* parOld = _params[jj];
    308308      if (parOld->isEqual(parReq)) {
    309309        found = true;
     
    321321  // Set Parameter Indices
    322322  // ---------------------
    323   sort(_params.begin(), _params.end(), t_param::sortFunction);
     323  sort(_params.begin(), _params.end(), t_pppParam::sortFunction);
    324324
    325325  for (unsigned ii = 0; ii < _params.size(); ii++) {
    326     t_param* par = _params[ii];
     326    t_pppParam* par = _params[ii];
    327327    par->setIndex(ii);
    328328    for (unsigned jj = 0; jj < obsVector.size(); jj++) {
     
    340340//
    341341////////////////////////////////////////////////////////////////////////////
    342 void t_parlist::printResult(const bncTime& epoTime, const SymmetricMatrix& QQ,
     342void t_pppParlist::printResult(const bncTime& epoTime, const SymmetricMatrix& QQ,
    343343                            const ColumnVector& xx, double ambFixRate) const {
    344344
     
    347347  LOG << endl;
    348348
    349   t_param* parX = 0;
    350   t_param* parY = 0;
    351   t_param* parZ = 0;
     349  t_pppParam* parX = 0;
     350  t_pppParam* parY = 0;
     351  t_pppParam* parZ = 0;
    352352  for (unsigned ii = 0; ii < _params.size(); ii++) {
    353     t_param* par = _params[ii];
    354     if      (par->type() == t_param::crdX) {
     353    t_pppParam* par = _params[ii];
     354    if      (par->type() == t_pppParam::crdX) {
    355355      parX = par;
    356356    }
    357     else if (par->type() == t_param::crdY) {
     357    else if (par->type() == t_pppParam::crdY) {
    358358      parY = par;
    359359    }
    360     else if (par->type() == t_param::crdZ) {
     360    else if (par->type() == t_pppParam::crdZ) {
    361361      parZ = par;
    362362    }
     
    367367          << showpos << setw(10) << setprecision(4) << xx[ind] << noshowpos << " +- "
    368368          << setw(8)  << setprecision(4) << sqrt(QQ[ind][ind]);
    369       if (par->type() == t_param::amb) {
     369      if (par->type() == t_pppParam::amb) {
    370370        LOG << " el = " << setw(6) << setprecision(2) << par->ambEleSat() * 180.0 / M_PI
    371371            << " epo = " << setw(4) << par->ambNumEpo();
     
    376376 
    377377  if (parX && parY && parZ) {
    378     const t_station* sta = PPP_CLIENT->staRover();
     378    const t_pppStation* sta = PPP_CLIENT->staRover();
    379379
    380380    ColumnVector xyz(3);
  • trunk/BNC/src/PPP/pppParlist.h

    r5809 r5810  
    44#include <vector>
    55#include <string>
    6 #include "ppp.h"
     6#include "pppInclude.h"
    77#include "t_prn.h"
    88#include "bnctime.h"
     
    1212class t_satObs;
    1313
    14 class t_param {
     14class t_pppParam {
    1515 public:
    1616  enum e_type {crdX, crdY, crdZ, clkR, amb, offGG, trp, bias};
    1717
    18   t_param(e_type type, const t_prn& prn, t_lc::type tLC,
     18  t_pppParam(e_type type, const t_prn& prn, t_lc::type tLC,
    1919          const std::vector<t_satObs*>* obsVector = 0);
    2020
    21   ~t_param();
     21  ~t_pppParam();
    2222  e_type type() const {return _type;}
    2323  double x0()  const {return _x0;}
     
    2525                 const t_lc::type& tLC) const;
    2626  bool   epoSpec() const {return _epoSpec;}
    27   bool   isEqual(const t_param* par2) const {
     27  bool   isEqual(const t_pppParam* par2) const {
    2828    return (_type == par2->_type && _prn == par2->_prn && _tLC == par2->_tLC);
    2929  }
     
    5252  void     stepAmbNumEpo()             {if (_ambInfo) _ambInfo->_numEpo += 1;}
    5353
    54   static bool sortFunction(const t_param* p1, const t_param* p2) {
     54  static bool sortFunction(const t_pppParam* p1, const t_pppParam* p2) {
    5555    if      (p1->_type != p2->_type) {
    5656      return p1->_type < p2->_type;
     
    9292};
    9393
    94 class t_parlist {
     94class t_pppParlist {
    9595 public:
    96   t_parlist();
    97   ~t_parlist();
     96  t_pppParlist();
     97  ~t_pppParlist();
    9898
    9999  t_irc set(const bncTime& epoTime, const std::vector<t_lc::type>& ambLCs,
     
    101101
    102102  unsigned nPar() const {return _params.size();}
    103   const std::vector<t_param*>& params() const {return _params;}
    104   std::vector<t_param*>& params() {return _params;}
     103  const std::vector<t_pppParam*>& params() const {return _params;}
     104  std::vector<t_pppParam*>& params() {return _params;}
    105105  void printResult(const bncTime& epoTime, const SymmetricMatrix& QQ,
    106106                   const ColumnVector& xx, double ambFixRate) const;
    107107 private:
    108   std::vector<t_param*> _params;
     108  std::vector<t_pppParam*> _params;
    109109};
    110110
  • trunk/BNC/src/PPP/pppSatBias.cpp

    r5809 r5810  
    3939 * -----------------------------------------------------------------------*/
    4040
    41 #include "satbias.h"
     41#include "pppSatBias.h"
    4242
    4343using namespace BNC;
  • trunk/BNC/src/PPP/pppSatBias.h

    r5809 r5810  
    33
    44#include <map>
    5 #include "ppp.h"
     5#include "pppInclude.h"
    66#include "bnctime.h"
    77
  • trunk/BNC/src/PPP/pppStation.cpp

    r5809 r5810  
    2727 * -------------------------------------------------------------------------
    2828 *
    29  * Class:      t_station
     29 * Class:      t_pppStation
    3030 *
    3131 * Purpose:    Processed station
     
    3939 * -----------------------------------------------------------------------*/
    4040
    41 #include "station.h"
     41#include "pppStation.h"
    4242#include "bncutils.h"
    4343#include "pppModel.h"
     
    4848// Constructor
    4949//////////////////////////////////////////////////////////////////////////////
    50 t_station::t_station() {
     50t_pppStation::t_pppStation() {
    5151  _windUp    = new t_windUp();
    5252}
     
    5454// Destructor
    5555//////////////////////////////////////////////////////////////////////////////
    56 t_station::~t_station() {
     56t_pppStation::~t_pppStation() {
    5757  delete _windUp;
    5858}
     
    6060//
    6161//////////////////////////////////////////////////////////////////////////////
    62 void t_station::setXyzApr(const ColumnVector& xyzApr) {
     62void t_pppStation::setXyzApr(const ColumnVector& xyzApr) {
    6363  _xyzApr = xyzApr;
    6464  _ellApr.ReSize(3);
     
    6868//
    6969//////////////////////////////////////////////////////////////////////////////
    70 void t_station::setNeuEcc(const ColumnVector& neuEcc) {
     70void t_pppStation::setNeuEcc(const ColumnVector& neuEcc) {
    7171  _neuEcc = neuEcc;
    7272  _xyzEcc.ReSize(3);
     
    7676//
    7777//////////////////////////////////////////////////////////////////////////////
    78 double t_station::windUp(const bncTime& time, t_prn prn,
     78double t_pppStation::windUp(const bncTime& time, t_prn prn,
    7979                         const ColumnVector& rSat) const {
    8080  return _windUp->value(time, _xyzApr, prn, rSat);
  • trunk/BNC/src/PPP/pppStation.h

    r5809 r5810  
    44#include <string>
    55#include <newmat.h>
    6 #include "ppp.h"
     6#include "pppInclude.h"
    77#include "bnctime.h"
    88
     
    1111class t_windUp;
    1212
    13 class t_station {
     13class t_pppStation {
    1414 public:
    15   t_station();
    16   ~t_station();
     15  t_pppStation();
     16  ~t_pppStation();
    1717  void setName(std::string name) {_name = name;}
    1818  void setAntName(std::string antName) {_antName = antName;}
  • trunk/BNC/src/PPP/pppThread.cpp

    r5793 r5810  
    2828 * -------------------------------------------------------------------------
    2929 *
    30  * Class:      t_pppThread, t_pppRun
     30 * Class:      t_pppInclude.hread, t_pppRun
    3131 *
    3232 * Purpose:    Single PPP Client (running in its own thread)
     
    4646#include <map>
    4747
    48 #include "pppThread.h"
     48#include "pppInclude.hread.h"
    4949#include "bnccore.h"
    5050
     
    5454// Constructor
    5555////////////////////////////////////////////////////////////////////////////
    56 t_pppThread::t_pppThread(const t_options* opt) : QThread(0) {
     56t_pppInclude.hread::t_pppInclude.hread(const t_pppOptions* opt) : QThread(0) {
    5757  _opt   = opt;
    5858  _pppRun = 0;
     
    6565// Destructor
    6666////////////////////////////////////////////////////////////////////////////
    67 t_pppThread::~t_pppThread() {
     67t_pppInclude.hread::~t_pppInclude.hread() {
    6868  delete _pppRun;
    6969}
     
    7171// Run (virtual)
    7272////////////////////////////////////////////////////////////////////////////
    73 void t_pppThread::run() {
     73void t_pppInclude.hread::run() {
    7474  try {
    7575    _pppRun = new t_pppRun(_opt);
     
    8484// Constructor
    8585////////////////////////////////////////////////////////////////////////////
    86 t_pppRun::t_pppRun(const t_options* opt) {
     86t_pppRun::t_pppRun(const t_pppOptions* opt) {
    8787  _opt = opt;
    8888  connect(this, SIGNAL(newMessage(QByteArray,bool)),
  • trunk/BNC/src/PPP/pppThread.h

    r5791 r5810  
    77
    88#include "GPSDecoder.h"
    9 #include "options.h"
     9#include "pppOptions.h"
    1010#include "pppClient.h"
    1111
     
    2727 Q_OBJECT
    2828 public:
    29   t_pppRun(const t_options* opt);
     29  t_pppRun(const t_pppOptions* opt);
    3030  ~t_pppRun();
    3131
     
    4242 private:
    4343  QMutex                    _mutex;
    44   const t_options*          _opt;
     44  const t_pppOptions*          _opt;
    4545  t_pppClient*              _pppClient;
    4646  std::deque<t_pppEpoData*> _pppEpochs;
    4747};
    4848
    49 class t_pppThread : public QThread {
     49class t_pppInclude.hread : public QThread {
    5050 Q_OBJECT
    5151 public:
    52   t_pppThread(const t_options* opt);
    53   ~t_pppThread();
     52  t_pppInclude.hread(const t_pppOptions* opt);
     53  ~t_pppInclude.hread();
    5454  virtual void run();
    5555
     
    5858
    5959 private:
    60   const t_options* _opt;
     60  const t_pppOptions* _opt;
    6161  t_pppRun*        _pppRun;
    6262};
  • trunk/BNC/src/PPP/pppWidgets.cpp

    r5809 r5810  
    4141#include <iostream>
    4242
    43 #include "PPP/pppwidgets.h"
     43#include "PPP/pppWidgets.h"
    4444#include "qtfilechooser.h"
    4545#include "bncsettings.h"
  • trunk/BNC/src/PPP/satobs.cpp

    r5808 r5810  
    4545#include "satobs.h"
    4646#include "bncconst.h"
    47 #include "ephpool.h"
    48 #include "station.h"
     47#include "pppEphPool.h"
     48#include "pppStation.h"
    4949#include "bncutils.h"
    5050#include "bncantex.h"
    51 #include "obspool.h"
     51#include "pppObsPool.h"
    5252#include "pppClient.h"
    5353
     
    174174//
    175175////////////////////////////////////////////////////////////////////////////
    176 t_irc t_satObs::cmpModel(const t_station* station) {
     176t_irc t_satObs::cmpModel(const t_pppStation* station) {
    177177
    178178  // Reset all model values
  • trunk/BNC/src/PPP/satobs.h

    r5780 r5810  
    55#include <map>
    66#include <newmat.h>
    7 #include "ppp.h"
     7#include "pppInclude.h"
    88#include "bnctime.h"
    99
     
    1212typedef std::string t_obsType;
    1313
    14 class t_station;
     14class t_pppStation;
    1515
    1616class t_satObs {
     
    2323  const ColumnVector& xc() const {return _xcSat;}
    2424  const bncTime&      time() const {return _time;}
    25   t_irc               cmpModel(const t_station* station);
     25  t_irc               cmpModel(const t_pppStation* station);
    2626  double              obsValue(t_lc::type tLC) const;
    2727  double              cmpValue(t_lc::type tLC) const;
Note: See TracChangeset for help on using the changeset viewer.