Changeset 9508 in ntrip


Ignore:
Timestamp:
Oct 6, 2021, 10:50:34 PM (16 months ago)
Author:
stuerze
Message:

some changes regarding PPP

Location:
trunk/BNC/src
Files:
8 edited

Legend:

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

    r9490 r9508  
    6969  if (_opt->_refSatRequired) {
    7070    for (unsigned iSys = 0; iSys < _opt->systems().size(); iSys++) {
    71       char system = _opt->systems()[iSys];
    72       _obsPool->initRefSatMapElement(system);
     71      char sys = _opt->systems()[iSys];
     72      _refSatMap[sys] = new t_pppRefSat();
    7373    }
    7474  }
     
    9494  delete _tides;
    9595  clearObs();
     96  QMapIterator<char, t_pppRefSat*> it(_refSatMap);
     97  while (it.hasNext()) {
     98    it.next();
     99    delete it.value();
     100  }
     101  _refSatMap.clear();
    96102}
    97103
     
    216222    while (it != obsVector.end()) {
    217223      t_pppSatObs* satObs = *it;
    218       char system = satObs->prn().system();
    219       t_pppRefSat* refSat = _obsPool->getRefSatMapElement(system);
     224      char sys = satObs->prn().system();
     225      t_pppRefSat* refSat = _refSatMap[sys];
    220226      double stecRef = refSat->stecValue();
    221227      if (stecRef && !satObs->isReference()) {
     
    605611#endif
    606612      if (_obsPool->refSatChanged()) {
    607         if(_filter->datumTransformation() != success) {
    608           LOG << "pppFilter::datumTransformation() != success" << endl;
     613        if(_filter->datumTransformation(_refSatMap) != success) {
     614          LOG << "t_pppFilter::datumTransformation() != success" << endl;
    609615          return finish(failure);
    610616        }
    611617        else {
    612           LOG << "pppFilter::datumTransformation() == success" << endl;
    613           if (!_obsPool->refSatChangeRequired()) {
    614             _obsPool->saveLastEpoRefSats();
    615           }
     618          LOG << "t_pppFilter::datumTransformation() == success" << endl;
    616619        }
    617620      }
     
    643646          return finish(failure);
    644647        }
    645         if (_obsPool->refSatChanged() &&
    646             (_opt->_obsModelType == OPT->DCMcodeBias ||
    647              _opt->_obsModelType == OPT->DCMphaseBias ||
    648              _opt->_pseudoObsIono)
    649            ) {
    650           LOG << "refSatChanged()" << endl;
     648        if (_obsPool->refSatChanged()) {
     649          LOG << "t_pppFilter: refSatChanged()" << endl;
    651650            epochReProcessing = true;
    652651            continue;
     
    669668      // Store last epoch of data
    670669      // ------------------------
    671       _obsPool->putEpoch(_epoTimeRover, _obsRover, _pseudoObsIono);
     670      _obsPool->putEpoch(_epoTimeRover, _obsRover, _pseudoObsIono, _refSatMap);
    672671
    673672      // Process Epoch in Filter
     
    798797    char sys = _opt->systems()[iSys];
    799798    bool refSatDefined = false;
    800     t_pppRefSat* refSat = _obsPool->getRefSatMapElement(sys);
     799    t_pppRefSat* refSat = _refSatMap[sys];
    801800    for (unsigned ii = 0; ii < obsVector.size(); ii++) {
    802801      t_pppSatObs* satObs = obsVector.at(ii);
     
    806805      // reference satellite is unchanged
    807806      // ================================
    808       if      (!_obsPool->refSatChangeRequired(sys) && refSat->prn() == satObs->prn()) {
     807      if (     !_obsPool->refSatChangeRequired(sys) && refSat->prn() == satObs->prn()) {
    809808        refSatDefined = true;
    810809        obsVector[ii]->setAsReference();
     
    878877  setRefSatellites(obsVector); // current epoch
    879878  LOG.setf(ios::fixed);
    880   QMapIterator<char, t_pppRefSat*> it(_obsPool->getRefSatMap());
     879  t_pppObsPool::t_epoch* epoch = _obsPool->lastEpoch();
     880  const QMap<char, t_pppRefSat*>& refSatMapLastEpoch = epoch->refSatMap();
     881 
     882  QMapIterator<char, t_pppRefSat*> it(_refSatMap);
    881883  while (it.hasNext()) {
    882884    it.next();
    883885    char  sys = it.key();
    884886    t_prn prn = it.value()->prn();
     887    t_prn refSatLastEpochPrn = t_prn();
     888    if (epoch) {
     889      refSatLastEpochPrn =  refSatMapLastEpoch[sys]->prn();
     890    }
    885891    if      (prn.number() ==  0) { // no obs for that system available
    886892      continue;
     
    891897    }
    892898    QString str;
    893     if (prn == _obsPool->getRefSatMapElementLastEpoch(sys) ||
    894                _obsPool->getRefSatMapElementLastEpoch(sys) == t_prn() )  {
     899    if (prn == refSatLastEpochPrn || refSatLastEpochPrn == t_prn() )  {
    895900      _obsPool->setRefSatChanged(sys, false);
    896901      str = " SET   ";
     
    906911
    907912void t_pppClient::setHistoricalRefSats() {
    908   QMapIterator<char, t_pppRefSat*> it(_obsPool->getRefSatMap());
     913  QMapIterator<char, t_pppRefSat*> it(_refSatMap);
    909914  while (it.hasNext()) {
    910915    it.next();
     
    914919      _historicalRefSats[sys].append(prn);
    915920    }
    916   }}
     921  }
     922}
    917923
    918924//
  • trunk/BNC/src/PPP/pppClient.h

    r9386 r9508  
    88#include "pppOptions.h"
    99#include "pppModel.h"
     10#include "pppRefSat.h"
    1011
    1112class bncAntex;
    12 class t_pppRefSat;
    1313
    1414namespace BNC_PPP {
     
    7979  double                    _offGC;
    8080  std::vector<t_pppSatObs*> _obsRover;
     81  QMap<char, t_pppRefSat*>  _refSatMap;
    8182  std::ostringstream*       _log;
    8283  t_pppOptions*             _opt;
  • trunk/BNC/src/PPP/pppFilter.cpp

    r9504 r9508  
    7272  string epoTimeStr = string(_epoTime);
    7373
     74  const QMap<char, t_pppRefSat*>& refSatMap = epoch->refSatMap();
     75
    7476  if (OPT->_obsModelType == OPT->DCMcodeBias ||
    7577      OPT->_obsModelType == OPT->DCMphaseBias) {
    7678     // Save parameters of epoch before
    7779    _parlist_sav = _parlist;
    78  }
     80  }
    7981
    8082  //--
    8183  // Set Parameters
    82   if (_parlist.set(_epoTime, allObs, _obsPool->getRefSatMap()) != success) {
     84  if (_parlist.set(_epoTime, allObs, refSatMap) != success) {
    8385    return failure;
    8486  }
    85 
    8687  const vector<t_pppParam*>& params = _parlist.params();
    8788#ifdef BNC_DEBUG_PPP
    88   for (int iPar = 0; iPar < params.size(); iPar++) {
    89     LOG << "available par " << params[iPar]->toString() << endl;
     89  for (unsigned iPar = 0; iPar < params.size(); iPar++) {
     90    LOG << "t_pppFilter::processEpoch par_cur " << params[iPar]->toString() << endl;
    9091  }
    9192#endif
     
    133134    for (int iSys = 0; iSys < usedSystems.size(); iSys++) {
    134135      char sys = usedSystems[iSys];
    135       _refPrn = (_obsPool->getRefSatMapElement(sys))->prn();
     136      _refPrn = refSatMap[sys]->prn();
    136137     vector<t_pppSatObs*> obsVector;
    137138      for (unsigned jj = 0; jj < allObs.size(); jj++) {
     
    170171    char sys = usedSystems[iSys];
    171172    if (OPT->_refSatRequired) {
    172       _refPrn = (_obsPool->getRefSatMapElement(sys))->prn();
     173      _refPrn = refSatMap[sys]->prn();
    173174    }
    174175    else {
     
    195196  // close epoch processing
    196197  // ----------------------
    197   cmpDOP(allObs);
     198  cmpDOP(allObs, refSatMap);
    198199  _parlist.printResult(_epoTime, _QFlt, _xFlt);
    199200  _lastEpoTimeOK = _epoTime;  // remember time of last successful epoch processing
    200   if (OPT->_refSatRequired) {
    201     _obsPool->saveLastEpoRefSats();
    202   }
    203201  return success;
    204202}
     
    596594// Compute various DOP Values
    597595////////////////////////////////////////////////////////////////////////////
    598 void t_pppFilter::cmpDOP(const vector<t_pppSatObs*>& obsVector) {
     596void t_pppFilter::cmpDOP(const vector<t_pppSatObs*>& obsVector,
     597                         const QMap<char, t_pppRefSat*>& refSatMap) {
    599598
    600599  _dop.reset();
     
    606605    for (unsigned ii = 0; ii < obsVector.size(); ii++) {
    607606      t_pppSatObs* obs = obsVector[ii];
    608       char system = obs->prn().system();
     607      char sys = obs->prn().system();
    609608      t_prn refPrn = t_prn();
    610609      if (OPT->_refSatRequired) {
    611         refPrn = _obsPool->getRefSatMapElement(system)->prn();
     610        refPrn = refSatMap[sys]->prn();
    612611      }
    613612      if (obs->isValid() && !obs->outlier()) {
     
    678677// Compute datum transformation
    679678////////////////////////////////////////////////////////////////////////////
    680 t_irc t_pppFilter::datumTransformation() {
     679t_irc t_pppFilter::datumTransformation(const QMap<char, t_pppRefSat*>& refSatMap) {
     680
    681681  // get last epoch
    682682  t_pppObsPool::t_epoch* epoch = _obsPool->lastEpoch();
    683683  if (!epoch) {
    684     LOG << "!lastEpoch" << endl;
     684    LOG << "t_pppFilter::datumTransformation: !lastEpoch" << endl;
    685685    return failure;
    686686  }
    687   else {
    688     LOG.setf(ios::fixed);
    689     LOG << string(epoch->epoTime()) << " DATUM TRANSFORMATION " << endl;
    690   }
     687  _epoTime = epoch->epoTime();
     688  LOG.setf(ios::fixed);
     689  LOG << string(_epoTime) << " DATUM TRANSFORMATION " << endl;
    691690
    692691  vector<t_pppSatObs*>& allObs = epoch->obsVector();
     692
     693  const QMap<char, t_pppRefSat*>& refSatMapLastEpoch = epoch->refSatMap();
     694
     695  bool peseudoObsIono = epoch->pseudoObsIono();
    693696
    694697  // reset old and set new refSats in last epoch (ambiguities/GIM)
    695698  // =============================================================
    696   if (resetRefSatellitesLastEpoch(allObs) != true) {
     699  if (resetRefSatellitesLastEpoch(allObs, refSatMap, refSatMapLastEpoch) != true) {
    697700    LOG  << "refsatChange required" << endl;
    698701    return success;
     
    705708  // set AA2
    706709  // =======
    707   if (_parlist.set(epoch->epoTime(), allObs, _obsPool->getRefSatMap()) != success) {
     710  if (_parlist.set(_epoTime, allObs, refSatMap) != success) {
    708711    return failure;
    709712  }
    710   const vector<t_pppParam*>& _params = _parlist.params();
     713  vector<t_pppParam*>& _params = _parlist.params();
    711714  unsigned nPar = _parlist.nPar();
    712715#ifdef BNC_DEBUG_PPP
    713   LOG << " parameters of last epoch" << endl;
     716  LOG << " t_pppFilter::datumTransformation par last epoch: " << _params.size() << "/" << nPar << endl;
    714717  for (unsigned iPar = 0; iPar < nPar; iPar++) {
    715     LOG << _params[iPar]->toString() << "\t\t" << endl;
     718    LOG << _params[iPar]->toString() << "\t\t" endl;
    716719  }
    717720#endif
     
    719722  for (int iSys = 0; iSys < usedSystems.size(); iSys++) {
    720723    char sys = usedSystems[iSys];
    721     t_prn refPrn = (_obsPool->getRefSatMapElement(sys))->prn();
     724    t_prn refPrn = refSatMap[sys]->prn();
    722725    vector<t_pppSatObs*> obsVector;
    723726    for (unsigned jj = 0; jj < allObs.size(); jj++) {
     
    731734    vector<t_lc::type> LCs = OPT->LCs(sys);
    732735    unsigned usedLCs = LCs.size();
    733     if (OPT->_pseudoObsIono && !epoch->pseudoObsIono()) {
     736    if (OPT->_pseudoObsIono && !peseudoObsIono) {
    734737        usedLCs -= 1;  // GIM not used
    735738    }
     
    744747      maxObs += 1;
    745748    }
    746     if (OPT->_pseudoObsIono && epoch->pseudoObsIono()) {
     749    if (OPT->_pseudoObsIono && peseudoObsIono) {
    747750      maxObs -= 1; // pseudo obs iono with respect to refSat
    748751    }
    749752    Matrix  AA(maxObs, nPar);
    750 
    751753    // Real Observations
    752754    // -----------------
     
    787789      continue;
    788790    }
    789     _datumTrafo->updateIndices(sys, iObs+1);
    790     _datumTrafo->prepareAA(AA.SubMatrix(1, iObs+1 , 1, nPar), 2);
     791    _datumTrafo->updateIndices(sys, iObs+1);    //LOG << "AA Ncols/Nrows: " << AA.Ncols() << "/" << AA.Nrows() << "  nPar: "  << nPar << endl;    //LOG << "AA.SubMatrix(1 .. " << iObs+1 << " , 1 .. " <<  nPar << ")" << endl;
     792    if(_datumTrafo->prepareAA(AA.SubMatrix(1, iObs+1 , 1, nPar), 2) != success) {
     793      return failure;
     794    }
    791795  }
    792796  _datumTrafo->updateNumObs();
     
    819823  for (int iSys = 0; iSys < usedSystems.size(); iSys++) {
    820824    char sys = usedSystems[iSys];
    821     t_prn refPrnOld = _obsPool->getRefSatMapElementLastEpoch(sys);
    822     t_prn refPrnNew = (_obsPool->getRefSatMapElement(sys))->prn();
     825    t_prn refPrnOld = refSatMapLastEpoch[sys]->prn();
     826    t_prn refPrnNew = refSatMap[sys]->prn();
    823827    if (refPrnNew != refPrnOld) {
    824       t_irc irc = resetAmb(_obsPool->getRefSatMapElementLastEpoch(sys), allObs);
     828      t_irc irc = resetAmb(refPrnOld, allObs);
    825829      if (OPT->_obsModelType == OPT->DCMcodeBias) {
    826830        if (irc == success) {
     
    834838  // =================
    835839  _datumTrafo->switchAA();
     840
     841  _obsPool->putEpoch(_epoTime, allObs, peseudoObsIono, refSatMap);
    836842
    837843  return success;
     
    877883//
    878884//////////////////////////////////////////////////////////////////////////////
    879 bool t_pppFilter::resetRefSatellitesLastEpoch(std::vector<t_pppSatObs*>& obsVector) {
     885bool t_pppFilter::resetRefSatellitesLastEpoch(std::vector<t_pppSatObs*>& obsVector,
     886    const QMap<char, t_pppRefSat*>& refSatMap,
     887    const QMap<char, t_pppRefSat*>& refSatMapLastEpoch) {
    880888  bool resetRefSat;
    881889  // reference satellite definition per system
     
    884892    resetRefSat = false;
    885893    char sys = usedSystems[iSys];
    886     t_pppRefSat* refSat = _obsPool->getRefSatMapElement(sys);
    887     t_prn newPrn = refSat->prn();
    888     t_prn oldPrn = _obsPool->getRefSatMapElementLastEpoch(sys);
     894    t_prn newPrn = refSatMap[sys]->prn();
     895    t_prn oldPrn = refSatMapLastEpoch[sys]->prn();
    889896#ifdef BNC_DEBUG_PPP
    890     LOG << "oldPrn: " << oldPrn.toString() << " => newPrn: " << newPrn.toString() << endl;
     897    if (oldPrn != newPrn) {
     898      LOG << "oldRef: " << oldPrn.toString() << " => newRef " <<  newPrn.toString() << endl;
     899    }
    891900#endif
    892901    vector<t_pppSatObs*>::iterator it = obsVector.begin();
     
    896905        resetRefSat = true;
    897906        satObs->setAsReference();
    898       }
    899       else if (satObs->prn() == oldPrn) {
     907      } else if (satObs->prn() == oldPrn) {
    900908        satObs->resetReference();
    901909      }
  • trunk/BNC/src/PPP/pppFilter.h

    r9504 r9508  
    2626  const SymmetricMatrix& Q() const {return _QFlt;}
    2727
    28   t_irc datumTransformation();
     28  t_irc datumTransformation(const QMap<char, t_pppRefSat*>& refSatMap);
    2929  void initDatumTransformation(const std::vector<t_pppSatObs*>& allObs, bool pseudoObsIono);
    3030  unsigned setTrafoObs();
     
    9191        _firstRow = _lastRow + 1;
    9292      }
    93       _lastRow += maxObsSys;//LOG << sys << " updateIndices: lastRow: " << _lastRow << "\n" ;
     93      _lastRow += maxObsSys; //LOG << sys << " updateIndices: lastRow: " << _lastRow << "\n" ;
    9494    };
    9595
     
    120120      _D21.ReSize(_numPar, _numPar); _D21 = 0.0;
    121121    }
    122     void prepareAA(const Matrix& AA, int ind) {
     122    t_irc prepareAA(const Matrix& AA, int ind) {
    123123      Matrix* Prep = &_AA2;
    124124      if (ind == 1) {
    125125        Prep = &_AA1;
    126126      }
     127      //LOG << "_firstRow: " << _firstRow << " _lastRow: " << _lastRow << " _numPar " << _numPar << std::endl;
     128      if (AA.Ncols() > _numPar) {
     129        LOG << "t_pppFilter::prepareAA: AA.Ncols() > _numPar: " << AA.Ncols() << " > " << _numPar << std::endl;
     130        return failure;
     131      }
    127132      Prep->SubMatrix(_firstRow, _lastRow, 1, _numPar) << AA;
     133      return success;
    128134    }
    129135    void switchAA() {
     
    132138    t_irc computeTrafoMatrix() {
    133139      if (((_AA2.t() * _AA2)).Determinant() == 0.0) {
    134         LOG << "(_AA2.t() * _AA2).inv() is singular" << std::endl;
     140        LOG << "t_pppFilter::computeTrafoMatrix: (_AA2.t() * _AA2).inv() is singular" << std::endl;
    135141        return failure;
    136142      }
     
    174180                 SymmetricMatrix* QSav = 0, ColumnVector* xSav = 0);
    175181
    176   void cmpDOP(const std::vector<t_pppSatObs*>& obsVector);
     182  void cmpDOP(const std::vector<t_pppSatObs*>& obsVector,
     183              const QMap<char, t_pppRefSat*>& refSatMap);
    177184
    178185  void predictCovCrdPart(const SymmetricMatrix& QFltOld);
     
    180187  t_irc addNoiseToIono(char sys);
    181188
    182   bool resetRefSatellitesLastEpoch(std::vector<t_pppSatObs*>& obsVector);
     189  bool resetRefSatellitesLastEpoch(std::vector<t_pppSatObs*>& obsVector,
     190                                   const QMap<char, t_pppRefSat*>& refSatMap,
     191                                   const QMap<char, t_pppRefSat*>& refSatMapLastEpoch);
    183192
    184193  bncTime         _epoTime;
  • trunk/BNC/src/PPP/pppObsPool.cpp

    r9386 r9508  
    2323/////////////////////////////////////////////////////////////////////////////
    2424t_pppObsPool::t_epoch::t_epoch(const bncTime& epoTime, vector<t_pppSatObs*>& obsVector,
    25                                bool pseudoObsIono) {
     25                               bool pseudoObsIono, const QMap<char, t_pppRefSat*>& refSatMap) {
    2626  _epoTime        = epoTime;
    2727  _pseudoObsIono  = pseudoObsIono;
     
    3030  }
    3131  obsVector.clear();
     32
     33  QMapIterator<char, t_pppRefSat*> it(refSatMap);
     34  while (it.hasNext()) {
     35    it.next();
     36    char sys = it.key();
     37    t_pppRefSat* refSat = it.value();
     38    _refSatMap[sys] = new t_pppRefSat(refSat->prn(), refSat->stecValue());
     39  }
     40  //refSatMap.clear();
    3241}
    3342
     
    3847    delete _obsVector[ii];
    3948  }
     49
     50  QMapIterator<char, t_pppRefSat*> it(_refSatMap);
     51  while (it.hasNext()) {
     52    it.next();
     53    delete it.value();
     54  }
     55  _refSatMap.clear();
    4056}
    4157
     
    7187    _epochs.pop_front();
    7288  }
    73   clearRefSatMap();
    7489}
    7590
     
    101116/////////////////////////////////////////////////////////////////////////////
    102117void t_pppObsPool::putEpoch(const bncTime& epoTime, vector<t_pppSatObs*>& obsVector,
    103     bool pseudoObsIono) {
     118                            bool pseudoObsIono, const QMap<char, t_pppRefSat*>& refSatMap) {
    104119  const unsigned MAXSIZE = 2;
    105 
    106   _epochs.push_back(new t_epoch(epoTime, obsVector, pseudoObsIono));
     120  _epochs.push_back(new t_epoch(epoTime, obsVector, pseudoObsIono, refSatMap));
    107121
    108122  if (_epochs.size() > MAXSIZE) {
  • trunk/BNC/src/PPP/pppObsPool.h

    r9386 r9508  
    1818   public:
    1919    t_epoch(const bncTime& epoTime, std::vector<t_pppSatObs*>& obsVector,
    20             bool pseudoObsIono);
     20            bool pseudoObsIono, const QMap<char, t_pppRefSat*>& refSatMap);
    2121    ~t_epoch();
    2222          std::vector<t_pppSatObs*>& obsVector() {return _obsVector;}
    2323    const std::vector<t_pppSatObs*>& obsVector() const {return _obsVector;}
     24    const QMap<char, t_pppRefSat*>& refSatMap() const {return _refSatMap;}
    2425    const bncTime& epoTime() const {return _epoTime;}
    2526    bool pseudoObsIono() const {return _pseudoObsIono;}
    2627   private:
    2728    bncTime                   _epoTime;
     29    bool                      _pseudoObsIono;
    2830    std::vector<t_pppSatObs*> _obsVector;
    29     bool                      _pseudoObsIono;
     31    QMap<char, t_pppRefSat*>  _refSatMap;
    3032  };
    3133
     
    3739
    3840  void putEpoch(const bncTime& epoTime, std::vector<t_pppSatObs*>& obsVector,
    39                 bool pseudoObs);
     41                bool pseudoObsIono, const QMap<char, t_pppRefSat*>& refSatMap);
    4042
    4143  void deleteLastEpoch();
     
    5658      return 0;
    5759    }
    58   }
    59 
    60   // RefSatMap of the current epoch
    61   // ==============================
    62   void initRefSatMapElement(char system) {_refSatMap[system] = new t_pppRefSat();}
    63   void clearRefSatMap() {
    64     QMapIterator<char, t_pppRefSat*> it(_refSatMap);
    65     while (it.hasNext()) {
    66       it.next();
    67       delete it.value();
    68     }
    69     _refSatMap.clear();
    70   }
    71   QMap<char, t_pppRefSat*> getRefSatMap() {return _refSatMap;}
    72   t_pppRefSat* getRefSatMapElement(char sys) {return _refSatMap[sys];}
    73 
    74 
    75   // RefSatMap of the last epoch
    76   // ===========================
    77   QMap<char, t_prn> getRefSatMapLastEpoch() {return _refSatMapLastEpoch;}
    78   t_prn getRefSatMapElementLastEpoch(char sys) {return _refSatMapLastEpoch[sys];}
    79   void setRefSatMapElementLastEpoch(char sys, t_prn prn) {_refSatMapLastEpoch[sys] = prn;}
    80   void saveLastEpoRefSats() {
    81     QMapIterator<char, t_pppRefSat*> it(getRefSatMap());
    82     while (it.hasNext()) {
    83       it.next();
    84       t_prn prn = it.value()->prn();
    85       setRefSatMapElementLastEpoch(prn.system(), prn);
    86     };
    8760  }
    8861
     
    130103  t_vTec*                  _vTec;
    131104  std::deque<t_epoch*>     _epochs;
    132   QMap<char, t_pppRefSat*> _refSatMap;
    133105  QMap<char, bool>         _refSatChangeRequiredMap;
    134106  QMap<char, bool>         _refSatChangedMap;
    135   QMap<char, t_prn>        _refSatMapLastEpoch;
    136107};
    137108
  • trunk/BNC/src/PPP/pppParlist.cpp

    r9506 r9508  
    143143  _sigma0   = old->sigma0();
    144144  _epoSpec  = old->epoSpec();
     145  _x0       = old->x0();
     146  setFirstObsTime(old->firstObsTime());
     147  setLastObsTime(old->lastObsTime());
    145148  _ambInfo  = 0;
    146149  if (_type == t_pppParam::amb) {
     
    149152    _ambInfo->_eleSat         = old->_ambInfo->_eleSat;
    150153    _ambInfo->_numEpo         = old->_ambInfo->_numEpo;
    151     _x0 = x0();
    152154  }
    153155}
     
    448450      if (OPT->_obsModelType == OPT->DCMcodeBias ||
    449451          OPT->_obsModelType == OPT->DCMphaseBias) {
    450         t_prn refPrn = (refSatMap[par->prn().system()])->prn();
     452        char sys = par->prn().system();
     453        t_prn refPrn = (refSatMap[sys])->prn();
    451454        if (par->lastObsTime().valid() &&
    452455            ((epoTime - par->lastObsTime() > 1.0) || (par->prn() == refPrn))) {
     
    475478    }
    476479    if (remove) {
     480#ifdef BNC_DEBUG_PPP
     481      LOG << "remove " << par->toString() << std::endl;
     482#endif
    477483      delete par;
    478484      it = _params.erase(it);
     
    519525      }
    520526      if (remove) {
     527#ifdef BNC_DEBUG_PPP
     528        LOG << "remove " << par->toString() << std::endl;
     529#endif
    521530        delete par;
    522531        it = _params.erase(it);
     
    711720    }
    712721    else {
     722#ifdef BNC_DEBUG_PPP
     723      LOG << "push_back  parReq " << parReq->toString() << std::endl;
     724#endif
    713725      _params.push_back(parReq);
    714726    }
  • trunk/BNC/src/src.pri

    r9420 r9508  
    131131  SOURCES += PPP/pppClient.cpp  PPP/pppObsPool.cpp PPP/pppEphPool.cpp \
    132132             PPP/pppStation.cpp PPP/pppFilter.cpp  PPP/pppParlist.cpp \
    133              PPP/pppSatObs.cpp  PPP/pppRefSat.cpp
     133             PPP/pppSatObs.cpp
    134134}
    135135else {
Note: See TracChangeset for help on using the changeset viewer.