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

Last change on this file since 9498 was 9498, 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: 23.0 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// Destructor
135////////////////////////////////////////////////////////////////////////////
136t_pppParam::~t_pppParam() {
137 delete _ambInfo;
138}
139
140//
141////////////////////////////////////////////////////////////////////////////
142double t_pppParam::partial(const bncTime& /* epoTime */, const t_pppSatObs* obs,
143 const t_lc::type& tLC, const t_prn refPrn) const {
144
145 // Special Case - Melbourne-Wuebbena
146 // ---------------------------------
147 if (tLC == t_lc::MW && _type != amb) {
148 return 0.0;
149 }
150
151 const t_pppStation* sta = PPP_CLIENT->staRover();
152 ColumnVector rhoV = sta->xyzApr() - obs->xc().Rows(1,3);
153
154 map<t_frequency::type, double> codeCoeff;
155 map<t_frequency::type, double> phaseCoeff;
156 map<t_frequency::type, double> ionoCoeff;
157 obs->lcCoeff(tLC, codeCoeff, phaseCoeff, ionoCoeff);
158
159 switch (_type) {
160 case crdX:
161 if (tLC == t_lc::GIM || tLC == t_lc::Tz0) {return 0.0;}
162 return (sta->xyzApr()[0] - obs->xc()[0]) / rhoV.NormFrobenius();
163 case crdY:
164 if (tLC == t_lc::GIM || tLC == t_lc::Tz0) {return 0.0;}
165 return (sta->xyzApr()[1] - obs->xc()[1]) / rhoV.NormFrobenius();
166 case crdZ:
167 if (tLC == t_lc::GIM || tLC == t_lc::Tz0) {return 0.0;}
168 return (sta->xyzApr()[2] - obs->xc()[2]) / rhoV.NormFrobenius();
169 case clkR:
170 if (tLC == t_lc::GIM || tLC == t_lc::Tz0) {return 0.0;}
171 return 1.0;
172 case offGR:
173 if (tLC == t_lc::GIM || tLC == t_lc::Tz0) {return 0.0;}
174 return (obs->prn().system() == 'R') ? 1.0 : 0.0;
175 case offGE:
176 if (tLC == t_lc::GIM || tLC == t_lc::Tz0) {return 0.0;}
177 return (obs->prn().system() == 'E') ? 1.0 : 0.0;
178 case offGC:
179 if (tLC == t_lc::GIM || tLC == t_lc::Tz0) {return 0.0;}
180 return (obs->prn().system() == 'C') ? 1.0 : 0.0;
181 case amb:
182 if (tLC == t_lc::GIM || tLC == t_lc::Tz0) {return 0.0;}
183 else if ((OPT->_obsModelType == OPT->IF) ||
184 (OPT->_obsModelType == OPT->PPPRTK) ||
185 (OPT->_obsModelType == OPT->UncombPPP) ||
186 (OPT->_obsModelType == OPT->DCMcodeBias && !obs->isReference()) ||
187 (OPT->_obsModelType == OPT->DCMphaseBias && !obs->isReference()) ) {
188
189 if (obs->prn() == _prn) {
190 if (tLC == _tLC) {
191 return (obs->lambda(tLC));
192 }
193 else if (tLC == t_lc::lIF && _tLC == t_lc::MW) {
194 return obs->lambda(t_lc::lIF) * obs->lambda(t_lc::MW) / obs->lambda(t_lc::l2);
195 }
196 else {
197 if (_tLC == t_lc::l1) {
198 return obs->lambda(t_lc::l1) * phaseCoeff[t_lc::toFreq(obs->prn().system(),t_lc::l1)];
199 }
200 else if (_tLC == t_lc::l2) {
201 return obs->lambda(t_lc::l2) * phaseCoeff[t_lc::toFreq(obs->prn().system(),t_lc::l2)];
202 }
203 }
204 }
205 }
206 break;
207 case trp:
208 if (tLC == t_lc::GIM) {
209 return 0.0;
210 }
211 else if (tLC == t_lc::Tz0) {
212 return 1.0;
213 }
214 else {
215 return 1.0 / sin(obs->eleSat());
216 }
217 case ion:
218 if (obs->prn() == _prn) {
219 if (tLC == t_lc::c1) {
220 return ionoCoeff[t_lc::toFreq(obs->prn().system(),t_lc::c1)];
221 }
222 else if (tLC == t_lc::c2) {
223 return ionoCoeff[t_lc::toFreq(obs->prn().system(),t_lc::c2)];
224 }
225 else if (tLC == t_lc::l1) {
226 return ionoCoeff[t_lc::toFreq(obs->prn().system(),t_lc::l1)];
227 }
228 else if (tLC == t_lc::l2) {
229 return ionoCoeff[t_lc::toFreq(obs->prn().system(),t_lc::l2)];
230 }
231 else if (tLC == t_lc::GIM) {
232 return -1.0;
233 }
234 }
235 if (tLC == t_lc::GIM && _prn == refPrn) {
236 return 1.0;
237 }
238 break;
239 case cBiasG1:
240 if ((obs->prn().system() == 'G') && (tLC == t_lc::c1)) {return 1.0;} else {return 0.0;}
241 break;
242 case cBiasR1:
243 if ((obs->prn().system() == 'R') && (tLC == t_lc::c1)) {return 1.0;} else {return 0.0;}
244 break;
245 case cBiasE1:
246 if ((obs->prn().system() == 'E') && (tLC == t_lc::c1)) {return 1.0;} else {return 0.0;}
247 break;
248 case cBiasC1:
249 if ((obs->prn().system() == 'C') && (tLC == t_lc::c1)) {return 1.0;} else {return 0.0;}
250 break;
251 case cBiasG2:
252 if ((obs->prn().system() == 'G') && (tLC == t_lc::c2)) {return 1.0;} else {return 0.0;}
253 break;
254 case cBiasR2:
255 if ((obs->prn().system() == 'R') && (tLC == t_lc::c2)) {return 1.0;} else {return 0.0;}
256 break;
257 case cBiasE2:
258 if ((obs->prn().system() == 'E') && (tLC == t_lc::c2)) {return 1.0;} else {return 0.0;}
259 break;
260 case cBiasC2:
261 if ((obs->prn().system() == 'C') && (tLC == t_lc::c2)) {return 1.0;} else {return 0.0;}
262 break;
263 case pBiasG1:
264 if ((obs->prn().system() == 'G') && (tLC == t_lc::l1)) {return 1.0;} else {return 0.0;}
265 break;
266 case pBiasR1:
267 if ((obs->prn().system() == 'R') && (tLC == t_lc::l1)) {return 1.0;} else {return 0.0;}
268 break;
269 case pBiasE1:
270 if ((obs->prn().system() == 'E') && (tLC == t_lc::l1)) {return 1.0;} else {return 0.0;}
271 break;
272 case pBiasC1:
273 if ((obs->prn().system() == 'C') && (tLC == t_lc::l1)) {return 1.0;} else {return 0.0;}
274 break;
275 case pBiasG2:
276 if ((obs->prn().system() == 'G') && (tLC == t_lc::l2)) {return 1.0;} else {return 0.0;}
277 break;
278 case pBiasR2:
279 if ((obs->prn().system() == 'R') && (tLC == t_lc::l2)) {return 1.0;} else {return 0.0;}
280 break;
281 case pBiasE2:
282 if ((obs->prn().system() == 'E') && (tLC == t_lc::l2)) {return 1.0;} else {return 0.0;}
283 break;
284 case pBiasC2:
285 if ((obs->prn().system() == 'C') && (tLC == t_lc::l2)) {return 1.0;} else {return 0.0;}
286 break;
287
288 }
289 return 0.0;
290}
291
292//
293////////////////////////////////////////////////////////////////////////////
294string t_pppParam::toString() const {
295 stringstream ss;
296 switch (_type) {
297 case crdX:
298 ss << "CRD_X";
299 break;
300 case crdY:
301 ss << "CRD_Y";
302 break;
303 case crdZ:
304 ss << "CRD_Z";
305 break;
306 case clkR:
307 ss << "REC_CLK ";
308 break;
309 case offGR:
310 ss << "OGR ";
311 break;
312 case offGE:
313 ss << "OGE ";
314 break;
315 case offGC:
316 ss << "OGC ";
317 break;
318 case trp:
319 ss << "TRP ";
320 break;
321 case amb:
322 ss << "AMB " << left << setw(3) << t_lc::toString(_tLC) << right << ' ' << _prn.toString();
323 break;
324 case ion:
325 ss << "ION " << left << setw(3) << t_lc::toString(_tLC) << right << ' ' << _prn.toString();
326 break;
327 case cBiasG1: case pBiasG1:
328 case cBiasG2: case pBiasG2:
329 ss << "BIA " << left << setw(3) << t_lc::toString(_tLC) << right << " G ";
330 break;
331 case cBiasR1: case pBiasR1:
332 case cBiasR2: case pBiasR2:
333 ss << "BIA " << left << setw(3) << t_lc::toString(_tLC) << right << " R ";
334 break;
335 case cBiasE1: case pBiasE1:
336 case cBiasE2: case pBiasE2:
337 ss << "BIA " << left << setw(3) << t_lc::toString(_tLC) << right << " E ";
338 break;
339 case cBiasC1: case pBiasC1:
340 case cBiasC2: case pBiasC2:
341 ss << "BIA " << left << setw(3) << t_lc::toString(_tLC) << right << " C ";
342 break;
343 }
344 return ss.str();
345}
346
347// Constructor
348////////////////////////////////////////////////////////////////////////////
349t_pppParlist::t_pppParlist() {
350}
351
352// Destructor
353////////////////////////////////////////////////////////////////////////////
354t_pppParlist::~t_pppParlist() {
355 for (unsigned ii = 0; ii < _params.size(); ii++) {
356 delete _params[ii];
357 }
358}
359
360//
361////////////////////////////////////////////////////////////////////////////
362t_irc t_pppParlist::set(const bncTime& epoTime, const std::vector<t_pppSatObs*>& obsVector,
363 const QMap<char, t_pppRefSat*>& refSatMap) {
364
365 // Remove some Parameters
366 // ----------------------
367 vector<t_pppParam*>::iterator it = _params.begin();
368 while (it != _params.end()) {
369 t_pppParam* par = *it;
370
371 bool remove = false;
372
373 if (par->epoSpec()) {
374 remove = true;
375 }
376
377 else if (par->type() == t_pppParam::crdX ||
378 par->type() == t_pppParam::crdY ||
379 par->type() == t_pppParam::crdZ) {
380 if (par->lastObsTime().valid() && (epoTime - par->lastObsTime() > 60.0)) {
381 remove = true;
382 }
383 }
384
385 else if (par->type() == t_pppParam::amb) {
386 if (OPT->_obsModelType == OPT->DCMcodeBias ||
387 OPT->_obsModelType == OPT->DCMphaseBias) {
388 t_prn refPrn = (refSatMap[par->prn().system()])->prn();
389 if (par->lastObsTime().valid() &&
390 ((epoTime - par->lastObsTime() > 1.0) || (par->prn() == refPrn))) {
391 remove = true;
392 }
393 }
394 else {
395 if (par->lastObsTime().valid() && (epoTime - par->lastObsTime() > 60.0)) {
396 remove = true;
397 }
398 }
399 }
400
401 else if (par->type() == t_pppParam::ion) {
402 if (OPT->_obsModelType == OPT->DCMcodeBias ||
403 OPT->_obsModelType == OPT->DCMphaseBias) {
404 if (par->lastObsTime().valid() && (epoTime - par->lastObsTime() > 1.0)) {
405 remove = true;
406 }
407 }
408 else {
409 if (par->lastObsTime().valid() && (epoTime - par->lastObsTime() > 60.0)) {
410 remove = true;
411 }
412 }
413 }
414 if (remove) {
415 delete par;
416 it = _params.erase(it);
417 }
418 else {
419 ++it;
420 }
421 }
422
423 // Check whether parameters have observations
424 // ------------------------------------------
425 for (unsigned ii = 0; ii < _params.size(); ii++) {
426 t_pppParam* par = _params[ii];
427 if (par->prn() == 0) {
428 par->setLastObsTime(epoTime);
429 if (par->firstObsTime().undef()) {
430 par->setFirstObsTime(epoTime);
431 }
432 }
433 else {
434 for (unsigned jj = 0; jj < obsVector.size(); jj++) {
435 const t_pppSatObs* satObs = obsVector[jj];
436 if (satObs->prn() == par->prn()) {
437 par->setLastObsTime(epoTime);
438 if (par->firstObsTime().undef()) {
439 par->setFirstObsTime(epoTime);
440 }
441 break;
442 }
443 }
444 }
445 }
446
447 // Check if ambiguity parameters have observations
448 // -----------------------------------------------
449 if (OPT->_obsModelType == OPT->DCMcodeBias ||
450 OPT->_obsModelType == OPT->DCMphaseBias) {
451 vector<t_pppParam*>::iterator it = _params.begin();
452 while (it != _params.end()) {
453 t_pppParam* par = *it;
454 bool remove = false;
455 if (par->type() == t_pppParam::amb && !par->lastObsTime().valid()) {
456 remove = true;
457 }
458 if (remove) {
459 delete par;
460 it = _params.erase(it);
461 }
462 else {
463 ++it;
464 }
465 }
466 }
467
468 // check which systems have observations
469 // -------------------------------------
470 _usedSystems.clear();
471 for (unsigned jj = 0; jj < obsVector.size(); jj++) {
472 const t_pppSatObs* satObs = obsVector[jj];
473 char sys = satObs->prn().system();
474 if (!_usedSystems.contains(sys)) {
475 _usedSystems.append(sys);
476 }
477 }
478
479 if (_usedSystems.size() > 1 &&
480 !_usedSystems.contains('G')) { // required to setup ISB w. r. t. GPS
481 return failure;
482 }
483
484 // Required Set of Parameters
485 // --------------------------
486 vector<t_pppParam*> required;
487
488 // Coordinates
489 // -----------
490 required.push_back(new t_pppParam(t_pppParam::crdX, t_prn(), t_lc::dummy));
491 required.push_back(new t_pppParam(t_pppParam::crdY, t_prn(), t_lc::dummy));
492 required.push_back(new t_pppParam(t_pppParam::crdZ, t_prn(), t_lc::dummy));
493
494 // Receiver Code Biases
495 // --------------------
496 if (OPT->_obsModelType == OPT->DCMcodeBias) {
497 std::vector<t_lc::type> lc;
498 if (_usedSystems.contains('G')) {
499 lc = OPT->LCs('G');
500 if (std::find(lc.begin(), lc.end(), t_lc::c1) != lc.end()) {
501 required.push_back(new t_pppParam(t_pppParam::cBiasG1, t_prn(), t_lc::c1));
502 }
503 if (std::find(lc.begin(), lc.end(), t_lc::c2) != lc.end()) {
504 required.push_back(new t_pppParam(t_pppParam::cBiasG2, t_prn(), t_lc::c2));
505 }
506 }
507 if (_usedSystems.contains('R')) {
508 lc = OPT->LCs('R');
509 if (std::find(lc.begin(), lc.end(), t_lc::c1) != lc.end()) {
510 required.push_back(new t_pppParam(t_pppParam::cBiasR1, t_prn(), t_lc::c1));
511 }
512 if (std::find(lc.begin(), lc.end(), t_lc::c2) != lc.end()) {
513 required.push_back(new t_pppParam(t_pppParam::cBiasR2, t_prn(), t_lc::c2));
514 }
515 }
516 if (_usedSystems.contains('E')) {
517 lc = OPT->LCs('E');
518 if (std::find(lc.begin(), lc.end(), t_lc::c1) != lc.end()) {
519 required.push_back(new t_pppParam(t_pppParam::cBiasE1, t_prn(), t_lc::c1));
520 }
521 if (std::find(lc.begin(), lc.end(), t_lc::c2) != lc.end()) {
522 required.push_back(new t_pppParam(t_pppParam::cBiasE2, t_prn(), t_lc::c2));
523 }
524 }
525 if (_usedSystems.contains('C')) {
526 lc = OPT->LCs('C');
527 if (std::find(lc.begin(), lc.end(), t_lc::c1) != lc.end()) {
528 required.push_back(new t_pppParam(t_pppParam::cBiasC1, t_prn(), t_lc::c1));
529 }
530 if (std::find(lc.begin(), lc.end(), t_lc::c2) != lc.end()) {
531 required.push_back(new t_pppParam(t_pppParam::cBiasC2, t_prn(), t_lc::c2));
532 }
533 }
534 }
535
536 // Receiver Phase Biases
537 // ---------------------
538 if ((OPT->_obsModelType == OPT->DCMphaseBias) ||
539 (OPT->_obsModelType == OPT->PPPRTK) ) {
540 std::vector<t_lc::type> lc;
541 if (_usedSystems.contains('G')) {
542 lc = OPT->LCs('G');
543 if (std::find(lc.begin(), lc.end(), t_lc::l1) != lc.end()) {
544 required.push_back(new t_pppParam(t_pppParam::pBiasG1, t_prn(), t_lc::l1));
545 }
546 if (std::find(lc.begin(), lc.end(), t_lc::l2) != lc.end()) {
547 required.push_back(new t_pppParam(t_pppParam::pBiasG2, t_prn(), t_lc::l2));
548 }
549 }
550 if (_usedSystems.contains('R')) {
551 lc = OPT->LCs('R');
552 if (std::find(lc.begin(), lc.end(), t_lc::l1) != lc.end()) {
553 required.push_back(new t_pppParam(t_pppParam::pBiasR1, t_prn(), t_lc::l1));
554 }
555 if (std::find(lc.begin(), lc.end(), t_lc::l2) != lc.end()) {
556 required.push_back(new t_pppParam(t_pppParam::pBiasR2, t_prn(), t_lc::l2));
557 }
558
559 }
560 if (_usedSystems.contains('E')) {
561 lc = OPT->LCs('E');
562 if (std::find(lc.begin(), lc.end(), t_lc::l1) != lc.end()) {
563 required.push_back(new t_pppParam(t_pppParam::pBiasE1, t_prn(), t_lc::l1));
564 }
565 if (std::find(lc.begin(), lc.end(), t_lc::l2) != lc.end()) {
566 required.push_back(new t_pppParam(t_pppParam::pBiasE2, t_prn(), t_lc::l2));
567 }
568 }
569 if (_usedSystems.contains('C')) {
570 lc = OPT->LCs('C');
571 if (std::find(lc.begin(), lc.end(), t_lc::l1) != lc.end()) {
572 required.push_back(new t_pppParam(t_pppParam::pBiasC1, t_prn(), t_lc::l1));
573 }
574 if (std::find(lc.begin(), lc.end(), t_lc::l2) != lc.end()) {
575 required.push_back(new t_pppParam(t_pppParam::pBiasC2, t_prn(), t_lc::l2));
576 }
577 }
578 }
579
580 // Receiver Clock
581 // --------------
582 required.push_back(new t_pppParam(t_pppParam::clkR, t_prn(), t_lc::dummy));
583
584 // GPS-GLONASS Clock Offset
585 // ------------------------
586 if (_usedSystems.contains('G') && _usedSystems.contains('R')) {
587 required.push_back(new t_pppParam(t_pppParam::offGR, t_prn(), t_lc::dummy));
588 }
589
590 //GPS-Galileo Clock Offset
591 // ------------------------
592 if (_usedSystems.contains('G') && _usedSystems.contains('E')) {
593 required.push_back(new t_pppParam(t_pppParam::offGE, t_prn(), t_lc::dummy));
594 }
595
596 // GPS-BDS Clock Offset
597 // ------------------------
598 if (_usedSystems.contains('G') && _usedSystems.contains('C')) {
599 required.push_back(new t_pppParam(t_pppParam::offGC, t_prn(), t_lc::dummy));
600 }
601
602 // Troposphere
603 // -----------
604 if (OPT->estTrp()) {
605 required.push_back(new t_pppParam(t_pppParam::trp, t_prn(), t_lc::dummy));
606 }
607
608 // Ionosphere
609 // ----------
610 if (OPT->_obsModelType == OPT->UncombPPP ||
611 OPT->_obsModelType == OPT->DCMcodeBias ||
612 OPT->_obsModelType == OPT->DCMphaseBias ) {
613 for (unsigned jj = 0; jj < obsVector.size(); jj++) {
614 const t_pppSatObs* satObs = obsVector[jj];
615 required.push_back(new t_pppParam(t_pppParam::ion, satObs->prn(), t_lc::dummy));
616 }
617 }
618 // Ambiguities
619 // -----------
620 for (unsigned jj = 0; jj < obsVector.size(); jj++) {
621 const t_pppSatObs* satObs = obsVector[jj];
622 if ((OPT->_obsModelType == OPT->IF) ||
623 (OPT->_obsModelType == OPT->PPPRTK) ||
624 (OPT->_obsModelType == OPT->UncombPPP) ||
625 (OPT->_obsModelType == OPT->DCMcodeBias && !satObs->isReference()) ||
626 (OPT->_obsModelType == OPT->DCMphaseBias && !satObs->isReference()) ) {
627 const vector<t_lc::type>& ambLCs = OPT->ambLCs(satObs->prn().system());
628 for (unsigned ii = 0; ii < ambLCs.size(); ii++) {
629 required.push_back(new t_pppParam(t_pppParam::amb, satObs->prn(), ambLCs[ii], &obsVector));
630 }
631 }
632 }
633
634 // Check if all required parameters are present
635 // --------------------------------------------
636 for (unsigned ii = 0; ii < required.size(); ii++) {
637 t_pppParam* parReq = required[ii];
638
639 bool found = false;
640 for (unsigned jj = 0; jj < _params.size(); jj++) {
641 t_pppParam* parOld = _params[jj];
642 if (parOld->isEqual(parReq)) {
643 found = true;
644 break;
645 }
646 }
647 if (found) {
648 delete parReq;
649 }
650 else {
651 _params.push_back(parReq);
652 }
653 }
654
655 // Set Parameter Indices
656 // ---------------------
657 sort(_params.begin(), _params.end(), t_pppParam::sortFunction);
658
659 for (unsigned ii = 0; ii < _params.size(); ii++) {
660 t_pppParam* par = _params[ii];
661 par->setIndex(ii);
662 for (unsigned jj = 0; jj < obsVector.size(); jj++) {
663 const t_pppSatObs* satObs = obsVector[jj];
664 if (satObs->prn() == par->prn()) {
665 par->setAmbEleSat(satObs->eleSat());
666 par->stepAmbNumEpo();
667 }
668 }
669 }
670
671 return success;
672}
673
674//
675////////////////////////////////////////////////////////////////////////////
676void t_pppParlist::printResult(const bncTime& epoTime, const SymmetricMatrix& QQ,
677 const ColumnVector& xx) const {
678
679 string epoTimeStr = string(epoTime);
680 const t_pppStation* sta = PPP_CLIENT->staRover();
681
682 LOG << endl;
683
684 t_pppParam* parX = 0;
685 t_pppParam* parY = 0;
686 t_pppParam* parZ = 0;
687 for (unsigned ii = 0; ii < _params.size(); ii++) {
688 t_pppParam* par = _params[ii];
689 if (par->type() == t_pppParam::crdX) {
690 parX = par;
691 }
692 else if (par->type() == t_pppParam::crdY) {
693 parY = par;
694 }
695 else if (par->type() == t_pppParam::crdZ) {
696 parZ = par;
697 }
698 else {
699 int ind = par->indexNew();
700 double apr = (par->type() == t_pppParam::trp) ?
701 t_tropo::delay_saast(sta->xyzApr(), M_PI/2.0) : par->x0();
702 LOG << epoTimeStr << ' ' << par->toString() << ' '
703 << setw(10) << setprecision(4) << apr << ' '
704 << showpos << setw(10) << setprecision(4) << xx[ind] << noshowpos << " +- "
705 << setw(8) << setprecision(4) << sqrt(QQ[ind][ind]);
706 if (par->type() == t_pppParam::amb) {
707 LOG << " el = " << setw(6) << setprecision(2) << par->ambEleSat() * 180.0 / M_PI
708 << " epo = " << setw(4) << par->ambNumEpo();
709 }
710 LOG << endl;
711 }
712 }
713
714 if (parX && parY && parZ) {
715
716 ColumnVector xyz(3);
717 xyz[0] = xx[parX->indexNew()];
718 xyz[1] = xx[parY->indexNew()];
719 xyz[2] = xx[parZ->indexNew()];
720
721 ColumnVector neu(3);
722 xyz2neu(sta->ellApr().data(), xyz.data(), neu.data());
723
724 SymmetricMatrix QQxyz = QQ.SymSubMatrix(1,3);
725
726 SymmetricMatrix QQneu(3);
727 covariXYZ_NEU(QQxyz, sta->ellApr().data(), QQneu);
728
729 LOG << epoTimeStr << ' ' << sta->name()
730 << " X = " << setprecision(4) << sta->xyzApr()[0] + xyz[0] << " +- "
731 << setprecision(4) << sqrt(QQxyz[0][0])
732
733 << " Y = " << setprecision(4) << sta->xyzApr()[1] + xyz[1] << " +- "
734 << setprecision(4) << sqrt(QQxyz[1][1])
735
736 << " Z = " << setprecision(4) << sta->xyzApr()[2] + xyz[2] << " +- "
737 << setprecision(4) << sqrt(QQxyz[2][2])
738
739 << " dN = " << setprecision(4) << neu[0] << " +- "
740 << setprecision(4) << sqrt(QQneu[0][0])
741
742 << " dE = " << setprecision(4) << neu[1] << " +- "
743 << setprecision(4) << sqrt(QQneu[1][1])
744
745 << " dU = " << setprecision(4) << neu[2] << " +- "
746 << setprecision(4) << sqrt(QQneu[2][2])
747
748 << endl;
749 }
750}
751
Note: See TracBrowser for help on using the repository browser.