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

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