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

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