source: ntrip/trunk/BNC/src/PPP/pppParlist.cpp@ 9511

Last change on this file since 9511 was 9511, checked in by stuerze, 3 years ago

minor changes regarding PPP
  • Property svn:keywords set to Author Date Id Rev URL;svn:eol-style=native
  • Property svn:mime-type set to text/plain
File size: 25.1 KB
Line 
1/* -------------------------------------------------------------------------
2 * BKG NTRIP Client
3 * -------------------------------------------------------------------------
4 *
5 * Class: t_pppParlist
6 *
7 * Purpose: List of estimated parameters
8 *
9 * Author: L. Mervart
10 *
11 * Created: 29-Jul-2014
12 *
13 * Changes:
14 *
15 * -----------------------------------------------------------------------*/
16
17#include <cmath>
18#include <iostream>
19#include <sstream>
20#include <iomanip>
21#include <algorithm>
22#include <newmatio.h>
23
24#include "pppParlist.h"
25#include "pppSatObs.h"
26#include "pppStation.h"
27#include "bncutils.h"
28#include "bncconst.h"
29#include "pppClient.h"
30
31using namespace BNC_PPP;
32using namespace std;
33
34// Constructor
35////////////////////////////////////////////////////////////////////////////
36t_pppParam::t_pppParam(e_type type, const t_prn& prn, t_lc::type tLC,
37 const vector<t_pppSatObs*>* obsVector) {
38
39 _type = type;
40 _prn = prn;
41 _tLC = tLC;
42 _x0 = 0.0;
43 _indexOld = -1;
44 _indexNew = -1;
45 _noise = 0.0;
46 _ambInfo = 0;
47
48 switch (_type) {
49 case crdX:
50 _epoSpec = false;
51 _sigma0 = OPT->_aprSigCrd[0];
52 _noise = OPT->_noiseCrd[0];
53 break;
54 case crdY:
55 _epoSpec = false;
56 _sigma0 = OPT->_aprSigCrd[1];
57 _noise = OPT->_noiseCrd[1];
58 break;
59 case crdZ:
60 _epoSpec = false;
61 _sigma0 = OPT->_aprSigCrd[2];
62 _noise = OPT->_noiseCrd[2];
63 break;
64 case clkR:
65 _epoSpec = true;
66 _sigma0 = OPT->_aprSigClk;
67 break;
68 case amb:
69 _epoSpec = false;
70 _sigma0 = OPT->_aprSigAmb;
71 _ambInfo = new t_ambInfo();
72 if (obsVector) {
73 for (unsigned ii = 0; ii < obsVector->size(); ii++) {
74 const t_pppSatObs* obs = obsVector->at(ii);
75 if (obs->prn() == _prn) {
76 double offGR = 0;
77 if (_prn.system() == 'R' && tLC != t_lc::MW) {
78 offGR = PPP_CLIENT->offGR();
79 }
80 double offGE = 0;
81 if (_prn.system() == 'E' && tLC != t_lc::MW) {
82 offGE = PPP_CLIENT->offGE();
83 }
84 double offGC = 0;
85 if (_prn.system() == 'C' && tLC != t_lc::MW) {
86 offGC = PPP_CLIENT->offGC();
87 }
88 _x0 = floor((obs->obsValue(tLC) - offGR -offGE - offGC - obs->cmpValue(tLC)) / obs->lambda(tLC) + 0.5);
89 break;
90 }
91 }
92 }
93 break;
94 case offGR:
95 _epoSpec = true;
96 _sigma0 = OPT->_aprSigOGR;
97 _x0 = PPP_CLIENT->offGR();
98 break;
99 case offGE:
100 _epoSpec = true;
101 _sigma0 = OPT->_aprSigOGE;
102 _x0 = PPP_CLIENT->offGE();
103 break;
104 case offGC:
105 _epoSpec = true;
106 _sigma0 = OPT->_aprSigOGC;
107 _x0 = PPP_CLIENT->offGC();
108 break;
109 case trp:
110 _epoSpec = false;
111 _sigma0 = OPT->_aprSigTrp;
112 _noise = OPT->_noiseTrp;
113 break;
114 case ion:
115 _epoSpec = false;
116 _sigma0 = OPT->_aprSigIon;
117 _noise = OPT->_noiseIon;
118 break;
119 case cBiasG1: case cBiasR1: case cBiasE1: case cBiasC1:
120 case cBiasG2: case cBiasR2: case cBiasE2: case cBiasC2:
121 _epoSpec = false;
122 _sigma0 = OPT->_aprSigCodeBias;
123 _noise = OPT->_noiseCodeBias;
124 break;
125 case pBiasG1: case pBiasE1: case pBiasR1: case pBiasC1:
126 case pBiasG2: case pBiasE2: case pBiasR2: case pBiasC2:
127 _epoSpec = false;
128 _sigma0 = OPT->_aprSigPhaseBias;
129 _noise = OPT->_noisePhaseBias;
130 break;
131 }
132}
133
134//
135////////////////////////////////////////////////////////////////////////////
136t_pppParam::t_pppParam(const t_pppParam* old) {
137 _type = old->type();
138 _prn = old->prn();
139 _tLC = old->tLC();
140 _indexOld = old->indexOld();
141 _indexNew = old->indexNew();
142 _noise = old->noise();
143 _sigma0 = old->sigma0();
144 _epoSpec = old->epoSpec();
145 _x0 = old->x0();
146 _indexOld = old->indexOld();
147 _indexNew = old->indexNew();
148 setFirstObsTime(old->firstObsTime());
149 setLastObsTime(old->lastObsTime());
150 _ambInfo = 0;
151 if (_type == t_pppParam::amb) {
152 _ambInfo = new t_ambInfo();
153 _ambInfo->_resetCandidate = old->_ambInfo->_resetCandidate;
154 _ambInfo->_eleSat = old->_ambInfo->_eleSat;
155 _ambInfo->_numEpo = old->_ambInfo->_numEpo;
156 }
157}
158
159// Destructor
160////////////////////////////////////////////////////////////////////////////
161t_pppParam::~t_pppParam() {
162 if (_ambInfo) {
163 delete _ambInfo;
164 }
165}
166//
167////////////////////////////////////////////////////////////////////////////
168double t_pppParam::partial(const bncTime& /* epoTime */, const t_pppSatObs* obs,
169 const t_lc::type& tLC, const t_prn refPrn) const {
170
171 // Special Case - Melbourne-Wuebbena
172 // ---------------------------------
173 if (tLC == t_lc::MW && _type != amb) {
174 return 0.0;
175 }
176
177 const t_pppStation* sta = PPP_CLIENT->staRover();
178 ColumnVector rhoV = sta->xyzApr() - obs->xc().Rows(1,3);
179
180 map<t_frequency::type, double> codeCoeff;
181 map<t_frequency::type, double> phaseCoeff;
182 map<t_frequency::type, double> ionoCoeff;
183 obs->lcCoeff(tLC, codeCoeff, phaseCoeff, ionoCoeff);
184
185 switch (_type) {
186 case crdX:
187 if (tLC == t_lc::GIM || tLC == t_lc::Tz0) {return 0.0;}
188 return (sta->xyzApr()[0] - obs->xc()[0]) / rhoV.NormFrobenius();
189 case crdY:
190 if (tLC == t_lc::GIM || tLC == t_lc::Tz0) {return 0.0;}
191 return (sta->xyzApr()[1] - obs->xc()[1]) / rhoV.NormFrobenius();
192 case crdZ:
193 if (tLC == t_lc::GIM || tLC == t_lc::Tz0) {return 0.0;}
194 return (sta->xyzApr()[2] - obs->xc()[2]) / rhoV.NormFrobenius();
195 case clkR:
196 if (tLC == t_lc::GIM || tLC == t_lc::Tz0) {return 0.0;}
197 return 1.0;
198 case offGR:
199 if (tLC == t_lc::GIM || tLC == t_lc::Tz0) {return 0.0;}
200 return (obs->prn().system() == 'R') ? 1.0 : 0.0;
201 case offGE:
202 if (tLC == t_lc::GIM || tLC == t_lc::Tz0) {return 0.0;}
203 return (obs->prn().system() == 'E') ? 1.0 : 0.0;
204 case offGC:
205 if (tLC == t_lc::GIM || tLC == t_lc::Tz0) {return 0.0;}
206 return (obs->prn().system() == 'C') ? 1.0 : 0.0;
207 case amb:
208 if (tLC == t_lc::GIM || tLC == t_lc::Tz0) {return 0.0;}
209 else if ((OPT->_obsModelType == OPT->IF) ||
210 (OPT->_obsModelType == OPT->PPPRTK) ||
211 (OPT->_obsModelType == OPT->UncombPPP) ||
212 (OPT->_obsModelType == OPT->DCMcodeBias && !obs->isReference()) ||
213 (OPT->_obsModelType == OPT->DCMphaseBias && !obs->isReference()) ) {
214
215 if (obs->prn() == _prn) {
216 if (tLC == _tLC) {
217 return (obs->lambda(tLC));
218 }
219 else if (tLC == t_lc::lIF && _tLC == t_lc::MW) {
220 return obs->lambda(t_lc::lIF) * obs->lambda(t_lc::MW) / obs->lambda(t_lc::l2);
221 }
222 else {
223 if (_tLC == t_lc::l1) {
224 return obs->lambda(t_lc::l1) * phaseCoeff[t_lc::toFreq(obs->prn().system(),t_lc::l1)];
225 }
226 else if (_tLC == t_lc::l2) {
227 return obs->lambda(t_lc::l2) * phaseCoeff[t_lc::toFreq(obs->prn().system(),t_lc::l2)];
228 }
229 }
230 }
231 }
232 break;
233 case trp:
234 if (tLC == t_lc::GIM) {
235 return 0.0;
236 }
237 else if (tLC == t_lc::Tz0) {
238 return 1.0;
239 }
240 else {
241 return 1.0 / sin(obs->eleSat());
242 }
243 case ion:
244 if (obs->prn() == _prn) {
245 if (tLC == t_lc::c1) {
246 return ionoCoeff[t_lc::toFreq(obs->prn().system(),t_lc::c1)];
247 }
248 else if (tLC == t_lc::c2) {
249 return ionoCoeff[t_lc::toFreq(obs->prn().system(),t_lc::c2)];
250 }
251 else if (tLC == t_lc::l1) {
252 return ionoCoeff[t_lc::toFreq(obs->prn().system(),t_lc::l1)];
253 }
254 else if (tLC == t_lc::l2) {
255 return ionoCoeff[t_lc::toFreq(obs->prn().system(),t_lc::l2)];
256 }
257 else if (tLC == t_lc::GIM) {
258 return -1.0;
259 }
260 }
261 if (tLC == t_lc::GIM && _prn == refPrn) {
262 return 1.0;
263 }
264 break;
265 case cBiasG1:
266 if ((obs->prn().system() == 'G') && (tLC == t_lc::c1)) {return 1.0;} else {return 0.0;}
267 break;
268 case cBiasR1:
269 if ((obs->prn().system() == 'R') && (tLC == t_lc::c1)) {return 1.0;} else {return 0.0;}
270 break;
271 case cBiasE1:
272 if ((obs->prn().system() == 'E') && (tLC == t_lc::c1)) {return 1.0;} else {return 0.0;}
273 break;
274 case cBiasC1:
275 if ((obs->prn().system() == 'C') && (tLC == t_lc::c1)) {return 1.0;} else {return 0.0;}
276 break;
277 case cBiasG2:
278 if ((obs->prn().system() == 'G') && (tLC == t_lc::c2)) {return 1.0;} else {return 0.0;}
279 break;
280 case cBiasR2:
281 if ((obs->prn().system() == 'R') && (tLC == t_lc::c2)) {return 1.0;} else {return 0.0;}
282 break;
283 case cBiasE2:
284 if ((obs->prn().system() == 'E') && (tLC == t_lc::c2)) {return 1.0;} else {return 0.0;}
285 break;
286 case cBiasC2:
287 if ((obs->prn().system() == 'C') && (tLC == t_lc::c2)) {return 1.0;} else {return 0.0;}
288 break;
289 case pBiasG1:
290 if ((obs->prn().system() == 'G') && (tLC == t_lc::l1)) {return 1.0;} else {return 0.0;}
291 break;
292 case pBiasR1:
293 if ((obs->prn().system() == 'R') && (tLC == t_lc::l1)) {return 1.0;} else {return 0.0;}
294 break;
295 case pBiasE1:
296 if ((obs->prn().system() == 'E') && (tLC == t_lc::l1)) {return 1.0;} else {return 0.0;}
297 break;
298 case pBiasC1:
299 if ((obs->prn().system() == 'C') && (tLC == t_lc::l1)) {return 1.0;} else {return 0.0;}
300 break;
301 case pBiasG2:
302 if ((obs->prn().system() == 'G') && (tLC == t_lc::l2)) {return 1.0;} else {return 0.0;}
303 break;
304 case pBiasR2:
305 if ((obs->prn().system() == 'R') && (tLC == t_lc::l2)) {return 1.0;} else {return 0.0;}
306 break;
307 case pBiasE2:
308 if ((obs->prn().system() == 'E') && (tLC == t_lc::l2)) {return 1.0;} else {return 0.0;}
309 break;
310 case pBiasC2:
311 if ((obs->prn().system() == 'C') && (tLC == t_lc::l2)) {return 1.0;} else {return 0.0;}
312 break;
313
314 }
315 return 0.0;
316}
317
318//
319////////////////////////////////////////////////////////////////////////////
320string t_pppParam::toString() const {
321 stringstream ss;
322 switch (_type) {
323 case crdX:
324 ss << "CRD_X";
325 break;
326 case crdY:
327 ss << "CRD_Y";
328 break;
329 case crdZ:
330 ss << "CRD_Z";
331 break;
332 case clkR:
333 ss << "REC_CLK ";
334 break;
335 case offGR:
336 ss << "OGR ";
337 break;
338 case offGE:
339 ss << "OGE ";
340 break;
341 case offGC:
342 ss << "OGC ";
343 break;
344 case trp:
345 ss << "TRP ";
346 break;
347 case amb:
348 ss << "AMB " << left << setw(3) << t_lc::toString(_tLC) << right << ' ' << _prn.toString();
349 break;
350 case ion:
351 ss << "ION " << left << setw(3) << t_lc::toString(_tLC) << right << ' ' << _prn.toString();
352 break;
353 case cBiasG1: case pBiasG1:
354 case cBiasG2: case pBiasG2:
355 ss << "BIA " << left << setw(3) << t_lc::toString(_tLC) << right << " G ";
356 break;
357 case cBiasR1: case pBiasR1:
358 case cBiasR2: case pBiasR2:
359 ss << "BIA " << left << setw(3) << t_lc::toString(_tLC) << right << " R ";
360 break;
361 case cBiasE1: case pBiasE1:
362 case cBiasE2: case pBiasE2:
363 ss << "BIA " << left << setw(3) << t_lc::toString(_tLC) << right << " E ";
364 break;
365 case cBiasC1: case pBiasC1:
366 case cBiasC2: case pBiasC2:
367 ss << "BIA " << left << setw(3) << t_lc::toString(_tLC) << right << " C ";
368 break;
369 }
370 return ss.str();
371}
372
373// Constructor
374////////////////////////////////////////////////////////////////////////////
375t_pppParlist::t_pppParlist() {
376}
377
378// Destructor
379////////////////////////////////////////////////////////////////////////////
380t_pppParlist::~t_pppParlist() {
381 _usedSystems.clear();
382
383 vector<t_pppParam*>::iterator it = _params.begin();
384 while (it != _params.end()) {
385 t_pppParam* par = *it;
386 delete par;
387 it = _params.erase(it);
388 }
389}
390
391//
392////////////////////////////////////////////////////////////////////////////
393t_pppParlist::t_pppParlist(const t_pppParlist& old) {
394
395 _usedSystems = old._usedSystems;
396
397 vector<t_pppParam*>::const_iterator it = old.params().begin();
398 while (it != old.params().end()) {
399 const t_pppParam* oldParam = *it;
400 _params.push_back(new t_pppParam(oldParam));
401 }
402}
403
404//
405////////////////////////////////////////////////////////////////////////////
406const t_pppParlist& t_pppParlist::operator= (const t_pppParlist& p) {
407
408 _usedSystems.clear();
409
410 _usedSystems = p._usedSystems;
411
412 vector<t_pppParam*>::iterator it = _params.begin();
413 while (it != _params.end()) {
414 t_pppParam* par = *it;
415 delete par;
416 it = _params.erase(it);
417 }
418
419 for (unsigned jj = 0; jj < p.params().size(); jj++) {
420 t_pppParam* parFrom = p.params()[jj];
421 _params.push_back(new t_pppParam(parFrom));
422 }
423 return *this;
424}
425
426//
427////////////////////////////////////////////////////////////////////////////
428t_irc t_pppParlist::set(const bncTime& epoTime, const std::vector<t_pppSatObs*>& obsVector,
429 const QMap<char, t_pppRefSat*>& refSatMap) {
430
431 // Remove some Parameters
432 // ----------------------
433 vector<t_pppParam*>::iterator it = _params.begin();
434 while (it != _params.end()) {
435 t_pppParam* par = *it;
436
437 bool remove = false;
438
439 if (par->epoSpec()) {
440 remove = true;
441 }
442
443 else if (par->type() == t_pppParam::crdX ||
444 par->type() == t_pppParam::crdY ||
445 par->type() == t_pppParam::crdZ) {
446 if (par->lastObsTime().valid() && (epoTime - par->lastObsTime() > 60.0)) {
447 remove = true;
448 }
449 }
450
451 else if (par->type() == t_pppParam::amb) {
452 if (OPT->_obsModelType == OPT->DCMcodeBias ||
453 OPT->_obsModelType == OPT->DCMphaseBias) {
454 char sys = par->prn().system();
455 t_prn refPrn = (refSatMap[sys])->prn();
456 if (par->lastObsTime().valid() &&
457 ((epoTime - par->lastObsTime() > 1.0) || (par->prn() == refPrn))) {
458 remove = true;
459 }
460 }
461 else {
462 if (par->lastObsTime().valid() && (epoTime - par->lastObsTime() > 60.0)) {
463 remove = true;
464 }
465 }
466 }
467
468 else if (par->type() == t_pppParam::ion) {
469 if (OPT->_obsModelType == OPT->DCMcodeBias ||
470 OPT->_obsModelType == OPT->DCMphaseBias) {
471 if (par->lastObsTime().valid() && (epoTime - par->lastObsTime() > 1.0)) {
472 remove = true;
473 }
474 }
475 else {
476 if (par->lastObsTime().valid() && (epoTime - par->lastObsTime() > 60.0)) {
477 remove = true;
478 }
479 }
480 }
481 if (remove) {
482#ifdef BNC_DEBUG_PPP
483 LOG << "remove " << par->toString() << std::endl;
484#endif
485 delete par;
486 it = _params.erase(it);
487 }
488 else {
489 ++it;
490 }
491 }
492
493 // Check whether parameters have observations
494 // ------------------------------------------
495 for (unsigned ii = 0; ii < _params.size(); ii++) {
496 t_pppParam* par = _params[ii];
497 if (par->prn() == 0) {
498 par->setLastObsTime(epoTime);
499 if (par->firstObsTime().undef()) {
500 par->setFirstObsTime(epoTime);
501 }
502 }
503 else {
504 for (unsigned jj = 0; jj < obsVector.size(); jj++) {
505 const t_pppSatObs* satObs = obsVector[jj];
506 if (satObs->prn() == par->prn()) {
507 par->setLastObsTime(epoTime);
508 if (par->firstObsTime().undef()) {
509 par->setFirstObsTime(epoTime);
510 }
511 break;
512 }
513 }
514 }
515 }
516
517 // Check if ambiguity parameters have observations
518 // -----------------------------------------------
519 if (OPT->_obsModelType == OPT->DCMcodeBias ||
520 OPT->_obsModelType == OPT->DCMphaseBias) {
521 vector<t_pppParam*>::iterator it = _params.begin();
522 while (it != _params.end()) {
523 t_pppParam* par = *it;
524 bool remove = false;
525 if (par->type() == t_pppParam::amb && !par->lastObsTime().valid()) {
526 remove = true;
527 }
528 if (remove) {
529#ifdef BNC_DEBUG_PPP
530 LOG << "remove " << par->toString() << std::endl;
531#endif
532 delete par;
533 it = _params.erase(it);
534 }
535 else {
536 ++it;
537 }
538 }
539 }
540
541 // check which systems have observations
542 // -------------------------------------
543 _usedSystems.clear();
544 for (unsigned jj = 0; jj < obsVector.size(); jj++) {
545 const t_pppSatObs* satObs = obsVector[jj];
546 char sys = satObs->prn().system();
547 if (!_usedSystems.contains(sys)) {
548 _usedSystems.append(sys);
549 }
550 }
551
552 if (_usedSystems.size() > 1 &&
553 !_usedSystems.contains('G')) { // required to setup ISB w. r. t. GPS
554 return failure;
555 }
556
557 // Required Set of Parameters
558 // --------------------------
559 vector<t_pppParam*> required;
560
561 // Coordinates
562 // -----------
563 required.push_back(new t_pppParam(t_pppParam::crdX, t_prn(), t_lc::dummy));
564 required.push_back(new t_pppParam(t_pppParam::crdY, t_prn(), t_lc::dummy));
565 required.push_back(new t_pppParam(t_pppParam::crdZ, t_prn(), t_lc::dummy));
566
567 // Receiver Code Biases
568 // --------------------
569 if (OPT->_obsModelType == OPT->DCMcodeBias) {
570 std::vector<t_lc::type> lc;
571 if (_usedSystems.contains('G')) {
572 lc = OPT->LCs('G');
573 if (std::find(lc.begin(), lc.end(), t_lc::c1) != lc.end()) {
574 required.push_back(new t_pppParam(t_pppParam::cBiasG1, t_prn(), t_lc::c1));
575 }
576 if (std::find(lc.begin(), lc.end(), t_lc::c2) != lc.end()) {
577 required.push_back(new t_pppParam(t_pppParam::cBiasG2, t_prn(), t_lc::c2));
578 }
579 }
580 if (_usedSystems.contains('R')) {
581 lc = OPT->LCs('R');
582 if (std::find(lc.begin(), lc.end(), t_lc::c1) != lc.end()) {
583 required.push_back(new t_pppParam(t_pppParam::cBiasR1, t_prn(), t_lc::c1));
584 }
585 if (std::find(lc.begin(), lc.end(), t_lc::c2) != lc.end()) {
586 required.push_back(new t_pppParam(t_pppParam::cBiasR2, t_prn(), t_lc::c2));
587 }
588 }
589 if (_usedSystems.contains('E')) {
590 lc = OPT->LCs('E');
591 if (std::find(lc.begin(), lc.end(), t_lc::c1) != lc.end()) {
592 required.push_back(new t_pppParam(t_pppParam::cBiasE1, t_prn(), t_lc::c1));
593 }
594 if (std::find(lc.begin(), lc.end(), t_lc::c2) != lc.end()) {
595 required.push_back(new t_pppParam(t_pppParam::cBiasE2, t_prn(), t_lc::c2));
596 }
597 }
598 if (_usedSystems.contains('C')) {
599 lc = OPT->LCs('C');
600 if (std::find(lc.begin(), lc.end(), t_lc::c1) != lc.end()) {
601 required.push_back(new t_pppParam(t_pppParam::cBiasC1, t_prn(), t_lc::c1));
602 }
603 if (std::find(lc.begin(), lc.end(), t_lc::c2) != lc.end()) {
604 required.push_back(new t_pppParam(t_pppParam::cBiasC2, t_prn(), t_lc::c2));
605 }
606 }
607 }
608
609 // Receiver Phase Biases
610 // ---------------------
611 if ((OPT->_obsModelType == OPT->DCMphaseBias) ||
612 (OPT->_obsModelType == OPT->PPPRTK) ) {
613 std::vector<t_lc::type> lc;
614 if (_usedSystems.contains('G')) {
615 lc = OPT->LCs('G');
616 if (std::find(lc.begin(), lc.end(), t_lc::l1) != lc.end()) {
617 required.push_back(new t_pppParam(t_pppParam::pBiasG1, t_prn(), t_lc::l1));
618 }
619 if (std::find(lc.begin(), lc.end(), t_lc::l2) != lc.end()) {
620 required.push_back(new t_pppParam(t_pppParam::pBiasG2, t_prn(), t_lc::l2));
621 }
622 }
623 if (_usedSystems.contains('R')) {
624 lc = OPT->LCs('R');
625 if (std::find(lc.begin(), lc.end(), t_lc::l1) != lc.end()) {
626 required.push_back(new t_pppParam(t_pppParam::pBiasR1, t_prn(), t_lc::l1));
627 }
628 if (std::find(lc.begin(), lc.end(), t_lc::l2) != lc.end()) {
629 required.push_back(new t_pppParam(t_pppParam::pBiasR2, t_prn(), t_lc::l2));
630 }
631
632 }
633 if (_usedSystems.contains('E')) {
634 lc = OPT->LCs('E');
635 if (std::find(lc.begin(), lc.end(), t_lc::l1) != lc.end()) {
636 required.push_back(new t_pppParam(t_pppParam::pBiasE1, t_prn(), t_lc::l1));
637 }
638 if (std::find(lc.begin(), lc.end(), t_lc::l2) != lc.end()) {
639 required.push_back(new t_pppParam(t_pppParam::pBiasE2, t_prn(), t_lc::l2));
640 }
641 }
642 if (_usedSystems.contains('C')) {
643 lc = OPT->LCs('C');
644 if (std::find(lc.begin(), lc.end(), t_lc::l1) != lc.end()) {
645 required.push_back(new t_pppParam(t_pppParam::pBiasC1, t_prn(), t_lc::l1));
646 }
647 if (std::find(lc.begin(), lc.end(), t_lc::l2) != lc.end()) {
648 required.push_back(new t_pppParam(t_pppParam::pBiasC2, t_prn(), t_lc::l2));
649 }
650 }
651 }
652
653 // Receiver Clock
654 // --------------
655 required.push_back(new t_pppParam(t_pppParam::clkR, t_prn(), t_lc::dummy));
656
657 // GPS-GLONASS Clock Offset
658 // ------------------------
659 if (_usedSystems.contains('G') && _usedSystems.contains('R')) {
660 required.push_back(new t_pppParam(t_pppParam::offGR, t_prn(), t_lc::dummy));
661 }
662
663 //GPS-Galileo Clock Offset
664 // ------------------------
665 if (_usedSystems.contains('G') && _usedSystems.contains('E')) {
666 required.push_back(new t_pppParam(t_pppParam::offGE, t_prn(), t_lc::dummy));
667 }
668
669 // GPS-BDS Clock Offset
670 // ------------------------
671 if (_usedSystems.contains('G') && _usedSystems.contains('C')) {
672 required.push_back(new t_pppParam(t_pppParam::offGC, t_prn(), t_lc::dummy));
673 }
674
675 // Troposphere
676 // -----------
677 if (OPT->estTrp()) {
678 required.push_back(new t_pppParam(t_pppParam::trp, t_prn(), t_lc::dummy));
679 }
680
681 // Ionosphere
682 // ----------
683 if (OPT->_obsModelType == OPT->UncombPPP ||
684 OPT->_obsModelType == OPT->DCMcodeBias ||
685 OPT->_obsModelType == OPT->DCMphaseBias ) {
686 for (unsigned jj = 0; jj < obsVector.size(); jj++) {
687 const t_pppSatObs* satObs = obsVector[jj];
688 required.push_back(new t_pppParam(t_pppParam::ion, satObs->prn(), t_lc::dummy));
689 }
690 }
691 // Ambiguities
692 // -----------
693 for (unsigned jj = 0; jj < obsVector.size(); jj++) {
694 const t_pppSatObs* satObs = obsVector[jj];
695 if ((OPT->_obsModelType == OPT->IF) ||
696 (OPT->_obsModelType == OPT->PPPRTK) ||
697 (OPT->_obsModelType == OPT->UncombPPP) ||
698 (OPT->_obsModelType == OPT->DCMcodeBias && !satObs->isReference()) ||
699 (OPT->_obsModelType == OPT->DCMphaseBias && !satObs->isReference()) ) {
700 const vector<t_lc::type>& ambLCs = OPT->ambLCs(satObs->prn().system());
701 for (unsigned ii = 0; ii < ambLCs.size(); ii++) {
702 required.push_back(new t_pppParam(t_pppParam::amb, satObs->prn(), ambLCs[ii], &obsVector));
703 }
704 }
705 }
706
707 // Check if all required parameters are present
708 // --------------------------------------------
709 for (unsigned ii = 0; ii < required.size(); ii++) {
710 t_pppParam* parReq = required[ii];
711
712 bool found = false;
713 for (unsigned jj = 0; jj < _params.size(); jj++) {
714 t_pppParam* parOld = _params[jj];
715 if (parOld->isEqual(parReq)) {
716 found = true;
717 break;
718 }
719 }
720 if (found) {
721 delete parReq;
722 }
723 else {
724#ifdef BNC_DEBUG_PPP
725 LOG << "push_back parReq " << parReq->toString() << std::endl;
726#endif
727 _params.push_back(parReq);
728 }
729 }
730
731 // Set Parameter Indices
732 // ---------------------
733 sort(_params.begin(), _params.end(), t_pppParam::sortFunction);
734
735 for (unsigned ii = 0; ii < _params.size(); ii++) {
736 t_pppParam* par = _params[ii];
737 par->setIndex(ii);
738 for (unsigned jj = 0; jj < obsVector.size(); jj++) {
739 const t_pppSatObs* satObs = obsVector[jj];
740 if (satObs->prn() == par->prn()) {
741 par->setAmbEleSat(satObs->eleSat());
742 par->stepAmbNumEpo();
743 }
744 }
745 }
746
747 return success;
748}
749
750//
751////////////////////////////////////////////////////////////////////////////
752void t_pppParlist::printResult(const bncTime& epoTime, const SymmetricMatrix& QQ,
753 const ColumnVector& xx) const {
754
755 string epoTimeStr = string(epoTime);
756 const t_pppStation* sta = PPP_CLIENT->staRover();
757
758 LOG << endl;
759
760 t_pppParam* parX = 0;
761 t_pppParam* parY = 0;
762 t_pppParam* parZ = 0;
763 vector<t_pppParam*>::const_iterator it = _params.begin();
764 while (it != _params.end()) {
765 t_pppParam* par = *it;
766 if (par->type() == t_pppParam::crdX) {
767 parX = par;
768 }
769 else if (par->type() == t_pppParam::crdY) {
770 parY = par;
771 }
772 else if (par->type() == t_pppParam::crdZ) {
773 parZ = par;
774 }
775 else {
776 int ind = par->indexNew();
777 double apr = (par->type() == t_pppParam::trp) ?
778 t_tropo::delay_saast(sta->xyzApr(), M_PI/2.0) : par->x0();
779 LOG << epoTimeStr << ' ' << par->toString() << ' '
780 << setw(10) << setprecision(4) << apr << ' '
781 << showpos << setw(10) << setprecision(4) << xx[ind] << noshowpos << " +- "
782 << setw(8) << setprecision(4) << sqrt(QQ[ind][ind]);
783 if (par->type() == t_pppParam::amb) {
784 LOG << " el = " << setw(6) << setprecision(2) << par->ambEleSat() * 180.0 / M_PI
785 << " epo = " << setw(4) << par->ambNumEpo();
786 }
787 LOG << endl;
788 }
789 ++it;
790 }
791
792 if (parX && parY && parZ) {
793
794 ColumnVector xyz(3);
795 xyz[0] = xx[parX->indexNew()];
796 xyz[1] = xx[parY->indexNew()];
797 xyz[2] = xx[parZ->indexNew()];
798
799 ColumnVector neu(3);
800 xyz2neu(sta->ellApr().data(), xyz.data(), neu.data());
801
802 SymmetricMatrix QQxyz = QQ.SymSubMatrix(1,3);
803
804 SymmetricMatrix QQneu(3);
805 covariXYZ_NEU(QQxyz, sta->ellApr().data(), QQneu);
806
807 LOG << epoTimeStr << ' ' << sta->name()
808 << " X = " << setprecision(4) << sta->xyzApr()[0] + xyz[0] << " +- "
809 << setprecision(4) << sqrt(QQxyz[0][0])
810
811 << " Y = " << setprecision(4) << sta->xyzApr()[1] + xyz[1] << " +- "
812 << setprecision(4) << sqrt(QQxyz[1][1])
813
814 << " Z = " << setprecision(4) << sta->xyzApr()[2] + xyz[2] << " +- "
815 << setprecision(4) << sqrt(QQxyz[2][2])
816
817 << " dN = " << setprecision(4) << neu[0] << " +- "
818 << setprecision(4) << sqrt(QQneu[0][0])
819
820 << " dE = " << setprecision(4) << neu[1] << " +- "
821 << setprecision(4) << sqrt(QQneu[1][1])
822
823 << " dU = " << setprecision(4) << neu[2] << " +- "
824 << setprecision(4) << sqrt(QQneu[2][2])
825
826 << endl;
827 }
828}
829
Note: See TracBrowser for help on using the repository browser.