Context Navigation

pppParlist.cpp@ 10123

Last change on this file since 10123 was 10034, checked in by stuerze, 3 years 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: 24.0 KB

Line
1	/* -------------------------------------------------------------------------
2	* BKG NTRIP Client
3	* -------------------------------------------------------------------------
4	*
5	* Class: t_pppParlist
6	*
7	* Purpose: List of estimated parameters
8	*
9	* Author: L. Mervart
10	*
11	* Created: 29-Jul-2014
12	*
13	* Changes:
14	*
15	* -----------------------------------------------------------------------*/
16
17	#include <cmath>
18	#include <iostream>
19	#include <sstream>
20	#include <iomanip>
21	#include <algorithm>
22	#include <newmatio.h>
23
24	#include "pppParlist.h"
25	#include "pppSatObs.h"
26	#include "pppStation.h"
27	#include "bncutils.h"
28	#include "bncconst.h"
29	#include "pppClient.h"
30
31	using namespace BNC_PPP;
32	using namespace std;
33
34	// Constructor
35	////////////////////////////////////////////////////////////////////////////
36	t_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 clkR:
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;
77	if (_prn.system() == 'R' && tLC != t_lc::MW) {
78	offGlo = PPP_CLIENT->offGlo();
79	}
80	double offGal = 0;
81	if (_prn.system() == 'E' && tLC != t_lc::MW) {
82	offGal = PPP_CLIENT->offGal();
83	}
84	double offBds = 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->_aprSigClk;
97	_x0 = PPP_CLIENT->offGlo();
98	break;
99	case offGal:
100	_epoSpec = true;
101	_sigma0 = OPT->_aprSigClk;
102	_x0 = PPP_CLIENT->offGal();
103	break;
104	case offBds:
105	_epoSpec = true;
106	_sigma0 = OPT->_aprSigClk;
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	////////////////////////////////////////////////////////////////////////////
136	t_pppParam::~t_pppParam() {
137	if (_ambInfo) {
138	delete _ambInfo;
139	}
140	}
141	//
142	////////////////////////////////////////////////////////////////////////////
143	double 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 clkR:
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[t_lc::toFreq(obs->prn().system(),t_lc::l1)];
197	}
198	else if (_tLC == t_lc::l2) {
199	return obs->lambda(t_lc::l2) * phaseCoeff[t_lc::toFreq(obs->prn().system(),t_lc::l2)];
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[t_lc::toFreq(obs->prn().system(),t_lc::c1)];
216	}
217	else if (tLC == t_lc::c2) {
218	return ionoCoeff[t_lc::toFreq(obs->prn().system(),t_lc::c2)];
219	}
220	else if (tLC == t_lc::l1) {
221	return ionoCoeff[t_lc::toFreq(obs->prn().system(),t_lc::l1)];
222	}
223	else if (tLC == t_lc::l2) {
224	return ionoCoeff[t_lc::toFreq(obs->prn().system(),t_lc::l2)];
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	////////////////////////////////////////////////////////////////////////////
286	string 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 clkR:
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	////////////////////////////////////////////////////////////////////////////
341	t_pppParlist::t_pppParlist() {
342	}
343
344	// Destructor
345	////////////////////////////////////////////////////////////////////////////
346	t_pppParlist::~t_pppParlist() {
347	_usedSystems.clear();
348
349	for (unsigned ii = 0; ii < _params.size(); ii++) {
350	delete _params[ii];
351	}
352	}
353
354	//
355	////////////////////////////////////////////////////////////////////////////
356	t_irc t_pppParlist::set(const bncTime& epoTime, const std::vector<t_pppSatObs*>& obsVector) {
357
358	// Remove some Parameters
359	// ----------------------
360	vector<t_pppParam*>::iterator it = _params.begin();
361	while (it != _params.end()) {
362	t_pppParam* par = *it;
363
364	bool remove = false;
365
366	if (par->epoSpec()) {
367	remove = true;
368	}
369
370	else if (par->type() == t_pppParam::amb \|\|
371	par->type() == t_pppParam::ion \|\|
372	par->type() == t_pppParam::crdX \|\|
373	par->type() == t_pppParam::crdY \|\|
374	par->type() == t_pppParam::crdZ) {
375	if (par->lastObsTime().valid() && (epoTime - par->lastObsTime() > 60.0)) {
376	remove = true;
377	}
378	}
379
380	if (remove) {
381	#ifdef BNC_DEBUG_PPP
382	// LOG << "remove0 " << par->toString() << std::endl;
383	#endif
384	delete par;
385	it = _params.erase(it);
386	}
387	else {
388	++it;
389	}
390	}
391
392	// check which systems have observations
393	// -------------------------------------
394	_usedSystems.clear();
395	for (unsigned jj = 0; jj < obsVector.size(); jj++) {
396	const t_pppSatObs* satObs = obsVector[jj];
397	char sys = satObs->prn().system();
398	if (!_usedSystems.contains(sys)) {
399	_usedSystems.append(sys);
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	if (OPT->_obsModelType == OPT->PPPRTK \|\| OPT->_pseudoObsIono) {
428	vector<t_pppParam*>::iterator it = _params.begin();
429	while (it != _params.end()) {
430	t_pppParam* par = *it;
431	// Check if systems have to be presented per biases
432	// ----------------------------------------------
433	if (( par->type() == t_pppParam::cBiasG1 \|\|
434	par->type() == t_pppParam::cBiasG2 \|\|
435	par->type() == t_pppParam::pBiasG1 \|\|
436	par->type() == t_pppParam::pBiasG2) && !usedSystems().contains('G')) {
437	#ifdef BNC_DEBUG_PPP
438	//LOG << "remove1 " << par->toString() << std::endl;
439	#endif
440	delete par;
441	it = _params.erase(it);
442	}
443	else if ((par->type() == t_pppParam::cBiasR1 \|\|
444	par->type() == t_pppParam::cBiasR2 \|\|
445	par->type() == t_pppParam::pBiasR1 \|\|
446	par->type() == t_pppParam::pBiasR2) && !usedSystems().contains('R')) {
447	#ifdef BNC_DEBUG_PPP
448	//LOG << "remove1 " << par->toString() << std::endl;
449	#endif
450	delete par;
451	it = _params.erase(it);
452	}
453	else if ((par->type() == t_pppParam::cBiasE1 \|\|
454	par->type() == t_pppParam::cBiasE2 \|\|
455	par->type() == t_pppParam::pBiasE1 \|\|
456	par->type() == t_pppParam::pBiasE2) && !usedSystems().contains('E')) {
457	#ifdef BNC_DEBUG_PPP
458	//LOG << "remove1 " << par->toString() << std::endl;
459	#endif
460	delete par;
461	it = _params.erase(it);
462	}
463	else if ((par->type() == t_pppParam::cBiasC1 \|\|
464	par->type() == t_pppParam::cBiasC2 \|\|
465	par->type() == t_pppParam::pBiasC1 \|\|
466	par->type() == t_pppParam::pBiasC2) && !usedSystems().contains('C')) {
467	#ifdef BNC_DEBUG_PPP
468	//LOG << "remove1 " << par->toString() << std::endl;
469	#endif
470	delete par;
471	it = _params.erase(it);
472	}
473	else {
474	++it;
475	}
476	}
477	}
478
479	// Required Set of Parameters
480	// --------------------------
481	vector<t_pppParam*> required;
482
483	// Coordinates
484	// -----------
485	required.push_back(new t_pppParam(t_pppParam::crdX, t_prn(), t_lc::dummy));
486	required.push_back(new t_pppParam(t_pppParam::crdY, t_prn(), t_lc::dummy));
487	required.push_back(new t_pppParam(t_pppParam::crdZ, t_prn(), t_lc::dummy));
488
489	// Receiver Clock
490	// --------------
491	required.push_back(new t_pppParam(t_pppParam::clkR, t_prn(), t_lc::dummy));
492
493	// GLONASS Clock Offset
494	// --------------------
495	if ( _usedSystems.contains('R') &&
496	(_usedSystems.contains('G') \|\| _usedSystems.contains('E') \|\| _usedSystems.contains('C'))) {
497	required.push_back(new t_pppParam(t_pppParam::offGlo, t_prn(), t_lc::dummy));
498	}
499
500	// Galileo Clock Offset
501	// --------------------
502	if (_usedSystems.contains('E') && _usedSystems.contains('G')) {
503	required.push_back(new t_pppParam(t_pppParam::offGal, t_prn(), t_lc::dummy));
504	}
505
506	// BDS Clock Offset
507	// ----------------
508	if (_usedSystems.contains('C') && (_usedSystems.contains('G') \|\| _usedSystems.contains('E'))) {
509	required.push_back(new t_pppParam(t_pppParam::offBds, t_prn(), t_lc::dummy));
510	}
511
512	// Troposphere
513	// -----------
514	if (OPT->estTrp()) {
515	required.push_back(new t_pppParam(t_pppParam::trp, t_prn(), t_lc::dummy));
516	}
517
518	// Ionosphere
519	// ----------
520	if (OPT->_obsModelType == OPT->UncombPPP) {
521	for (unsigned jj = 0; jj < obsVector.size(); jj++) {
522	const t_pppSatObs* satObs = obsVector[jj];
523	required.push_back(new t_pppParam(t_pppParam::ion, satObs->prn(), t_lc::dummy));
524	}
525	}
526	// Ambiguities
527	// -----------
528	for (unsigned jj = 0; jj < obsVector.size(); jj++) {
529	const t_pppSatObs* satObs = obsVector[jj];
530	const vector<t_lc::type>& ambLCs = OPT->ambLCs(satObs->prn().system());
531	for (unsigned ii = 0; ii < ambLCs.size(); ii++) {
532	required.push_back(new t_pppParam(t_pppParam::amb, satObs->prn(), ambLCs[ii], &obsVector));
533	}
534	}
535
536	// Receiver Code Biases
537	// --------------------
538	if (OPT->_obsModelType == OPT->PPPRTK) {
539	std::vector<t_lc::type> lc;
540	if (_usedSystems.contains('G')) {
541	lc = OPT->LCs('G');
542	if (std::find(lc.begin(), lc.end(), t_lc::c1) != lc.end()) {
543	required.push_back(new t_pppParam(t_pppParam::cBiasG1, t_prn(), t_lc::c1));
544	}
545	if (std::find(lc.begin(), lc.end(), t_lc::c2) != lc.end()) {
546	required.push_back(new t_pppParam(t_pppParam::cBiasG2, t_prn(), t_lc::c2));
547	}
548	}
549	if (_usedSystems.contains('R')) {
550	lc = OPT->LCs('R');
551	if (std::find(lc.begin(), lc.end(), t_lc::c1) != lc.end()) {
552	required.push_back(new t_pppParam(t_pppParam::cBiasR1, t_prn(), t_lc::c1));
553	}
554	if (std::find(lc.begin(), lc.end(), t_lc::c2) != lc.end()) {
555	required.push_back(new t_pppParam(t_pppParam::cBiasR2, t_prn(), t_lc::c2));
556	}
557	}
558	if (_usedSystems.contains('E')) {
559	lc = OPT->LCs('E');
560	if (std::find(lc.begin(), lc.end(), t_lc::c1) != lc.end()) {
561	required.push_back(new t_pppParam(t_pppParam::cBiasE1, t_prn(), t_lc::c1));
562	}
563	if (std::find(lc.begin(), lc.end(), t_lc::c2) != lc.end()) {
564	required.push_back(new t_pppParam(t_pppParam::cBiasE2, t_prn(), t_lc::c2));
565	}
566	}
567	if (_usedSystems.contains('C')) {
568	lc = OPT->LCs('C');
569	if (std::find(lc.begin(), lc.end(), t_lc::c1) != lc.end()) {
570	required.push_back(new t_pppParam(t_pppParam::cBiasC1, t_prn(), t_lc::c1));
571	}
572	if (std::find(lc.begin(), lc.end(), t_lc::c2) != lc.end()) {
573	required.push_back(new t_pppParam(t_pppParam::cBiasC2, t_prn(), t_lc::c2));
574	}
575	}
576	}
577	if (OPT->_pseudoObsIono) {
578	std::vector<t_lc::type> lc;
579	if (_usedSystems.contains('G')) {
580	lc = OPT->LCs('G');
581	if (std::find(lc.begin(), lc.end(), t_lc::c2) != lc.end()) {
582	required.push_back(new t_pppParam(t_pppParam::cBiasG2, t_prn(), t_lc::c2));
583	}
584	}
585	if (_usedSystems.contains('R')) {
586	lc = OPT->LCs('R');
587	if (std::find(lc.begin(), lc.end(), t_lc::c2) != lc.end()) {
588	required.push_back(new t_pppParam(t_pppParam::cBiasR2, t_prn(), t_lc::c2));
589	}
590	}
591	if (_usedSystems.contains('E')) {
592	lc = OPT->LCs('E');
593	if (std::find(lc.begin(), lc.end(), t_lc::c2) != lc.end()) {
594	required.push_back(new t_pppParam(t_pppParam::cBiasE2, t_prn(), t_lc::c2));
595	}
596	}
597	if (_usedSystems.contains('C')) {
598	lc = OPT->LCs('C');
599	if (std::find(lc.begin(), lc.end(), t_lc::c2) != lc.end()) {
600	required.push_back(new t_pppParam(t_pppParam::cBiasC2, t_prn(), t_lc::c2));
601	}
602	}
603	}
604
605	// Receiver Phase Biases
606	// ---------------------
607	if (OPT->_obsModelType == OPT->PPPRTK) {
608	std::vector<t_lc::type> lc;
609	if (_usedSystems.contains('G')) {
610	lc = OPT->LCs('G');
611	if (std::find(lc.begin(), lc.end(), t_lc::l1) != lc.end()) {
612	required.push_back(new t_pppParam(t_pppParam::pBiasG1, t_prn(), t_lc::l1));
613	}
614	if (std::find(lc.begin(), lc.end(), t_lc::l2) != lc.end()) {
615	required.push_back(new t_pppParam(t_pppParam::pBiasG2, t_prn(), t_lc::l2));
616	}
617	}
618	if (_usedSystems.contains('R')) {
619	lc = OPT->LCs('R');
620	if (std::find(lc.begin(), lc.end(), t_lc::l1) != lc.end()) {
621	required.push_back(new t_pppParam(t_pppParam::pBiasR1, t_prn(), t_lc::l1));
622	}
623	if (std::find(lc.begin(), lc.end(), t_lc::l2) != lc.end()) {
624	required.push_back(new t_pppParam(t_pppParam::pBiasR2, t_prn(), t_lc::l2));
625	}
626	}
627	if (_usedSystems.contains('E')) {
628	lc = OPT->LCs('E');
629	if (std::find(lc.begin(), lc.end(), t_lc::l1) != lc.end()) {
630	required.push_back(new t_pppParam(t_pppParam::pBiasE1, t_prn(), t_lc::l1));
631	}
632	if (std::find(lc.begin(), lc.end(), t_lc::l2) != lc.end()) {
633	required.push_back(new t_pppParam(t_pppParam::pBiasE2, t_prn(), t_lc::l2));
634	}
635	}
636	if (_usedSystems.contains('C')) {
637	lc = OPT->LCs('C');
638	if (std::find(lc.begin(), lc.end(), t_lc::l1) != lc.end()) {
639	required.push_back(new t_pppParam(t_pppParam::pBiasC1, t_prn(), t_lc::l1));
640	}
641	if (std::find(lc.begin(), lc.end(), t_lc::l2) != lc.end()) {
642	required.push_back(new t_pppParam(t_pppParam::pBiasC2, t_prn(), t_lc::l2));
643	}
644	}
645	}
646
647	// Check if all required parameters are present
648	// --------------------------------------------
649	for (unsigned ii = 0; ii < required.size(); ii++) {
650	t_pppParam* parReq = required[ii];
651
652	bool found = false;
653	for (unsigned jj = 0; jj < _params.size(); jj++) {
654	t_pppParam* parOld = _params[jj];
655	if (parOld->isEqual(parReq)) {
656	found = true;
657	break;
658	}
659	}
660	if (found) {
661	delete parReq;
662	}
663	else {
664	#ifdef BNC_DEBUG_PPP
665	//LOG << "push_back parReq " << parReq->toString() << std::endl;
666	#endif
667	_params.push_back(parReq);
668	}
669	}
670
671	// Set Parameter Indices
672	// ---------------------
673	sort(_params.begin(), _params.end(), t_pppParam::sortFunction);
674
675	for (unsigned ii = 0; ii < _params.size(); ii++) {
676	t_pppParam* par = _params[ii];
677	par->setIndex(ii);
678	for (unsigned jj = 0; jj < obsVector.size(); jj++) {
679	const t_pppSatObs* satObs = obsVector[jj];
680	if (satObs->prn() == par->prn()) {
681	par->setAmbEleSat(satObs->eleSat());
682	par->stepAmbNumEpo();
683	}
684	}
685	}
686
687	return success;
688	}
689
690	//
691	////////////////////////////////////////////////////////////////////////////
692	void t_pppParlist::printResult(const bncTime& epoTime, const SymmetricMatrix& QQ,
693	const ColumnVector& xx) const {
694
695	string epoTimeStr = string(epoTime);
696	const t_pppStation* sta = PPP_CLIENT->staRover();
697
698	LOG << endl;
699
700	t_pppParam* parX = 0;
701	t_pppParam* parY = 0;
702	t_pppParam* parZ = 0;
703	for (unsigned ii = 0; ii < _params.size(); ii++) {
704	t_pppParam* par = _params[ii];
705	if (par->type() == t_pppParam::crdX) {
706	parX = par;
707	}
708	else if (par->type() == t_pppParam::crdY) {
709	parY = par;
710	}
711	else if (par->type() == t_pppParam::crdZ) {
712	parZ = par;
713	}
714	else {
715	int ind = par->indexNew();
716	double apr = (par->type() == t_pppParam::trp) ?
717	t_tropo::delay_saast(sta->xyzApr(), M_PI/2.0) : par->x0();
718	LOG << epoTimeStr << ' ' << par->toString() << ' '
719	<< setw(10) << setprecision(4) << apr << ' '
720	<< showpos << setw(10) << setprecision(4) << xx[ind] << noshowpos << " +- "
721	<< setw(8) << setprecision(4) << sqrt(QQ[ind][ind]);
722	if (par->type() == t_pppParam::amb) {
723	LOG << " el = " << setw(6) << setprecision(2) << par->ambEleSat() * 180.0 / M_PI
724	<< " epo = " << setw(4) << par->ambNumEpo();
725	}
726	LOG << endl;
727	}
728	}
729
730	if (parX && parY && parZ) {
731
732	ColumnVector xyz(3);
733	xyz[0] = xx[parX->indexNew()];
734	xyz[1] = xx[parY->indexNew()];
735	xyz[2] = xx[parZ->indexNew()];
736
737	ColumnVector neu(3);
738	xyz2neu(sta->ellApr().data(), xyz.data(), neu.data());
739
740	SymmetricMatrix QQxyz = QQ.SymSubMatrix(1,3);
741
742	SymmetricMatrix QQneu(3);
743	covariXYZ_NEU(QQxyz, sta->ellApr().data(), QQneu);
744
745	LOG << epoTimeStr << ' ' << sta->name()
746	<< " X = " << setprecision(4) << sta->xyzApr()[0] + xyz[0] << " +- "
747	<< setprecision(4) << sqrt(QQxyz[0][0])
748
749	<< " Y = " << setprecision(4) << sta->xyzApr()[1] + xyz[1] << " +- "
750	<< setprecision(4) << sqrt(QQxyz[1][1])
751
752	<< " Z = " << setprecision(4) << sta->xyzApr()[2] + xyz[2] << " +- "
753	<< setprecision(4) << sqrt(QQxyz[2][2])
754
755	<< " dN = " << setprecision(4) << neu[0] << " +- "
756	<< setprecision(4) << sqrt(QQneu[0][0])
757
758	<< " dE = " << setprecision(4) << neu[1] << " +- "
759	<< setprecision(4) << sqrt(QQneu[1][1])
760
761	<< " dU = " << setprecision(4) << neu[2] << " +- "
762	<< setprecision(4) << sqrt(QQneu[2][2])
763
764	<< endl;
765	}
766	return;
767	}
768
769	//
770	////////////////////////////////////////////////////////////////////////////
771	void t_pppParlist::printParams(const bncTime& epoTime) {
772
773	for (unsigned iPar = 0; iPar < _params.size(); iPar++) {
774	LOG << _params[iPar]->toString()
775	<< "\t lastObsTime().valid() \t" << _params[iPar]->lastObsTime().valid()
776	<< "\t epoTime - par->lastObsTime() \t" << (epoTime - _params[iPar]->lastObsTime())
777	<< endl;
778	}
779	}
780

Note: See TracBrowser for help on using the repository browser.

Download in other formats:

Original Format