Changeset 6100 in ntrip


Ignore:
Timestamp:
Sep 8, 2014, 9:02:33 AM (7 years ago)
Author:
mervart
Message:
 
Location:
trunk/BNC/src/PPP_free
Files:
4 edited

Legend:

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

    r6099 r6100  
    4444
    4545#include "pppClient.h"
    46 #include "pppFilter.h"
    4746#include "bncephuser.h"
    4847#include "bncutils.h"
     
    5049using namespace BNC_PPP;
    5150using namespace std;
    52 
    53 // Global variable holding thread-specific pointers
    54 //////////////////////////////////////////////////////////////////////////////
    55 QThreadStorage<t_pppClient*> CLIENTS;
    56 
    57 // Static function returning thread-specific pointer
    58 //////////////////////////////////////////////////////////////////////////////
    59 t_pppClient* t_pppClient::instance() {
    60   return CLIENTS.localData();
    61 }
    6251
    6352// Constructor
     
    7059  _log     = new ostringstream();
    7160  _ephUser = new bncEphUser(false);
    72   _staID   = QByteArray(_opt->_roverName.c_str());
    73 
    74   CLIENTS.setLocalData(this);  // CLIENTS takes ownership over "this"
    7561}
    7662
  • trunk/BNC/src/PPP_free/pppClient.h

    r6099 r6100  
    3131#include "pppInclude.h"
    3232#include "pppOptions.h"
     33#include "pppFilter.h"
    3334
    3435class bncEphUser;
     
    3738namespace BNC_PPP {
    3839 
    39 class t_pppFilter;
    40 
    41 class t_satData {
    42  public:
    43   t_satData() {
    44     obsIndex = 0;
    45     P1 = 0.0;
    46     P2 = 0.0;
    47     P5 = 0.0;
    48     P3 = 0.0;
    49     L1 = 0.0;
    50     L2 = 0.0;
    51     L5 = 0.0;
    52     L3 = 0.0;
    53   }
    54   ~t_satData() {}
    55   bncTime      tt;
    56   QString      prn;
    57   double       P1;
    58   double       P2;
    59   double       P5;
    60   double       P3;
    61   double       L1;
    62   double       L2;
    63   double       L5;
    64   double       L3;
    65   ColumnVector xx;
    66   ColumnVector vv;
    67   double       clk;
    68   double       eleSat;
    69   double       azSat;
    70   double       rho;
    71   bool         slipFlag;
    72   double       lambda3;
    73   unsigned     obsIndex;
    74   char system() const {return prn.toAscii()[0];}
    75 };
    76 
    77 class t_epoData {
    78  public:
    79   t_epoData() {}
    80 
    81   ~t_epoData() {
    82     clear();
    83   }
    84 
    85   void clear() {
    86     QMapIterator<QString, t_satData*> it(satData);
    87     while (it.hasNext()) {
    88       it.next();
    89       delete it.value();
    90     }
    91     satData.clear();
    92     tt.reset();
    93   }
    94 
    95   void deepCopy(const t_epoData* from) {
    96     clear();
    97     tt = from->tt;
    98     QMapIterator<QString, t_satData*> it(from->satData);
    99     while (it.hasNext()) {
    100       it.next();
    101       satData[it.key()] = new t_satData(*it.value());
    102     }
    103   }
    104 
    105   unsigned sizeSys(char system) const {
    106     unsigned ans = 0;
    107     QMapIterator<QString, t_satData*> it(satData);
    108     while (it.hasNext()) {
    109       it.next();
    110       if (it.value()->system() == system) {
    111         ++ans;
    112       }
    113     }
    114     return ans;
    115   }
    116   unsigned sizeAll() const {return satData.size();}
    117 
    118   bncTime                   tt;
    119   QMap<QString, t_satData*> satData;
    120 };
    121 
    12240class t_pppClient {
    12341 public:
     
    12947  void                putClkCorrections(const std::vector<t_clkCorr*>& corr);
    13048  void                putBiases(const std::vector<t_satBias*>& satBias);   
    131   QByteArray          staID() const {return _staID;}
     49  std::ostringstream& log() {return *_log;}
    13250  const t_pppOptions* opt() const {return _opt;}
    133   static t_pppClient* instance();
    134   std::ostringstream& log() {return *_log;}
    13551
    13652 private:
     
    14157  bncEphUser*         _ephUser;
    14258  t_pppOptions*       _opt;
    143   QByteArray          _staID;
    14459  t_epoData*          _epoData;
    14560  t_pppFilter*        _filter;
     
    14762};
    14863
    149 }
    150 
    151 #define LOG (BNC_PPP::t_pppClient::instance()->log())
     64} // namespace
    15265
    15366#endif
  • trunk/BNC/src/PPP_free/pppFilter.cpp

    r6094 r6100  
    6262const double   GLONASS_WEIGHT_FACTOR = 5.0;
    6363
     64#define LOG (_pppClient->log())
     65#define OPT (_pppClient->opt())
     66
    6467// Constructor
    6568////////////////////////////////////////////////////////////////////////////
     
    152155
    153156  _pppClient = pppClient;
    154   _staID     = pppClient->staID();
    155   _opt       = pppClient->opt();
    156 
    157157  _tides     = new t_tides();
    158158
     
    160160  // ------------------------
    161161  _antex = 0;
    162   if (!_opt->_antexFileName.empty()) {
    163     _antex = new bncAntex(_opt->_antexFileName.c_str());
     162  if (!OPT->_antexFileName.empty()) {
     163    _antex = new bncAntex(OPT->_antexFileName.c_str());
    164164  }
    165165
     
    178178t_pppFilter::~t_pppFilter() {
    179179  delete _tides;
    180   for (int ii = 0; ii < _posAverage.size(); ++ii) {
    181     delete _posAverage[ii];
    182   }
    183180  delete _antex;
    184181  for (int iPar = 1; iPar <= _params.size(); iPar++) {
     
    212209  _params.push_back(new t_pppParam(t_pppParam::CRD_Z,  ++nextPar, ""));
    213210  _params.push_back(new t_pppParam(t_pppParam::RECCLK, ++nextPar, ""));
    214   if (_opt->estTrp()) {
     211  if (OPT->estTrp()) {
    215212    _params.push_back(new t_pppParam(t_pppParam::TROPO, ++nextPar, ""));
    216213  }
    217   if (_opt->useSystem('R')) {
     214  if (OPT->useSystem('R')) {
    218215    _params.push_back(new t_pppParam(t_pppParam::GLONASS_OFFSET, ++nextPar, ""));
    219216  }
    220   if (_opt->useSystem('E')) {
     217  if (OPT->useSystem('E')) {
    221218    _params.push_back(new t_pppParam(t_pppParam::GALILEO_OFFSET, ++nextPar, ""));
    222219  }
     
    228225    pp->xx = 0.0;
    229226    if      (pp->isCrd()) {
    230       _QQ(iPar,iPar) = _opt->_aprSigCrd(1) * _opt->_aprSigCrd(1);
     227      _QQ(iPar,iPar) = OPT->_aprSigCrd(1) * OPT->_aprSigCrd(1);
    231228    }
    232229    else if (pp->type == t_pppParam::RECCLK) {
    233       _QQ(iPar,iPar) = _opt->_noiseClk * _opt->_noiseClk;
     230      _QQ(iPar,iPar) = OPT->_noiseClk * OPT->_noiseClk;
    234231    }
    235232    else if (pp->type == t_pppParam::TROPO) {
    236       _QQ(iPar,iPar) = _opt->_aprSigTrp * _opt->_aprSigTrp;
     233      _QQ(iPar,iPar) = OPT->_aprSigTrp * OPT->_aprSigTrp;
    237234      pp->xx = lastTrp;
    238235    }
     
    253250
    254251  if (epoData->sizeSys('G') < MINOBS) {
    255     _log += "t_pppFilter::cmpBancroft: not enough data\n";
     252    LOG << "t_pppFilter::cmpBancroft: not enough data\n";
    256253    return failure;
    257254  }
     
    337334  if (_antex) {
    338335    bool found;
    339     phaseCenter = _antex->pco(QString(_opt->_antNameRover.c_str()), satData->eleSat, found);
     336    phaseCenter = _antex->pco(QString(OPT->_antNameRover.c_str()), satData->eleSat, found);
    340337    if (!found) {
    341       LOG << "ANTEX: antenna >" << _opt->_antNameRover << "< not found\n";
     338      LOG << "ANTEX: antenna >" << OPT->_antNameRover << "< not found\n";
    342339    }
    343340  }
     
    348345  double cose = cos(satData->eleSat);
    349346  double sine = sin(satData->eleSat);
    350   antennaOffset = -_opt->_neuEccRover(1) * cosa*cose
    351                   -_opt->_neuEccRover(2) * sina*cose
    352                   -_opt->_neuEccRover(3) * sine;
     347  antennaOffset = -OPT->_neuEccRover(1) * cosa*cose
     348                  -OPT->_neuEccRover(2) * sina*cose
     349                  -OPT->_neuEccRover(3) * sine;
    353350
    354351  return satData->rho + phaseCenter + antennaOffset + clk()
     
    416413    // Use different white noise for Quick-Start mode
    417414    // ----------------------------------------------
    418     double sigCrdP_used = _opt->_noiseCrd(1);
    419     if ( _opt->_seedingTime > 0.0 && _opt->_seedingTime > (epoData->tt - _startTime) ) {
     415    double sigCrdP_used = OPT->_noiseCrd(1);
     416    if ( OPT->_seedingTime > 0.0 && OPT->_seedingTime > (epoData->tt - _startTime) ) {
    420417      sigCrdP_used   = 0.0;
    421418    }
     
    430427      if      (pp->type == t_pppParam::CRD_X) {
    431428        if (firstCrd) {
    432           if (_opt->xyzAprRoverSet()) {
    433             pp->xx = _opt->_xyzAprRover[0];
     429          if (OPT->xyzAprRoverSet()) {
     430            pp->xx = OPT->_xyzAprRover[0];
    434431          }
    435432          else {
     
    441438      else if (pp->type == t_pppParam::CRD_Y) {
    442439        if (firstCrd) {
    443           if (_opt->xyzAprRoverSet()) {
    444             pp->xx = _opt->_xyzAprRover[1];
     440          if (OPT->xyzAprRoverSet()) {
     441            pp->xx = OPT->_xyzAprRover[1];
    445442          }
    446443          else {
     
    452449      else if (pp->type == t_pppParam::CRD_Z) {
    453450        if (firstCrd) {
    454           if (_opt->xyzAprRoverSet()) {
    455             pp->xx = _opt->_xyzAprRover[2];
     451          if (OPT->xyzAprRoverSet()) {
     452            pp->xx = OPT->_xyzAprRover[2];
    456453          }
    457454          else {
     
    469466          _QQ(iPar, jj) = 0.0;
    470467        }
    471         _QQ(iPar,iPar) = _opt->_noiseClk * _opt->_noiseClk;
     468        _QQ(iPar,iPar) = OPT->_noiseClk * OPT->_noiseClk;
    472469      }
    473470   
     
    475472      // ------------------
    476473      else if (pp->type == t_pppParam::TROPO) {
    477         _QQ(iPar,iPar) += _opt->_noiseTrp * _opt->_noiseTrp;
     474        _QQ(iPar,iPar) += OPT->_noiseTrp * OPT->_noiseTrp;
    478475      }
    479476   
     
    498495  // Add New Ambiguities if necessary
    499496  // --------------------------------
    500   if (_opt->ambLCs('G').size() || _opt->ambLCs('R').size() || _opt->ambLCs('E').size()) {
     497  if (OPT->ambLCs('G').size() || OPT->ambLCs('R').size() || OPT->ambLCs('E').size()) {
    501498
    502499    // Make a copy of QQ and xx, set parameter indices
     
    556553      t_pppParam* par = _params[ii-1];
    557554      if (par->index_old == 0) {
    558         _QQ(par->index, par->index) = _opt->_aprSigAmb * _opt->_aprSigAmb;
     555        _QQ(par->index, par->index) = OPT->_aprSigAmb * OPT->_aprSigAmb;
    559556      }
    560557      par->index_old = par->index;
     
    569566  Tracer tracer("t_pppFilter::update");
    570567
    571   _log.clear(); 
    572 
    573568  _time = epoData->tt; // current epoch time
    574569
    575   if (_opt->useOrbClkCorr()) {
    576     _log += "Precise Point Positioning of Epoch "
    577           + QByteArray(_time.timestr(1).c_str()) +
    578           "\n---------------------------------------------------------------\n";
     570  if (OPT->useOrbClkCorr()) {
     571    LOG << "Precise Point Positioning of Epoch " << _time.timestr(1)
     572        << "\n---------------------------------------------------------------\n";
    579573  }
    580574  else {
    581     _log += "Single Point Positioning of Epoch "
    582           + QByteArray(_time.timestr(1).c_str()) +
    583           "\n--------------------------------------------------------------\n";
     575    LOG << "Single Point Positioning of Epoch " << _time.timestr(1)
     576        << "\n--------------------------------------------------------------\n";
    584577  }
    585578
     
    587580  // ----------------------
    588581  if (update_p(epoData) != success) {
    589     LOG << _log.data() << endl;
    590582    return failure;
    591583  }
    592 
    593   // Remember the Epoch-specific Results for the computation of means
    594   // ----------------------------------------------------------------
    595   pppPos* newPos = new pppPos;
    596   newPos->time   = epoData->tt;
    597584
    598585  // Set Solution Vector
    599586  // -------------------
    600   ostringstream strB;
    601   strB.setf(ios::fixed);
     587  LOG.setf(ios::fixed);
    602588  QVectorIterator<t_pppParam*> itPar(_params);
    603589  while (itPar.hasNext()) {
    604590    t_pppParam* par = itPar.next();
    605 
    606591    if      (par->type == t_pppParam::RECCLK) {
    607       strB << "\n    clk     = " << setw(10) << setprecision(3) << par->xx
    608            << " +- " << setw(6) << setprecision(3)
    609            << sqrt(_QQ(par->index,par->index));
     592      LOG << "\n    clk     = " << setw(10) << setprecision(3) << par->xx
     593          << " +- " << setw(6) << setprecision(3)
     594          << sqrt(_QQ(par->index,par->index));
    610595    }
    611596    else if (par->type == t_pppParam::AMB_L3) {
    612597      ++par->numEpo;
    613       strB << "\n    amb " << par->prn.toAscii().data() << " = "
    614            << setw(10) << setprecision(3) << par->xx
    615            << " +- " << setw(6) << setprecision(3)
    616            << sqrt(_QQ(par->index,par->index))
    617            << "   nEpo = " << par->numEpo;
     598      LOG << "\n    amb " << par->prn.toAscii().data() << " = "
     599          << setw(10) << setprecision(3) << par->xx
     600          << " +- " << setw(6) << setprecision(3)
     601          << sqrt(_QQ(par->index,par->index))
     602          << "   nEpo = " << par->numEpo;
    618603    }
    619604    else if (par->type == t_pppParam::TROPO) {
    620605      double aprTrp = delay_saast(M_PI/2.0);
    621       strB << "\n    trp     = " << par->prn.toAscii().data()
    622            << setw(7) << setprecision(3) << aprTrp << " "
    623            << setw(6) << setprecision(3) << showpos << par->xx << noshowpos
    624            << " +- " << setw(6) << setprecision(3)
    625            << sqrt(_QQ(par->index,par->index));
    626       newPos->xnt[6] = aprTrp + par->xx;
     606      LOG << "\n    trp     = " << par->prn.toAscii().data()
     607          << setw(7) << setprecision(3) << aprTrp << " "
     608          << setw(6) << setprecision(3) << showpos << par->xx << noshowpos
     609          << " +- " << setw(6) << setprecision(3)
     610          << sqrt(_QQ(par->index,par->index));
    627611    }
    628612    else if (par->type == t_pppParam::GLONASS_OFFSET) {
    629       strB << "\n    offGlo  = " << setw(10) << setprecision(3) << par->xx
    630            << " +- " << setw(6) << setprecision(3)
    631            << sqrt(_QQ(par->index,par->index));
     613      LOG << "\n    offGlo  = " << setw(10) << setprecision(3) << par->xx
     614          << " +- " << setw(6) << setprecision(3)
     615          << sqrt(_QQ(par->index,par->index));
    632616    }
    633617    else if (par->type == t_pppParam::GALILEO_OFFSET) {
    634       strB << "\n    offGal  = " << setw(10) << setprecision(3) << par->xx
    635            << " +- " << setw(6) << setprecision(3)
    636            << sqrt(_QQ(par->index,par->index));
    637     }
    638   }
    639   strB << '\n';
    640   _log += strB.str().c_str();
    641   LOG << _log.data() << endl;
     618      LOG << "\n    offGal  = " << setw(10) << setprecision(3) << par->xx
     619          << " +- " << setw(6) << setprecision(3)
     620          << sqrt(_QQ(par->index,par->index));
     621    }
     622  }
     623
     624  LOG << endl;
    642625
    643626  // Final Message (both log file and screen)
    644627  // ----------------------------------------
    645   ostringstream strC;
    646   strC.setf(ios::fixed);
    647   strC << _staID.data() << "  PPP "
    648        << epoData->tt.timestr(1) << " " << epoData->sizeAll() << " "
    649        << setw(14) << setprecision(3) << x()                  << " +- "
    650        << setw(6)  << setprecision(3) << sqrt(_QQ(1,1))       << " "
    651        << setw(14) << setprecision(3) << y()                  << " +- "
    652        << setw(6)  << setprecision(3) << sqrt(_QQ(2,2))       << " "
    653        << setw(14) << setprecision(3) << z()                  << " +- "
    654        << setw(6)  << setprecision(3) << sqrt(_QQ(3,3));
     628  LOG << OPT->_roverName << "  PPP "
     629      << epoData->tt.timestr(1) << " " << epoData->sizeAll() << " "
     630      << setw(14) << setprecision(3) << x()                  << " +- "
     631      << setw(6)  << setprecision(3) << sqrt(_QQ(1,1))       << " "
     632      << setw(14) << setprecision(3) << y()                  << " +- "
     633      << setw(6)  << setprecision(3) << sqrt(_QQ(2,2))       << " "
     634      << setw(14) << setprecision(3) << z()                  << " +- "
     635      << setw(6)  << setprecision(3) << sqrt(_QQ(3,3));
    655636
    656637  // NEU Output
    657638  // ----------
    658   if (_opt->xyzAprRoverSet()) {
    659     newPos->xnt[0] = x() - _opt->_xyzAprRover[0];
    660     newPos->xnt[1] = y() - _opt->_xyzAprRover[1];
    661     newPos->xnt[2] = z() - _opt->_xyzAprRover[2];
     639  if (OPT->xyzAprRoverSet()) {
     640    double xyz[3];
     641    xyz[0] = x() - OPT->_xyzAprRover[0];
     642    xyz[1] = y() - OPT->_xyzAprRover[1];
     643    xyz[2] = z() - OPT->_xyzAprRover[2];
    662644
    663645    double ellRef[3];
    664     xyz2ell(_opt->_xyzAprRover.data(), ellRef);
    665     xyz2neu(ellRef, newPos->xnt, &newPos->xnt[3]);
    666 
    667     strC << "  NEU "
    668          << setw(8) << setprecision(3) << newPos->xnt[3] << " "
    669          << setw(8) << setprecision(3) << newPos->xnt[4] << " "
    670          << setw(8) << setprecision(3) << newPos->xnt[5] << endl;
    671 
    672   }
    673 
    674   LOG << strC.str() << endl;
    675 
    676   delete newPos;
     646    xyz2ell(OPT->_xyzAprRover.data(), ellRef);
     647    double neu[3];
     648    xyz2neu(ellRef, xyz, neu);
     649
     650    LOG << "  NEU "
     651        << setw(8) << setprecision(3) << neu[0] << " "
     652        << setw(8) << setprecision(3) << neu[1] << " "
     653        << setw(8) << setprecision(3) << neu[2] << endl;
     654  }
     655  else {
     656    LOG << endl;
     657  }
    677658
    678659  _lastTimeOK = _time; // remember time of last successful update
     
    695676  if      (iPhase == 1) {
    696677    if      (maxResGlo > MAXRES_PHASE_GLONASS) {
    697       _log += "Outlier Phase " + prnGlo + " "
    698             + QByteArray::number(maxResGlo, 'f', 3) + "\n";
     678      LOG << "Outlier Phase " << prnGlo.toAscii().data() << ' ' << maxResGlo << endl;
    699679      return prnGlo;
    700680    }
    701681    else if (maxResGPS > MAXRES_PHASE_GPS) {
    702       _log += "Outlier Phase " + prnGPS + " "
    703             + QByteArray::number(maxResGPS, 'f', 3) + "\n";
     682      LOG << "Outlier Phase " << prnGPS.toAscii().data() << ' ' << maxResGPS << endl;
    704683      return prnGPS;
    705684    }
    706685  }
    707686  else if (iPhase == 0 && maxResGPS > MAXRES_CODE) {
    708     _log += "Outlier Code  " + prnGPS + " "
    709           + QByteArray::number(maxResGPS, 'f', 3) + "\n";
     687    LOG << "Outlier Code  " << prnGPS.toAscii().data() << ' ' << maxResGPS << endl;
    710688    return prnGPS;
    711689  }
     
    894872  if (iPhase == 1) {
    895873    ll(iObs)      = satData->L3 - cmpValue(satData, true);
    896     double sigL3 = 2.98 * _opt->_sigmaL1;
     874    double sigL3 = 2.98 * OPT->_sigmaL1;
    897875    if (satData->system() == 'R') {
    898876      sigL3 *= GLONASS_WEIGHT_FACTOR;
     
    911889  // -----------------
    912890  else {
    913     double sigP3 = 2.98 * _opt->_sigmaC1;
     891    double sigP3 = 2.98 * OPT->_sigmaC1;
    914892    ll(iObs)      = satData->P3 - cmpValue(satData, false);
    915893    PP(iObs,iObs) = 1.0 / (sigP3 * sigP3) / (ellWgtCoef * ellWgtCoef);
     
    1006984    // First update using code observations, then phase observations
    1007985    // -------------------------------------------------------------     
    1008     bool usePhase = _opt->ambLCs('G').size() || _opt->ambLCs('R').size() ||
    1009                     _opt->ambLCs('E').size();
     986    bool usePhase = OPT->ambLCs('G').size() || OPT->ambLCs('R').size() ||
     987                    OPT->ambLCs('E').size();
    1010988
    1011989    for (int iPhase = 0; iPhase <= (usePhase ? 1 : 0); iPhase++) {
     
    10741052        if (!usePhase || iPhase == 1) {
    10751053          if (_outlierGPS.size() > 0 || _outlierGlo.size() > 0) {
    1076             _log += "Neglected PRNs: ";
     1054            LOG << "Neglected PRNs: ";
    10771055            if (!_outlierGPS.isEmpty()) {
    1078               _log += _outlierGPS.last() + ' ';
     1056              LOG << _outlierGPS.last().toAscii().data() << ' ';
    10791057            }
    10801058            QStringListIterator itGlo(_outlierGlo);
    10811059            while (itGlo.hasNext()) {
    10821060              QString prn = itGlo.next();
    1083               _log += prn + ' ';
     1061              LOG << prn.toAscii().data() << ' ';
    10841062            }
    10851063          }
    1086           _log += '\n';
    1087 
    1088           _log += strResCode + strResPhase;
     1064          LOG << endl << strResCode.data() << strResPhase.data();
    10891065
    10901066          return success;
  • trunk/BNC/src/PPP_free/pppFilter.h

    r6093 r6100  
    4242class t_satData;
    4343class t_tides;
     44
     45class t_satData {
     46 public:
     47  t_satData() {
     48    obsIndex = 0;
     49    P1 = 0.0;
     50    P2 = 0.0;
     51    P5 = 0.0;
     52    P3 = 0.0;
     53    L1 = 0.0;
     54    L2 = 0.0;
     55    L5 = 0.0;
     56    L3 = 0.0;
     57  }
     58  ~t_satData() {}
     59  bncTime      tt;
     60  QString      prn;
     61  double       P1;
     62  double       P2;
     63  double       P5;
     64  double       P3;
     65  double       L1;
     66  double       L2;
     67  double       L5;
     68  double       L3;
     69  ColumnVector xx;
     70  ColumnVector vv;
     71  double       clk;
     72  double       eleSat;
     73  double       azSat;
     74  double       rho;
     75  bool         slipFlag;
     76  double       lambda3;
     77  unsigned     obsIndex;
     78  char system() const {return prn.toAscii()[0];}
     79};
     80
     81class t_epoData {
     82 public:
     83  t_epoData() {}
     84
     85  ~t_epoData() {
     86    clear();
     87  }
     88
     89  void clear() {
     90    QMapIterator<QString, t_satData*> it(satData);
     91    while (it.hasNext()) {
     92      it.next();
     93      delete it.value();
     94    }
     95    satData.clear();
     96    tt.reset();
     97  }
     98
     99  void deepCopy(const t_epoData* from) {
     100    clear();
     101    tt = from->tt;
     102    QMapIterator<QString, t_satData*> it(from->satData);
     103    while (it.hasNext()) {
     104      it.next();
     105      satData[it.key()] = new t_satData(*it.value());
     106    }
     107  }
     108
     109  unsigned sizeSys(char system) const {
     110    unsigned ans = 0;
     111    QMapIterator<QString, t_satData*> it(satData);
     112    while (it.hasNext()) {
     113      it.next();
     114      if (it.value()->system() == system) {
     115        ++ans;
     116      }
     117    }
     118    return ans;
     119  }
     120  unsigned sizeAll() const {return satData.size();}
     121
     122  bncTime                   tt;
     123  QMap<QString, t_satData*> satData;
     124};
    44125
    45126class t_pppParam {
     
    136217  void bancroft(const Matrix& BBpass, ColumnVector& pos);
    137218
    138   class pppPos {
    139    public:
    140     pppPos() {
    141       for (int ii = 0; ii < 7; ++ii) {
    142         xnt[ii] = 0.0;
    143       }
    144     }
    145     bncTime time;
    146     double  xnt[7];
    147   };
    148 
    149219  t_pppClient*          _pppClient;
    150   const t_pppOptions*   _opt;
    151220  bncTime               _time;
    152221  bncTime               _lastTimeOK;
    153   QByteArray            _staID;
    154222  QVector<t_pppParam*>  _params;
    155223  SymmetricMatrix       _QQ;
     
    159227  ColumnVector          _xcBanc;
    160228  ColumnVector          _ellBanc;
    161   QByteArray            _log;
    162229  QMap<QString, double> _windUpTime;
    163230  QMap<QString, double> _windUpSum;
    164   QVector<pppPos*>      _posAverage;
    165231  QStringList           _outlierGPS;
    166232  QStringList           _outlierGlo;
Note: See TracChangeset for help on using the changeset viewer.