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

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