Changeset 6093 in ntrip


Ignore:
Timestamp:
Sep 7, 2014, 7:18:16 PM (7 years ago)
Author:
mervart
Message:
 
Location:
trunk/BNC/src/PPP_free
Files:
4 edited

Legend:

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

    r6088 r6093  
    4444
    4545#include "pppClient.h"
     46#include "pppFilter.h"
    4647#include "pppOptions.h"
    4748#include "bncutils.h"
    4849#include "bncconst.h"
    49 #include "bncmodel.h"
    5050
    5151using namespace BNC_PPP;
     
    6666t_pppClient::t_pppClient(const t_pppOptions* opt) : bncEphUser(false) {
    6767
    68   _opt       = new t_pppOptions(*opt);
    69   _model     = new bncModel(this);
    70   _epoData   = new t_epoData();
    71   _log       = new ostringstream();
    72   _staID     = QByteArray(_opt->_roverName.c_str());
     68  _opt     = new t_pppOptions(*opt);
     69  _filter  = new t_pppFilter(this);
     70  _epoData = new t_epoData();
     71  _log     = new ostringstream();
     72  _staID   = QByteArray(_opt->_roverName.c_str());
    7373
    7474  CLIENTS.setLocalData(this);  // CLIENTS takes ownership over "this"
     
    7878////////////////////////////////////////////////////////////////////////////
    7979t_pppClient::~t_pppClient() {
    80   delete _model;
     80  delete _filter;
    8181  delete _epoData;
    8282  delete _opt;
     
    147147  // Filter Solution
    148148  // ---------------
    149   if (_model->update(_epoData) == success) {
     149  if (_filter->update(_epoData) == success) {
    150150    output->_error = false;
    151     output->_epoTime     = _model->time();
    152     output->_xyzRover[0] = _model->x();
    153     output->_xyzRover[1] = _model->y();
    154     output->_xyzRover[2] = _model->z();
     151    output->_epoTime     = _filter->time();
     152    output->_xyzRover[0] = _filter->x();
     153    output->_xyzRover[1] = _filter->y();
     154    output->_xyzRover[2] = _filter->z();
    155155    output->_numSat      = 0;
    156156    output->_pDop        = 0.0;
  • trunk/BNC/src/PPP_free/pppClient.h

    r6085 r6093  
    2323// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
    2424
    25 #ifndef BNCPPPCLIENT_H
    26 #define BNCPPPCLIENT_H
     25#ifndef PPPCLIENT_H
     26#define PPPCLIENT_H
    2727
    2828#include <vector>
     
    3131namespace BNC_PPP {
    3232 
    33 class bncModel;
     33class t_pppFilter;
    3434class t_pppOptions;
    3535class t_satObs;
     
    6363  QByteArray          _staID;
    6464  t_epoData*          _epoData;
    65   bncModel*           _model;
     65  t_pppFilter*        _filter;
    6666  std::ostringstream* _log;
    6767};
  • trunk/BNC/src/PPP_free/pppFilter.cpp

    r6091 r6093  
    2727 * -------------------------------------------------------------------------
    2828 *
    29  * Class:      bncParam, bncModel
     29 * Class:      t_pppParam, t_pppFilter
    3030 *
    3131 * Purpose:    Model for PPP
     
    4444#include <sstream>
    4545
    46 #include "bncmodel.h"
     46#include "pppFilter.h"
    4747#include "pppClient.h"
    4848#include "bncutils.h"
     
    6363// Constructor
    6464////////////////////////////////////////////////////////////////////////////
    65 bncParam::bncParam(bncParam::parType typeIn, int indexIn,
     65t_pppParam::t_pppParam(t_pppParam::parType typeIn, int indexIn,
    6666                   const QString& prnIn) {
    6767  type      = typeIn;
     
    7575// Destructor
    7676////////////////////////////////////////////////////////////////////////////
    77 bncParam::~bncParam() {
     77t_pppParam::~t_pppParam() {
    7878}
    7979
    8080// Partial
    8181////////////////////////////////////////////////////////////////////////////
    82 double bncParam::partial(t_satData* satData, bool phase) {
    83 
    84   Tracer tracer("bncParam::partial");
     82double t_pppParam::partial(t_satData* satData, bool phase) {
     83
     84  Tracer tracer("t_pppParam::partial");
    8585
    8686  // Coordinates
     
    148148// Constructor
    149149////////////////////////////////////////////////////////////////////////////
    150 bncModel::bncModel(t_pppClient* pppClient) {
     150t_pppFilter::t_pppFilter(t_pppClient* pppClient) {
    151151
    152152  _pppClient = pppClient;
     
    175175// Destructor
    176176////////////////////////////////////////////////////////////////////////////
    177 bncModel::~bncModel() {
     177t_pppFilter::~t_pppFilter() {
    178178  delete _tides;
    179179  for (int ii = 0; ii < _posAverage.size(); ++ii) {
     
    192192// Reset Parameters and Variance-Covariance Matrix
    193193////////////////////////////////////////////////////////////////////////////
    194 void bncModel::reset() {
    195 
    196   Tracer tracer("bncModel::reset");
     194void t_pppFilter::reset() {
     195
     196  Tracer tracer("t_pppFilter::reset");
    197197
    198198  double lastTrp = 0.0;
    199199  for (int ii = 0; ii < _params.size(); ii++) {
    200     bncParam* pp = _params[ii];
    201     if (pp->type == bncParam::TROPO) {
     200    t_pppParam* pp = _params[ii];
     201    if (pp->type == t_pppParam::TROPO) {
    202202      lastTrp = pp->xx;
    203203    }
     
    207207
    208208  int nextPar = 0;
    209   _params.push_back(new bncParam(bncParam::CRD_X,  ++nextPar, ""));
    210   _params.push_back(new bncParam(bncParam::CRD_Y,  ++nextPar, ""));
    211   _params.push_back(new bncParam(bncParam::CRD_Z,  ++nextPar, ""));
    212   _params.push_back(new bncParam(bncParam::RECCLK, ++nextPar, ""));
     209  _params.push_back(new t_pppParam(t_pppParam::CRD_X,  ++nextPar, ""));
     210  _params.push_back(new t_pppParam(t_pppParam::CRD_Y,  ++nextPar, ""));
     211  _params.push_back(new t_pppParam(t_pppParam::CRD_Z,  ++nextPar, ""));
     212  _params.push_back(new t_pppParam(t_pppParam::RECCLK, ++nextPar, ""));
    213213  if (_opt->estTrp()) {
    214     _params.push_back(new bncParam(bncParam::TROPO, ++nextPar, ""));
     214    _params.push_back(new t_pppParam(t_pppParam::TROPO, ++nextPar, ""));
    215215  }
    216216  if (_opt->useSystem('R')) {
    217     _params.push_back(new bncParam(bncParam::GLONASS_OFFSET, ++nextPar, ""));
     217    _params.push_back(new t_pppParam(t_pppParam::GLONASS_OFFSET, ++nextPar, ""));
    218218  }
    219219  if (_opt->useSystem('E')) {
    220     _params.push_back(new bncParam(bncParam::GALILEO_OFFSET, ++nextPar, ""));
     220    _params.push_back(new t_pppParam(t_pppParam::GALILEO_OFFSET, ++nextPar, ""));
    221221  }
    222222
     
    224224  _QQ = 0.0;
    225225  for (int iPar = 1; iPar <= _params.size(); iPar++) {
    226     bncParam* pp = _params[iPar-1];
     226    t_pppParam* pp = _params[iPar-1];
    227227    pp->xx = 0.0;
    228228    if      (pp->isCrd()) {
    229229      _QQ(iPar,iPar) = _opt->_aprSigCrd(1) * _opt->_aprSigCrd(1);
    230230    }
    231     else if (pp->type == bncParam::RECCLK) {
     231    else if (pp->type == t_pppParam::RECCLK) {
    232232      _QQ(iPar,iPar) = _opt->_noiseClk * _opt->_noiseClk;
    233233    }
    234     else if (pp->type == bncParam::TROPO) {
     234    else if (pp->type == t_pppParam::TROPO) {
    235235      _QQ(iPar,iPar) = _opt->_aprSigTrp * _opt->_aprSigTrp;
    236236      pp->xx = lastTrp;
    237237    }
    238     else if (pp->type == bncParam::GLONASS_OFFSET) {
     238    else if (pp->type == t_pppParam::GLONASS_OFFSET) {
    239239      _QQ(iPar,iPar) = 1000.0 * 1000.0;
    240240    }
    241     else if (pp->type == bncParam::GALILEO_OFFSET) {
     241    else if (pp->type == t_pppParam::GALILEO_OFFSET) {
    242242      _QQ(iPar,iPar) = 1000.0 * 1000.0;
    243243    }
     
    247247// Bancroft Solution
    248248////////////////////////////////////////////////////////////////////////////
    249 t_irc bncModel::cmpBancroft(t_epoData* epoData) {
    250 
    251   Tracer tracer("bncModel::cmpBancroft");
     249t_irc t_pppFilter::cmpBancroft(t_epoData* epoData) {
     250
     251  Tracer tracer("t_pppFilter::cmpBancroft");
    252252
    253253  if (epoData->sizeSys('G') < MINOBS) {
    254     _log += "bncModel::cmpBancroft: not enough data\n";
     254    _log += "t_pppFilter::cmpBancroft: not enough data\n";
    255255    return failure;
    256256  }
     
    297297// Computed Value
    298298////////////////////////////////////////////////////////////////////////////
    299 double bncModel::cmpValue(t_satData* satData, bool phase) {
    300 
    301   Tracer tracer("bncModel::cmpValue");
     299double t_pppFilter::cmpValue(t_satData* satData, bool phase) {
     300
     301  Tracer tracer("t_pppFilter::cmpValue");
    302302
    303303  ColumnVector xRec(3);
     
    357357// Tropospheric Model (Saastamoinen)
    358358////////////////////////////////////////////////////////////////////////////
    359 double bncModel::delay_saast(double Ele) {
    360 
    361   Tracer tracer("bncModel::delay_saast");
     359double t_pppFilter::delay_saast(double Ele) {
     360
     361  Tracer tracer("t_pppFilter::delay_saast");
    362362
    363363  double xyz[3];
     
    398398// Prediction Step of the Filter
    399399////////////////////////////////////////////////////////////////////////////
    400 void bncModel::predict(int iPhase, t_epoData* epoData) {
    401 
    402   Tracer tracer("bncModel::predict");
     400void t_pppFilter::predict(int iPhase, t_epoData* epoData) {
     401
     402  Tracer tracer("t_pppFilter::predict");
    403403
    404404  if (iPhase == 0) {
     
    423423    // -----------------------------------------
    424424    for (int iPar = 1; iPar <= _params.size(); iPar++) {
    425       bncParam* pp = _params[iPar-1];
     425      t_pppParam* pp = _params[iPar-1];
    426426   
    427427      // Coordinates
    428428      // -----------
    429       if      (pp->type == bncParam::CRD_X) {
     429      if      (pp->type == t_pppParam::CRD_X) {
    430430        if (firstCrd) {
    431431          if (_opt->xyzAprRoverSet()) {
     
    438438        _QQ(iPar,iPar) += sigCrdP_used * sigCrdP_used;
    439439      }
    440       else if (pp->type == bncParam::CRD_Y) {
     440      else if (pp->type == t_pppParam::CRD_Y) {
    441441        if (firstCrd) {
    442442          if (_opt->xyzAprRoverSet()) {
     
    449449        _QQ(iPar,iPar) += sigCrdP_used * sigCrdP_used;
    450450      }
    451       else if (pp->type == bncParam::CRD_Z) {
     451      else if (pp->type == t_pppParam::CRD_Z) {
    452452        if (firstCrd) {
    453453          if (_opt->xyzAprRoverSet()) {
     
    463463      // Receiver Clocks
    464464      // ---------------
    465       else if (pp->type == bncParam::RECCLK) {
     465      else if (pp->type == t_pppParam::RECCLK) {
    466466        pp->xx = _xcBanc(4);
    467467        for (int jj = 1; jj <= _params.size(); jj++) {
     
    473473      // Tropospheric Delay
    474474      // ------------------
    475       else if (pp->type == bncParam::TROPO) {
     475      else if (pp->type == t_pppParam::TROPO) {
    476476        _QQ(iPar,iPar) += _opt->_noiseTrp * _opt->_noiseTrp;
    477477      }
     
    479479      // Glonass Offset
    480480      // --------------
    481       else if (pp->type == bncParam::GLONASS_OFFSET) {
     481      else if (pp->type == t_pppParam::GLONASS_OFFSET) {
    482482        pp->xx = 0.0;
    483483        for (int jj = 1; jj <= _params.size(); jj++) {
     
    489489      // Galileo Offset
    490490      // --------------
    491       else if (pp->type == bncParam::GALILEO_OFFSET) {
     491      else if (pp->type == t_pppParam::GALILEO_OFFSET) {
    492492        _QQ(iPar,iPar) += 0.1 * 0.1;
    493493      }
     
    511511    // ------------------------------------------------
    512512    int iPar = 0;
    513     QMutableVectorIterator<bncParam*> im(_params);
     513    QMutableVectorIterator<t_pppParam*> im(_params);
    514514    while (im.hasNext()) {
    515       bncParam* par = im.next();
     515      t_pppParam* par = im.next();
    516516      bool removed = false;
    517       if (par->type == bncParam::AMB_L3) {
     517      if (par->type == t_pppParam::AMB_L3) {
    518518        if (epoData->satData.find(par->prn) == epoData->satData.end()) {
    519519          removed = true;
     
    540540    _QQ.ReSize(nPar); _QQ = 0.0;
    541541    for (int i1 = 1; i1 <= nPar; i1++) {
    542       bncParam* p1 = _params[i1-1];
     542      t_pppParam* p1 = _params[i1-1];
    543543      if (p1->index_old != 0) {
    544544        _QQ(p1->index, p1->index) = QQ_old(p1->index_old, p1->index_old);
    545545        for (int i2 = 1; i2 <= nPar; i2++) {
    546           bncParam* p2 = _params[i2-1];
     546          t_pppParam* p2 = _params[i2-1];
    547547          if (p2->index_old != 0) {
    548548            _QQ(p1->index, p2->index) = QQ_old(p1->index_old, p2->index_old);
     
    553553   
    554554    for (int ii = 1; ii <= nPar; ii++) {
    555       bncParam* par = _params[ii-1];
     555      t_pppParam* par = _params[ii-1];
    556556      if (par->index_old == 0) {
    557557        _QQ(par->index, par->index) = _opt->_aprSigAmb * _opt->_aprSigAmb;
     
    564564// Update Step of the Filter (currently just a single-epoch solution)
    565565////////////////////////////////////////////////////////////////////////////
    566 t_irc bncModel::update(t_epoData* epoData) {
    567 
    568   Tracer tracer("bncModel::update");
     566t_irc t_pppFilter::update(t_epoData* epoData) {
     567
     568  Tracer tracer("t_pppFilter::update");
    569569
    570570  _log.clear(); 
     
    599599  ostringstream strB;
    600600  strB.setf(ios::fixed);
    601   QVectorIterator<bncParam*> itPar(_params);
     601  QVectorIterator<t_pppParam*> itPar(_params);
    602602  while (itPar.hasNext()) {
    603     bncParam* par = itPar.next();
    604 
    605     if      (par->type == bncParam::RECCLK) {
     603    t_pppParam* par = itPar.next();
     604
     605    if      (par->type == t_pppParam::RECCLK) {
    606606      strB << "\n    clk     = " << setw(10) << setprecision(3) << par->xx
    607607           << " +- " << setw(6) << setprecision(3)
    608608           << sqrt(_QQ(par->index,par->index));
    609609    }
    610     else if (par->type == bncParam::AMB_L3) {
     610    else if (par->type == t_pppParam::AMB_L3) {
    611611      ++par->numEpo;
    612612      strB << "\n    amb " << par->prn.toAscii().data() << " = "
     
    616616           << "   nEpo = " << par->numEpo;
    617617    }
    618     else if (par->type == bncParam::TROPO) {
     618    else if (par->type == t_pppParam::TROPO) {
    619619      double aprTrp = delay_saast(M_PI/2.0);
    620620      strB << "\n    trp     = " << par->prn.toAscii().data()
     
    625625      newPos->xnt[6] = aprTrp + par->xx;
    626626    }
    627     else if (par->type == bncParam::GLONASS_OFFSET) {
     627    else if (par->type == t_pppParam::GLONASS_OFFSET) {
    628628      strB << "\n    offGlo  = " << setw(10) << setprecision(3) << par->xx
    629629           << " +- " << setw(6) << setprecision(3)
    630630           << sqrt(_QQ(par->index,par->index));
    631631    }
    632     else if (par->type == bncParam::GALILEO_OFFSET) {
     632    else if (par->type == t_pppParam::GALILEO_OFFSET) {
    633633      strB << "\n    offGal  = " << setw(10) << setprecision(3) << par->xx
    634634           << " +- " << setw(6) << setprecision(3)
     
    681681// Outlier Detection
    682682////////////////////////////////////////////////////////////////////////////
    683 QString bncModel::outlierDetection(int iPhase, const ColumnVector& vv,
     683QString t_pppFilter::outlierDetection(int iPhase, const ColumnVector& vv,
    684684                                   QMap<QString, t_satData*>& satData) {
    685685
    686   Tracer tracer("bncModel::outlierDetection");
     686  Tracer tracer("t_pppFilter::outlierDetection");
    687687
    688688  QString prnGPS;
     
    715715//
    716716//////////////////////////////////////////////////////////////////////////////
    717 void bncModel::kalman(const Matrix& AA, const ColumnVector& ll,
     717void t_pppFilter::kalman(const Matrix& AA, const ColumnVector& ll,
    718718                      const DiagonalMatrix& PP,
    719719                      SymmetricMatrix& QQ, ColumnVector& dx) {
    720720
    721   Tracer tracer("bncModel::kalman");
     721  Tracer tracer("t_pppFilter::kalman");
    722722
    723723  int nPar = AA.Ncols();
     
    752752// Phase Wind-Up Correction
    753753///////////////////////////////////////////////////////////////////////////
    754 double bncModel::windUp(const QString& prn, const ColumnVector& rSat,
     754double t_pppFilter::windUp(const QString& prn, const ColumnVector& rSat,
    755755                        const ColumnVector& rRec) {
    756756
    757   Tracer tracer("bncModel::windUp");
     757  Tracer tracer("t_pppFilter::windUp");
    758758
    759759  double Mjd = _time.mjd() + _time.daysec() / 86400.0;
     
    835835//
    836836///////////////////////////////////////////////////////////////////////////
    837 void bncModel::cmpEle(t_satData* satData) {
    838   Tracer tracer("bncModel::cmpEle");
     837void t_pppFilter::cmpEle(t_satData* satData) {
     838  Tracer tracer("t_pppFilter::cmpEle");
    839839  ColumnVector rr = satData->xx - _xcBanc.Rows(1,3);
    840840  double       rho = rr.norm_Frobenius();
     
    852852//
    853853///////////////////////////////////////////////////////////////////////////
    854 void bncModel::addAmb(t_satData* satData) {
    855   Tracer tracer("bncModel::addAmb");
     854void t_pppFilter::addAmb(t_satData* satData) {
     855  Tracer tracer("t_pppFilter::addAmb");
    856856  bool    found = false;
    857857  for (int iPar = 1; iPar <= _params.size(); iPar++) {
    858     if (_params[iPar-1]->type == bncParam::AMB_L3 &&
     858    if (_params[iPar-1]->type == t_pppParam::AMB_L3 &&
    859859        _params[iPar-1]->prn == satData->prn) {
    860860      found = true;
     
    863863  }
    864864  if (!found) {
    865     bncParam* par = new bncParam(bncParam::AMB_L3,
     865    t_pppParam* par = new t_pppParam(t_pppParam::AMB_L3,
    866866                                 _params.size()+1, satData->prn);
    867867    _params.push_back(par);
     
    872872//
    873873///////////////////////////////////////////////////////////////////////////
    874 void bncModel::addObs(int iPhase, unsigned& iObs, t_satData* satData,
     874void t_pppFilter::addObs(int iPhase, unsigned& iObs, t_satData* satData,
    875875                      Matrix& AA, ColumnVector& ll, DiagonalMatrix& PP) {
    876876
    877   Tracer tracer("bncModel::addObs");
     877  Tracer tracer("t_pppFilter::addObs");
    878878
    879879  const double ELEWGHT = 20.0;
     
    899899    PP(iObs,iObs) = 1.0 / (sigL3 * sigL3) / (ellWgtCoef * ellWgtCoef);
    900900    for (int iPar = 1; iPar <= _params.size(); iPar++) {
    901       if (_params[iPar-1]->type == bncParam::AMB_L3 &&
     901      if (_params[iPar-1]->type == t_pppParam::AMB_L3 &&
    902902          _params[iPar-1]->prn  == satData->prn) {
    903903        ll(iObs) -= _params[iPar-1]->xx;
     
    921921//
    922922///////////////////////////////////////////////////////////////////////////
    923 QByteArray bncModel::printRes(int iPhase, const ColumnVector& vv,
     923QByteArray t_pppFilter::printRes(int iPhase, const ColumnVector& vv,
    924924                              const QMap<QString, t_satData*>& satDataMap) {
    925925
    926   Tracer tracer("bncModel::printRes");
     926  Tracer tracer("t_pppFilter::printRes");
    927927
    928928  ostringstream str;
     
    946946//
    947947///////////////////////////////////////////////////////////////////////////
    948 void bncModel::findMaxRes(const ColumnVector& vv,
     948void t_pppFilter::findMaxRes(const ColumnVector& vv,
    949949                          const QMap<QString, t_satData*>& satData,
    950950                          QString& prnGPS, QString& prnGlo,
    951951                          double& maxResGPS, double& maxResGlo) {
    952952
    953   Tracer tracer("bncModel::findMaxRes");
     953  Tracer tracer("t_pppFilter::findMaxRes");
    954954
    955955  maxResGPS  = 0.0;
     
    980980// Update Step (private - loop over outliers)
    981981////////////////////////////////////////////////////////////////////////////
    982 t_irc bncModel::update_p(t_epoData* epoData) {
    983 
    984   Tracer tracer("bncModel::update_p");
     982t_irc t_pppFilter::update_p(t_epoData* epoData) {
     983
     984  Tracer tracer("t_pppFilter::update_p");
    985985
    986986  // Save Variance-Covariance Matrix, and Status Vector
     
    10651065      if (lastOutlierPrn.isEmpty()) {
    10661066
    1067         QVectorIterator<bncParam*> itPar(_params);
     1067        QVectorIterator<t_pppParam*> itPar(_params);
    10681068        while (itPar.hasNext()) {
    1069           bncParam* par = itPar.next();
     1069          t_pppParam* par = itPar.next();
    10701070          par->xx += dx(par->index);
    10711071        }
     
    11081108// Remeber Original State Vector and Variance-Covariance Matrix
    11091109////////////////////////////////////////////////////////////////////////////
    1110 void bncModel::rememberState(t_epoData* epoData) {
     1110void t_pppFilter::rememberState(t_epoData* epoData) {
    11111111
    11121112  _QQ_sav = _QQ;
    11131113
    1114   QVectorIterator<bncParam*> itSav(_params_sav);
     1114  QVectorIterator<t_pppParam*> itSav(_params_sav);
    11151115  while (itSav.hasNext()) {
    1116     bncParam* par = itSav.next();
     1116    t_pppParam* par = itSav.next();
    11171117    delete par;
    11181118  }
    11191119  _params_sav.clear();
    11201120
    1121   QVectorIterator<bncParam*> it(_params);
     1121  QVectorIterator<t_pppParam*> it(_params);
    11221122  while (it.hasNext()) {
    1123     bncParam* par = it.next();
    1124     _params_sav.push_back(new bncParam(*par));
     1123    t_pppParam* par = it.next();
     1124    _params_sav.push_back(new t_pppParam(*par));
    11251125  }
    11261126
     
    11301130// Restore Original State Vector and Variance-Covariance Matrix
    11311131////////////////////////////////////////////////////////////////////////////
    1132 void bncModel::restoreState(t_epoData* epoData) {
     1132void t_pppFilter::restoreState(t_epoData* epoData) {
    11331133
    11341134  _QQ = _QQ_sav;
    11351135
    1136   QVectorIterator<bncParam*> it(_params);
     1136  QVectorIterator<t_pppParam*> it(_params);
    11371137  while (it.hasNext()) {
    1138     bncParam* par = it.next();
     1138    t_pppParam* par = it.next();
    11391139    delete par;
    11401140  }
    11411141  _params.clear();
    11421142
    1143   QVectorIterator<bncParam*> itSav(_params_sav);
     1143  QVectorIterator<t_pppParam*> itSav(_params_sav);
    11441144  while (itSav.hasNext()) {
    1145     bncParam* par = itSav.next();
    1146     _params.push_back(new bncParam(*par));
     1145    t_pppParam* par = itSav.next();
     1146    _params.push_back(new t_pppParam(*par));
    11471147  }
    11481148
     
    11521152//
    11531153////////////////////////////////////////////////////////////////////////////
    1154 t_irc bncModel::selectSatellites(const QString& lastOutlierPrn,
     1154t_irc t_pppFilter::selectSatellites(const QString& lastOutlierPrn,
    11551155                                 QMap<QString, t_satData*>& satData) {
    11561156
     
    12091209//
    12101210////////////////////////////////////////////////////////////////////////////
    1211 void bncModel::bancroft(const Matrix& BBpass, ColumnVector& pos) {
     1211void t_pppFilter::bancroft(const Matrix& BBpass, ColumnVector& pos) {
    12121212
    12131213  if (pos.Nrows() != 4) {
  • trunk/BNC/src/PPP_free/pppFilter.h

    r6091 r6093  
    2323// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
    2424
    25 #ifndef BNCMODEL_H
    26 #define BNCMODEL_H
     25#ifndef PPPFILTER_H
     26#define PPPFILTER_H
    2727
    2828#include <QtCore>
     
    4343class t_tides;
    4444
    45 class bncParam {
     45class t_pppParam {
    4646 public:
    4747  enum parType {CRD_X, CRD_Y, CRD_Z, RECCLK, TROPO, AMB_L3,
    4848                GLONASS_OFFSET, GALILEO_OFFSET};
    49   bncParam(parType typeIn, int indexIn, const QString& prn);
    50   ~bncParam();
     49  t_pppParam(parType typeIn, int indexIn, const QString& prn);
     50  ~t_pppParam();
    5151  double partial(t_satData* satData, bool phase);
    5252  bool isCrd() const {
     
    6161};
    6262
    63 class bncModel {
     63class t_pppFilter {
    6464 public:
    65   bncModel(t_pppClient* pppClient);
    66   ~bncModel();
     65  t_pppFilter(t_pppClient* pppClient);
     66  ~t_pppFilter();
    6767  t_irc update(t_epoData* epoData);
    6868  bncTime time()  const {return _time;}
     
    7373  double trp() const {
    7474    for (int ii = 0; ii < _params.size(); ++ii) {
    75       bncParam* pp = _params[ii];
    76       if (pp->type == bncParam::TROPO) {
     75      t_pppParam* pp = _params[ii];
     76      if (pp->type == t_pppParam::TROPO) {
    7777        return pp->xx;
    7878      }
     
    8282  double Glonass_offset() const {
    8383    for (int ii = 0; ii < _params.size(); ++ii) {
    84       bncParam* pp = _params[ii];
    85       if (pp->type == bncParam::GLONASS_OFFSET) {
     84      t_pppParam* pp = _params[ii];
     85      if (pp->type == t_pppParam::GLONASS_OFFSET) {
    8686        return pp->xx;
    8787      }
     
    9191  double Galileo_offset() const {
    9292    for (int ii = 0; ii < _params.size(); ++ii) {
    93       bncParam* pp = _params[ii];
    94       if (pp->type == bncParam::GALILEO_OFFSET) {
     93      t_pppParam* pp = _params[ii];
     94      if (pp->type == t_pppParam::GALILEO_OFFSET) {
    9595        return pp->xx;
    9696      }
     
    152152  bncTime               _lastTimeOK;
    153153  QByteArray            _staID;
    154   QVector<bncParam*>    _params;
     154  QVector<t_pppParam*>  _params;
    155155  SymmetricMatrix       _QQ;
    156   QVector<bncParam*>    _params_sav;
     156  QVector<t_pppParam*>  _params_sav;
    157157  SymmetricMatrix       _QQ_sav;
    158158  t_epoData*            _epoData_sav;
Note: See TracChangeset for help on using the changeset viewer.