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

Last change on this file since 10319 was 10319, checked in by stuerze, 5 months ago

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