Changeset 5819 in ntrip


Ignore:
Timestamp:
Aug 6, 2014, 1:02:08 PM (8 years ago)
Author:
mervart
Message:
 
Location:
trunk/BNC/src/PPP
Files:
13 edited

Legend:

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

    r5818 r5819  
    7878  _log      = new ostringstream();
    7979  _ephPool  = new t_pppEphPool();
    80   _obsPool  = new t_pppObsPool();
     80  _obsPool  = new t_frqObsPool();
    8181  _staRover = new t_pppStation();
    8282  _filter   = new t_pppFilter();
     
    150150//
    151151//////////////////////////////////////////////////////////////////////////////
    152 t_irc t_pppClient::prepareObs(const vector<t_pppSatObs*>& pppSatObs,
    153                               vector<t_satObs*>& obsVector, bncTime& epoTime) {
     152t_irc t_pppClient::prepareObs(const vector<t_satObs*>& pppSatObs,
     153                              vector<t_pppSatObs*>& obsVector, bncTime& epoTime) {
    154154  // Default
    155155  // -------
     
    162162    char system = pppSatObs[ii]->_prn.system();
    163163    if (system == 'G' || (system == 'R' && OPT->useGlonass())) {
    164       t_satObs* satObs = new t_satObs(*pppSatObs[ii]);
     164      t_pppSatObs* satObs = new t_pppSatObs(*pppSatObs[ii]);
    165165      if (satObs->isValid()) {
    166166        obsVector.push_back(satObs);
     
    180180  double meanDt = 0.0;
    181181  for (unsigned ii = 0; ii < obsVector.size(); ii++) {
    182     const t_satObs* satObs = obsVector.at(ii);
     182    const t_pppSatObs* satObs = obsVector.at(ii);
    183183    if (epoTime.undef()) {
    184184      epoTime = satObs->time();
     
    204204//////////////////////////////////////////////////////////////////////////////
    205205t_irc t_pppClient::cmpBancroft(const bncTime& epoTime,
    206                                   vector<t_satObs*>& obsVector,
     206                                  vector<t_pppSatObs*>& obsVector,
    207207                                  ColumnVector& xyzc, bool print) {
    208208
     
    213213    int iObs = -1;
    214214    for (unsigned ii = 0; ii < obsVector.size(); ii++) {
    215       const t_satObs* satObs = obsVector.at(ii);
     215      const t_pppSatObs* satObs = obsVector.at(ii);
    216216      if ( satObs->isValid() && satObs->prn().system() == 'G' &&
    217217           (!satObs->modelSet() || satObs->eleSat() >= OPT->_minEle) ) {
     
    238238    unsigned maxResIndex = 0;
    239239    for (unsigned ii = 0; ii < obsVector.size(); ii++) {
    240       const t_satObs* satObs = obsVector.at(ii);
     240      const t_pppSatObs* satObs = obsVector.at(ii);
    241241      if ( satObs->isValid() && satObs->prn().system() == 'G' &&
    242242           (!satObs->modelSet() || satObs->eleSat() >= OPT->_minEle) ) {
     
    262262    }
    263263    else {
    264       t_satObs* satObs = obsVector.at(maxResIndex);
     264      t_pppSatObs* satObs = obsVector.at(maxResIndex);
    265265      LOG << "t_pppClient::cmpBancroft outlier " << satObs->prn().toString()
    266266          << " " << maxRes << endl;
     
    275275// Compute A Priori GPS-Glonass Offset
    276276//////////////////////////////////////////////////////////////////////////////
    277 double t_pppClient::cmpOffGG(vector<t_satObs*>& obsVector) {
     277double t_pppClient::cmpOffGG(vector<t_pppSatObs*>& obsVector) {
    278278
    279279  t_lc::type tLC   = (OPT->dualFreqRequired() ? t_lc::cIF : t_lc::c1);
     
    286286      unsigned nObs  = 0;
    287287      for (unsigned ii = 0; ii < obsVector.size(); ii++) {
    288         t_satObs* satObs = obsVector.at(ii);
     288        t_pppSatObs* satObs = obsVector.at(ii);
    289289        if ( !satObs->outlier() && satObs->isValid() && satObs->prn().system() == 'R' &&
    290290             (!satObs->modelSet() || satObs->eleSat() >= OPT->_minEle) ) {
     
    360360//////////////////////////////////////////////////////////////////////////////
    361361t_irc t_pppClient::cmpModel(t_pppStation* station, const ColumnVector& xyzc,
    362                                vector<t_satObs*>& obsVector) {
     362                               vector<t_pppSatObs*>& obsVector) {
    363363
    364364  bncTime time;
     
    384384  // Observation model
    385385  // -----------------
    386   vector<t_satObs*>::iterator it = obsVector.begin();
     386  vector<t_pppSatObs*>::iterator it = obsVector.begin();
    387387  while (it != obsVector.end()) {
    388     t_satObs* satObs = *it;
     388    t_pppSatObs* satObs = *it;
    389389    satObs->cmpModel(station);
    390390    if (satObs->isValid() && satObs->eleSat() >= OPT->_minEle) {
     
    402402//
    403403//////////////////////////////////////////////////////////////////////////////
    404 void t_pppClient::processEpoch(const vector<t_pppSatObs*>& pppSatObs, t_output* output) {
     404void t_pppClient::processEpoch(const vector<t_satObs*>& pppSatObs, t_output* output) {
    405405
    406406  try {
  • trunk/BNC/src/PPP/pppClient.h

    r5816 r5819  
    1414
    1515class t_pppEphPool;
    16 class t_pppObsPool;
    17 class t_satObs;
     16class t_frqObsPool;
     17class t_pppSatObs;
    1818class t_pppStation;
    1919class t_pppFilter;
     
    2828  void putClkCorrections(const std::vector<t_clkCorr*>& corr);
    2929  void putBiases(const std::vector<t_satBiases*>& biases);   
    30   void processEpoch(const std::vector<t_pppSatObs*>& pppSatObs, t_output* output);
     30  void processEpoch(const std::vector<t_satObs*>& pppSatObs, t_output* output);
    3131
    3232  const t_pppEphPool* ephPool() const {return _ephPool;}
    33   const t_pppObsPool* obsPool() const {return _obsPool;}
     33  const t_frqObsPool* obsPool() const {return _obsPool;}
    3434  const bncAntex*  antex() const {return _antex;}
    3535  const t_pppStation* staRover() const {return _staRover;}
     
    4747  void finish(t_irc irc);
    4848  void clearObs();
    49   t_irc prepareObs(const std::vector<t_pppSatObs*>& pppSatObs,
    50                    std::vector<t_satObs*>& obsVector, bncTime& epoTime);
     49  t_irc prepareObs(const std::vector<t_satObs*>& pppSatObs,
     50                   std::vector<t_pppSatObs*>& obsVector, bncTime& epoTime);
    5151  t_irc cmpModel(t_pppStation* station, const ColumnVector& xyzc,
    52                  std::vector<t_satObs*>& obsVector);
    53   t_irc cmpBancroft(const bncTime& epoTime, std::vector<t_satObs*>& obsVector,
     52                 std::vector<t_pppSatObs*>& obsVector);
     53  t_irc cmpBancroft(const bncTime& epoTime, std::vector<t_pppSatObs*>& obsVector,
    5454                    ColumnVector& xyzc, bool print);
    55   double cmpOffGG(std::vector<t_satObs*>& obsVector);
     55  double cmpOffGG(std::vector<t_pppSatObs*>& obsVector);
    5656
    5757  t_output*              _output;
    5858  t_pppEphPool*             _ephPool;
    59   t_pppObsPool*             _obsPool;
     59  t_frqObsPool*             _obsPool;
    6060  bncTime                _epoTimeRover;
    6161  t_pppStation*             _staRover;
     
    6363  t_pppFilter*              _filter;
    6464  double                 _offGG;
    65   std::vector<t_satObs*> _obsRover;
     65  std::vector<t_pppSatObs*> _obsRover;
    6666  std::ostringstream*    _log;
    6767  t_pppOptions*             _opt;
  • trunk/BNC/src/PPP/pppFilter.cpp

    r5814 r5819  
    3030// Process Single Epoch
    3131////////////////////////////////////////////////////////////////////////////
    32 t_irc t_pppFilter::processEpoch(t_pppObsPool* obsPool) {
     32t_irc t_pppFilter::processEpoch(t_frqObsPool* obsPool) {
    3333
    3434  _numSat     = 0;
     
    4040  // Vector of all Observations
    4141  // --------------------------
    42   t_pppObsPool::t_epoch* epoch = obsPool->lastEpoch();
     42  t_frqObsPool::t_epoch* epoch = obsPool->lastEpoch();
    4343  if (!epoch) {
    4444    return failure;
    4545  }
    46   vector<t_satObs*>& obsVector = epoch->obsVector();
     46  vector<t_pppSatObs*>& obsVector = epoch->obsVector();
    4747
    4848  // Time of the Epoch
     
    128128////////////////////////////////////////////////////////////////////////////
    129129t_irc t_pppFilter::processLC(const vector<t_lc::type>& LCs,
    130                                vector<t_satObs*>& obsVector) {
     130                               vector<t_pppSatObs*>& obsVector) {
    131131
    132132  LOG.setf(ios::fixed);
     
    160160   
    161161    int iObs = -1;
    162     vector<t_satObs*>  usedObs;
     162    vector<t_pppSatObs*>  usedObs;
    163163    vector<t_lc::type> usedTypes;
    164164    for (unsigned ii = 0; ii < obsVector.size(); ii++) {
    165       t_satObs* obs = obsVector[ii];
     165      t_pppSatObs* obs = obsVector[ii];
    166166      if (!obs->outlier()) {
    167167        Matrix CC(LCs.size(), 4);
     
    237237    // --------------------------------------------
    238238    if (maxOutlierIndex > -1) {
    239       t_satObs* obs = usedObs[maxOutlierIndex];
     239      t_pppSatObs* obs = usedObs[maxOutlierIndex];
    240240      t_pppParam* par = 0;
    241241      LOG << epoTimeStr << " Outlier " << t_lc::toString(maxOutlierLC) << ' '
     
    269269        for (unsigned ii = 0; ii < usedObs.size(); ii++) {
    270270          const t_lc::type tLC = usedTypes[ii];
    271           t_satObs*        obs = usedObs[ii];
     271          t_pppSatObs*        obs = usedObs[ii];
    272272          if (tLC == LCs[jj]) {
    273273            obs->setRes(tLC, vv[ii]);
     
    290290////////////////////////////////////////////////////////////////////////////
    291291t_irc t_pppFilter::detectCycleSlips(const vector<t_lc::type>& LCs,
    292                                       const vector<t_satObs*>& obsVector) {
     292                                      const vector<t_pppSatObs*>& obsVector) {
    293293
    294294  const double            SLIP       = 20.0;  // slip threshold
     
    300300    if (t_lc::includesPhase(tLC)) {
    301301      for (unsigned iObs = 0; iObs < obsVector.size(); iObs++) {
    302         const t_satObs* obs = obsVector[iObs];
     302        const t_pppSatObs* obs = obsVector[iObs];
    303303
    304304        // Check set Slips and Jump Counters
     
    358358// Reset Ambiguity Parameter (cycle slip)
    359359////////////////////////////////////////////////////////////////////////////
    360 t_irc t_pppFilter::resetAmb(t_prn prn, const vector<t_satObs*>& obsVector,
     360t_irc t_pppFilter::resetAmb(t_prn prn, const vector<t_pppSatObs*>& obsVector,
    361361                         SymmetricMatrix* QSav, ColumnVector* xSav) {
    362362  t_irc irc = failure;
  • trunk/BNC/src/PPP/pppFilter.h

    r5814 r5819  
    1212
    1313class t_pppParlist;
    14 class t_pppObsPool;
    15 class t_satObs;
     14class t_frqObsPool;
     15class t_pppSatObs;
    1616
    1717class t_pppFilter {
     
    2020  ~t_pppFilter();
    2121
    22   t_irc processEpoch(t_pppObsPool* obsPool);
     22  t_irc processEpoch(t_frqObsPool* obsPool);
    2323
    2424  const ColumnVector&    x() const {return _xFlt;}
     
    5050    double G;
    5151  };
    52   t_irc processLC(const std::vector<t_lc::type>& LCs, std::vector<t_satObs*>& obsVector);
     52  t_irc processLC(const std::vector<t_lc::type>& LCs, std::vector<t_pppSatObs*>& obsVector);
    5353
    5454  t_irc detectCycleSlips(const std::vector<t_lc::type>& LCs,
    55                          const std::vector<t_satObs*>& obsVector);
     55                         const std::vector<t_pppSatObs*>& obsVector);
    5656
    57   t_irc resetAmb(t_prn prn, const std::vector<t_satObs*>& obsVector,
     57  t_irc resetAmb(t_prn prn, const std::vector<t_pppSatObs*>& obsVector,
    5858                 SymmetricMatrix* QSav = 0, ColumnVector* xSav = 0);
    5959
  • trunk/BNC/src/PPP/pppInclude.h

    r5814 r5819  
    3333};
    3434
    35 class t_pppObs  {
     35class t_frqObs  {
    3636 public:
    37   t_pppObs() {
     37  t_frqObs() {
    3838    _code            = 0.0;         
    3939    _codeValid       = false;     
     
    6262};
    6363
    64 class t_pppSatObs {
     64class t_satObs {
    6565 public:
    66   t_pppSatObs() {}
    67   ~t_pppSatObs() {for (unsigned ii = 0; ii < _obs.size(); ii++) delete _obs[ii];}
     66  t_satObs() {}
     67  ~t_satObs() {for (unsigned ii = 0; ii < _obs.size(); ii++) delete _obs[ii];}
    6868  t_prn                  _prn;
    6969  bncTime                _time;
    70   std::vector<t_pppObs*> _obs;
     70  std::vector<t_frqObs*> _obs;
    7171};
    7272
  • trunk/BNC/src/PPP/pppObsPool.cpp

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

    r5818 r5819  
    1010namespace BNC_PPP {
    1111
    12 class t_pppObsPool {
     12class t_frqObsPool {
    1313 public:
    1414
    1515  class t_epoch {
    1616   public:
    17     t_epoch(const bncTime& epoTime, std::vector<t_satObs*>& obsVector);
     17    t_epoch(const bncTime& epoTime, std::vector<t_pppSatObs*>& obsVector);
    1818    ~t_epoch();
    19     std::vector<t_satObs*>& obsVector() {return _obsVector;}
    20     const std::vector<t_satObs*>& obsVector() const {return _obsVector;}
     19    std::vector<t_pppSatObs*>& obsVector() {return _obsVector;}
     20    const std::vector<t_pppSatObs*>& obsVector() const {return _obsVector;}
    2121    const bncTime& epoTime() const {return _epoTime;}
    2222   private:
    2323    bncTime                _epoTime;
    24     std::vector<t_satObs*> _obsVector;
     24    std::vector<t_pppSatObs*> _obsVector;
    2525  };
    2626
    27   t_pppObsPool();
    28   ~t_pppObsPool();
     27  t_frqObsPool();
     28  ~t_frqObsPool();
    2929  void putBiases(t_pppSatBias* satBias);
    3030
    31   void putEpoch(const bncTime& epoTime, std::vector<t_satObs*>& obsVector);
     31  void putEpoch(const bncTime& epoTime, std::vector<t_pppSatObs*>& obsVector);
    3232
    3333  const t_pppSatBias* satBias(const t_prn& prn) const { 
  • trunk/BNC/src/PPP/pppParlist.cpp

    r5814 r5819  
    1919////////////////////////////////////////////////////////////////////////////
    2020t_pppParam::t_pppParam(e_type type, const t_prn& prn, t_lc::type tLC,
    21                  const vector<t_satObs*>* obsVector) {
     21                 const vector<t_pppSatObs*>* obsVector) {
    2222
    2323  _type     = type;
     
    5151     if (obsVector) {
    5252       for (unsigned ii = 0; ii < obsVector->size(); ii++) {
    53          const t_satObs* obs = obsVector->at(ii);
     53         const t_pppSatObs* obs = obsVector->at(ii);
    5454         if (obs->prn() == _prn) {
    5555           double offGG = 0;
     
    9090//
    9191////////////////////////////////////////////////////////////////////////////
    92 double t_pppParam::partial(const bncTime& /* epoTime */, const t_satObs* obs,
     92double t_pppParam::partial(const bncTime& /* epoTime */, const t_pppSatObs* obs,
    9393                        const t_lc::type& tLC) const {
    9494
     
    196196////////////////////////////////////////////////////////////////////////////
    197197t_irc t_pppParlist::set(const bncTime& epoTime, const vector<t_lc::type>& ambLCs,
    198                      const vector<t_satObs*>& obsVector) {
     198                     const vector<t_pppSatObs*>& obsVector) {
    199199
    200200  // Remove some Parameters
     
    243243    else {
    244244      for (unsigned jj = 0; jj < obsVector.size(); jj++) {
    245         const t_satObs* satObs = obsVector[jj];
     245        const t_pppSatObs* satObs = obsVector[jj];
    246246        if (satObs->prn() == par->prn()) {
    247247          par->setLastObsTime(epoTime);
     
    293293    const t_lc::type& tLC = ambLCs[ii];
    294294    for (unsigned jj = 0; jj < obsVector.size(); jj++) {
    295       const t_satObs* satObs = obsVector[jj];
     295      const t_pppSatObs* satObs = obsVector[jj];
    296296      required.push_back(new t_pppParam(t_pppParam::amb, satObs->prn(), tLC, &obsVector));
    297297    }
     
    327327    par->setIndex(ii);
    328328    for (unsigned jj = 0; jj < obsVector.size(); jj++) {
    329       const t_satObs* satObs = obsVector[jj];
     329      const t_pppSatObs* satObs = obsVector[jj];
    330330      if (satObs->prn() == par->prn()) {
    331331        par->setAmbEleSat(satObs->eleSat());
  • trunk/BNC/src/PPP/pppParlist.h

    r5814 r5819  
    1010namespace BNC_PPP {
    1111
    12 class t_satObs;
     12class t_pppSatObs;
    1313
    1414class t_pppParam {
     
    1717
    1818  t_pppParam(e_type type, const t_prn& prn, t_lc::type tLC,
    19           const std::vector<t_satObs*>* obsVector = 0);
     19          const std::vector<t_pppSatObs*>* obsVector = 0);
    2020
    2121  ~t_pppParam();
    2222  e_type type() const {return _type;}
    2323  double x0()  const {return _x0;}
    24   double partial(const bncTime& epoTime, const t_satObs* obs,
     24  double partial(const bncTime& epoTime, const t_pppSatObs* obs,
    2525                 const t_lc::type& tLC) const;
    2626  bool   epoSpec() const {return _epoSpec;}
     
    9898
    9999  t_irc set(const bncTime& epoTime, const std::vector<t_lc::type>& ambLCs,
    100             const std::vector<t_satObs*>& obsVector);
     100            const std::vector<t_pppSatObs*>& obsVector);
    101101
    102102  unsigned nPar() const {return _params.size();}
  • trunk/BNC/src/PPP/pppThread.cpp

    r5814 r5819  
    171171  while (it.hasNext()) {
    172172    const t_obs& oldObs = it.next();
    173     t_pppSatObs* newObs = new t_pppSatObs;
     173    t_satObs* newObs = new t_satObs;
    174174   
    175175    newObs->_prn.set(oldObs.satSys, oldObs.satNum);
     
    198198    if (epoData != 0) {
    199199      epoData->_pppSatObs.push_back(newObs);
    200       map<string, t_pppObs*> pppObsMap;
     200      map<string, t_frqObs*> pppObsMap;
    201201      for (unsigned iEntry = 0; iEntry < GNSSENTRY_NUMBER; iEntry++) {
    202202        string hlp(oldObs.rnxStr(iEntry).toAscii().data());
     
    205205          string rnxType2ch = hlp.substr(1);
    206206          if (obsType == 'C' || obsType == 'L') {
    207             t_pppObs* pppObs = 0;
     207            t_frqObs* pppObs = 0;
    208208            if (pppObsMap.find(rnxType2ch) == pppObsMap.end()) {
    209               pppObs                = new t_pppObs();
     209              pppObs                = new t_frqObs();
    210210              pppObsMap[rnxType2ch] = pppObs;
    211211              pppObs->_rnxType2ch   = rnxType2ch;
     
    233233  if (_pppEpochs.size() > 1) {
    234234
    235     const vector<t_pppSatObs*>& pppSatObs = _pppEpochs.front()->_pppSatObs;
     235    const vector<t_satObs*>& pppSatObs = _pppEpochs.front()->_pppSatObs;
    236236
    237237    t_output output;
  • trunk/BNC/src/PPP/pppThread.h

    r5817 r5819  
    3838    }
    3939    bncTime                   _time;
    40     std::vector<t_pppSatObs*> _pppSatObs;
     40    std::vector<t_satObs*> _pppSatObs;
    4141  };
    4242
  • trunk/BNC/src/PPP/satobs.cpp

    r5818 r5819  
    2727 * -------------------------------------------------------------------------
    2828 *
    29  * Class:      t_satObs
     29 * Class:      t_pppSatObs
    3030 *
    3131 * Purpose:    Satellite observations
     
    5757// Constructor
    5858////////////////////////////////////////////////////////////////////////////
    59 t_satObs::t_satObs(const t_pppSatObs& pppSatObs) {
     59t_pppSatObs::t_pppSatObs(const t_satObs& pppSatObs) {
    6060  _prn  = pppSatObs._prn;
    6161  _time = pppSatObs._time;
    6262  _outlier    = false;
    6363  for (unsigned ii = 0; ii < pppSatObs._obs.size(); ii++) {
    64     const t_pppObs* obs = pppSatObs._obs[ii];
     64    const t_frqObs* obs = pppSatObs._obs[ii];
    6565    t_obsType obsType = string(obs->_rnxType2ch).substr(0,2);
    66     _allObs[obsType] = new t_pppObs(*obs);
     66    _allObs[obsType] = new t_frqObs(*obs);
    6767  }
    6868  prepareObs();
     
    7171// Destructor
    7272////////////////////////////////////////////////////////////////////////////
    73 t_satObs::~t_satObs() {
    74   map<t_obsType, t_pppObs*>::const_iterator it;
     73t_pppSatObs::~t_pppSatObs() {
     74  map<t_obsType, t_frqObs*>::const_iterator it;
    7575  for (it = _allObs.begin(); it != _allObs.end(); it++) {
    7676    delete it->second;
     
    8080//
    8181////////////////////////////////////////////////////////////////////////////
    82 void t_satObs::prepareObs() {
     82void t_pppSatObs::prepareObs() {
    8383  _model.reset();
    8484  _valid     = true;
     
    9595    obsType1[1] = preferredAttrib[iPref];
    9696    if (_validObs1 == 0 && _allObs.find(obsType1) != _allObs.end()) {
    97       t_pppObs* obs = _allObs[obsType1];
     97      t_frqObs* obs = _allObs[obsType1];
    9898      if (obs->_codeValid && obs->_phaseValid) {
    9999        _validObs1 = obs;
     
    104104      obsType2[1] = preferredAttrib[iPref];
    105105      if (_validObs2 == 0 && _allObs.find(obsType2) != _allObs.end()) {
    106         t_pppObs* obs = _allObs[obsType2];
     106        t_frqObs* obs = _allObs[obsType2];
    107107        if (obs->_codeValid && obs->_phaseValid) {
    108108          _validObs2 = obs;
     
    174174//
    175175////////////////////////////////////////////////////////////////////////////
    176 t_irc t_satObs::cmpModel(const t_pppStation* station) {
     176t_irc t_pppSatObs::cmpModel(const t_pppStation* station) {
    177177
    178178  // Reset all model values
     
    301301//
    302302////////////////////////////////////////////////////////////////////////////
    303 void t_satObs::printModel() const {
     303void t_pppSatObs::printModel() const {
    304304  LOG.setf(ios::fixed);
    305305  LOG << "MODEL for Satellite " << _prn.toString() << endl
     
    348348//
    349349////////////////////////////////////////////////////////////////////////////
    350 double t_satObs::obsValue(t_lc::type tLC) const {
     350double t_pppSatObs::obsValue(t_lc::type tLC) const {
    351351
    352352  if (!_validObs2 && t_lc::need2ndFreq(tLC)) {
     
    359359//
    360360////////////////////////////////////////////////////////////////////////////
    361 double t_satObs::cmpValueForBanc(t_lc::type tLC) const {
     361double t_pppSatObs::cmpValueForBanc(t_lc::type tLC) const {
    362362  return cmpValue(tLC) - _model._rho - _model._sagnac - _model._recClkM;
    363363}
     
    365365//
    366366////////////////////////////////////////////////////////////////////////////
    367 double t_satObs::cmpValue(t_lc::type tLC) const {
     367double t_pppSatObs::cmpValue(t_lc::type tLC) const {
    368368
    369369  if (!_validObs2 && t_lc::need2ndFreq(tLC)) {
     
    389389//
    390390////////////////////////////////////////////////////////////////////////////
    391 double t_satObs::lc(t_lc::type tLC,
     391double t_pppSatObs::lc(t_lc::type tLC,
    392392                    double L1, double L2, double C1, double C2,
    393393                    ColumnVector* coeff) const {
     
    458458//
    459459////////////////////////////////////////////////////////////////////////////
    460 t_irc t_satObs::createDifference(const t_satObs* obsBase) {
     460t_irc t_pppSatObs::createDifference(const t_pppSatObs* obsBase) {
    461461
    462462  _rawC1          -= obsBase->_rawC1;
     
    484484//
    485485////////////////////////////////////////////////////////////////////////////
    486 double t_satObs::lambda(t_lc::type tLC) const {
     486double t_pppSatObs::lambda(t_lc::type tLC) const {
    487487
    488488  if      (tLC == t_lc::l1) {
     
    507507//
    508508////////////////////////////////////////////////////////////////////////////
    509 double t_satObs::sigma(t_lc::type tLC) const {
     509double t_pppSatObs::sigma(t_lc::type tLC) const {
    510510
    511511  ColumnVector sig(4);
     
    535535//
    536536////////////////////////////////////////////////////////////////////////////
    537 void t_satObs::setRes(t_lc::type tLC, double res) {
     537void t_pppSatObs::setRes(t_lc::type tLC, double res) {
    538538  _res[tLC] = res;
    539539}
     
    541541//
    542542////////////////////////////////////////////////////////////////////////////
    543 double t_satObs::getRes(t_lc::type tLC) const {
     543double t_pppSatObs::getRes(t_lc::type tLC) const {
    544544  map<t_lc::type, double>::const_iterator it = _res.find(tLC);
    545545  if (it != _res.end()) {
  • trunk/BNC/src/PPP/satobs.h

    r5814 r5819  
    1414class t_pppStation;
    1515
    16 class t_satObs {
     16class t_pppSatObs {
    1717 public:
    18   t_satObs(const t_pppSatObs& pppSatObs);
    19   ~t_satObs();
     18  t_pppSatObs(const t_satObs& pppSatObs);
     19  ~t_pppSatObs();
    2020  bool                isValid() const {return _valid;}
    2121  void                prepareObs();
     
    3232  bool                modelSet() const {return _model._set;}
    3333  void                printModel() const;
    34   t_irc               createDifference(const t_satObs* obsBase);
     34  t_irc               createDifference(const t_pppSatObs* obsBase);
    3535  double              lc(t_lc::type tLC, double L1, double L2,
    3636                         double C1, double C2, ColumnVector* coeff = 0) const;
     
    4444
    4545  bool slip() const {
    46     std::map<t_obsType, t_pppObs*>::const_iterator it;
     46    std::map<t_obsType, t_frqObs*>::const_iterator it;
    4747    for (it = _allObs.begin(); it != _allObs.end(); it++) {
    4848      if (it->second->_slip) {
     
    5555  int slipCounter() const {
    5656    int cnt = -1;
    57     std::map<t_obsType, t_pppObs*>::const_iterator it;
     57    std::map<t_obsType, t_frqObs*>::const_iterator it;
    5858    for (it = _allObs.begin(); it != _allObs.end(); it++) {
    5959      if (it->second->_slipCounter > cnt) {
     
    6666  int biasJumpCounter() const {
    6767    int jmp = -1;
    68     std::map<t_obsType, t_pppObs*>::const_iterator it;
     68    std::map<t_obsType, t_frqObs*>::const_iterator it;
    6969    for (it = _allObs.begin(); it != _allObs.end(); it++) {
    7070      if (it->second->_biasJumpCounter > jmp) {
     
    121121  bncTime                        _time;
    122122  int                            _channel;
    123   std::map<t_obsType, t_pppObs*> _allObs;
     123  std::map<t_obsType, t_frqObs*> _allObs;
    124124  bool                           _valid;
    125   t_pppObs*                      _validObs1;
    126   t_pppObs*                      _validObs2;
     125  t_frqObs*                      _validObs1;
     126  t_frqObs*                      _validObs2;
    127127  double                         _f1;
    128128  double                         _f2;
Note: See TracChangeset for help on using the changeset viewer.