Changeset 10384 in ntrip


Ignore:
Timestamp:
Mar 11, 2024, 3:28:32 PM (5 weeks ago)
Author:
stuerze
Message:

changes regarding PPP

Location:
trunk/BNC/src/PPP
Files:
6 edited

Legend:

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

    r10373 r10384  
    6767    }
    6868  }
    69   _offGps = 0.0;
    7069  _offGlo = 0.0;
    7170  _offGal = 0.0;
     
    256255                                  ColumnVector& xyzc, bool print) {
    257256  t_lc::type tLC = t_lc::dummy;
    258   char sysBancroft = 'G';
    259257  int  numBancroft = obsVector.size();
    260 
    261   _usedSystems['G'] = _usedSystems['R'] = _usedSystems['E'] = _usedSystems['C'] = 0;
    262   for (unsigned jj = 0; jj < obsVector.size(); jj++) {
    263     const t_pppSatObs* satObs = obsVector[jj];
    264     char sys = satObs->prn().system();
    265     _usedSystems[sys]++;
    266   }
    267 
    268   if      ((numBancroft = _usedSystems.value('G')) >= _opt->_minObs) {
    269     sysBancroft = 'G';
    270   }
    271   else if ((numBancroft = _usedSystems.value('E')) >= _opt->_minObs) {
    272     sysBancroft = 'E';
    273   }
    274   else if ((numBancroft = _usedSystems.value('C')) >= _opt->_minObs) {
    275     sysBancroft = 'C';
    276   }
    277   else if ((numBancroft = _usedSystems.value('R')) >= _opt->_minObs) {
    278     sysBancroft = 'R';
    279   }
    280   else {
    281     LOG << "t_pppClient::cmpBancroft not enough observations: " << endl;
    282     return failure;
    283   }
    284258
    285259  while (_running) {
     
    288262    for (unsigned ii = 0; ii < obsVector.size(); ii++) {
    289263      const t_pppSatObs* satObs = obsVector.at(ii);
    290       if (satObs->prn().system() == sysBancroft) {
    291264      if (tLC == t_lc::dummy) {
    292265        if (satObs->isValid(t_lc::cIF)) {
     
    309282      }
    310283    }
    311     }
    312284    if (iObs + 1 < _opt->_minObs) {
    313285      LOG << "t_pppClient::cmpBancroft not enough observations: " << iObs + 1 << endl;
     
    329301      const t_pppSatObs* satObs = obsVector.at(ii);
    330302      char sys = satObs->prn().system();
    331       if (satObs->isValid() && sys == sysBancroft &&
     303      if (satObs->isValid() &&
    332304          (!satObs->modelSet() || satObs->eleSat() >= _opt->_minEle) ) {
    333305        ColumnVector rr = satObs->xc().Rows(1,3) - xyzc.Rows(1,3);
     
    346318        if (!_epoTimeRover.undef()) LOG << string(_epoTimeRover);
    347319        LOG << "\n---------------------------------------------------------------\n";
    348         LOG << string(epoTime) << " BANCROFT " <<   sysBancroft << ": "
     320        LOG << string(epoTime) << " BANCROFT: "
    349321            << setw(14) << setprecision(3) << xyzc[0] << ' '
    350322            << setw(14) << setprecision(3) << xyzc[1] << ' '
     
    364336
    365337  return success;
    366 }
    367 // Compute A Priori Gps Clock Offset
    368 //////////////////////////////////////////////////////////////////////////////
    369 double t_pppClient::cmpOffGps(vector<t_pppSatObs*>& obsVector) {
    370 
    371   t_lc::type tLC   = t_lc::dummy;
    372   double     offGps = 0.0;
    373 
    374   if (_opt->useSystem('G')) {
    375     while (obsVector.size() > 0) {
    376       offGps = 0.0;
    377       double   maxRes      = 0.0;
    378       int      maxResIndex = -1;
    379       unsigned nObs        = 0;
    380       t_prn    maxResPrn;
    381       for (unsigned ii = 0; ii < obsVector.size(); ii++) {
    382         const t_pppSatObs* satObs = obsVector.at(ii);
    383         if (satObs->prn().system() == 'G') {
    384           if (tLC == t_lc::dummy) {
    385             tLC = satObs->isValid(t_lc::cIF) ? t_lc::cIF : t_lc::c1;
    386           }
    387           if (satObs->isValid(tLC) && (!satObs->modelSet() || satObs->eleSat() >= _opt->_minEle)) {
    388             double ll = satObs->obsValue(tLC) - satObs->cmpValue(tLC);
    389             ++nObs;
    390             offGps += ll;
    391             if (fabs(ll) > fabs(maxRes)) {
    392               maxRes      = ll;
    393               maxResIndex = ii;
    394               maxResPrn   = satObs->prn();
    395             }
    396           }
    397         }
    398       }
    399 
    400       if (nObs > 0) {
    401         offGps = offGps / nObs;
    402       }
    403       else {
    404         offGps = 0.0;
    405       }
    406 
    407       if (fabs(maxRes) > 100.0) {
    408         LOG << "t_pppClient::cmpOffGps outlier " << maxResPrn.toString() << " " << maxRes << endl;
    409         delete obsVector.at(maxResIndex);
    410         obsVector.erase(obsVector.begin() + maxResIndex);
    411       }
    412       else {
    413         break;
    414       }
    415     }
    416   }
    417   return offGps;
    418338}
    419339
     
    718638    }
    719639
    720     _offGps = cmpOffGps(_obsRover);
    721640    _offGlo = cmpOffGlo(_obsRover);
    722641    _offGal = cmpOffGal(_obsRover);
  • trunk/BNC/src/PPP/pppClient.h

    r10373 r10384  
    3636  const bncAntex*     antex() const {return _antex;}
    3737  const t_pppStation* staRover() const {return _staRover;}
    38   double              offGps() const {return _offGps;}
    3938  double              offGlo() const {return _offGlo;}
    4039  double              offGal() const {return _offGal;}
    4140  double              offBds() const {return _offBds;}
    42   void                resetOffGps() {_offGps = 0.0;}
    43   void                resetOffGlo() {_offGlo = 0.0;}
    44   void                resetOffGal() {_offGal = 0.0;}
    45   void                resetOffBds() {_offBds = 0.0;}
    4641
    4742
     
    6661  t_irc cmpBancroft(const bncTime& epoTime, std::vector<t_pppSatObs*>& obsVector,
    6762                    ColumnVector& xyzc, bool print);
    68   double cmpOffGps(std::vector<t_pppSatObs*>& obsVector);
    6963  double cmpOffGlo(std::vector<t_pppSatObs*>& obsVector);
    7064  double cmpOffGal(std::vector<t_pppSatObs*>& obsVector);
     
    7973  bncAntex*                 _antex;
    8074  t_pppFilter*              _filter;
    81   double                    _offGps;
    8275  double                    _offGlo;
    8376  double                    _offGal;
  • trunk/BNC/src/PPP/pppFilter.cpp

    r10381 r10384  
    7676  string epoTimeStr = string(_epoTime);
    7777
    78   const QMap<char, int> &usedSystems = _parlist->usedSystems();
    79 
    8078  // Set Parameters
    8179  // --------------
     
    9290  // Process Satellite Systems separately
    9391  // ------------------------------------
    94   for (auto it = usedSystems.begin(); it != usedSystems.end(); ++it) {
    95     char     sys = it.key();
    96     unsigned num = 0;
     92  for (unsigned iSys = 0; iSys < OPT->systems().size(); iSys++) {
     93    char sys = OPT->systems()[iSys];
     94    int num = 0;
    9795    vector<t_pppSatObs*> obsVector;
    9896    for (unsigned jj = 0; jj < allObs.size(); jj++) {
     
    167165    for (unsigned ii = 0; ii < obsVector.size(); ii++) {
    168166      t_pppSatObs *obs = obsVector[ii];
    169       char sys = obs->prn().system();
    170167      if (iOutlier == 0) {
    171168        obs->resetOutlier();
     
    185182            AA[iObs][iPar] = par->partial(_epoTime, obs, tLC);
    186183          }
    187           double offGps = 0.0;
    188           if (sys == 'G' && tLC != t_lc::MW) {
    189             offGps = PPP_CLIENT->offGps();
    190           }
    191           double offGlo = 0.0;
    192           if (sys == 'R' && tLC != t_lc::MW) {
    193             offGlo = PPP_CLIENT->offGlo();
    194           }
    195           double offGal = 0.0;
    196           if (sys == 'E' && tLC != t_lc::MW) {
    197             offGal = PPP_CLIENT->offGal();
    198           }
    199           double offBds = 0.0;
    200           if (sys == 'C' && tLC != t_lc::MW) {
    201             offBds = PPP_CLIENT->offBds();
    202           }
    203           ll[iObs] = obs->obsValue(tLC) -offGps - offGlo - offGal - offBds  - obs->cmpValue(tLC) - DotProduct(_x0, AA.Row(iObs + 1));
     184
     185          ll[iObs] = obs->obsValue(tLC) - obs->cmpValue(tLC) - DotProduct(_x0, AA.Row(iObs + 1));
    204186          PP[iObs] = 1.0 / (obs->sigma(tLC) * obs->sigma(tLC));
    205187        }
     
    218200      for (unsigned ii = 0; ii < obsVector.size(); ii++) {
    219201        t_pppSatObs *obs = obsVector[ii];
    220         char sys = obs->prn().system();
    221202        if (!obs->outlier()) {
    222203          for (unsigned jj = 0; jj < usedLCs; jj++) {
     
    233214              AA[iObs][iPar] = par->partial(_epoTime, obs, tLC);
    234215            }
    235             double offGps = 0.0;
    236             if (sys == 'G' && tLC != t_lc::MW) {
    237               offGps = PPP_CLIENT->offGps();
    238             }
    239             double offGlo = 0.0;
    240             if (sys == 'R' && tLC != t_lc::MW) {
    241               offGlo = PPP_CLIENT->offGlo();
    242             }
    243             double offGal = 0.0;
    244             if (sys == 'E' && tLC != t_lc::MW) {
    245               offGal = PPP_CLIENT->offGal();
    246             }
    247             double offBds = 0.0;
    248             if (sys == 'C' && tLC != t_lc::MW) {
    249               offBds = PPP_CLIENT->offBds();
    250             }
    251             ll[iObs] = obs->obsValue(tLC) -offGps - offGlo - offGal - offBds  - obs->cmpValue(tLC) - DotProduct(_x0, AA.Row(iObs + 1));
     216            ll[iObs] = obs->obsValue(tLC) - obs->cmpValue(tLC) - DotProduct(_x0, AA.Row(iObs + 1));
    252217            PP[iObs] = 1.0 / (obs->sigma(tLC) * obs->sigma(tLC));
    253218          }
     
    351316      for (unsigned iObs = 0; iObs < obsVector.size(); iObs++) {
    352317        const t_pppSatObs *obs = obsVector[iObs];
    353         char sys = obs->prn().system();
    354318
    355319        // Check set Slips and Jump Counters
     
    383347
    384348        // Check Pre-Fit Residuals
    385         /* -----------------------
     349        // -----------------------
    386350        else {
    387351          ColumnVector AA(params.size());
     
    390354            AA[iPar] = par->partial(_epoTime, obs, tLC);
    391355          }
    392           double offGps = 0.0;
    393           if (sys == 'G' && tLC != t_lc::MW) {
    394             offGps = PPP_CLIENT->offGps();
    395           }
    396           double offGlo = 0.0;
    397           if (sys == 'R' && tLC != t_lc::MW) {
    398             offGlo = PPP_CLIENT->offGlo();
    399           }
    400           double offGal = 0.0;
    401           if (sys == 'E' && tLC != t_lc::MW) {
    402             offGal = PPP_CLIENT->offGal();
    403           }
    404           double offBds = 0.0;
    405           if (sys == 'C' && tLC != t_lc::MW) {
    406             offBds = PPP_CLIENT->offBds();
    407           }
    408           double ll = obs->obsValue(tLC) -offGps - offGlo - offGal - offBds  - obs->cmpValue(tLC) - DotProduct(_x0, AA);
     356          double ll = obs->obsValue(tLC) - obs->cmpValue(tLC) - DotProduct(_x0, AA);
    409357          double vv = DotProduct(AA, _xFlt) - ll;
    410358
     
    414362            resetAmb(obs->prn(), obsVector, tLC);
    415363          }
    416         }*/
     364        }
    417365      }
    418366    }
  • trunk/BNC/src/PPP/pppParlist.cpp

    r10373 r10384  
    7474         const t_pppSatObs* obs = obsVector->at(ii);
    7575         if (obs->prn() == _prn) {
    76            double offGps = 0.0;
    77            if (_prn.system() == 'G' && tLC != t_lc::MW) {
    78              offGps = PPP_CLIENT->offGps();
    79            }
    8076           double offGlo = 0.0;
    8177           if (_prn.system() == 'R' && tLC != t_lc::MW) {
     
    9086             offBds = PPP_CLIENT->offBds();
    9187           }
    92            _x0 = floor((obs->obsValue(tLC) - offGps - offGlo - offGal - offBds - obs->cmpValue(tLC)) / obs->lambda(tLC) + 0.5);
     88           _x0 = floor((obs->obsValue(tLC) - offGlo - offGal - offBds - obs->cmpValue(tLC)) / obs->lambda(tLC) + 0.5);
    9389           break;
    9490         }
    9591       }
    9692     }
    97      break;
    98    case offGps:
    99      _epoSpec = true;
    100      _sigma0  = OPT->_aprSigClkOff;
    101      _x0      = PPP_CLIENT->offGps();
    10293     break;
    10394   case offGlo:
     
    180171    if (tLC == t_lc::GIM) {return 0.0;}
    181172    return 1.0;
    182   case offGps:
    183     if (tLC == t_lc::GIM) {return 0.0;}
    184     return (obs->prn().system() == 'G') ? 1.0 : 0.0;
    185173  case offGlo:
    186174    if (tLC == t_lc::GIM) {return 0.0;}
     
    311299    ss << "REC_CLK     ";
    312300    break;
    313   case offGps:
    314     ss << "OFF_GPS     ";
    315     break;
    316301  case offGlo:
    317302    ss << "OFF_GLO     ";
     
    385370             par->type() == t_pppParam::crdX ||
    386371             par->type() == t_pppParam::crdY ||
    387              par->type() == t_pppParam::crdZ) {
     372             par->type() == t_pppParam::crdZ ||
     373             par->type() == t_pppParam::ion  ||
     374             par->type() == t_pppParam::cBiasC1 ||
     375             par->type() == t_pppParam::cBiasC2 ||
     376             par->type() == t_pppParam::cBiasE1 ||
     377             par->type() == t_pppParam::cBiasE2 ||
     378             par->type() == t_pppParam::cBiasR1 ||
     379             par->type() == t_pppParam::cBiasR2 ||
     380             par->type() == t_pppParam::pBiasC1 ||
     381             par->type() == t_pppParam::pBiasC2 ||
     382             par->type() == t_pppParam::pBiasE1 ||
     383             par->type() == t_pppParam::pBiasE2 ||
     384             par->type() == t_pppParam::pBiasR1 ||
     385             par->type() == t_pppParam::pBiasR2) {
    388386      if (par->lastObsTime().valid() && (epoTime - par->lastObsTime() > 60.0)) {
    389387        remove = true;
    390388      }
    391389    }
    392     else if (par->type() == t_pppParam::ion) {
    393       if (par->lastObsTime().valid() && (epoTime - par->lastObsTime() > 5.0)) {
    394         remove = true;
    395       }
    396 }
    397390
    398391    if (remove) {
     
    406399      ++it;
    407400    }
    408   }
    409 
    410   // check which systems have observations
    411   // -------------------------------------
    412   _usedSystems['G'] = _usedSystems['R'] = _usedSystems['E'] = _usedSystems['C'] = 0;
    413   for (unsigned jj = 0; jj < obsVector.size(); jj++) {
    414     const t_pppSatObs* satObs = obsVector[jj];
    415     char sys = satObs->prn().system();
    416     _usedSystems[sys]++;
    417401  }
    418402
     
    441425  }
    442426
    443   if (OPT->_ionoModelType == OPT->PPP_RTK || OPT->_pseudoObsIono) {
    444     vector<t_pppParam*>::iterator it = _params.begin();
    445     while (it != _params.end()) {
    446       t_pppParam* par = *it;
    447       // Check if systems have to be presented per biases
    448       // ----------------------------------------------
    449       if ((     par->type() == t_pppParam::cBiasG1 ||
    450                 par->type() == t_pppParam::cBiasG2 ||
    451                 par->type() == t_pppParam::pBiasG1 ||
    452                 par->type() == t_pppParam::pBiasG2) && !_usedSystems.value('G')) {
    453 #ifdef BNC_DEBUG_PPP
    454        //LOG << "remove1 " << par->toString() << std::endl;
    455 #endif
    456         delete par;
    457         it = _params.erase(it);
    458       }
    459       else if ((par->type() == t_pppParam::cBiasR1 ||
    460                 par->type() == t_pppParam::cBiasR2 ||
    461                 par->type() == t_pppParam::pBiasR1 ||
    462                 par->type() == t_pppParam::pBiasR2) && !_usedSystems.value('R')){
    463 #ifdef BNC_DEBUG_PPP
    464         //LOG << "remove1 " << par->toString() << std::endl;
    465 #endif
    466         delete par;
    467         it = _params.erase(it);
    468       }
    469       else if ((par->type() == t_pppParam::cBiasE1 ||
    470                 par->type() == t_pppParam::cBiasE2 ||
    471                 par->type() == t_pppParam::pBiasE1 ||
    472                 par->type() == t_pppParam::pBiasE2) && !_usedSystems.value('E')) {
    473 #ifdef BNC_DEBUG_PPP
    474         //LOG << "remove1 " << par->toString() << std::endl;
    475 #endif
    476         delete par;
    477         it = _params.erase(it);
    478       }
    479       else if ((par->type() == t_pppParam::cBiasC1 ||
    480                 par->type() == t_pppParam::cBiasC2 ||
    481                 par->type() == t_pppParam::pBiasC1 ||
    482                 par->type() == t_pppParam::pBiasC2) && !_usedSystems.value('C')) {
    483 #ifdef BNC_DEBUG_PPP
    484         //LOG << "remove1 " << par->toString() << std::endl;
    485 #endif
    486         delete par;
    487         it = _params.erase(it);
    488       }
    489       else {
    490         ++it;
    491       }
    492     }
    493   }
    494 
    495427  // Required Set of Parameters
    496428  // --------------------------
     
    509441  // GLONASS Clock Offset
    510442  // --------------------
    511   if ( _usedSystems.value('R')  &&
    512       (_usedSystems.value('G') || _usedSystems.value('E') || _usedSystems.value('C'))) {
     443  if (OPT->useSystem('R')) {
    513444    required.push_back(new t_pppParam(t_pppParam::offGlo, t_prn(), t_lc::dummy));
    514   }
    515   else {
    516     PPP_CLIENT->resetOffGlo();
    517445  }
    518446
    519447  // Galileo Clock Offset
    520448  // --------------------
    521   if (_usedSystems.value('E') && _usedSystems.value('G') && _usedSystems.value('G') >= OPT->_minObs) {
     449  if (OPT->useSystem('E')) {
    522450    required.push_back(new t_pppParam(t_pppParam::offGal, t_prn(), t_lc::dummy));
    523   }
    524   else {
    525     PPP_CLIENT->resetOffGal();
    526   }
    527 
    528   // GPS Clock Offset
    529   // --------------------
    530   if (_usedSystems.value('E') && _usedSystems.value('G') && _usedSystems.value('G') < OPT->_minObs) {
    531     required.push_back(new t_pppParam(t_pppParam::offGps, t_prn(), t_lc::dummy));
    532   }
    533   else {
    534     PPP_CLIENT->resetOffGps();
    535451  }
    536452
    537453  // BDS Clock Offset
    538454  // ----------------
    539   if (_usedSystems.contains('C')  &&
    540       (_usedSystems.contains('G') || _usedSystems.contains('E'))) {
     455  if (OPT->useSystem('C')) {
    541456    required.push_back(new t_pppParam(t_pppParam::offBds, t_prn(), t_lc::dummy));
    542   }
    543   else {
    544     PPP_CLIENT->resetOffBds();
    545457  }
    546458
     
    577489  // Receiver Code Biases
    578490  // --------------------
    579   if (OPT->_ionoModelType == OPT->PPP_RTK) {
     491    if (OPT->_ionoModelType == OPT->PPP_RTK) {
    580492    std::vector<t_lc::type> lc;
    581     if (_usedSystems.contains('G')) {
     493    if (OPT->useSystem('G')) {
    582494      lc = OPT->LCs('G');
    583495      if (std::find(lc.begin(), lc.end(), t_lc::c1) != lc.end()) {
     
    588500      }
    589501    }
    590     if (_usedSystems.contains('R')) {
     502    if (OPT->useSystem('R')) {
    591503      lc = OPT->LCs('R');
    592504      if (std::find(lc.begin(), lc.end(), t_lc::c1) != lc.end()) {
     
    597509      }
    598510    }
    599     if (_usedSystems.contains('E')) {
     511    if (OPT->useSystem('E')) {
    600512      lc = OPT->LCs('E');
    601513      if (std::find(lc.begin(), lc.end(), t_lc::c1) != lc.end()) {
     
    606518      }
    607519    }
    608     if (_usedSystems.contains('C')) {
     520    if (OPT->useSystem('C')) {
    609521      lc = OPT->LCs('C');
    610522      if (std::find(lc.begin(), lc.end(), t_lc::c1) != lc.end()) {
     
    616528    }
    617529  }
     530
    618531  if (OPT->_pseudoObsIono) {
    619532    std::vector<t_lc::type> lc;
    620     if (_usedSystems.contains('G')) {
     533    if (OPT->useSystem('G')) {
    621534      lc = OPT->LCs('G');
    622535      if (std::find(lc.begin(), lc.end(), t_lc::c2) != lc.end()) {
     
    624537      }
    625538    }
    626     if (_usedSystems.contains('R')) {
     539    if (OPT->useSystem('R')) {
    627540      lc = OPT->LCs('R');
    628541      if (std::find(lc.begin(), lc.end(), t_lc::c2) != lc.end()) {
     
    630543      }
    631544    }
    632     if (_usedSystems.contains('E')) {
     545    if (OPT->useSystem('E')) {
    633546      lc = OPT->LCs('E');
    634547      if (std::find(lc.begin(), lc.end(), t_lc::c2) != lc.end()) {
     
    636549      }
    637550    }
    638     if (_usedSystems.contains('C')) {
     551    if (OPT->useSystem('C')) {
    639552      lc = OPT->LCs('C');
    640553      if (std::find(lc.begin(), lc.end(), t_lc::c2) != lc.end()) {
     
    644557  }
    645558
    646   // Receiver Phase Biases
    647   // ---------------------
    648559  if (OPT->_ionoModelType == OPT->PPP_RTK) {
    649560    std::vector<t_lc::type> lc;
    650     if (_usedSystems.contains('G')) {
     561    if (OPT->useSystem('G')) {
    651562      lc = OPT->LCs('G');
    652563      if (std::find(lc.begin(), lc.end(), t_lc::l1) != lc.end()) {
     
    657568      }
    658569    }
    659     if (_usedSystems.contains('R')) {
     570    if (OPT->useSystem('R')) {
    660571      lc = OPT->LCs('R');
    661572      if (std::find(lc.begin(), lc.end(), t_lc::l1) != lc.end()) {
     
    666577      }
    667578    }
    668     if (_usedSystems.contains('E')) {
     579    if (OPT->useSystem('E')) {
    669580      lc = OPT->LCs('E');
    670581      if (std::find(lc.begin(), lc.end(), t_lc::l1) != lc.end()) {
     
    675586      }
    676587    }
    677     if (_usedSystems.contains('C')) {
     588    if (OPT->useSystem('C')) {
    678589      lc = OPT->LCs('C');
    679590      if (std::find(lc.begin(), lc.end(), t_lc::l1) != lc.end()) {
  • trunk/BNC/src/PPP/pppParlist.h

    r10373 r10384  
    1414class t_pppParam {
    1515 public:
    16   enum e_type {crdX, crdY, crdZ, rClk, offGps, offGlo, offGal, offBds, trp, ion, amb,
     16  enum e_type {crdX, crdY, crdZ, rClk, offGlo, offGal, offBds, trp, ion, amb,
    1717               cBiasG1, cBiasR1, cBiasE1, cBiasC1, pBiasG1, pBiasR1, pBiasE1, pBiasC1,
    1818               cBiasG2, cBiasR2, cBiasE2, cBiasC2, pBiasG2, pBiasR2, pBiasE2, pBiasC2};
     
    104104  const std::vector<t_pppParam*>& params() const {return _params;}
    105105  std::vector<t_pppParam*>& params() {return _params;}
    106   const QMap<char, int>& usedSystems() const {return _usedSystems;}
    107106  void printResult(const bncTime& epoTime, const SymmetricMatrix& QQ,
    108107                   const ColumnVector& xx) const;
     
    111110 private:
    112111  std::vector<t_pppParam*> _params;
    113   QMap<char, int>          _usedSystems;
    114112};
    115113
  • trunk/BNC/src/PPP/pppSatObs.cpp

    r10373 r10384  
    3333using namespace std;
    3434
    35 const double   GLO_WEIGHT_FACTOR = 1.0;
     35const double   GLO_WEIGHT_FACTOR = 5.0;
     36const double   BDS_WEIGHT_FACTOR = 1.0;
    3637
    3738// Constructor
     
    6162//
    6263////////////////////////////////////////////////////////////////////////////
    63 void t_pppSatObs::prepareObs(const t_satObs& pppSatObs) {//cout << "SATELLITE: " << _prn.toString() << endl;
     64void t_pppSatObs::prepareObs(const t_satObs& pppSatObs) {
    6465
    6566  _model.reset();
     
    353354  retVal = sqrt(retVal);
    354355
    355   // De-Weight GLO
     356  // De-Weight R+C
    356357  // -------------
    357   if (_prn.system() == 'R' && t_lc::includesCode(tLC)) {
     358  if (_prn.system() == 'R') {
    358359    retVal *= GLO_WEIGHT_FACTOR;
     360  }
     361  if (_prn.system() == 'C') {
     362    retVal *= BDS_WEIGHT_FACTOR;
    359363  }
    360364
     
    394398
    395399  retVal = sqrt(retVal);
    396 
    397   // Enlarge maxRes GLO
    398   // ------------------
    399   if (_prn.system() == 'R' && t_lc::includesCode(tLC)) {
    400     retVal *= GLO_WEIGHT_FACTOR;
    401   }
    402400
    403401  return retVal;
     
    660658  for (unsigned ii = 0; ii < OPT->LCs(sys).size(); ii++) {
    661659    t_lc::type tLC = OPT->LCs(sys)[ii];
    662     double offGps = 0.0;
    663     if (_prn.system() == 'G' && tLC != t_lc::MW) {
    664       offGps = PPP_CLIENT->offGps();
    665     }
    666     double offGlo = 0;
    667     if (sys == 'R' && tLC != t_lc::MW) {
    668       offGlo = PPP_CLIENT->offGlo();
    669     }
    670     double offGal = 0;
    671     if (sys == 'E' && tLC != t_lc::MW) {
    672       offGal = PPP_CLIENT->offGal();
    673     }
    674     double offBds = 0;
    675     if (sys == 'C' && tLC != t_lc::MW) {
    676       offBds = PPP_CLIENT->offBds();
    677     }
    678660    LOG << "OBS-CMP " << setw(4) << t_lc::toString(tLC) << ": " << _prn.toString() << " "
    679661        << setw(12) << setprecision(3) << obsValue(tLC) << " "
    680662        << setw(12) << setprecision(3) << cmpValue(tLC) << " "
    681         << setw(12) << setprecision(3) << obsValue(tLC) - offGps - offGlo - offGal - offBds - cmpValue(tLC) << endl;
     663        << setw(12) << setprecision(3) << obsValue(tLC) - cmpValue(tLC) << endl;
    682664  }
    683665}
Note: See TracChangeset for help on using the changeset viewer.