Context Navigation

pppParlist.cpp@ 9549

Last change on this file since 9549 was 9549, checked in by stuerze, 4 years ago
minor changes
Property svn:keywords set to `Author Date Id Rev URL;svn:eol-style=native` Property svn:mime-type set to `text/plain`
File size: 27.2 KB

Rev	Line
[7237]	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,
[9504]	37	const vector<t_pppSatObs> obsVector) {
[7237]	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;
[9303]	66	_sigma0 = OPT->_aprSigClk;
[7237]	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) {
[9288]	76	double offGR = 0;
[7237]	77	if (_prn.system() == 'R' && tLC != t_lc::MW) {
[9288]	78	offGR = PPP_CLIENT->offGR();
[7237]	79	}
[9288]	80	double offGE = 0;
	81	if (_prn.system() == 'E' && tLC != t_lc::MW) {
	82	offGE = PPP_CLIENT->offGE();
	83	}
	84	double offGC = 0;
[8993]	85	if (_prn.system() == 'C' && tLC != t_lc::MW) {
[9288]	86	offGC = PPP_CLIENT->offGC();
[8993]	87	}
[9288]	88	_x0 = floor((obs->obsValue(tLC) - offGR -offGE - offGC - obs->cmpValue(tLC)) / obs->lambda(tLC) + 0.5);
[7237]	89	break;
	90	}
	91	}
	92	}
	93	break;
[9288]	94	case offGR:
[7237]	95	_epoSpec = true;
[9386]	96	_sigma0 = OPT->_aprSigOGR;
[9288]	97	_x0 = PPP_CLIENT->offGR();
[7237]	98	break;
[9288]	99	case offGE:
[8993]	100	_epoSpec = true;
[9386]	101	_sigma0 = OPT->_aprSigOGE;
[9288]	102	_x0 = PPP_CLIENT->offGE();
[8993]	103	break;
[9288]	104	case offGC:
	105	_epoSpec = true;
[9386]	106	_sigma0 = OPT->_aprSigOGC;
[9288]	107	_x0 = PPP_CLIENT->offGC();
	108	break;
[7237]	109	case trp:
	110	_epoSpec = false;
	111	_sigma0 = OPT->_aprSigTrp;
	112	_noise = OPT->_noiseTrp;
	113	break;
[8905]	114	case ion:
[9439]	115	_epoSpec = false;
[9386]	116	_sigma0 = OPT->_aprSigIon;
[9439]	117	_noise = OPT->_noiseIon;
[8905]	118	break;
[9386]	119	case cBiasG1: case cBiasR1: case cBiasE1: case cBiasC1:
	120	case cBiasG2: case cBiasR2: case cBiasE2: case cBiasC2:
[9486]	121	_epoSpec = false;
[8905]	122	_sigma0 = OPT->_aprSigCodeBias;
[9486]	123	_noise = OPT->_noiseCodeBias;
[8905]	124	break;
[9419]	125	case pBiasG1: case pBiasE1: case pBiasR1: case pBiasC1:
	126	case pBiasG2: case pBiasE2: case pBiasR2: case pBiasC2:
[9486]	127	_epoSpec = false;
[8905]	128	_sigma0 = OPT->_aprSigPhaseBias;
[9486]	129	_noise = OPT->_noisePhaseBias;
[8905]	130	break;
[7237]	131	}
	132	}
	133
[9504]	134	//
	135	////////////////////////////////////////////////////////////////////////////
	136	t_pppParam::t_pppParam(const t_pppParam* old) {
	137	_type = old->type();
	138	_prn = old->prn();
	139	_tLC = old->tLC();
	140	_indexOld = old->indexOld();
	141	_indexNew = old->indexNew();
	142	_noise = old->noise();
	143	_sigma0 = old->sigma0();
	144	_epoSpec = old->epoSpec();
[9508]	145	_x0 = old->x0();
	146	setFirstObsTime(old->firstObsTime());
	147	setLastObsTime(old->lastObsTime());
[9504]	148	_ambInfo = 0;
	149	if (_type == t_pppParam::amb) {
	150	_ambInfo = new t_ambInfo();
	151	_ambInfo->_resetCandidate = old->_ambInfo->_resetCandidate;
	152	_ambInfo->_eleSat = old->_ambInfo->_eleSat;
	153	_ambInfo->_numEpo = old->_ambInfo->_numEpo;
	154	}
	155	}
	156
[7237]	157	// Destructor
	158	////////////////////////////////////////////////////////////////////////////
	159	t_pppParam::~t_pppParam() {
[9504]	160	if (_ambInfo) {
	161	delete _ambInfo;
	162	}
[7237]	163	}
	164	//
	165	////////////////////////////////////////////////////////////////////////////
	166	double t_pppParam::partial(const bncTime& /* epoTime /, const t_pppSatObs obs,
[8956]	167	const t_lc::type& tLC, const t_prn refPrn) const {
[7237]	168
	169	// Special Case - Melbourne-Wuebbena
	170	// ---------------------------------
	171	if (tLC == t_lc::MW && _type != amb) {
	172	return 0.0;
	173	}
	174
	175	const t_pppStation* sta = PPP_CLIENT->staRover();
[8905]	176	ColumnVector rhoV = sta->xyzApr() - obs->xc().Rows(1,3);
[7237]	177
[8905]	178	map<t_frequency::type, double> codeCoeff;
	179	map<t_frequency::type, double> phaseCoeff;
	180	map<t_frequency::type, double> ionoCoeff;
	181	obs->lcCoeff(tLC, codeCoeff, phaseCoeff, ionoCoeff);
	182
[7237]	183	switch (_type) {
	184	case crdX:
[9548]	185	if (tLC == t_lc::GIM) {return 0.0;}
[8905]	186	return (sta->xyzApr()[0] - obs->xc()[0]) / rhoV.NormFrobenius();
[7237]	187	case crdY:
[9548]	188	if (tLC == t_lc::GIM) {return 0.0;}
[8905]	189	return (sta->xyzApr()[1] - obs->xc()[1]) / rhoV.NormFrobenius();
[7237]	190	case crdZ:
[9548]	191	if (tLC == t_lc::GIM) {return 0.0;}
[8905]	192	return (sta->xyzApr()[2] - obs->xc()[2]) / rhoV.NormFrobenius();
[7237]	193	case clkR:
[9548]	194	if (tLC == t_lc::GIM) {return 0.0;}
[7237]	195	return 1.0;
[9288]	196	case offGR:
[9548]	197	if (tLC == t_lc::GIM) {return 0.0;}
[7237]	198	return (obs->prn().system() == 'R') ? 1.0 : 0.0;
[9288]	199	case offGE:
[9548]	200	if (tLC == t_lc::GIM) {return 0.0;}
[9288]	201	return (obs->prn().system() == 'E') ? 1.0 : 0.0;
	202	case offGC:
[9548]	203	if (tLC == t_lc::GIM) {return 0.0;}
[8993]	204	return (obs->prn().system() == 'C') ? 1.0 : 0.0;
[7237]	205	case amb:
[9548]	206	if (tLC == t_lc::GIM) {return 0.0;}
[8905]	207	else if ((OPT->_obsModelType == OPT->IF) \|\|
	208	(OPT->_obsModelType == OPT->PPPRTK) \|\|
	209	(OPT->_obsModelType == OPT->UncombPPP) \|\|
	210	(OPT->_obsModelType == OPT->DCMcodeBias && !obs->isReference()) \|\|
	211	(OPT->_obsModelType == OPT->DCMphaseBias && !obs->isReference()) ) {
[9386]	212
[8905]	213	if (obs->prn() == _prn) {
	214	if (tLC == _tLC) {
	215	return (obs->lambda(tLC));
	216	}
	217	else if (tLC == t_lc::lIF && _tLC == t_lc::MW) {
	218	return obs->lambda(t_lc::lIF) * obs->lambda(t_lc::MW) / obs->lambda(t_lc::l2);
	219	}
	220	else {
	221	if (_tLC == t_lc::l1) {
	222	return obs->lambda(t_lc::l1) * phaseCoeff[t_lc::toFreq(obs->prn().system(),t_lc::l1)];
	223	}
	224	else if (_tLC == t_lc::l2) {
	225	return obs->lambda(t_lc::l2) * phaseCoeff[t_lc::toFreq(obs->prn().system(),t_lc::l2)];
	226	}
	227	}
	228	}
	229	}
	230	break;
	231	case trp:
[8961]	232	if (tLC == t_lc::GIM) {
	233	return 0.0;
	234	}
	235	else {
	236	return 1.0 / sin(obs->eleSat());
	237	}
[8905]	238	case ion:
[7237]	239	if (obs->prn() == _prn) {
[8905]	240	if (tLC == t_lc::c1) {
	241	return ionoCoeff[t_lc::toFreq(obs->prn().system(),t_lc::c1)];
[7237]	242	}
[8905]	243	else if (tLC == t_lc::c2) {
	244	return ionoCoeff[t_lc::toFreq(obs->prn().system(),t_lc::c2)];
[7237]	245	}
[8905]	246	else if (tLC == t_lc::l1) {
	247	return ionoCoeff[t_lc::toFreq(obs->prn().system(),t_lc::l1)];
[7237]	248	}
[8905]	249	else if (tLC == t_lc::l2) {
	250	return ionoCoeff[t_lc::toFreq(obs->prn().system(),t_lc::l2)];
	251	}
	252	else if (tLC == t_lc::GIM) {
	253	return -1.0;
	254	}
[7237]	255	}
[8956]	256	if (tLC == t_lc::GIM && _prn == refPrn) {
[8961]	257	return 1.0;
[8905]	258	}
	259	break;
[9386]	260	case cBiasG1:
	261	if ((obs->prn().system() == 'G') && (tLC == t_lc::c1)) {return 1.0;} else {return 0.0;}
[8905]	262	break;
[9386]	263	case cBiasR1:
	264	if ((obs->prn().system() == 'R') && (tLC == t_lc::c1)) {return 1.0;} else {return 0.0;}
[8905]	265	break;
[9386]	266	case cBiasE1:
	267	if ((obs->prn().system() == 'E') && (tLC == t_lc::c1)) {return 1.0;} else {return 0.0;}
[8905]	268	break;
[9386]	269	case cBiasC1:
	270	if ((obs->prn().system() == 'C') && (tLC == t_lc::c1)) {return 1.0;} else {return 0.0;}
	271	break;
	272	case cBiasG2:
	273	if ((obs->prn().system() == 'G') && (tLC == t_lc::c2)) {return 1.0;} else {return 0.0;}
	274	break;
	275	case cBiasR2:
	276	if ((obs->prn().system() == 'R') && (tLC == t_lc::c2)) {return 1.0;} else {return 0.0;}
	277	break;
	278	case cBiasE2:
	279	if ((obs->prn().system() == 'E') && (tLC == t_lc::c2)) {return 1.0;} else {return 0.0;}
	280	break;
	281	case cBiasC2:
	282	if ((obs->prn().system() == 'C') && (tLC == t_lc::c2)) {return 1.0;} else {return 0.0;}
	283	break;
	284	case pBiasG1:
	285	if ((obs->prn().system() == 'G') && (tLC == t_lc::l1)) {return 1.0;} else {return 0.0;}
	286	break;
[9419]	287	case pBiasR1:
	288	if ((obs->prn().system() == 'R') && (tLC == t_lc::l1)) {return 1.0;} else {return 0.0;}
	289	break;
[9386]	290	case pBiasE1:
	291	if ((obs->prn().system() == 'E') && (tLC == t_lc::l1)) {return 1.0;} else {return 0.0;}
	292	break;
	293	case pBiasC1:
	294	if ((obs->prn().system() == 'C') && (tLC == t_lc::l1)) {return 1.0;} else {return 0.0;}
	295	break;
	296	case pBiasG2:
	297	if ((obs->prn().system() == 'G') && (tLC == t_lc::l2)) {return 1.0;} else {return 0.0;}
	298	break;
[9419]	299	case pBiasR2:
	300	if ((obs->prn().system() == 'R') && (tLC == t_lc::l2)) {return 1.0;} else {return 0.0;}
	301	break;
[9386]	302	case pBiasE2:
	303	if ((obs->prn().system() == 'E') && (tLC == t_lc::l2)) {return 1.0;} else {return 0.0;}
	304	break;
	305	case pBiasC2:
	306	if ((obs->prn().system() == 'C') && (tLC == t_lc::l2)) {return 1.0;} else {return 0.0;}
	307	break;
	308
[7237]	309	}
	310	return 0.0;
	311	}
	312
	313	//
	314	////////////////////////////////////////////////////////////////////////////
	315	string t_pppParam::toString() const {
	316	stringstream ss;
	317	switch (_type) {
	318	case crdX:
	319	ss << "CRD_X";
	320	break;
	321	case crdY:
	322	ss << "CRD_Y";
	323	break;
	324	case crdZ:
	325	ss << "CRD_Z";
	326	break;
	327	case clkR:
[9386]	328	ss << "REC_CLK ";
[7237]	329	break;
[9288]	330	case offGR:
[9386]	331	ss << "OGR ";
[7237]	332	break;
[9288]	333	case offGE:
[9386]	334	ss << "OGE ";
[9288]	335	break;
	336	case offGC:
[9386]	337	ss << "OGC ";
[8993]	338	break;
[7237]	339	case trp:
[9386]	340	ss << "TRP ";
[7237]	341	break;
[8905]	342	case amb:
	343	ss << "AMB " << left << setw(3) << t_lc::toString(_tLC) << right << ' ' << _prn.toString();
	344	break;
	345	case ion:
	346	ss << "ION " << left << setw(3) << t_lc::toString(_tLC) << right << ' ' << _prn.toString();
	347	break;
[9386]	348	case cBiasG1: case pBiasG1:
	349	case cBiasG2: case pBiasG2:
	350	ss << "BIA " << left << setw(3) << t_lc::toString(_tLC) << right << " G ";
[8905]	351	break;
[9419]	352	case cBiasR1: case pBiasR1:
	353	case cBiasR2: case pBiasR2:
[9386]	354	ss << "BIA " << left << setw(3) << t_lc::toString(_tLC) << right << " R ";
	355	break;
	356	case cBiasE1: case pBiasE1:
	357	case cBiasE2: case pBiasE2:
	358	ss << "BIA " << left << setw(3) << t_lc::toString(_tLC) << right << " E ";
	359	break;
	360	case cBiasC1: case pBiasC1:
	361	case cBiasC2: case pBiasC2:
	362	ss << "BIA " << left << setw(3) << t_lc::toString(_tLC) << right << " C ";
	363	break;
[7237]	364	}
	365	return ss.str();
	366	}
	367
	368	// Constructor
	369	////////////////////////////////////////////////////////////////////////////
	370	t_pppParlist::t_pppParlist() {
	371	}
	372
	373	// Destructor
	374	////////////////////////////////////////////////////////////////////////////
	375	t_pppParlist::~t_pppParlist() {
[9504]	376	_usedSystems.clear();
	377
	378	vector<t_pppParam*>::iterator it = _params.begin();
	379	while (it != _params.end()) {
	380	t_pppParam* par = *it;
	381	delete par;
	382	it = _params.erase(it);
[7237]	383	}
	384	}
	385
	386	//
	387	////////////////////////////////////////////////////////////////////////////
[9504]	388	t_pppParlist::t_pppParlist(const t_pppParlist& old) {
	389
	390	_usedSystems = old._usedSystems;
	391
	392	vector<t_pppParam*>::const_iterator it = old.params().begin();
	393	while (it != old.params().end()) {
	394	const t_pppParam* oldParam = *it;
	395	_params.push_back(new t_pppParam(oldParam));
	396	}
	397	}
	398
	399	//
	400	////////////////////////////////////////////////////////////////////////////
	401	const t_pppParlist& t_pppParlist::operator= (const t_pppParlist& p) {
	402
	403	_usedSystems.clear();
	404
	405	_usedSystems = p._usedSystems;
	406
	407	vector<t_pppParam*>::iterator it = _params.begin();
	408	while (it != _params.end()) {
	409	t_pppParam* par = *it;
	410	delete par;
	411	it = _params.erase(it);
	412	}
	413
	414	for (unsigned jj = 0; jj < p.params().size(); jj++) {
	415	t_pppParam* parFrom = p.params()[jj];
	416	_params.push_back(new t_pppParam(parFrom));
	417	}
	418	return *this;
	419	}
	420
	421	//
	422	////////////////////////////////////////////////////////////////////////////
[9419]	423	t_irc t_pppParlist::set(const bncTime& epoTime, const std::vector<t_pppSatObs*>& obsVector,
[8956]	424	const QMap<char, t_pppRefSat*>& refSatMap) {
[7237]	425
	426	// Remove some Parameters
	427	// ----------------------
	428	vector<t_pppParam*>::iterator it = _params.begin();
	429	while (it != _params.end()) {
	430	t_pppParam* par = *it;
	431
	432	bool remove = false;
	433
	434	if (par->epoSpec()) {
	435	remove = true;
	436	}
	437
[8956]	438	else if (par->type() == t_pppParam::crdX \|\|
[7988]	439	par->type() == t_pppParam::crdY \|\|
	440	par->type() == t_pppParam::crdZ) {
[7973]	441	if (par->lastObsTime().valid() && (epoTime - par->lastObsTime() > 60.0)) {
[7237]	442	remove = true;
	443	}
	444	}
[9419]	445
[8956]	446	else if (par->type() == t_pppParam::amb) {
[9545]	447	if (par->lastObsTime().valid() && (epoTime - par->lastObsTime() > 60.0)) {
	448	remove = true;
	449	}
[9494]	450	if (OPT->_obsModelType == OPT->DCMcodeBias \|\|
	451	OPT->_obsModelType == OPT->DCMphaseBias) {
[9508]	452	char sys = par->prn().system();
	453	t_prn refPrn = (refSatMap[sys])->prn();
[9527]	454	if (par->lastObsTime().valid() && par->prn() == refPrn) {
[9419]	455	remove = true;
	456	}
[8956]	457	}
	458	}
[7237]	459
[9447]	460	else if (par->type() == t_pppParam::ion) {
[9527]	461	if (par->lastObsTime().valid() && (epoTime - par->lastObsTime() > 60.0)) {
	462	remove = true;
[9447]	463	}
	464	}
[7237]	465	if (remove) {
[9508]	466	#ifdef BNC_DEBUG_PPP
[9527]	467	LOG << "remove0 " << par->toString() << std::endl;
[9508]	468	#endif
[7237]	469	delete par;
	470	it = _params.erase(it);
	471	}
	472	else {
	473	++it;
	474	}
	475	}
	476
[9532]	477	// check which systems have observations
	478	// -------------------------------------
	479	_usedSystems.clear();
	480	for (unsigned jj = 0; jj < obsVector.size(); jj++) {
	481	const t_pppSatObs* satObs = obsVector[jj];
[9533]	482	char sys = satObs->prn().system();
[9532]	483	if (!_usedSystems.contains(sys)) {
	484	_usedSystems.append(sys);
	485	}
	486	}
	487
	488	if (_usedSystems.size() > 1 &&
	489	!_usedSystems.contains('G')) { // required to setup ISB w. r. t. GPS
	490	return failure;
	491	}
	492
	493
	494
[7237]	495	// Check whether parameters have observations
	496	// ------------------------------------------
	497	for (unsigned ii = 0; ii < _params.size(); ii++) {
	498	t_pppParam* par = _params[ii];
	499	if (par->prn() == 0) {
	500	par->setLastObsTime(epoTime);
	501	if (par->firstObsTime().undef()) {
	502	par->setFirstObsTime(epoTime);
	503	}
	504	}
	505	else {
	506	for (unsigned jj = 0; jj < obsVector.size(); jj++) {
	507	const t_pppSatObs* satObs = obsVector[jj];
	508	if (satObs->prn() == par->prn()) {
	509	par->setLastObsTime(epoTime);
	510	if (par->firstObsTime().undef()) {
	511	par->setFirstObsTime(epoTime);
	512	}
	513	break;
	514	}
	515	}
	516	}
	517	}
	518
[9527]	519
[9419]	520	if (OPT->_obsModelType == OPT->DCMcodeBias \|\|
	521	OPT->_obsModelType == OPT->DCMphaseBias) {
[9527]	522	// Check if ambiguity parameters have observations
	523	// -----------------------------------------------
[9419]	524	vector<t_pppParam*>::iterator it = _params.begin();
[9527]	525	QList<t_prn> lostSats;
[9419]	526	while (it != _params.end()) {
	527	t_pppParam* par = *it;
[9527]	528	if ((par->type() == t_pppParam::amb) &&
[9528]	529	(!par->lastObsTime().valid() \|\| (epoTime - par->lastObsTime() > 0.0))) {
[9534]	530	#ifdef BNC_DEBUG_PPP
[9527]	531	LOG << "remove1 " << par->toString() << std::endl;
[9534]	532	#endif
[9527]	533	lostSats.append(par->prn());
[9419]	534	delete par;
	535	it = _params.erase(it);
	536	}
[9532]	537	// Check if systems have to be presented per biases
[9535]	538	// ----------------------------------------------
[9532]	539	else if ((par->type() == t_pppParam::cBiasG1 \|\|
	540	par->type() == t_pppParam::cBiasG2 \|\|
	541	par->type() == t_pppParam::pBiasG1 \|\|
	542	par->type() == t_pppParam::pBiasG2) && !usedSystems().contains('G')) {
[9534]	543	#ifdef BNC_DEBUG_PPP
	544	LOG << "remove1 " << par->toString() << std::endl;
	545	#endif
[9548]	546	delete par;
	547	it = _params.erase(it);
[9532]	548	}
	549	else if ((par->type() == t_pppParam::cBiasR1 \|\|
	550	par->type() == t_pppParam::cBiasR2 \|\|
	551	par->type() == t_pppParam::pBiasR1 \|\|
	552	par->type() == t_pppParam::pBiasR2) && !usedSystems().contains('R')) {
[9534]	553	#ifdef BNC_DEBUG_PPP
	554	LOG << "remove1 " << par->toString() << std::endl;
	555	#endif
[9548]	556	delete par;
	557	it = _params.erase(it);
[9532]	558	}
	559	else if ((par->type() == t_pppParam::cBiasE1 \|\|
	560	par->type() == t_pppParam::cBiasE2 \|\|
	561	par->type() == t_pppParam::pBiasE1 \|\|
	562	par->type() == t_pppParam::pBiasE2) && !usedSystems().contains('E')) {
[9534]	563	#ifdef BNC_DEBUG_PPP
	564	LOG << "remove1 " << par->toString() << std::endl;
	565	#endif
[9548]	566	delete par;
	567	it = _params.erase(it);
[9532]	568	}
	569	else if ((par->type() == t_pppParam::cBiasC1 \|\|
	570	par->type() == t_pppParam::cBiasC2 \|\|
	571	par->type() == t_pppParam::pBiasC1 \|\|
[9548]	572	par->type() == t_pppParam::pBiasC2) && !usedSystems().contains('C')) {
[9534]	573	#ifdef BNC_DEBUG_PPP
	574	LOG << "remove1 " << par->toString() << std::endl;
	575	#endif
[9548]	576	delete par;
	577	it = _params.erase(it);
[9532]	578	}
[9419]	579	else {
	580	++it;
	581	}
	582	}
[9527]	583	// remove respective iono parameters
	584	// ---------------------------------
	585	it = _params.begin();
	586	while (it != _params.end()) {
	587	t_pppParam* par = *it;
	588	if ((par->type() == t_pppParam::ion) &&
[9528]	589	(lostSats.contains(par->prn()) \|\| (epoTime - par->lastObsTime() > 0.0))) {
[9549]	590	#ifdef BNC_DEBUG_PPP
[9527]	591	LOG << "remove1 " << par->toString() << std::endl;
[9549]	592	#endif
[9527]	593	delete par;
	594	it = _params.erase(it);
	595	}
	596	else {
	597	++it;
	598	}
	599	}
[9419]	600	}
	601
	602
[7237]	603	// Required Set of Parameters
	604	// --------------------------
	605	vector<t_pppParam*> required;
	606
	607	// Coordinates
	608	// -----------
	609	required.push_back(new t_pppParam(t_pppParam::crdX, t_prn(), t_lc::dummy));
	610	required.push_back(new t_pppParam(t_pppParam::crdY, t_prn(), t_lc::dummy));
	611	required.push_back(new t_pppParam(t_pppParam::crdZ, t_prn(), t_lc::dummy));
	612
[9386]	613	// Receiver Code Biases
	614	// --------------------
	615	if (OPT->_obsModelType == OPT->DCMcodeBias) {
[9494]	616	std::vector<t_lc::type> lc;
[9419]	617	if (_usedSystems.contains('G')) {
[9494]	618	lc = OPT->LCs('G');
	619	if (std::find(lc.begin(), lc.end(), t_lc::c1) != lc.end()) {
	620	required.push_back(new t_pppParam(t_pppParam::cBiasG1, t_prn(), t_lc::c1));
	621	}
	622	if (std::find(lc.begin(), lc.end(), t_lc::c2) != lc.end()) {
	623	required.push_back(new t_pppParam(t_pppParam::cBiasG2, t_prn(), t_lc::c2));
	624	}
[9386]	625	}
[9419]	626	if (_usedSystems.contains('R')) {
[9494]	627	lc = OPT->LCs('R');
	628	if (std::find(lc.begin(), lc.end(), t_lc::c1) != lc.end()) {
	629	required.push_back(new t_pppParam(t_pppParam::cBiasR1, t_prn(), t_lc::c1));
	630	}
	631	if (std::find(lc.begin(), lc.end(), t_lc::c2) != lc.end()) {
	632	required.push_back(new t_pppParam(t_pppParam::cBiasR2, t_prn(), t_lc::c2));
	633	}
[9386]	634	}
[9419]	635	if (_usedSystems.contains('E')) {
[9494]	636	lc = OPT->LCs('E');
	637	if (std::find(lc.begin(), lc.end(), t_lc::c1) != lc.end()) {
	638	required.push_back(new t_pppParam(t_pppParam::cBiasE1, t_prn(), t_lc::c1));
	639	}
	640	if (std::find(lc.begin(), lc.end(), t_lc::c2) != lc.end()) {
	641	required.push_back(new t_pppParam(t_pppParam::cBiasE2, t_prn(), t_lc::c2));
	642	}
[9386]	643	}
[9419]	644	if (_usedSystems.contains('C')) {
[9494]	645	lc = OPT->LCs('C');
	646	if (std::find(lc.begin(), lc.end(), t_lc::c1) != lc.end()) {
	647	required.push_back(new t_pppParam(t_pppParam::cBiasC1, t_prn(), t_lc::c1));
	648	}
	649	if (std::find(lc.begin(), lc.end(), t_lc::c2) != lc.end()) {
	650	required.push_back(new t_pppParam(t_pppParam::cBiasC2, t_prn(), t_lc::c2));
	651	}
[9386]	652	}
	653	}
	654
	655	// Receiver Phase Biases
	656	// ---------------------
	657	if ((OPT->_obsModelType == OPT->DCMphaseBias) \|\|
	658	(OPT->_obsModelType == OPT->PPPRTK) ) {
[9494]	659	std::vector<t_lc::type> lc;
[9419]	660	if (_usedSystems.contains('G')) {
[9494]	661	lc = OPT->LCs('G');
	662	if (std::find(lc.begin(), lc.end(), t_lc::l1) != lc.end()) {
	663	required.push_back(new t_pppParam(t_pppParam::pBiasG1, t_prn(), t_lc::l1));
	664	}
	665	if (std::find(lc.begin(), lc.end(), t_lc::l2) != lc.end()) {
	666	required.push_back(new t_pppParam(t_pppParam::pBiasG2, t_prn(), t_lc::l2));
	667	}
[9386]	668	}
[9419]	669	if (_usedSystems.contains('R')) {
[9494]	670	lc = OPT->LCs('R');
	671	if (std::find(lc.begin(), lc.end(), t_lc::l1) != lc.end()) {
	672	required.push_back(new t_pppParam(t_pppParam::pBiasR1, t_prn(), t_lc::l1));
	673	}
	674	if (std::find(lc.begin(), lc.end(), t_lc::l2) != lc.end()) {
	675	required.push_back(new t_pppParam(t_pppParam::pBiasR2, t_prn(), t_lc::l2));
	676	}
	677
[9419]	678	}
	679	if (_usedSystems.contains('E')) {
[9494]	680	lc = OPT->LCs('E');
	681	if (std::find(lc.begin(), lc.end(), t_lc::l1) != lc.end()) {
	682	required.push_back(new t_pppParam(t_pppParam::pBiasE1, t_prn(), t_lc::l1));
	683	}
	684	if (std::find(lc.begin(), lc.end(), t_lc::l2) != lc.end()) {
	685	required.push_back(new t_pppParam(t_pppParam::pBiasE2, t_prn(), t_lc::l2));
	686	}
[9386]	687	}
[9419]	688	if (_usedSystems.contains('C')) {
[9494]	689	lc = OPT->LCs('C');
	690	if (std::find(lc.begin(), lc.end(), t_lc::l1) != lc.end()) {
	691	required.push_back(new t_pppParam(t_pppParam::pBiasC1, t_prn(), t_lc::l1));
	692	}
	693	if (std::find(lc.begin(), lc.end(), t_lc::l2) != lc.end()) {
	694	required.push_back(new t_pppParam(t_pppParam::pBiasC2, t_prn(), t_lc::l2));
	695	}
[9386]	696	}
	697	}
[9419]	698
[7237]	699	// Receiver Clock
	700	// --------------
	701	required.push_back(new t_pppParam(t_pppParam::clkR, t_prn(), t_lc::dummy));
	702
[8905]	703	// GPS-GLONASS Clock Offset
[7237]	704	// ------------------------
[9498]	705	if (_usedSystems.contains('G') && _usedSystems.contains('R')) {
	706	required.push_back(new t_pppParam(t_pppParam::offGR, t_prn(), t_lc::dummy));
	707	}
[7237]	708
[9419]	709	//GPS-Galileo Clock Offset
[9288]	710	// ------------------------
[9498]	711	if (_usedSystems.contains('G') && _usedSystems.contains('E')) {
	712	required.push_back(new t_pppParam(t_pppParam::offGE, t_prn(), t_lc::dummy));
	713	}
[9288]	714
[8993]	715	// GPS-BDS Clock Offset
	716	// ------------------------
[9498]	717	if (_usedSystems.contains('G') && _usedSystems.contains('C')) {
	718	required.push_back(new t_pppParam(t_pppParam::offGC, t_prn(), t_lc::dummy));
	719	}
[8993]	720
[7237]	721	// Troposphere
	722	// -----------
	723	if (OPT->estTrp()) {
	724	required.push_back(new t_pppParam(t_pppParam::trp, t_prn(), t_lc::dummy));
	725	}
	726
[8905]	727	// Ionosphere
	728	// ----------
	729	if (OPT->_obsModelType == OPT->UncombPPP \|\|
	730	OPT->_obsModelType == OPT->DCMcodeBias \|\|
	731	OPT->_obsModelType == OPT->DCMphaseBias ) {
	732	for (unsigned jj = 0; jj < obsVector.size(); jj++) {
[9386]	733	const t_pppSatObs* satObs = obsVector[jj];
[8905]	734	required.push_back(new t_pppParam(t_pppParam::ion, satObs->prn(), t_lc::dummy));
	735	}
	736	}
[7237]	737	// Ambiguities
	738	// -----------
	739	for (unsigned jj = 0; jj < obsVector.size(); jj++) {
[9419]	740	const t_pppSatObs* satObs = obsVector[jj];
[8905]	741	if ((OPT->_obsModelType == OPT->IF) \|\|
	742	(OPT->_obsModelType == OPT->PPPRTK) \|\|
	743	(OPT->_obsModelType == OPT->UncombPPP) \|\|
	744	(OPT->_obsModelType == OPT->DCMcodeBias && !satObs->isReference()) \|\|
	745	(OPT->_obsModelType == OPT->DCMphaseBias && !satObs->isReference()) ) {
	746	const vector<t_lc::type>& ambLCs = OPT->ambLCs(satObs->prn().system());
	747	for (unsigned ii = 0; ii < ambLCs.size(); ii++) {
	748	required.push_back(new t_pppParam(t_pppParam::amb, satObs->prn(), ambLCs[ii], &obsVector));
	749	}
[7237]	750	}
	751	}
	752
	753	// Check if all required parameters are present
	754	// --------------------------------------------
	755	for (unsigned ii = 0; ii < required.size(); ii++) {
	756	t_pppParam* parReq = required[ii];
	757
	758	bool found = false;
	759	for (unsigned jj = 0; jj < _params.size(); jj++) {
	760	t_pppParam* parOld = _params[jj];
	761	if (parOld->isEqual(parReq)) {
	762	found = true;
	763	break;
	764	}
	765	}
	766	if (found) {
	767	delete parReq;
	768	}
	769	else {
[9508]	770	#ifdef BNC_DEBUG_PPP
	771	LOG << "push_back parReq " << parReq->toString() << std::endl;
	772	#endif
[7237]	773	_params.push_back(parReq);
	774	}
	775	}
	776
	777	// Set Parameter Indices
	778	// ---------------------
	779	sort(_params.begin(), _params.end(), t_pppParam::sortFunction);
	780
	781	for (unsigned ii = 0; ii < _params.size(); ii++) {
	782	t_pppParam* par = _params[ii];
	783	par->setIndex(ii);
	784	for (unsigned jj = 0; jj < obsVector.size(); jj++) {
	785	const t_pppSatObs* satObs = obsVector[jj];
	786	if (satObs->prn() == par->prn()) {
	787	par->setAmbEleSat(satObs->eleSat());
	788	par->stepAmbNumEpo();
	789	}
	790	}
	791	}
	792
	793	return success;
	794	}
	795
	796	//
	797	////////////////////////////////////////////////////////////////////////////
	798	void t_pppParlist::printResult(const bncTime& epoTime, const SymmetricMatrix& QQ,
	799	const ColumnVector& xx) const {
	800
	801	string epoTimeStr = string(epoTime);
	802	const t_pppStation* sta = PPP_CLIENT->staRover();
	803
	804	LOG << endl;
	805
	806	t_pppParam* parX = 0;
	807	t_pppParam* parY = 0;
	808	t_pppParam* parZ = 0;
[9504]	809	vector<t_pppParam*>::const_iterator it = _params.begin();
	810	while (it != _params.end()) {
	811	t_pppParam* par = *it;
[7237]	812	if (par->type() == t_pppParam::crdX) {
	813	parX = par;
	814	}
	815	else if (par->type() == t_pppParam::crdY) {
	816	parY = par;
	817	}
	818	else if (par->type() == t_pppParam::crdZ) {
	819	parZ = par;
	820	}
	821	else {
	822	int ind = par->indexNew();
	823	double apr = (par->type() == t_pppParam::trp) ?
	824	t_tropo::delay_saast(sta->xyzApr(), M_PI/2.0) : par->x0();
	825	LOG << epoTimeStr << ' ' << par->toString() << ' '
	826	<< setw(10) << setprecision(4) << apr << ' '
	827	<< showpos << setw(10) << setprecision(4) << xx[ind] << noshowpos << " +- "
	828	<< setw(8) << setprecision(4) << sqrt(QQ[ind][ind]);
	829	if (par->type() == t_pppParam::amb) {
	830	LOG << " el = " << setw(6) << setprecision(2) << par->ambEleSat() * 180.0 / M_PI
	831	<< " epo = " << setw(4) << par->ambNumEpo();
	832	}
	833	LOG << endl;
	834	}
[9504]	835	++it;
[7237]	836	}
	837
	838	if (parX && parY && parZ) {
	839
	840	ColumnVector xyz(3);
	841	xyz[0] = xx[parX->indexNew()];
	842	xyz[1] = xx[parY->indexNew()];
	843	xyz[2] = xx[parZ->indexNew()];
	844
	845	ColumnVector neu(3);
	846	xyz2neu(sta->ellApr().data(), xyz.data(), neu.data());
	847
	848	SymmetricMatrix QQxyz = QQ.SymSubMatrix(1,3);
	849
	850	SymmetricMatrix QQneu(3);
	851	covariXYZ_NEU(QQxyz, sta->ellApr().data(), QQneu);
	852
	853	LOG << epoTimeStr << ' ' << sta->name()
	854	<< " X = " << setprecision(4) << sta->xyzApr()[0] + xyz[0] << " +- "
	855	<< setprecision(4) << sqrt(QQxyz[0][0])
	856
	857	<< " Y = " << setprecision(4) << sta->xyzApr()[1] + xyz[1] << " +- "
	858	<< setprecision(4) << sqrt(QQxyz[1][1])
	859
	860	<< " Z = " << setprecision(4) << sta->xyzApr()[2] + xyz[2] << " +- "
	861	<< setprecision(4) << sqrt(QQxyz[2][2])
	862
	863	<< " dN = " << setprecision(4) << neu[0] << " +- "
	864	<< setprecision(4) << sqrt(QQneu[0][0])
	865
	866	<< " dE = " << setprecision(4) << neu[1] << " +- "
	867	<< setprecision(4) << sqrt(QQneu[1][1])
	868
	869	<< " dU = " << setprecision(4) << neu[2] << " +- "
	870	<< setprecision(4) << sqrt(QQneu[2][2])
	871
	872	<< endl;
	873	}
[9545]	874	return;
[7237]	875	}
	876
[9525]	877	//
	878	////////////////////////////////////////////////////////////////////////////
[9527]	879	void t_pppParlist::printParams(const bncTime& epoTime) {
[9526]	880
	881	for (unsigned iPar = 0; iPar < _params.size(); iPar++) {
[9527]	882	LOG << _params[iPar]->toString()
	883	<< "\t lastObsTime().valid() \t" << _params[iPar]->lastObsTime().valid()
	884	<< "\t epoTime - par->lastObsTime() \t" << (epoTime - _params[iPar]->lastObsTime())
	885	<< endl;
[9525]	886	}
	887	}
	888

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

Download in other formats:

Original Format