Index: trunk/BNC/src/PPP/pppEphPool.cpp =================================================================== --- trunk/BNC/src/PPP/pppEphPool.cpp (revision 7203) +++ (revision ) @@ -1,132 +1,0 @@ -/* ------------------------------------------------------------------------- - * BKG NTRIP Client - * ------------------------------------------------------------------------- - * - * Class: t_pppEphPool - * - * Purpose: Buffer with satellite ephemerides - * - * Author: L. Mervart - * - * Created: 29-Jul-2014 - * - * Changes: - * - * -----------------------------------------------------------------------*/ - -#include -#include "pppEphPool.h" -#include "pppInclude.h" -#include "pppClient.h" - -using namespace BNC_PPP; -using namespace std; - -// -///////////////////////////////////////////////////////////////////////////// -void t_pppEphPool::putEphemeris(t_eph* eph) { - if (eph && eph->checkState() != t_eph::bad) { - _satEphPool[eph->prn().toInt()].putEphemeris(_maxQueueSize, eph); - } - else { - delete eph; - } -} - -// -///////////////////////////////////////////////////////////////////////////// -void t_pppEphPool::putOrbCorrection(t_orbCorr* corr) { - if (corr) { - _satEphPool[corr->_prn.toInt()].putOrbCorrection(corr); - } -} - -// -///////////////////////////////////////////////////////////////////////////// -void t_pppEphPool::putClkCorrection(t_clkCorr* corr) { - if (corr) { - _satEphPool[corr->_prn.toInt()].putClkCorrection(corr); - } -} - -// -///////////////////////////////////////////////////////////////////////////// -t_irc t_pppEphPool::getCrd(const t_prn& prn, const bncTime& tt, - ColumnVector& xc, ColumnVector& vv) const { - return _satEphPool[prn.toInt()].getCrd(tt, xc, vv); -} - -// -///////////////////////////////////////////////////////////////////////////// -int t_pppEphPool::getChannel(const t_prn& prn) const { - return _satEphPool[prn.toInt()].getChannel(); -} - -// -///////////////////////////////////////////////////////////////////////////// -void t_pppEphPool::t_satEphPool::putEphemeris(unsigned maxQueueSize, t_eph* eph) { - if (_ephs.empty() || eph->isNewerThan(_ephs.front())) { - _ephs.push_front(eph); - if (maxQueueSize > 0 && _ephs.size() > maxQueueSize) { - delete _ephs.back(); - _ephs.pop_back(); - } - } - else { - delete eph; - } -} - -// -///////////////////////////////////////////////////////////////////////////// -void t_pppEphPool::t_satEphPool::putOrbCorrection(t_orbCorr* corr) { - for (unsigned ii = 0; ii < _ephs.size(); ii++) { - t_eph* eph = _ephs[ii]; - if (eph->IOD() == corr->_iod) { - eph->setOrbCorr(corr); - return; - } - } - delete corr; -} - -// -///////////////////////////////////////////////////////////////////////////// -void t_pppEphPool::t_satEphPool::putClkCorrection(t_clkCorr* corr) { - for (unsigned ii = 0; ii < _ephs.size(); ii++) { - t_eph* eph = _ephs[ii]; - if (eph->IOD() == corr->_iod) { - eph->setClkCorr(corr); - } - } - delete corr; -} - -// -///////////////////////////////////////////////////////////////////////////// -t_irc t_pppEphPool::t_satEphPool::getCrd(const bncTime& tt, ColumnVector& xc, - ColumnVector& vv) const { - for (unsigned ii = 0; ii < _ephs.size(); ii++) { - t_eph* eph = _ephs[ii]; - t_irc irc = eph->getCrd(tt, xc, vv, OPT->useOrbClkCorr()); - if (irc == success) { - if (eph->prn().system() == 'R') { - double age = tt - eph->TOC(); - if (fabs(age) > 3600.0) { - continue; - } - } - return irc; - } - } - return failure; -} - -// -///////////////////////////////////////////////////////////////////////////// -int t_pppEphPool::t_satEphPool::getChannel() const { - if (_ephs.size() > 0) { - return _ephs[0]->slotNum(); - } - return 0; -} Index: trunk/BNC/src/PPP/pppEphPool.h =================================================================== --- trunk/BNC/src/PPP/pppEphPool.h (revision 7203) +++ (revision ) @@ -1,56 +1,0 @@ -#ifndef EPHPOOL_H -#define EPHPOOL_H - -#include -#include "pppInclude.h" -#include "bnctime.h" -#include "ephemeris.h" - -namespace BNC_PPP { - -class t_pppEphPool { - public: - t_pppEphPool(unsigned maxQueueSize = 3) { - _maxQueueSize = maxQueueSize; - } - ~t_pppEphPool() {}; - - void putEphemeris(t_eph* eph); - void putOrbCorrection(t_orbCorr* corr); - void putClkCorrection(t_clkCorr* corr); - - t_irc getCrd(const t_prn& prn, const bncTime& tt, - ColumnVector& xc, ColumnVector& vv) const; - - int getChannel(const t_prn& prn) const; - - std::deque& ephs(t_prn prn) { - return _satEphPool[prn]._ephs; - } - - private: - - class t_satEphPool { - public: - t_satEphPool() {}; - ~t_satEphPool() { - for (unsigned ii = 0; ii < _ephs.size(); ii++) { - delete _ephs[ii]; - } - } - void putEphemeris(unsigned maxQueueSize, t_eph* eph); - void putOrbCorrection(t_orbCorr* corr); - void putClkCorrection(t_clkCorr* corr); - t_irc getCrd(const bncTime& tt, - ColumnVector& xc, ColumnVector& vv) const; - int getChannel() const; - std::deque _ephs; - }; - - t_satEphPool _satEphPool[t_prn::MAXPRN+1]; - unsigned _maxQueueSize; -}; - -} - -#endif Index: trunk/BNC/src/PPP/pppObsPool.cpp =================================================================== --- trunk/BNC/src/PPP/pppObsPool.cpp (revision 7203) +++ (revision ) @@ -1,77 +1,0 @@ -/* ------------------------------------------------------------------------- - * BKG NTRIP Client - * ------------------------------------------------------------------------- - * - * Class: t_pppObsPool - * - * Purpose: Buffer with observations - * - * Author: L. Mervart - * - * Created: 29-Jul-2014 - * - * Changes: - * - * -----------------------------------------------------------------------*/ - -#include "pppObsPool.h" - -using namespace BNC_PPP; -using namespace std; - -// Constructor -///////////////////////////////////////////////////////////////////////////// -t_pppObsPool::t_epoch::t_epoch(const bncTime& epoTime, vector& obsVector) { - _epoTime = epoTime; - for (unsigned ii = 0; ii < obsVector.size(); ii++) { - _obsVector.push_back(obsVector[ii]); - } - obsVector.clear(); -} - -// Destructor -///////////////////////////////////////////////////////////////////////////// -t_pppObsPool::t_epoch::~t_epoch() { - for (unsigned ii = 0; ii < _obsVector.size(); ii++) { - delete _obsVector[ii]; - } -} - -// Constructor -///////////////////////////////////////////////////////////////////////////// -t_pppObsPool::t_pppObsPool() { - for (unsigned ii = 0; ii <= t_prn::MAXPRN; ii++) { - _satCodeBiases[ii] = 0; - } -} - -// Destructor -///////////////////////////////////////////////////////////////////////////// -t_pppObsPool::~t_pppObsPool() { - for (unsigned ii = 0; ii <= t_prn::MAXPRN; ii++) { - delete _satCodeBiases[ii]; - } - while (_epochs.size() > 0) { - delete _epochs.front(); - _epochs.pop_front(); - } -} - -// -///////////////////////////////////////////////////////////////////////////// -void t_pppObsPool::putCodeBias(t_satCodeBias* satCodeBias) { - int iPrn = satCodeBias->_prn.toInt(); - delete _satCodeBiases[iPrn]; - _satCodeBiases[iPrn] = satCodeBias; -} - -// -///////////////////////////////////////////////////////////////////////////// -void t_pppObsPool::putEpoch(const bncTime& epoTime, vector& obsVector) { - const unsigned MAXSIZE = 2; - _epochs.push_back(new t_epoch(epoTime, obsVector)); - if (_epochs.size() > MAXSIZE) { - delete _epochs.front(); - _epochs.pop_front(); - } -} Index: trunk/BNC/src/PPP/pppObsPool.h =================================================================== --- trunk/BNC/src/PPP/pppObsPool.h (revision 7203) +++ (revision ) @@ -1,52 +1,0 @@ -#ifndef OBSPOOL_H -#define OBSPOOL_H - -#include -#include -#include "pppSatObs.h" -#include "bnctime.h" - -namespace BNC_PPP { - -class t_pppObsPool { - public: - - class t_epoch { - public: - t_epoch(const bncTime& epoTime, std::vector& obsVector); - ~t_epoch(); - std::vector& obsVector() {return _obsVector;} - const std::vector& obsVector() const {return _obsVector;} - const bncTime& epoTime() const {return _epoTime;} - private: - bncTime _epoTime; - std::vector _obsVector; - }; - - t_pppObsPool(); - ~t_pppObsPool(); - void putCodeBias(t_satCodeBias* satCodeBias); - - void putEpoch(const bncTime& epoTime, std::vector& obsVector); - - const t_satCodeBias* satCodeBias(const t_prn& prn) const { - return _satCodeBiases[prn.toInt()]; - } - - t_epoch* lastEpoch() { - if (_epochs.size()) { - return _epochs.back(); - } - else { - return 0; - } - } - - private: - t_satCodeBias* _satCodeBiases[t_prn::MAXPRN+1]; - std::deque _epochs; -}; - -} - -#endif Index: trunk/BNC/src/PPP/pppParlist.cpp =================================================================== --- trunk/BNC/src/PPP/pppParlist.cpp (revision 7203) +++ (revision ) @@ -1,415 +1,0 @@ -/* ------------------------------------------------------------------------- - * BKG NTRIP Client - * ------------------------------------------------------------------------- - * - * Class: t_pppParlist - * - * Purpose: List of estimated parameters - * - * Author: L. Mervart - * - * Created: 29-Jul-2014 - * - * Changes: - * - * -----------------------------------------------------------------------*/ - -#include -#include -#include -#include -#include -#include - -#include "pppParlist.h" -#include "pppSatObs.h" -#include "pppStation.h" -#include "bncutils.h" -#include "bncconst.h" -#include "pppClient.h" - -using namespace BNC_PPP; -using namespace std; - -// Constructor -//////////////////////////////////////////////////////////////////////////// -t_pppParam::t_pppParam(e_type type, const t_prn& prn, t_lc::type tLC, - const vector* obsVector) { - - _type = type; - _prn = prn; - _tLC = tLC; - _x0 = 0.0; - _indexOld = -1; - _indexNew = -1; - _noise = 0.0; - _ambInfo = 0; - - switch (_type) { - case crdX: - _epoSpec = false; - _sigma0 = OPT->_aprSigCrd[0]; - _noise = OPT->_noiseCrd[0]; - break; - case crdY: - _epoSpec = false; - _sigma0 = OPT->_aprSigCrd[1]; - _noise = OPT->_noiseCrd[1]; - break; - case crdZ: - _epoSpec = false; - _sigma0 = OPT->_aprSigCrd[2]; - _noise = OPT->_noiseCrd[2]; - break; - case clkR: - _epoSpec = true; - _sigma0 = OPT->_noiseClk; - break; - case amb: - _epoSpec = false; - _sigma0 = OPT->_aprSigAmb; - _ambInfo = new t_ambInfo(); - if (obsVector) { - for (unsigned ii = 0; ii < obsVector->size(); ii++) { - const t_pppSatObs* obs = obsVector->at(ii); - if (obs->prn() == _prn) { - double offGG = 0; - if (_prn.system() == 'R' && tLC != t_lc::MW) { - offGG = PPP_CLIENT->offGG(); - } - _x0 = floor((obs->obsValue(tLC) - offGG - obs->cmpValue(tLC)) / obs->lambda(tLC) + 0.5); - break; - } - } - } - break; - case offGG: - _epoSpec = true; - _sigma0 = 1000.0; - _x0 = PPP_CLIENT->offGG(); - break; - case trp: - _epoSpec = false; - _sigma0 = OPT->_aprSigTrp; - _noise = OPT->_noiseTrp; - break; - } -} - -// Destructor -//////////////////////////////////////////////////////////////////////////// -t_pppParam::~t_pppParam() { - delete _ambInfo; -} - -// -//////////////////////////////////////////////////////////////////////////// -double t_pppParam::partial(const bncTime& /* epoTime */, const t_pppSatObs* obs, - const t_lc::type& tLC) const { - - // Special Case - Melbourne-Wuebbena - // --------------------------------- - if (tLC == t_lc::MW && _type != amb) { - return 0.0; - } - - const t_pppStation* sta = PPP_CLIENT->staRover(); - ColumnVector rhoV = sta->xyzApr() - obs->xc().Rows(1,3); - - switch (_type) { - case crdX: - return (sta->xyzApr()[0] - obs->xc()[0]) / rhoV.norm_Frobenius(); - case crdY: - return (sta->xyzApr()[1] - obs->xc()[1]) / rhoV.norm_Frobenius(); - case crdZ: - return (sta->xyzApr()[2] - obs->xc()[2]) / rhoV.norm_Frobenius(); - case clkR: - return 1.0; - case offGG: - return (obs->prn().system() == 'R') ? 1.0 : 0.0; - case amb: - if (obs->prn() == _prn) { - if (tLC == _tLC) { - return (obs->lambda(tLC)); - } - else if (tLC == t_lc::lIF && _tLC == t_lc::MW) { - return obs->lambda(t_lc::lIF) * obs->lambda(t_lc::MW) / obs->lambda(t_lc::l2); - } - else { - map codeCoeff; - map phaseCoeff; - obs->lcCoeff(tLC, codeCoeff, phaseCoeff); - if (_tLC == t_lc::l1) { - return obs->lambda(t_lc::l1) * phaseCoeff[t_lc::toFreq(obs->prn().system(),t_lc::l1)]; - } - else if (_tLC == t_lc::l2) { - return obs->lambda(t_lc::l2) * phaseCoeff[t_lc::toFreq(obs->prn().system(),t_lc::l2)]; - } - } - } - return 0.0; - case trp: - return 1.0 / sin(obs->eleSat()); - } - - return 0.0; -} - -// -//////////////////////////////////////////////////////////////////////////// -string t_pppParam::toString() const { - stringstream ss; - switch (_type) { - case crdX: - ss << "CRD_X"; - break; - case crdY: - ss << "CRD_Y"; - break; - case crdZ: - ss << "CRD_Z"; - break; - case clkR: - ss << "CLK "; - break; - case amb: - ss << "AMB " << left << setw(3) << t_lc::toString(_tLC) << right << ' ' << _prn.toString(); - break; - case offGG: - ss << "OGG "; - break; - case trp: - ss << "TRP "; - break; - } - return ss.str(); -} - -// Constructor -//////////////////////////////////////////////////////////////////////////// -t_pppParlist::t_pppParlist() { -} - -// Destructor -//////////////////////////////////////////////////////////////////////////// -t_pppParlist::~t_pppParlist() { - for (unsigned ii = 0; ii < _params.size(); ii++) { - delete _params[ii]; - } -} - -// -//////////////////////////////////////////////////////////////////////////// -t_irc t_pppParlist::set(const bncTime& epoTime, const std::vector& obsVector) { - - // Remove some Parameters - // ---------------------- - vector::iterator it = _params.begin(); - while (it != _params.end()) { - t_pppParam* par = *it; - - bool remove = false; - - if (par->epoSpec()) { - remove = true; - } - - else if (par->type() == t_pppParam::amb) { - if (par->lastObsTime().valid() && (epoTime - par->lastObsTime() > 120.0)) { - remove = true; - } - } - - else if (par->type() == t_pppParam::amb) { - if (par->lastObsTime().valid() && (epoTime - par->lastObsTime() > 3600.0)) { - remove = true; - } - } - - if (remove) { - delete par; - it = _params.erase(it); - } - else { - ++it; - } - } - - // Check whether parameters have observations - // ------------------------------------------ - for (unsigned ii = 0; ii < _params.size(); ii++) { - t_pppParam* par = _params[ii]; - if (par->prn() == 0) { - par->setLastObsTime(epoTime); - if (par->firstObsTime().undef()) { - par->setFirstObsTime(epoTime); - } - } - else { - for (unsigned jj = 0; jj < obsVector.size(); jj++) { - const t_pppSatObs* satObs = obsVector[jj]; - if (satObs->prn() == par->prn()) { - par->setLastObsTime(epoTime); - if (par->firstObsTime().undef()) { - par->setFirstObsTime(epoTime); - } - break; - } - } - } - } - - // Required Set of Parameters - // -------------------------- - vector required; - - // Coordinates - // ----------- - required.push_back(new t_pppParam(t_pppParam::crdX, t_prn(), t_lc::dummy)); - required.push_back(new t_pppParam(t_pppParam::crdY, t_prn(), t_lc::dummy)); - required.push_back(new t_pppParam(t_pppParam::crdZ, t_prn(), t_lc::dummy)); - - // Receiver Clock - // -------------- - required.push_back(new t_pppParam(t_pppParam::clkR, t_prn(), t_lc::dummy)); - - // GPS-Glonass Clock Offset - // ------------------------ - if (OPT->useSystem('R')) { - required.push_back(new t_pppParam(t_pppParam::offGG, t_prn(), t_lc::dummy)); - } - - // Troposphere - // ----------- - if (OPT->estTrp()) { - required.push_back(new t_pppParam(t_pppParam::trp, t_prn(), t_lc::dummy)); - } - - // Ambiguities - // ----------- - for (unsigned jj = 0; jj < obsVector.size(); jj++) { - const t_pppSatObs* satObs = obsVector[jj]; - const vector& ambLCs = OPT->ambLCs(satObs->prn().system()); - for (unsigned ii = 0; ii < ambLCs.size(); ii++) { - required.push_back(new t_pppParam(t_pppParam::amb, satObs->prn(), ambLCs[ii], &obsVector)); - } - } - - // Check if all required parameters are present - // -------------------------------------------- - for (unsigned ii = 0; ii < required.size(); ii++) { - t_pppParam* parReq = required[ii]; - - bool found = false; - for (unsigned jj = 0; jj < _params.size(); jj++) { - t_pppParam* parOld = _params[jj]; - if (parOld->isEqual(parReq)) { - found = true; - break; - } - } - if (found) { - delete parReq; - } - else { - _params.push_back(parReq); - } - } - - // Set Parameter Indices - // --------------------- - sort(_params.begin(), _params.end(), t_pppParam::sortFunction); - - for (unsigned ii = 0; ii < _params.size(); ii++) { - t_pppParam* par = _params[ii]; - par->setIndex(ii); - for (unsigned jj = 0; jj < obsVector.size(); jj++) { - const t_pppSatObs* satObs = obsVector[jj]; - if (satObs->prn() == par->prn()) { - par->setAmbEleSat(satObs->eleSat()); - par->stepAmbNumEpo(); - } - } - } - - return success; -} - -// -//////////////////////////////////////////////////////////////////////////// -void t_pppParlist::printResult(const bncTime& epoTime, const SymmetricMatrix& QQ, - const ColumnVector& xx) const { - - string epoTimeStr = string(epoTime); - const t_pppStation* sta = PPP_CLIENT->staRover(); - - LOG << endl; - - t_pppParam* parX = 0; - t_pppParam* parY = 0; - t_pppParam* parZ = 0; - for (unsigned ii = 0; ii < _params.size(); ii++) { - t_pppParam* par = _params[ii]; - if (par->type() == t_pppParam::crdX) { - parX = par; - } - else if (par->type() == t_pppParam::crdY) { - parY = par; - } - else if (par->type() == t_pppParam::crdZ) { - parZ = par; - } - else { - int ind = par->indexNew(); - double apr = (par->type() == t_pppParam::trp) ? - t_tropo::delay_saast(sta->xyzApr(), M_PI/2.0) : par->x0(); - LOG << epoTimeStr << ' ' << par->toString() << ' ' - << setw(10) << setprecision(4) << apr << ' ' - << showpos << setw(10) << setprecision(4) << xx[ind] << noshowpos << " +- " - << setw(8) << setprecision(4) << sqrt(QQ[ind][ind]); - if (par->type() == t_pppParam::amb) { - LOG << " el = " << setw(6) << setprecision(2) << par->ambEleSat() * 180.0 / M_PI - << " epo = " << setw(4) << par->ambNumEpo(); - } - LOG << endl; - } - } - - if (parX && parY && parZ) { - - ColumnVector xyz(3); - xyz[0] = xx[parX->indexNew()]; - xyz[1] = xx[parY->indexNew()]; - xyz[2] = xx[parZ->indexNew()]; - - ColumnVector neu(3); - xyz2neu(sta->ellApr().data(), xyz.data(), neu.data()); - - SymmetricMatrix QQxyz = QQ.SymSubMatrix(1,3); - - SymmetricMatrix QQneu(3); - covariXYZ_NEU(QQxyz, sta->ellApr().data(), QQneu); - - LOG << epoTimeStr << ' ' << sta->name() - << " X = " << setprecision(4) << sta->xyzApr()[0] + xyz[0] << " +- " - << setprecision(4) << sqrt(QQxyz[0][0]) - - << " Y = " << setprecision(4) << sta->xyzApr()[1] + xyz[1] << " +- " - << setprecision(4) << sqrt(QQxyz[1][1]) - - << " Z = " << setprecision(4) << sta->xyzApr()[2] + xyz[2] << " +- " - << setprecision(4) << sqrt(QQxyz[2][2]) - - << " dN = " << setprecision(4) << neu[0] << " +- " - << setprecision(4) << sqrt(QQneu[0][0]) - - << " dE = " << setprecision(4) << neu[1] << " +- " - << setprecision(4) << sqrt(QQneu[1][1]) - - << " dU = " << setprecision(4) << neu[2] << " +- " - << setprecision(4) << sqrt(QQneu[2][2]) - - << endl; - } -} - Index: trunk/BNC/src/PPP/pppParlist.h =================================================================== --- trunk/BNC/src/PPP/pppParlist.h (revision 7203) +++ (revision ) @@ -1,111 +1,0 @@ -#ifndef PARLIST_H -#define PARLIST_H - -#include -#include -#include "pppInclude.h" -#include "t_prn.h" -#include "bnctime.h" - -namespace BNC_PPP { - -class t_pppSatObs; - -class t_pppParam { - public: - enum e_type {crdX, crdY, crdZ, clkR, amb, offGG, trp}; - - t_pppParam(e_type type, const t_prn& prn, t_lc::type tLC, - const std::vector* obsVector = 0); - - ~t_pppParam(); - e_type type() const {return _type;} - double x0() const {return _x0;} - double partial(const bncTime& epoTime, const t_pppSatObs* obs, - const t_lc::type& tLC) const; - bool epoSpec() const {return _epoSpec;} - bool isEqual(const t_pppParam* par2) const { - return (_type == par2->_type && _prn == par2->_prn && _tLC == par2->_tLC); - } - void setIndex(int indexNew) { - _indexOld = _indexNew; - _indexNew = indexNew; - } - int indexOld() const {return _indexOld;} - int indexNew() const {return _indexNew;} - double sigma0() const {return _sigma0;} - double noise() const {return _noise;} - t_lc::type tLC() const {return _tLC;} - t_prn prn() const {return _prn;} - std::string toString() const; - - const bncTime& lastObsTime() const {return _lastObsTime;} - void setLastObsTime(const bncTime& epoTime) {_lastObsTime = epoTime;} - const bncTime& firstObsTime() const {return _firstObsTime;} - void setFirstObsTime(const bncTime& epoTime) {_firstObsTime = epoTime;} - - bool ambResetCandidate() const {return _ambInfo && _ambInfo->_resetCandidate;} - void setAmbResetCandidate() {if (_ambInfo) _ambInfo->_resetCandidate = true;} - double ambEleSat() const {return _ambInfo ? _ambInfo->_eleSat : 0.0;} - void setAmbEleSat(double eleSat) {if (_ambInfo) _ambInfo->_eleSat = eleSat;} - unsigned ambNumEpo() const {return _ambInfo ? _ambInfo->_numEpo : 0;} - void stepAmbNumEpo() {if (_ambInfo) _ambInfo->_numEpo += 1;} - - static bool sortFunction(const t_pppParam* p1, const t_pppParam* p2) { - if (p1->_type != p2->_type) { - return p1->_type < p2->_type; - } - else if (p1->_tLC != p2->_tLC) { - return p1->_tLC < p2->_tLC; - } - else if (p1->_prn != p2->_prn) { - return p1->_prn < p2->_prn; - } - return false; - } - - private: - class t_ambInfo { - public: - t_ambInfo() { - _resetCandidate = false; - _eleSat = 0.0; - _numEpo = 0; - } - ~t_ambInfo() {} - bool _resetCandidate; - double _eleSat; - unsigned _numEpo; - }; - e_type _type; - t_prn _prn; - t_lc::type _tLC; - double _x0; - bool _epoSpec; - int _indexOld; - int _indexNew; - double _sigma0; - double _noise; - t_ambInfo* _ambInfo; - bncTime _lastObsTime; - bncTime _firstObsTime; -}; - -class t_pppParlist { - public: - t_pppParlist(); - ~t_pppParlist(); - - t_irc set(const bncTime& epoTime, const std::vector& obsVector); - unsigned nPar() const {return _params.size();} - const std::vector& params() const {return _params;} - std::vector& params() {return _params;} - void printResult(const bncTime& epoTime, const SymmetricMatrix& QQ, - const ColumnVector& xx) const; - private: - std::vector _params; -}; - -} - -#endif Index: trunk/BNC/src/PPP/pppSatObs.cpp =================================================================== --- trunk/BNC/src/PPP/pppSatObs.cpp (revision 7203) +++ (revision ) @@ -1,505 +1,0 @@ -/* ------------------------------------------------------------------------- - * BKG NTRIP Client - * ------------------------------------------------------------------------- - * - * Class: t_pppSatObs - * - * Purpose: Satellite observations - * - * Author: L. Mervart - * - * Created: 29-Jul-2014 - * - * Changes: - * - * -----------------------------------------------------------------------*/ - - -#include -#include -#include - -#include "pppSatObs.h" -#include "bncconst.h" -#include "pppEphPool.h" -#include "pppStation.h" -#include "bncutils.h" -#include "bncantex.h" -#include "pppObsPool.h" -#include "pppClient.h" - -using namespace BNC_PPP; -using namespace std; - -// Constructor -//////////////////////////////////////////////////////////////////////////// -t_pppSatObs::t_pppSatObs(const t_satObs& pppSatObs) { - _prn = pppSatObs._prn; - _time = pppSatObs._time; - _outlier = false; - _valid = true; - for (unsigned ii = 0; ii < t_frequency::max; ii++) { - _obs[ii] = 0; - } - prepareObs(pppSatObs); -} - -// Destructor -//////////////////////////////////////////////////////////////////////////// -t_pppSatObs::~t_pppSatObs() { - for (unsigned iFreq = 1; iFreq < t_frequency::max; iFreq++) { - delete _obs[iFreq]; - } -} - -// -//////////////////////////////////////////////////////////////////////////// -void t_pppSatObs::prepareObs(const t_satObs& pppSatObs) { - - _model.reset(); - - // Select pseudoranges and phase observations - // ------------------------------------------ - const string preferredAttrib = "CWPX_"; - - for (unsigned iFreq = 1; iFreq < t_frequency::max; iFreq++) { - string frqNum = t_frequency::toString(t_frequency::type(iFreq)).substr(1); - for (unsigned iPref = 0; iPref < preferredAttrib.length(); iPref++) { - string obsType = (preferredAttrib[iPref] == '_') ? frqNum : frqNum + preferredAttrib[iPref]; - if (_obs[iFreq] == 0) { - for (unsigned ii = 0; ii < pppSatObs._obs.size(); ii++) { - const t_frqObs* obs = pppSatObs._obs[ii]; - if (obs->_rnxType2ch == obsType && obs->_codeValid && obs->_phaseValid) { - _obs[iFreq] = new t_frqObs(*obs); - } - } - } - } - } - - // Used frequency types - // -------------------- - _fType1 = t_lc::toFreq(_prn.system(),t_lc::l1); - _fType2 = t_lc::toFreq(_prn.system(),t_lc::l2); - - // Check whether all required frequencies available - // ------------------------------------------------ - for (unsigned ii = 0; ii < OPT->LCs(_prn.system()).size(); ii++) { - t_lc::type tLC = OPT->LCs(_prn.system())[ii]; - if (!isValid(tLC)) { - _valid = false; - return; - } - } - - // Find Glonass Channel Number - // --------------------------- - if (_prn.system() == 'R') { - _channel = PPP_CLIENT->ephPool()->getChannel(_prn); - } - else { - _channel = 0; - } - - // Compute Satellite Coordinates at Time of Transmission - // ----------------------------------------------------- - _xcSat.ReSize(4); _xcSat = 0.0; - _vvSat.ReSize(4); _vvSat = 0.0; - bool totOK = false; - ColumnVector satPosOld(4); satPosOld = 0.0; - t_lc::type tLC = isValid(t_lc::cIF) ? t_lc::cIF : t_lc::c1; - double prange = obsValue(tLC); - for (int ii = 1; ii <= 10; ii++) { - bncTime ToT = _time - prange / t_CST::c - _xcSat[3]; - if (PPP_CLIENT->ephPool()->getCrd(_prn, ToT, _xcSat, _vvSat) != success) { - _valid = false; - return; - } - ColumnVector dx = _xcSat - satPosOld; - dx[3] *= t_CST::c; - if (dx.norm_Frobenius() < 1.e-4) { - totOK = true; - break; - } - satPosOld = _xcSat; - } - if (totOK) { - _model._satClkM = _xcSat[3] * t_CST::c; - } - else { - _valid = false; - } -} - -// -//////////////////////////////////////////////////////////////////////////// -void t_pppSatObs::lcCoeff(t_lc::type tLC, - map& codeCoeff, - map& phaseCoeff) const { - - codeCoeff.clear(); - phaseCoeff.clear(); - - double f1 = t_CST::freq(_fType1, _channel); - double f2 = t_CST::freq(_fType2, _channel); - - switch (tLC) { - case t_lc::l1: - phaseCoeff[_fType1] = 1.0; - return; - case t_lc::l2: - phaseCoeff[_fType2] = 1.0; - return; - case t_lc::lIF: - phaseCoeff[_fType1] = f1 * f1 / (f1 * f1 - f2 * f2); - phaseCoeff[_fType2] = -f2 * f2 / (f1 * f1 - f2 * f2); - return; - case t_lc::MW: - phaseCoeff[_fType1] = f1 / (f1 - f2); - phaseCoeff[_fType2] = -f2 / (f1 - f2); - codeCoeff[_fType1] = -f1 / (f1 + f2); - codeCoeff[_fType2] = -f2 / (f1 + f2); - return; - case t_lc::CL: - phaseCoeff[_fType1] = 0.5; - codeCoeff[_fType1] = 0.5; - return; - case t_lc::c1: - codeCoeff[_fType1] = 1.0; - return; - case t_lc::c2: - codeCoeff[_fType2] = 1.0; - return; - case t_lc::cIF: - codeCoeff[_fType1] = f1 * f1 / (f1 * f1 - f2 * f2); - codeCoeff[_fType2] = -f2 * f2 / (f1 * f1 - f2 * f2); - return; - case t_lc::dummy: - case t_lc::maxLc: - return; - } -} - -// -//////////////////////////////////////////////////////////////////////////// -bool t_pppSatObs::isValid(t_lc::type tLC) const { - bool valid = true; - obsValue(tLC, &valid); - return valid; -} -// -//////////////////////////////////////////////////////////////////////////// -double t_pppSatObs::obsValue(t_lc::type tLC, bool* valid) const { - - map codeCoeff; - map phaseCoeff; - lcCoeff(tLC, codeCoeff, phaseCoeff); - - double retVal = 0.0; - if (valid) *valid = true; - - map::const_iterator it; - for (it = codeCoeff.begin(); it != codeCoeff.end(); it++) { - t_frequency::type tFreq = it->first; - if (_obs[tFreq] == 0) { - if (valid) *valid = false; - return 0.0; - } - else { - retVal += it->second * _obs[tFreq]->_code; - } - } - for (it = phaseCoeff.begin(); it != phaseCoeff.end(); it++) { - t_frequency::type tFreq = it->first; - if (_obs[tFreq] == 0) { - if (valid) *valid = false; - return 0.0; - } - else { - retVal += it->second * _obs[tFreq]->_phase * t_CST::lambda(tFreq, _channel); - } - } - - return retVal; -} - -// -//////////////////////////////////////////////////////////////////////////// -double t_pppSatObs::lambda(t_lc::type tLC) const { - - double f1 = t_CST::freq(_fType1, _channel); - double f2 = t_CST::freq(_fType2, _channel); - - if (tLC == t_lc::l1) { - return t_CST::c / f1; - } - else if (tLC == t_lc::l2) { - return t_CST::c / f2; - } - else if (tLC == t_lc::lIF) { - return t_CST::c / (f1 + f2); - } - else if (tLC == t_lc::MW) { - return t_CST::c / (f1 - f2); - } - else if (tLC == t_lc::CL) { - return t_CST::c / f1 / 2.0; - } - - return 0.0; -} - -// -//////////////////////////////////////////////////////////////////////////// -double t_pppSatObs::sigma(t_lc::type tLC) const { - - map codeCoeff; - map phaseCoeff; - lcCoeff(tLC, codeCoeff, phaseCoeff); - - double retVal = 0.0; - - map::const_iterator it; - for (it = codeCoeff.begin(); it != codeCoeff.end(); it++) { - retVal += it->second * it->second * OPT->_sigmaC1 * OPT->_sigmaC1; - } - for (it = phaseCoeff.begin(); it != phaseCoeff.end(); it++) { - retVal += it->second * it->second * OPT->_sigmaL1 * OPT->_sigmaL1; - } - - retVal = sqrt(retVal); - - // De-Weight GLONASS - // ----------------- - if (_prn.system() == 'R') { - retVal *= 5.0; - } - - // Elevation-Dependent Weighting - // ----------------------------- - double cEle = 1.0; - if ( (OPT->_eleWgtCode && t_lc::includesCode(tLC)) || - (OPT->_eleWgtPhase && t_lc::includesPhase(tLC)) ) { - double eleD = eleSat()*180.0/M_PI; - double hlp = fabs(90.0 - eleD); - cEle = (1.0 + hlp*hlp*hlp*0.000004); - } - - return cEle * retVal; -} - -// -//////////////////////////////////////////////////////////////////////////// -double t_pppSatObs::maxRes(t_lc::type tLC) const { - - map codeCoeff; - map phaseCoeff; - lcCoeff(tLC, codeCoeff, phaseCoeff); - - double retVal = 0.0; - - map::const_iterator it; - for (it = codeCoeff.begin(); it != codeCoeff.end(); it++) { - retVal += it->second * it->second * OPT->_maxResC1 * OPT->_maxResC1; - } - for (it = phaseCoeff.begin(); it != phaseCoeff.end(); it++) { - retVal += it->second * it->second * OPT->_maxResL1 * OPT->_maxResL1; - } - - return sqrt(retVal); -} - - -// -//////////////////////////////////////////////////////////////////////////// -t_irc t_pppSatObs::cmpModel(const t_pppStation* station) { - - // Reset all model values - // ---------------------- - _model.reset(); - - // Topocentric Satellite Position - // ------------------------------ - ColumnVector rSat = _xcSat.Rows(1,3); - ColumnVector rhoV = rSat - station->xyzApr(); - _model._rho = rhoV.norm_Frobenius(); - - ColumnVector neu(3); - xyz2neu(station->ellApr().data(), rhoV.data(), neu.data()); - - _model._eleSat = acos( sqrt(neu[0]*neu[0] + neu[1]*neu[1]) / _model._rho ); - if (neu[2] < 0) { - _model._eleSat *= -1.0; - } - _model._azSat = atan2(neu[1], neu[0]); - - // Satellite Clocks - // ---------------- - _model._satClkM = _xcSat[3] * t_CST::c; - - // Receiver Clocks - // --------------- - _model._recClkM = station->dClk() * t_CST::c; - - // Sagnac Effect (correction due to Earth rotation) - // ------------------------------------------------ - ColumnVector Omega(3); - Omega[0] = 0.0; - Omega[1] = 0.0; - Omega[2] = t_CST::omega / t_CST::c; - _model._sagnac = DotProduct(Omega, crossproduct(rSat, station->xyzApr())); - - // Antenna Eccentricity - // -------------------- - _model._antEcc = -DotProduct(station->xyzEcc(), rhoV) / _model._rho; - - // Antenna Phase Center Offsets and Variations - // ------------------------------------------- - if (PPP_CLIENT->antex()) { - for (unsigned ii = 0; ii < t_frequency::max; ii++) { - t_frequency::type frqType = static_cast(ii); - bool found; - _model._antPCO[ii] = PPP_CLIENT->antex()->rcvCorr(station->antName(), frqType, - _model._eleSat, _model._azSat, found); - } - } - - // Tropospheric Delay - // ------------------ - _model._tropo = t_tropo::delay_saast(station->xyzApr(), _model._eleSat); - - // Phase Wind-Up - // ------------- - _model._windUp = station->windUp(_time, _prn, rSat); - - // Code Biases - // ----------- - const t_satCodeBias* satCodeBias = PPP_CLIENT->obsPool()->satCodeBias(_prn); - if (satCodeBias) { - for (unsigned ii = 0; ii < satCodeBias->_bias.size(); ii++) { - const t_frqCodeBias& bias = satCodeBias->_bias[ii]; - for (unsigned iFreq = 1; iFreq < t_frequency::max; iFreq++) { - const t_frqObs* obs = _obs[iFreq]; - if (obs && obs->_rnxType2ch == bias._rnxType2ch) { - _model._codeBias[iFreq] = bias._value; - } - } - } - } - - // Tidal Correction - // ---------------- - _model._tide = -DotProduct(station->tideDspl(), rhoV) / _model._rho; - - // Ionospheric Delay - // ----------------- - // TODO - - // Ocean Loading - // ------------- - // TODO - - // Set Model Set Flag - // ------------------ - _model._set = true; - - return success; -} - -// -//////////////////////////////////////////////////////////////////////////// -void t_pppSatObs::printModel() const { - LOG.setf(ios::fixed); - LOG << "MODEL for Satellite " << _prn.toString() << endl - << "RHO: " << setw(12) << setprecision(3) << _model._rho << endl - << "ELE: " << setw(12) << setprecision(3) << _model._eleSat * 180.0 / M_PI << endl - << "AZI: " << setw(12) << setprecision(3) << _model._azSat * 180.0 / M_PI << endl - << "SATCLK: " << setw(12) << setprecision(3) << _model._satClkM << endl - << "RECCLK: " << setw(12) << setprecision(3) << _model._recClkM << endl - << "SAGNAC: " << setw(12) << setprecision(3) << _model._sagnac << endl - << "ANTECC: " << setw(12) << setprecision(3) << _model._antEcc << endl - << "TROPO: " << setw(12) << setprecision(3) << _model._tropo << endl - << "WINDUP: " << setw(12) << setprecision(3) << _model._windUp << endl - << "TIDES: " << setw(12) << setprecision(3) << _model._tide << endl; - for (unsigned iFreq = 1; iFreq < t_frequency::max; iFreq++) { - if (_obs[iFreq]) { - LOG << "PCO: " << t_frequency::toString(t_frequency::type(iFreq)) << setw(12) << setprecision(3) << _model._antPCO[iFreq] << endl - << "BIAS CODE: " << t_frequency::toString(t_frequency::type(iFreq)) << setw(12) << setprecision(3) << _model._codeBias[iFreq] << endl - << "BIAS PHASE: " << t_frequency::toString(t_frequency::type(iFreq)) << setw(12) << setprecision(3) << _model._phaseBias[iFreq] << endl; - } - } - LOG << "OBS-CMP P3: " << _prn.toString() << " " - << setw(12) << setprecision(3) << obsValue(t_lc::cIF) << " " - << setw(12) << setprecision(3) << cmpValue(t_lc::cIF) << " " - << setw(12) << setprecision(3) << obsValue(t_lc::cIF) - cmpValue(t_lc::cIF) << endl; - - LOG << "OBS-CMP L3: " << _prn.toString() << " " - << setw(12) << setprecision(3) << obsValue(t_lc::lIF) << " " - << setw(12) << setprecision(3) << cmpValue(t_lc::lIF) << " " - << setw(12) << setprecision(3) << obsValue(t_lc::lIF) - cmpValue(t_lc::lIF) << endl; - - LOG << "OBS-CMP MW: " << _prn.toString() << " " - << setw(12) << setprecision(3) << obsValue(t_lc::MW) << " " - << setw(12) << setprecision(3) << cmpValue(t_lc::MW) << " " - << setw(12) << setprecision(3) << obsValue(t_lc::MW) - cmpValue(t_lc::MW) << endl; -} - -// -//////////////////////////////////////////////////////////////////////////// -double t_pppSatObs::cmpValueForBanc(t_lc::type tLC) const { - return cmpValue(tLC) - _model._rho - _model._sagnac - _model._recClkM; -} - -// -//////////////////////////////////////////////////////////////////////////// -double t_pppSatObs::cmpValue(t_lc::type tLC) const { - - if (!isValid(tLC)) { - return 0.0; - } - - // Non-Dispersive Part - // ------------------- - double nonDisp = _model._rho + _model._recClkM - _model._satClkM - + _model._sagnac + _model._antEcc + _model._tropo - + _model._tide; - - // Add Dispersive Part - // ------------------- - map codeCoeff; - map phaseCoeff; - lcCoeff(tLC, codeCoeff, phaseCoeff); - - double dispPart = 0.0; - - map::const_iterator it; - for (it = codeCoeff.begin(); it != codeCoeff.end(); it++) { - t_frequency::type tFreq = it->first; - dispPart += it->second * (_model._antPCO[tFreq] + _model._codeBias[tFreq]); - } - for (it = phaseCoeff.begin(); it != phaseCoeff.end(); it++) { - t_frequency::type tFreq = it->first; - dispPart += it->second * (_model._antPCO[tFreq] + _model._phaseBias[tFreq] + - _model._windUp * t_CST::lambda(tFreq, _channel)); - } - - return nonDisp + dispPart; -} - -// -//////////////////////////////////////////////////////////////////////////// -void t_pppSatObs::setRes(t_lc::type tLC, double res) { - _res[tLC] = res; -} - -// -//////////////////////////////////////////////////////////////////////////// -double t_pppSatObs::getRes(t_lc::type tLC) const { - map::const_iterator it = _res.find(tLC); - if (it != _res.end()) { - return it->second; - } - else { - return 0.0; - } -} Index: trunk/BNC/src/PPP/pppSatObs.h =================================================================== --- trunk/BNC/src/PPP/pppSatObs.h (revision 7203) +++ (revision ) @@ -1,130 +1,0 @@ -#ifndef PPPSATOBS_H -#define PPPSATOBS_H - -#include -#include -#include -#include "pppInclude.h" -#include "satObs.h" -#include "bnctime.h" - -namespace BNC_PPP { - -class t_pppStation; - -class t_pppSatObs { - public: - t_pppSatObs(const t_satObs& satObs); - ~t_pppSatObs(); - bool isValid() const {return _valid;}; - bool isValid(t_lc::type tLC) const; - const t_prn& prn() const {return _prn;} - const ColumnVector& xc() const {return _xcSat;} - const bncTime& time() const {return _time;} - t_irc cmpModel(const t_pppStation* station); - double obsValue(t_lc::type tLC, bool* valid = 0) const; - double cmpValue(t_lc::type tLC) const; - double cmpValueForBanc(t_lc::type tLC) const; - double rho() const {return _model._rho;} - double sagnac() const {return _model._sagnac;} - double eleSat() const {return _model._eleSat;} - bool modelSet() const {return _model._set;} - void printModel() const; - void lcCoeff(t_lc::type tLC, - std::map& codeCoeff, - std::map& phaseCoeff) const; - double lambda(t_lc::type tLC) const; - double sigma(t_lc::type tLC) const; - double maxRes(t_lc::type tLC) const; - bool outlier() const {return _outlier;} - void setOutlier() {_outlier = true;} - void setRes(t_lc::type tLC, double res); - double getRes(t_lc::type tLC) const; - - bool slip() const { - for (unsigned ii = 1; ii < t_frequency::max; ii++) { - if (_obs[ii] && _obs[ii]->_slip) { - return true; - } - } - return false; - } - - int slipCounter() const { - int cnt = -1; - for (unsigned ii = 1; ii < t_frequency::max; ii++) { - if (_obs[ii] && _obs[ii]->_slipCounter > cnt) { - cnt = _obs[ii]->_slipCounter; - } - } - return cnt; - } - - int biasJumpCounter() const { - int jmp = -1; - for (unsigned ii = 1; ii < t_frequency::max; ii++) { - if (_obs[ii] && _obs[ii]->_biasJumpCounter > jmp) { - jmp = _obs[ii]->_biasJumpCounter; - } - } - return jmp; - } - - private: - class t_model { - public: - t_model() {reset();} - ~t_model() {} - void reset() { - _set = false; - _rho = 0.0; - _eleSat = 0.0; - _azSat = 0.0; - _recClkM = 0.0; - _satClkM = 0.0; - _sagnac = 0.0; - _antEcc = 0.0; - _tropo = 0.0; - _tide = 0.0; - _windUp = 0.0; - for (unsigned ii = 0; ii < t_frequency::max; ii++) { - _antPCO[ii] = 0.0; - _codeBias[ii] = 0.0; - _phaseBias[ii] = 0.0; - } - } - bool _set; - double _rho; - double _eleSat; - double _azSat; - double _recClkM; - double _satClkM; - double _sagnac; - double _antEcc; - double _tropo; - double _tide; - double _windUp; - double _antPCO[t_frequency::max]; - double _codeBias[t_frequency::max]; - double _phaseBias[t_frequency::max]; - }; - - void prepareObs(const t_satObs& satObs); - - bool _valid; - t_frequency::type _fType1; - t_frequency::type _fType2; - t_prn _prn; - bncTime _time; - int _channel; - t_frqObs* _obs[t_frequency::max]; - ColumnVector _xcSat; - ColumnVector _vvSat; - t_model _model; - bool _outlier; - std::map _res; -}; - -} - -#endif Index: trunk/BNC/src/PPP/pppStation.cpp =================================================================== --- trunk/BNC/src/PPP/pppStation.cpp (revision 7203) +++ (revision ) @@ -1,58 +1,0 @@ -/* ------------------------------------------------------------------------- - * BKG NTRIP Client - * ------------------------------------------------------------------------- - * - * Class: t_pppStation - * - * Purpose: Processed station - * - * Author: L. Mervart - * - * Created: 29-Jul-2014 - * - * Changes: - * - * -----------------------------------------------------------------------*/ - -#include "pppStation.h" -#include "bncutils.h" -#include "pppModel.h" - -using namespace BNC_PPP; -using namespace std; - -// Constructor -////////////////////////////////////////////////////////////////////////////// -t_pppStation::t_pppStation() { - _windUp = new t_windUp(); -} - -// Destructor -////////////////////////////////////////////////////////////////////////////// -t_pppStation::~t_pppStation() { - delete _windUp; -} - -// -////////////////////////////////////////////////////////////////////////////// -void t_pppStation::setXyzApr(const ColumnVector& xyzApr) { - _xyzApr = xyzApr; - _ellApr.ReSize(3); - xyz2ell(_xyzApr.data(), _ellApr.data()); -} - -// -////////////////////////////////////////////////////////////////////////////// -void t_pppStation::setNeuEcc(const ColumnVector& neuEcc) { - _neuEcc = neuEcc; - _xyzEcc.ReSize(3); - neu2xyz(_ellApr.data(), _neuEcc.data(), _xyzEcc.data()); -} - -// -////////////////////////////////////////////////////////////////////////////// -double t_pppStation::windUp(const bncTime& time, t_prn prn, - const ColumnVector& rSat) const { - return _windUp->value(time, _xyzApr, prn, rSat); -} - Index: trunk/BNC/src/PPP/pppStation.h =================================================================== --- trunk/BNC/src/PPP/pppStation.h (revision 7203) +++ (revision ) @@ -1,49 +1,0 @@ -#ifndef STATION_H -#define STATION_H - -#include -#include -#include "pppInclude.h" -#include "bnctime.h" - -namespace BNC_PPP { - -class t_windUp; - -class t_pppStation { - public: - t_pppStation(); - ~t_pppStation(); - void setName(std::string name) {_name = name;} - void setAntName(std::string antName) {_antName = antName;} - void setXyzApr(const ColumnVector& xyzApr); - void setNeuEcc(const ColumnVector& neuEcc); - void setDClk(double dClk) {_dClk = dClk;} - void setTideDspl(const ColumnVector& tideDspl) {_tideDspl = tideDspl;} - const std::string& name() const {return _name;} - const std::string& antName() const {return _antName;} - const ColumnVector& xyzApr() const {return _xyzApr;} - const ColumnVector& ellApr() const {return _ellApr;} - const ColumnVector& neuEcc() const {return _neuEcc;} - const ColumnVector& xyzEcc() const {return _xyzEcc;} - const ColumnVector& tideDspl() const {return _tideDspl;} - double dClk() const {return _dClk;} - double windUp(const bncTime& time, t_prn prn, const ColumnVector& rSat) const; - - private: - std::string _name; - std::string _antName; - ColumnVector _xyzApr; - ColumnVector _ellApr; - ColumnVector _neuEcc; - ColumnVector _xyzEcc; - ColumnVector _tideDspl; - double _dClk; - mutable t_windUp* _windUp; - bncTime _timeCheck; - ColumnVector _xyzCheck; -}; - -} - -#endif