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

Last change on this file since 10232 was 10232, checked in by stuerze, 7 months ago
  • 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.3 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 cBiasR1: case cBiasE1: case cBiasC1:
105 case cBiasG2: case cBiasR2: case cBiasE2: case cBiasC2:
106 _epoSpec = false;
107 _sigma0 = OPT->_aprSigCodeBias;
108 _noise = OPT->_noiseCodeBias;
109 break;
110 case pBiasG1: case pBiasR1: case pBiasE1: case pBiasC1:
111 case pBiasG2: case pBiasR2: case pBiasE2: case pBiasC2:
112 _epoSpec = false;
113 _sigma0 = OPT->_aprSigPhaseBias;
114 _noise = OPT->_noisePhaseBias;
115 break;
116 }
117}
118
119// Destructor
120////////////////////////////////////////////////////////////////////////////
121t_pppParam::~t_pppParam() {
122 if (_ambInfo) {
123 delete _ambInfo;
124 }
125}
126//
127////////////////////////////////////////////////////////////////////////////
128double t_pppParam::partial(const bncTime& /* epoTime */, const t_pppSatObs* obs,
129 const t_lc::type& tLC) const {
130
131 // Special Case - Melbourne-Wuebbena
132 // ---------------------------------
133 if (tLC == t_lc::MW && _type != amb) {
134 return 0.0;
135 }
136
137 const t_pppStation* sta = PPP_CLIENT->staRover();
138 ColumnVector rhoV = sta->xyzApr() - obs->xc().Rows(1,3);
139
140 map<t_frequency::type, double> codeCoeff;
141 map<t_frequency::type, double> phaseCoeff;
142 map<t_frequency::type, double> ionoCoeff;
143 obs->lcCoeff(tLC, codeCoeff, phaseCoeff, ionoCoeff);
144
145 switch (_type) {
146 case crdX:
147 if (tLC == t_lc::GIM) {return 0.0;}
148 return (sta->xyzApr()[0] - obs->xc()[0]) / rhoV.NormFrobenius();
149 case crdY:
150 if (tLC == t_lc::GIM) {return 0.0;}
151 return (sta->xyzApr()[1] - obs->xc()[1]) / rhoV.NormFrobenius();
152 case crdZ:
153 if (tLC == t_lc::GIM) {return 0.0;}
154 return (sta->xyzApr()[2] - obs->xc()[2]) / rhoV.NormFrobenius();
155 case rClkG:
156 if (tLC == t_lc::GIM) {return 0.0;}
157 return (obs->prn().system() == 'G') ? 1.0 : 0.0;
158 case rClkR:
159 if (tLC == t_lc::GIM) {return 0.0;}
160 return (obs->prn().system() == 'R') ? 1.0 : 0.0;
161 case rClkE:
162 if (tLC == t_lc::GIM) {return 0.0;}
163 return (obs->prn().system() == 'E') ? 1.0 : 0.0;
164 case rClkC:
165 if (tLC == t_lc::GIM) {return 0.0;}
166 return (obs->prn().system() == 'C') ? 1.0 : 0.0;
167 case amb:
168 if (tLC == t_lc::GIM) {
169 return 0.0;
170 }
171 else {
172 if (obs->prn() == _prn) {
173 if (tLC == _tLC) {
174 return (obs->lambda(tLC));
175 }
176 else if (tLC == t_lc::lIF && _tLC == t_lc::MW) {
177 return obs->lambda(t_lc::lIF) * obs->lambda(t_lc::MW) / obs->lambda(t_lc::l2);
178 }
179 else {
180 if (_tLC == t_lc::l1) {
181 return obs->lambda(t_lc::l1) * phaseCoeff[t_lc::toFreq(obs->prn().system(),t_lc::l1)];
182 }
183 else if (_tLC == t_lc::l2) {
184 return obs->lambda(t_lc::l2) * phaseCoeff[t_lc::toFreq(obs->prn().system(),t_lc::l2)];
185 }
186 }
187 }
188 }
189 break;
190 case trp:
191 if (tLC == t_lc::GIM) {
192 return 0.0;
193 }
194 else {
195 return 1.0 / sin(obs->eleSat());
196 }
197 case ion:
198 if (obs->prn() == _prn) {
199 if (tLC == t_lc::c1) {
200 return ionoCoeff[t_lc::toFreq(obs->prn().system(),t_lc::c1)];
201 }
202 else if (tLC == t_lc::c2) {
203 return ionoCoeff[t_lc::toFreq(obs->prn().system(),t_lc::c2)];
204 }
205 else if (tLC == t_lc::l1) {
206 return ionoCoeff[t_lc::toFreq(obs->prn().system(),t_lc::l1)];
207 }
208 else if (tLC == t_lc::l2) {
209 return ionoCoeff[t_lc::toFreq(obs->prn().system(),t_lc::l2)];
210 }
211 else if (tLC == t_lc::GIM) {
212 return 1.0;
213 }
214 }
215 break;
216 case cBiasG1:
217 if ((obs->prn().system() == 'G') && (tLC == t_lc::c1)) {return 1.0;} else {return 0.0;}
218 break;
219 case cBiasR1:
220 if ((obs->prn().system() == 'R') && (tLC == t_lc::c1)) {return 1.0;} else {return 0.0;}
221 break;
222 case cBiasE1:
223 if ((obs->prn().system() == 'E') && (tLC == t_lc::c1)) {return 1.0;} else {return 0.0;}
224 break;
225 case cBiasC1:
226 if ((obs->prn().system() == 'C') && (tLC == t_lc::c1)) {return 1.0;} else {return 0.0;}
227 break;
228 case cBiasG2:
229 if ((obs->prn().system() == 'G') && (tLC == t_lc::c2)) {return 1.0;} else {return 0.0;}
230 break;
231 case cBiasR2:
232 if ((obs->prn().system() == 'R') && (tLC == t_lc::c2)) {return 1.0;} else {return 0.0;}
233 break;
234 case cBiasE2:
235 if ((obs->prn().system() == 'E') && (tLC == t_lc::c2)) {return 1.0;} else {return 0.0;}
236 break;
237 case cBiasC2:
238 if ((obs->prn().system() == 'C') && (tLC == t_lc::c2)) {return 1.0;} else {return 0.0;}
239 break;
240 case pBiasG1:
241 if ((obs->prn().system() == 'G') && (tLC == t_lc::l1)) {return 1.0;} else {return 0.0;}
242 break;
243 case pBiasR1:
244 if ((obs->prn().system() == 'R') && (tLC == t_lc::l1)) {return 1.0;} else {return 0.0;}
245 break;
246 case pBiasE1:
247 if ((obs->prn().system() == 'E') && (tLC == t_lc::l1)) {return 1.0;} else {return 0.0;}
248 break;
249 case pBiasC1:
250 if ((obs->prn().system() == 'C') && (tLC == t_lc::l1)) {return 1.0;} else {return 0.0;}
251 break;
252 case pBiasG2:
253 if ((obs->prn().system() == 'G') && (tLC == t_lc::l2)) {return 1.0;} else {return 0.0;}
254 break;
255 case pBiasR2:
256 if ((obs->prn().system() == 'R') && (tLC == t_lc::l2)) {return 1.0;} else {return 0.0;}
257 break;
258 case pBiasE2:
259 if ((obs->prn().system() == 'E') && (tLC == t_lc::l2)) {return 1.0;} else {return 0.0;}
260 break;
261 case pBiasC2:
262 if ((obs->prn().system() == 'C') && (tLC == t_lc::l2)) {return 1.0;} else {return 0.0;}
263 break;
264
265 }
266 return 0.0;
267}
268
269//
270////////////////////////////////////////////////////////////////////////////
271string t_pppParam::toString() const {
272 stringstream ss;
273 switch (_type) {
274 case crdX:
275 ss << "CRD_X";
276 break;
277 case crdY:
278 ss << "CRD_Y";
279 break;
280 case crdZ:
281 ss << "CRD_Z";
282 break;
283 case rClkG:
284 ss << "REC_CLK G ";
285 break;
286 case rClkR:
287 ss << "REC_CLK R ";
288 break;
289 case rClkE:
290 ss << "REC_CLK E ";
291 break;
292 case rClkC:
293 ss << "REC_CLK C ";
294 break;
295 case trp:
296 ss << "TRP ";
297 break;
298 case amb:
299 ss << "AMB " << left << setw(3) << t_lc::toString(_tLC) << right << ' ' << _prn.toString();
300 break;
301 case ion:
302 ss << "ION " << left << setw(3) << t_lc::toString(_tLC) << right << ' ' << _prn.toString();
303 break;
304 case cBiasG1: case pBiasG1:
305 case cBiasG2: case pBiasG2:
306 ss << "BIA " << left << setw(3) << t_lc::toString(_tLC) << right << " G ";
307 break;
308 case cBiasR1: case pBiasR1:
309 case cBiasR2: case pBiasR2:
310 ss << "BIA " << left << setw(3) << t_lc::toString(_tLC) << right << " R ";
311 break;
312 case cBiasE1: case pBiasE1:
313 case cBiasE2: case pBiasE2:
314 ss << "BIA " << left << setw(3) << t_lc::toString(_tLC) << right << " E ";
315 break;
316 case cBiasC1: case pBiasC1:
317 case cBiasC2: case pBiasC2:
318 ss << "BIA " << left << setw(3) << t_lc::toString(_tLC) << right << " C ";
319 break;
320 }
321 return ss.str();
322}
323
324// Constructor
325////////////////////////////////////////////////////////////////////////////
326t_pppParlist::t_pppParlist() {
327}
328
329// Destructor
330////////////////////////////////////////////////////////////////////////////
331t_pppParlist::~t_pppParlist() {
332 _usedSystems.clear();
333
334 for (unsigned ii = 0; ii < _params.size(); ii++) {
335 delete _params[ii];
336 }
337}
338
339//
340////////////////////////////////////////////////////////////////////////////
341t_irc t_pppParlist::set(const bncTime& epoTime, const std::vector<t_pppSatObs*>& obsVector) {
342
343 // Remove some Parameters
344 // ----------------------
345 vector<t_pppParam*>::iterator it = _params.begin();
346 while (it != _params.end()) {
347 t_pppParam* par = *it;
348
349 bool remove = false;
350
351 if (par->epoSpec()) {
352 remove = true;
353 }
354
355 else if (par->type() == t_pppParam::amb ||
356 par->type() == t_pppParam::crdX ||
357 par->type() == t_pppParam::crdY ||
358 par->type() == t_pppParam::crdZ) {
359 if (par->lastObsTime().valid() && (epoTime - par->lastObsTime() > 60.0)) {
360 remove = true;
361 }
362 }
363 else if (par->type() == t_pppParam::ion) {
364 if (par->lastObsTime().valid() && (epoTime - par->lastObsTime() > 5.0)) {
365 remove = true;
366 }
367}
368
369 if (remove) {
370#ifdef BNC_DEBUG_PPP
371// LOG << "remove0 " << par->toString() << std::endl;
372#endif
373 delete par;
374 it = _params.erase(it);
375 }
376 else {
377 ++it;
378 }
379 }
380
381 // check which systems have observations
382 // -------------------------------------
383 _usedSystems.clear();
384 for (unsigned jj = 0; jj < obsVector.size(); jj++) {
385 const t_pppSatObs* satObs = obsVector[jj];
386 char sys = satObs->prn().system();
387 if (!_usedSystems.contains(sys)) {
388 _usedSystems.append(sys);
389 }
390 }
391
392 // Check whether parameters have observations
393 // ------------------------------------------
394 for (unsigned ii = 0; ii < _params.size(); ii++) {
395 t_pppParam* par = _params[ii];
396 if (par->prn() == 0) {
397 par->setLastObsTime(epoTime);
398 if (par->firstObsTime().undef()) {
399 par->setFirstObsTime(epoTime);
400 }
401 }
402 else {
403 for (unsigned jj = 0; jj < obsVector.size(); jj++) {
404 const t_pppSatObs* satObs = obsVector[jj];
405 if (satObs->prn() == par->prn()) {
406 par->setLastObsTime(epoTime);
407 if (par->firstObsTime().undef()) {
408 par->setFirstObsTime(epoTime);
409 }
410 break;
411 }
412 }
413 }
414 }
415
416 if (OPT->_obsModelType == OPT->PPPRTK || OPT->_pseudoObsIono) {
417 vector<t_pppParam*>::iterator it = _params.begin();
418 while (it != _params.end()) {
419 t_pppParam* par = *it;
420 // Check if systems have to be presented per biases
421 // ----------------------------------------------
422 if (( par->type() == t_pppParam::cBiasG1 ||
423 par->type() == t_pppParam::cBiasG2 ||
424 par->type() == t_pppParam::pBiasG1 ||
425 par->type() == t_pppParam::pBiasG2) && !usedSystems().contains('G')) {
426#ifdef BNC_DEBUG_PPP
427 //LOG << "remove1 " << par->toString() << std::endl;
428#endif
429 delete par;
430 it = _params.erase(it);
431 }
432 else if ((par->type() == t_pppParam::cBiasR1 ||
433 par->type() == t_pppParam::cBiasR2 ||
434 par->type() == t_pppParam::pBiasR1 ||
435 par->type() == t_pppParam::pBiasR2) && !usedSystems().contains('R')) {
436#ifdef BNC_DEBUG_PPP
437 //LOG << "remove1 " << par->toString() << std::endl;
438#endif
439 delete par;
440 it = _params.erase(it);
441 }
442 else if ((par->type() == t_pppParam::cBiasE1 ||
443 par->type() == t_pppParam::cBiasE2 ||
444 par->type() == t_pppParam::pBiasE1 ||
445 par->type() == t_pppParam::pBiasE2) && !usedSystems().contains('E')) {
446#ifdef BNC_DEBUG_PPP
447 //LOG << "remove1 " << par->toString() << std::endl;
448#endif
449 delete par;
450 it = _params.erase(it);
451 }
452 else if ((par->type() == t_pppParam::cBiasC1 ||
453 par->type() == t_pppParam::cBiasC2 ||
454 par->type() == t_pppParam::pBiasC1 ||
455 par->type() == t_pppParam::pBiasC2) && !usedSystems().contains('C')) {
456#ifdef BNC_DEBUG_PPP
457 //LOG << "remove1 " << par->toString() << std::endl;
458#endif
459 delete par;
460 it = _params.erase(it);
461 }
462 else {
463 ++it;
464 }
465 }
466 }
467
468 // Required Set of Parameters
469 // --------------------------
470 vector<t_pppParam*> required;
471
472 // Coordinates
473 // -----------
474 required.push_back(new t_pppParam(t_pppParam::crdX, t_prn(), t_lc::dummy));
475 required.push_back(new t_pppParam(t_pppParam::crdY, t_prn(), t_lc::dummy));
476 required.push_back(new t_pppParam(t_pppParam::crdZ, t_prn(), t_lc::dummy));
477
478 // Receiver Clocks
479 // ---------------
480 if (_usedSystems.contains('G')) {
481 required.push_back(new t_pppParam(t_pppParam::rClkG, t_prn(), t_lc::dummy));
482 }
483
484 if (_usedSystems.contains('R')) {
485 required.push_back(new t_pppParam(t_pppParam::rClkR, t_prn(), t_lc::dummy));
486 }
487
488 if (_usedSystems.contains('E')) {
489 required.push_back(new t_pppParam(t_pppParam::rClkE, t_prn(), t_lc::dummy));
490 }
491
492 if (_usedSystems.contains('C')) {
493 required.push_back(new t_pppParam(t_pppParam::rClkC, t_prn(), t_lc::dummy));
494 }
495
496 // Troposphere
497 // -----------
498 if (OPT->estTrp()) {
499 required.push_back(new t_pppParam(t_pppParam::trp, t_prn(), t_lc::dummy));
500 }
501
502 // Ionosphere
503 // ----------
504 if (OPT->_obsModelType == OPT->UncombPPP) {
505 for (unsigned jj = 0; jj < obsVector.size(); jj++) {
506 const t_pppSatObs* satObs = obsVector[jj];
507 required.push_back(new t_pppParam(t_pppParam::ion, satObs->prn(), t_lc::dummy));
508 }
509 }
510 // Ambiguities
511 // -----------
512 for (unsigned jj = 0; jj < obsVector.size(); jj++) {
513 const t_pppSatObs* satObs = obsVector[jj];
514 const vector<t_lc::type>& ambLCs = OPT->ambLCs(satObs->prn().system());
515 for (unsigned ii = 0; ii < ambLCs.size(); ii++) {
516 required.push_back(new t_pppParam(t_pppParam::amb, satObs->prn(), ambLCs[ii], &obsVector));
517 }
518 }
519
520 // Receiver Code Biases
521 // --------------------
522 if (OPT->_obsModelType == OPT->PPPRTK) {
523 std::vector<t_lc::type> lc;
524 if (_usedSystems.contains('G')) {
525 lc = OPT->LCs('G');
526 if (std::find(lc.begin(), lc.end(), t_lc::c1) != lc.end()) {
527 required.push_back(new t_pppParam(t_pppParam::cBiasG1, t_prn(), t_lc::c1));
528 }
529 if (std::find(lc.begin(), lc.end(), t_lc::c2) != lc.end()) {
530 required.push_back(new t_pppParam(t_pppParam::cBiasG2, t_prn(), t_lc::c2));
531 }
532 }
533 if (_usedSystems.contains('R')) {
534 lc = OPT->LCs('R');
535 if (std::find(lc.begin(), lc.end(), t_lc::c1) != lc.end()) {
536 required.push_back(new t_pppParam(t_pppParam::cBiasR1, t_prn(), t_lc::c1));
537 }
538 if (std::find(lc.begin(), lc.end(), t_lc::c2) != lc.end()) {
539 required.push_back(new t_pppParam(t_pppParam::cBiasR2, t_prn(), t_lc::c2));
540 }
541 }
542 if (_usedSystems.contains('E')) {
543 lc = OPT->LCs('E');
544 if (std::find(lc.begin(), lc.end(), t_lc::c1) != lc.end()) {
545 required.push_back(new t_pppParam(t_pppParam::cBiasE1, t_prn(), t_lc::c1));
546 }
547 if (std::find(lc.begin(), lc.end(), t_lc::c2) != lc.end()) {
548 required.push_back(new t_pppParam(t_pppParam::cBiasE2, t_prn(), t_lc::c2));
549 }
550 }
551 if (_usedSystems.contains('C')) {
552 lc = OPT->LCs('C');
553 if (std::find(lc.begin(), lc.end(), t_lc::c1) != lc.end()) {
554 required.push_back(new t_pppParam(t_pppParam::cBiasC1, t_prn(), t_lc::c1));
555 }
556 if (std::find(lc.begin(), lc.end(), t_lc::c2) != lc.end()) {
557 required.push_back(new t_pppParam(t_pppParam::cBiasC2, t_prn(), t_lc::c2));
558 }
559 }
560 }
561 if (OPT->_pseudoObsIono) {
562 std::vector<t_lc::type> lc;
563 if (_usedSystems.contains('G')) {
564 lc = OPT->LCs('G');
565 if (std::find(lc.begin(), lc.end(), t_lc::c2) != lc.end()) {
566 required.push_back(new t_pppParam(t_pppParam::cBiasG2, t_prn(), t_lc::c2));
567 }
568 }
569 if (_usedSystems.contains('R')) {
570 lc = OPT->LCs('R');
571 if (std::find(lc.begin(), lc.end(), t_lc::c2) != lc.end()) {
572 required.push_back(new t_pppParam(t_pppParam::cBiasR2, t_prn(), t_lc::c2));
573 }
574 }
575 if (_usedSystems.contains('E')) {
576 lc = OPT->LCs('E');
577 if (std::find(lc.begin(), lc.end(), t_lc::c2) != lc.end()) {
578 required.push_back(new t_pppParam(t_pppParam::cBiasE2, t_prn(), t_lc::c2));
579 }
580 }
581 if (_usedSystems.contains('C')) {
582 lc = OPT->LCs('C');
583 if (std::find(lc.begin(), lc.end(), t_lc::c2) != lc.end()) {
584 required.push_back(new t_pppParam(t_pppParam::cBiasC2, t_prn(), t_lc::c2));
585 }
586 }
587 }
588
589 // Receiver Phase Biases
590 // ---------------------
591 if (OPT->_obsModelType == OPT->PPPRTK) {
592 std::vector<t_lc::type> lc;
593 if (_usedSystems.contains('G')) {
594 lc = OPT->LCs('G');
595 if (std::find(lc.begin(), lc.end(), t_lc::l1) != lc.end()) {
596 required.push_back(new t_pppParam(t_pppParam::pBiasG1, t_prn(), t_lc::l1));
597 }
598 if (std::find(lc.begin(), lc.end(), t_lc::l2) != lc.end()) {
599 required.push_back(new t_pppParam(t_pppParam::pBiasG2, t_prn(), t_lc::l2));
600 }
601 }
602 if (_usedSystems.contains('R')) {
603 lc = OPT->LCs('R');
604 if (std::find(lc.begin(), lc.end(), t_lc::l1) != lc.end()) {
605 required.push_back(new t_pppParam(t_pppParam::pBiasR1, t_prn(), t_lc::l1));
606 }
607 if (std::find(lc.begin(), lc.end(), t_lc::l2) != lc.end()) {
608 required.push_back(new t_pppParam(t_pppParam::pBiasR2, t_prn(), t_lc::l2));
609 }
610 }
611 if (_usedSystems.contains('E')) {
612 lc = OPT->LCs('E');
613 if (std::find(lc.begin(), lc.end(), t_lc::l1) != lc.end()) {
614 required.push_back(new t_pppParam(t_pppParam::pBiasE1, t_prn(), t_lc::l1));
615 }
616 if (std::find(lc.begin(), lc.end(), t_lc::l2) != lc.end()) {
617 required.push_back(new t_pppParam(t_pppParam::pBiasE2, t_prn(), t_lc::l2));
618 }
619 }
620 if (_usedSystems.contains('C')) {
621 lc = OPT->LCs('C');
622 if (std::find(lc.begin(), lc.end(), t_lc::l1) != lc.end()) {
623 required.push_back(new t_pppParam(t_pppParam::pBiasC1, t_prn(), t_lc::l1));
624 }
625 if (std::find(lc.begin(), lc.end(), t_lc::l2) != lc.end()) {
626 required.push_back(new t_pppParam(t_pppParam::pBiasC2, t_prn(), t_lc::l2));
627 }
628 }
629 }
630
631 // Check if all required parameters are present
632 // --------------------------------------------
633 for (unsigned ii = 0; ii < required.size(); ii++) {
634 t_pppParam* parReq = required[ii];
635
636 bool found = false;
637 for (unsigned jj = 0; jj < _params.size(); jj++) {
638 t_pppParam* parOld = _params[jj];
639 if (parOld->isEqual(parReq)) {
640 found = true;
641 break;
642 }
643 }
644 if (found) {
645 delete parReq;
646 }
647 else {
648#ifdef BNC_DEBUG_PPP
649 //LOG << "push_back parReq " << parReq->toString() << std::endl;
650#endif
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 return;
751}
752
753//
754////////////////////////////////////////////////////////////////////////////
755void t_pppParlist::printParams(const bncTime& epoTime) {
756
757 for (unsigned iPar = 0; iPar < _params.size(); iPar++) {
758 LOG << _params[iPar]->toString()
759 << "\t lastObsTime().valid() \t" << _params[iPar]->lastObsTime().valid()
760 << "\t epoTime - par->lastObsTime() \t" << (epoTime - _params[iPar]->lastObsTime())
761 << endl;
762 }
763}
764
Note: See TracBrowser for help on using the repository browser.