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

Last change on this file since 10373 was 10373, checked in by stuerze, 17 months ago

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