Changeset 10034 in ntrip for trunk/BNC/src/PPP/pppParlist.cpp


Ignore:
Timestamp:
Apr 21, 2023, 11:48:24 AM (12 months ago)
Author:
stuerze
Message:
 
File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/BNC/src/PPP/pppParlist.cpp

    r10031 r10034  
    6262     _noise   = OPT->_noiseCrd[2];
    6363     break;
    64    case rClkG:
    65      _epoSpec = true;
    66      _sigma0  = OPT->_aprSigClk;
    67      break;
    68    case rClkR:
    69      _epoSpec = true;
    70      _sigma0  = OPT->_aprSigClk;
    71      break;
    72    case rClkE:
    73      _epoSpec = true;
    74      _sigma0  = OPT->_aprSigClk;
    75      break;
    76    case rClkC:
     64   case clkR:
    7765     _epoSpec = true;
    7866     _sigma0  = OPT->_aprSigClk;
    … …  
    8674         const t_pppSatObs* obs = obsVector->at(ii);
    8775         if (obs->prn() == _prn) {
    88            _x0 = floor((obs->obsValue(tLC) - obs->cmpValue(tLC)) / obs->lambda(tLC) + 0.5);
     76           double offGlo = 0;
     77           if (_prn.system() == 'R' && tLC != t_lc::MW) {
     78             offGlo = PPP_CLIENT->offGlo();
     79           }
     80           double offGal = 0;
     81           if (_prn.system() == 'E' && tLC != t_lc::MW) {
     82             offGal = PPP_CLIENT->offGal();
     83           }
     84           double offBds = 0;
     85           if (_prn.system() == 'C' && tLC != t_lc::MW) {
     86             offBds = PPP_CLIENT->offBds();
     87           }
     88           _x0 = floor((obs->obsValue(tLC) - offGlo - offGal - offBds - obs->cmpValue(tLC)) / obs->lambda(tLC) + 0.5);
    8989           break;
    9090         }
    9191       }
    9292     }
     93     break;
     94   case offGlo:
     95     _epoSpec = true;
     96     _sigma0  = OPT->_aprSigClk;
     97     _x0      = PPP_CLIENT->offGlo();
     98     break;
     99   case offGal:
     100     _epoSpec = true;
     101     _sigma0  = OPT->_aprSigClk;
     102     _x0      = PPP_CLIENT->offGal();
     103     break;
     104   case offBds:
     105     _epoSpec = true;
     106     _sigma0  = OPT->_aprSigClk;
     107     _x0      = PPP_CLIENT->offBds();
    93108     break;
    94109   case trp:
    … …  
    117132}
    118133
    119 //
    120 ////////////////////////////////////////////////////////////////////////////
    121 t_pppParam::t_pppParam(const t_pppParam* old) {
    122   _type     = old->type();
    123   _prn      = old->prn();
    124   _tLC      = old->tLC();
    125   _indexOld = old->indexOld();
    126   _indexNew = old->indexNew();
    127   _noise    = old->noise();
    128   _sigma0   = old->sigma0();
    129   _epoSpec  = old->epoSpec();
    130   _x0       = old->x0();
    131   setFirstObsTime(old->firstObsTime());
    132   setLastObsTime(old->lastObsTime());
    133   _ambInfo  = 0;
    134   if (_type == t_pppParam::amb) {
    135     _ambInfo  = new t_ambInfo();
    136     _ambInfo->_resetCandidate = old->_ambInfo->_resetCandidate;
    137     _ambInfo->_eleSat         = old->_ambInfo->_eleSat;
    138     _ambInfo->_numEpo         = old->_ambInfo->_numEpo;
    139   }
    140 }
    141 
    142134// Destructor
    143135////////////////////////////////////////////////////////////////////////////
    … …  
    150142////////////////////////////////////////////////////////////////////////////
    151143double t_pppParam::partial(const bncTime& /* epoTime */, const t_pppSatObs* obs,
    152                            const t_lc::type& tLC, const t_prn refPrn) const {
     144                           const t_lc::type& tLC) const {
    153145
    154146  // Special Case - Melbourne-Wuebbena
    … …  
    176168    if (tLC == t_lc::GIM) {return 0.0;}
    177169    return (sta->xyzApr()[2] - obs->xc()[2]) / rhoV.NormFrobenius();
    178   case rClkG:
     170  case clkR:
    179171    if (tLC == t_lc::GIM) {return 0.0;}
    180     return (obs->prn().system() == 'G') ? 1.0 : 0.0;
    181   case rClkR:
     172    return 1.0;
     173  case offGlo:
    182174    if (tLC == t_lc::GIM) {return 0.0;}
    183175    return (obs->prn().system() == 'R') ? 1.0 : 0.0;
    184   case rClkE:
     176  case offGal:
    185177    if (tLC == t_lc::GIM) {return 0.0;}
    186178    return (obs->prn().system() == 'E') ? 1.0 : 0.0;
    187   case rClkC:
     179  case offBds:
    188180    if (tLC == t_lc::GIM) {return 0.0;}
    189181    return (obs->prn().system() == 'C') ? 1.0 : 0.0;
    190182  case amb:
    191     if      (tLC == t_lc::GIM) {return 0.0;}
    192     else if ((OPT->_obsModelType == OPT->IF)     ||
    193              (OPT->_obsModelType == OPT->PPPRTK) ||
    194              (OPT->_obsModelType == OPT->UncombPPP) ||
    195              (OPT->_obsModelType == OPT->DCMcodeBias  && !obs->isReference()) ||
    196              (OPT->_obsModelType == OPT->DCMphaseBias && !obs->isReference())   ) {
    197 
     183    if (tLC == t_lc::GIM) {
     184      return 0.0;
     185    }
     186    else {
    198187      if (obs->prn() == _prn) {
    199188        if      (tLC == _tLC) {
    … …  
    236225      }
    237226      else if (tLC == t_lc::GIM) {
    238         return -1.0;
    239       }
    240     }
    241     if (tLC == t_lc::GIM && _prn == refPrn) {
    242       return 1.0;
     227        return 1.0;
     228      }
    243229    }
    244230    break;
    … …  
    310296    ss << "CRD_Z";
    311297    break;
    312   case rClkG:
    313     ss << "REC_CLK  G  ";
    314     break;
    315   case rClkR:
    316     ss << "REC_CLK  R  ";
    317     break;
    318   case rClkE:
    319     ss << "REC_CLK  E  ";
    320     break;
    321   case rClkC:
    322     ss << "REC_CLK  C  ";
     298  case clkR:
     299    ss << "REC_CLK     ";
     300    break;
     301  case offGlo:
     302    ss << "OFF_GLO     ";
     303    break;
     304  case offGal:
     305    ss << "OFF_GAL     ";
     306    break;
     307  case offBds:
     308    ss << "OFF_BDS     ";
    323309    break;
    324310  case trp:
    … …  
    361347  _usedSystems.clear();
    362348
    363   vector<t_pppParam*>::iterator it = _params.begin();
    364   while (it != _params.end()) {
    365     t_pppParam* par = *it;
    366     delete par;
    367     it = _params.erase(it);
     349  for (unsigned ii = 0; ii < _params.size(); ii++) {
     350    delete _params[ii];
    368351  }
    369352}
    … …  
    371354//
    372355////////////////////////////////////////////////////////////////////////////
    373 t_pppParlist::t_pppParlist(const t_pppParlist& old) {
    374 
    375   _usedSystems = old._usedSystems;
    376 
    377   vector<t_pppParam*>::const_iterator it = old.params().begin();
    378   while (it != old.params().end()) {
    379     const t_pppParam* oldParam = *it;
    380     _params.push_back(new t_pppParam(oldParam));
    381   }
    382 }
    383 
    384 //
    385 ////////////////////////////////////////////////////////////////////////////
    386 const t_pppParlist& t_pppParlist::operator= (const t_pppParlist& p) {
    387 
    388   _usedSystems.clear();
    389 
    390   _usedSystems = p._usedSystems;
    391 
    392   vector<t_pppParam*>::iterator it = _params.begin();
    393   while (it != _params.end()) {
    394     t_pppParam* par = *it;
    395     delete par;
    396     it = _params.erase(it);
    397   }
    398 
    399   for (unsigned jj = 0; jj < p.params().size(); jj++) {
    400     t_pppParam* parFrom = p.params()[jj];
    401     _params.push_back(new t_pppParam(parFrom));
    402   }
    403   return *this;
    404 }
    405 
    406 //
    407 ////////////////////////////////////////////////////////////////////////////
    408 t_irc t_pppParlist::set(const bncTime& epoTime, const std::vector<t_pppSatObs*>& obsVector,
    409     const QMap<char, t_pppRefSat*>& refSatMap) {
     356t_irc t_pppParlist::set(const bncTime& epoTime, const std::vector<t_pppSatObs*>& obsVector) {
    410357
    411358  // Remove some Parameters
    … …  
    421368    }
    422369
    423     else if (par->type() == t_pppParam::crdX ||
     370    else if (par->type() == t_pppParam::amb  ||
     371             par->type() == t_pppParam::ion  ||
     372             par->type() == t_pppParam::crdX ||
    424373             par->type() == t_pppParam::crdY ||
    425374             par->type() == t_pppParam::crdZ) {
    … …  
    429378    }
    430379
    431     else if (par->type() == t_pppParam::amb) {
    432       if (par->lastObsTime().valid() && (epoTime - par->lastObsTime() > 60.0)) {
    433           remove = true;
    434       }
    435       if (OPT->_obsModelType == OPT->DCMcodeBias ||
    436           OPT->_obsModelType == OPT->DCMphaseBias) {
    437         char sys = par->prn().system();
    438         t_prn refPrn = (refSatMap[sys])->prn();
    439         if (par->lastObsTime().valid() && par->prn() == refPrn) {
    440             remove = true;
    441         }
    442       }
    443     }
    444 
    445     else if (par->type() == t_pppParam::ion) {
    446       if (par->lastObsTime().valid() && (epoTime - par->lastObsTime() > 60.0)) {
    447           remove = true;
    448       }
    449     }
    450380    if (remove) {
    451381#ifdef BNC_DEBUG_PPP
    … …  
    495425  }
    496426
    497   if (OPT->_obsModelType == OPT->DCMcodeBias ||
    498       OPT->_obsModelType == OPT->DCMphaseBias) {
    499     // Check if ambiguity parameters have observations
    500     // -----------------------------------------------
     427  if (OPT->_obsModelType == OPT->PPPRTK || OPT->_pseudoObsIono) {
    501428    vector<t_pppParam*>::iterator it = _params.begin();
    502     QList<t_prn> lostSats;
    503429    while (it != _params.end()) {
    504430      t_pppParam* par = *it;
    505       if ((par->type() == t_pppParam::amb) &&
    506           (!par->lastObsTime().valid() || (epoTime - par->lastObsTime() > 0.0))) {
    507 #ifdef BNC_DEBUG_PPP
    508         //LOG << "remove1 " << par->toString() << std::endl;
    509 #endif
    510         lostSats.append(par->prn());
    511         delete par;
    512         it = _params.erase(it);
    513       }
    514431      // Check if systems have to be presented per biases
    515432      // ----------------------------------------------
    516       else if ((par->type() == t_pppParam::cBiasG1 ||
     433      if ((     par->type() == t_pppParam::cBiasG1 ||
    517434                par->type() == t_pppParam::cBiasG2 ||
    518435                par->type() == t_pppParam::pBiasG1 ||
    … …  
    558475      }
    559476    }
    560     // remove respective iono parameters
    561     // ---------------------------------
    562     it = _params.begin();
    563     while (it != _params.end()) {
    564       t_pppParam* par = *it;
    565       if ((par->type() == t_pppParam::ion) &&
    566           (lostSats.contains(par->prn()) || (epoTime - par->lastObsTime() > 0.0))) {
    567 #ifdef BNC_DEBUG_PPP
    568        //LOG << "remove1 " << par->toString() << std::endl;
    569 #endif
    570         delete par;
    571         it = _params.erase(it);
    572       }
    573       else {
    574         ++it;
    575       }
    576     }
    577   }
    578 
     477  }
    579478
    580479  // Required Set of Parameters
    … …  
    588487  required.push_back(new t_pppParam(t_pppParam::crdZ, t_prn(), t_lc::dummy));
    589488
     489  // Receiver Clock
     490  // --------------
     491  required.push_back(new t_pppParam(t_pppParam::clkR, t_prn(), t_lc::dummy));
     492
     493  // GLONASS Clock Offset
     494  // --------------------
     495  if ( _usedSystems.contains('R')  &&
     496      (_usedSystems.contains('G') || _usedSystems.contains('E') || _usedSystems.contains('C'))) {
     497    required.push_back(new t_pppParam(t_pppParam::offGlo, t_prn(), t_lc::dummy));
     498  }
     499
     500  // Galileo Clock Offset
     501  // --------------------
     502  if (_usedSystems.contains('E') && _usedSystems.contains('G')) {
     503    required.push_back(new t_pppParam(t_pppParam::offGal, t_prn(), t_lc::dummy));
     504  }
     505
     506  // BDS Clock Offset
     507  // ----------------
     508  if (_usedSystems.contains('C')  && (_usedSystems.contains('G') || _usedSystems.contains('E'))) {
     509    required.push_back(new t_pppParam(t_pppParam::offBds, t_prn(), t_lc::dummy));
     510  }
     511
     512  // Troposphere
     513  // -----------
     514  if (OPT->estTrp()) {
     515    required.push_back(new t_pppParam(t_pppParam::trp, t_prn(), t_lc::dummy));
     516  }
     517
     518  // Ionosphere
     519  // ----------
     520  if (OPT->_obsModelType == OPT->UncombPPP) {
     521    for (unsigned jj = 0; jj < obsVector.size(); jj++) {
     522      const t_pppSatObs* satObs = obsVector[jj];
     523      required.push_back(new t_pppParam(t_pppParam::ion, satObs->prn(), t_lc::dummy));
     524    }
     525  }
     526  // Ambiguities
     527  // -----------
     528  for (unsigned jj = 0; jj < obsVector.size(); jj++) {
     529    const t_pppSatObs*  satObs = obsVector[jj];
     530    const vector<t_lc::type>& ambLCs = OPT->ambLCs(satObs->prn().system());
     531    for (unsigned ii = 0; ii < ambLCs.size(); ii++) {
     532      required.push_back(new t_pppParam(t_pppParam::amb, satObs->prn(), ambLCs[ii], &obsVector));
     533    }
     534  }
     535
    590536  // Receiver Code Biases
    591537  // --------------------
    592   if (OPT->_obsModelType == OPT->DCMcodeBias) {
     538  if (OPT->_obsModelType == OPT->PPPRTK) {
    593539    std::vector<t_lc::type> lc;
    594540    if (_usedSystems.contains('G')) {
    … …  
    629575    }
    630576  }
     577  if (OPT->_pseudoObsIono) {
     578    std::vector<t_lc::type> lc;
     579    if (_usedSystems.contains('G')) {
     580      lc = OPT->LCs('G');
     581      if (std::find(lc.begin(), lc.end(), t_lc::c2) != lc.end()) {
     582        required.push_back(new t_pppParam(t_pppParam::cBiasG2, t_prn(), t_lc::c2));
     583      }
     584    }
     585    if (_usedSystems.contains('R')) {
     586      lc = OPT->LCs('R');
     587      if (std::find(lc.begin(), lc.end(), t_lc::c2) != lc.end()) {
     588        required.push_back(new t_pppParam(t_pppParam::cBiasR2, t_prn(), t_lc::c2));
     589      }
     590    }
     591    if (_usedSystems.contains('E')) {
     592      lc = OPT->LCs('E');
     593      if (std::find(lc.begin(), lc.end(), t_lc::c2) != lc.end()) {
     594        required.push_back(new t_pppParam(t_pppParam::cBiasE2, t_prn(), t_lc::c2));
     595      }
     596    }
     597    if (_usedSystems.contains('C')) {
     598      lc = OPT->LCs('C');
     599      if (std::find(lc.begin(), lc.end(), t_lc::c2) != lc.end()) {
     600        required.push_back(new t_pppParam(t_pppParam::cBiasC2, t_prn(), t_lc::c2));
     601      }
     602    }
     603  }
    631604
    632605  // Receiver Phase Biases
    633606  // ---------------------
    634   if ((OPT->_obsModelType == OPT->DCMphaseBias) ||
    635       (OPT->_obsModelType == OPT->PPPRTK)     ) {
     607  if (OPT->_obsModelType == OPT->PPPRTK) {
    636608    std::vector<t_lc::type> lc;
    637609    if (_usedSystems.contains('G')) {
    … …  
    669641      if (std::find(lc.begin(), lc.end(), t_lc::l2) != lc.end()) {
    670642        required.push_back(new t_pppParam(t_pppParam::pBiasC2, t_prn(), t_lc::l2));
    671       }
    672     }
    673   }
    674 
    675   // Receiver Clocks
    676   // ---------------
    677    if (_usedSystems.contains('G')) {
    678      required.push_back(new t_pppParam(t_pppParam::rClkG, t_prn(), t_lc::dummy));
    679    }
    680 
    681    if (_usedSystems.contains('R')) {
    682      required.push_back(new t_pppParam(t_pppParam::rClkR, t_prn(), t_lc::dummy));
    683    }
    684 
    685    if (_usedSystems.contains('E')) {
    686      required.push_back(new t_pppParam(t_pppParam::rClkE, t_prn(), t_lc::dummy));
    687    }
    688 
    689    if (_usedSystems.contains('C')) {
    690      required.push_back(new t_pppParam(t_pppParam::rClkC, t_prn(), t_lc::dummy));
    691    }
    692 
    693   // Troposphere
    694   // -----------
    695   if (OPT->estTrp()) {
    696     required.push_back(new t_pppParam(t_pppParam::trp, t_prn(), t_lc::dummy));
    697   }
    698 
    699   // Ionosphere
    700   // ----------
    701   if (OPT->_obsModelType == OPT->UncombPPP    ||
    702       OPT->_obsModelType == OPT->DCMcodeBias  ||
    703       OPT->_obsModelType == OPT->DCMphaseBias   ) {
    704     for (unsigned jj = 0; jj < obsVector.size(); jj++) {
    705       const t_pppSatObs* satObs = obsVector[jj];
    706       required.push_back(new t_pppParam(t_pppParam::ion, satObs->prn(), t_lc::dummy));
    707     }
    708   }
    709   // Ambiguities
    710   // -----------
    711   for (unsigned jj = 0; jj < obsVector.size(); jj++) {
    712     const t_pppSatObs*  satObs = obsVector[jj];
    713     if ((OPT->_obsModelType == OPT->IF)        ||
    714         (OPT->_obsModelType == OPT->PPPRTK)    ||
    715         (OPT->_obsModelType == OPT->UncombPPP) ||
    716         (OPT->_obsModelType == OPT->DCMcodeBias  && !satObs->isReference()) ||
    717         (OPT->_obsModelType == OPT->DCMphaseBias && !satObs->isReference())   ) {
    718       const vector<t_lc::type>& ambLCs = OPT->ambLCs(satObs->prn().system());
    719       for (unsigned ii = 0; ii < ambLCs.size(); ii++) {
    720         required.push_back(new t_pppParam(t_pppParam::amb, satObs->prn(), ambLCs[ii], &obsVector));
    721643      }
    722644    }
    … …  
    779701  t_pppParam* parY = 0;
    780702  t_pppParam* parZ = 0;
    781   vector<t_pppParam*>::const_iterator it = _params.begin();
    782   while (it != _params.end()) {
    783     t_pppParam* par = *it;
     703  for (unsigned ii = 0; ii < _params.size(); ii++) {
     704    t_pppParam* par = _params[ii];
    784705    if      (par->type() == t_pppParam::crdX) {
    785706      parX = par;
    … …  
    805726      LOG << endl;
    806727    }
    807     ++it;
    808728  }
    809729
Note: See TracChangeset for help on using the changeset viewer.