Context Navigation

pppParlist.cpp@ 9528

Last change on this file since 9528 was 9528, checked in by stuerze, 2 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: 25.7 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:
[8961]	185	if (tLC == t_lc::GIM \|\| tLC == t_lc::Tz0) {return 0.0;}
[8905]	186	return (sta->xyzApr()[0] - obs->xc()[0]) / rhoV.NormFrobenius();
[7237]	187	case crdY:
[8961]	188	if (tLC == t_lc::GIM \|\| tLC == t_lc::Tz0) {return 0.0;}
[8905]	189	return (sta->xyzApr()[1] - obs->xc()[1]) / rhoV.NormFrobenius();
[7237]	190	case crdZ:
[8961]	191	if (tLC == t_lc::GIM \|\| tLC == t_lc::Tz0) {return 0.0;}
[8905]	192	return (sta->xyzApr()[2] - obs->xc()[2]) / rhoV.NormFrobenius();
[7237]	193	case clkR:
[8961]	194	if (tLC == t_lc::GIM \|\| tLC == t_lc::Tz0) {return 0.0;}
[7237]	195	return 1.0;
[9288]	196	case offGR:
[8961]	197	if (tLC == t_lc::GIM \|\| tLC == t_lc::Tz0) {return 0.0;}
[7237]	198	return (obs->prn().system() == 'R') ? 1.0 : 0.0;
[9288]	199	case offGE:
[8993]	200	if (tLC == t_lc::GIM \|\| tLC == t_lc::Tz0) {return 0.0;}
[9288]	201	return (obs->prn().system() == 'E') ? 1.0 : 0.0;
	202	case offGC:
	203	if (tLC == t_lc::GIM \|\| tLC == t_lc::Tz0) {return 0.0;}
[8993]	204	return (obs->prn().system() == 'C') ? 1.0 : 0.0;
[7237]	205	case amb:
[8961]	206	if (tLC == t_lc::GIM \|\| tLC == t_lc::Tz0) {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 if (tLC == t_lc::Tz0) {
	236	return 1.0;
	237	}
	238	else {
	239	return 1.0 / sin(obs->eleSat());
	240	}
[8905]	241	case ion:
[7237]	242	if (obs->prn() == _prn) {
[8905]	243	if (tLC == t_lc::c1) {
	244	return ionoCoeff[t_lc::toFreq(obs->prn().system(),t_lc::c1)];
[7237]	245	}
[8905]	246	else if (tLC == t_lc::c2) {
	247	return ionoCoeff[t_lc::toFreq(obs->prn().system(),t_lc::c2)];
[7237]	248	}
[8905]	249	else if (tLC == t_lc::l1) {
	250	return ionoCoeff[t_lc::toFreq(obs->prn().system(),t_lc::l1)];
[7237]	251	}
[8905]	252	else if (tLC == t_lc::l2) {
	253	return ionoCoeff[t_lc::toFreq(obs->prn().system(),t_lc::l2)];
	254	}
	255	else if (tLC == t_lc::GIM) {
	256	return -1.0;
	257	}
[7237]	258	}
[8956]	259	if (tLC == t_lc::GIM && _prn == refPrn) {
[8961]	260	return 1.0;
[8905]	261	}
	262	break;
[9386]	263	case cBiasG1:
	264	if ((obs->prn().system() == 'G') && (tLC == t_lc::c1)) {return 1.0;} else {return 0.0;}
[8905]	265	break;
[9386]	266	case cBiasR1:
	267	if ((obs->prn().system() == 'R') && (tLC == t_lc::c1)) {return 1.0;} else {return 0.0;}
[8905]	268	break;
[9386]	269	case cBiasE1:
	270	if ((obs->prn().system() == 'E') && (tLC == t_lc::c1)) {return 1.0;} else {return 0.0;}
[8905]	271	break;
[9386]	272	case cBiasC1:
	273	if ((obs->prn().system() == 'C') && (tLC == t_lc::c1)) {return 1.0;} else {return 0.0;}
	274	break;
	275	case cBiasG2:
	276	if ((obs->prn().system() == 'G') && (tLC == t_lc::c2)) {return 1.0;} else {return 0.0;}
	277	break;
	278	case cBiasR2:
	279	if ((obs->prn().system() == 'R') && (tLC == t_lc::c2)) {return 1.0;} else {return 0.0;}
	280	break;
	281	case cBiasE2:
	282	if ((obs->prn().system() == 'E') && (tLC == t_lc::c2)) {return 1.0;} else {return 0.0;}
	283	break;
	284	case cBiasC2:
	285	if ((obs->prn().system() == 'C') && (tLC == t_lc::c2)) {return 1.0;} else {return 0.0;}
	286	break;
	287	case pBiasG1:
	288	if ((obs->prn().system() == 'G') && (tLC == t_lc::l1)) {return 1.0;} else {return 0.0;}
	289	break;
[9419]	290	case pBiasR1:
	291	if ((obs->prn().system() == 'R') && (tLC == t_lc::l1)) {return 1.0;} else {return 0.0;}
	292	break;
[9386]	293	case pBiasE1:
	294	if ((obs->prn().system() == 'E') && (tLC == t_lc::l1)) {return 1.0;} else {return 0.0;}
	295	break;
	296	case pBiasC1:
	297	if ((obs->prn().system() == 'C') && (tLC == t_lc::l1)) {return 1.0;} else {return 0.0;}
	298	break;
	299	case pBiasG2:
	300	if ((obs->prn().system() == 'G') && (tLC == t_lc::l2)) {return 1.0;} else {return 0.0;}
	301	break;
[9419]	302	case pBiasR2:
	303	if ((obs->prn().system() == 'R') && (tLC == t_lc::l2)) {return 1.0;} else {return 0.0;}
	304	break;
[9386]	305	case pBiasE2:
	306	if ((obs->prn().system() == 'E') && (tLC == t_lc::l2)) {return 1.0;} else {return 0.0;}
	307	break;
	308	case pBiasC2:
	309	if ((obs->prn().system() == 'C') && (tLC == t_lc::l2)) {return 1.0;} else {return 0.0;}
	310	break;
	311
[7237]	312	}
	313	return 0.0;
	314	}
	315
	316	//
	317	////////////////////////////////////////////////////////////////////////////
	318	string t_pppParam::toString() const {
	319	stringstream ss;
	320	switch (_type) {
	321	case crdX:
	322	ss << "CRD_X";
	323	break;
	324	case crdY:
	325	ss << "CRD_Y";
	326	break;
	327	case crdZ:
	328	ss << "CRD_Z";
	329	break;
	330	case clkR:
[9386]	331	ss << "REC_CLK ";
[7237]	332	break;
[9288]	333	case offGR:
[9386]	334	ss << "OGR ";
[7237]	335	break;
[9288]	336	case offGE:
[9386]	337	ss << "OGE ";
[9288]	338	break;
	339	case offGC:
[9386]	340	ss << "OGC ";
[8993]	341	break;
[7237]	342	case trp:
[9386]	343	ss << "TRP ";
[7237]	344	break;
[8905]	345	case amb:
	346	ss << "AMB " << left << setw(3) << t_lc::toString(_tLC) << right << ' ' << _prn.toString();
	347	break;
	348	case ion:
	349	ss << "ION " << left << setw(3) << t_lc::toString(_tLC) << right << ' ' << _prn.toString();
	350	break;
[9386]	351	case cBiasG1: case pBiasG1:
	352	case cBiasG2: case pBiasG2:
	353	ss << "BIA " << left << setw(3) << t_lc::toString(_tLC) << right << " G ";
[8905]	354	break;
[9419]	355	case cBiasR1: case pBiasR1:
	356	case cBiasR2: case pBiasR2:
[9386]	357	ss << "BIA " << left << setw(3) << t_lc::toString(_tLC) << right << " R ";
	358	break;
	359	case cBiasE1: case pBiasE1:
	360	case cBiasE2: case pBiasE2:
	361	ss << "BIA " << left << setw(3) << t_lc::toString(_tLC) << right << " E ";
	362	break;
	363	case cBiasC1: case pBiasC1:
	364	case cBiasC2: case pBiasC2:
	365	ss << "BIA " << left << setw(3) << t_lc::toString(_tLC) << right << " C ";
	366	break;
[7237]	367	}
	368	return ss.str();
	369	}
	370
	371	// Constructor
	372	////////////////////////////////////////////////////////////////////////////
	373	t_pppParlist::t_pppParlist() {
	374	}
	375
	376	// Destructor
	377	////////////////////////////////////////////////////////////////////////////
	378	t_pppParlist::~t_pppParlist() {
[9504]	379	_usedSystems.clear();
	380
	381	vector<t_pppParam*>::iterator it = _params.begin();
	382	while (it != _params.end()) {
	383	t_pppParam* par = *it;
	384	delete par;
	385	it = _params.erase(it);
[7237]	386	}
	387	}
	388
	389	//
	390	////////////////////////////////////////////////////////////////////////////
[9504]	391	t_pppParlist::t_pppParlist(const t_pppParlist& old) {
	392
	393	_usedSystems = old._usedSystems;
	394
	395	vector<t_pppParam*>::const_iterator it = old.params().begin();
	396	while (it != old.params().end()) {
	397	const t_pppParam* oldParam = *it;
	398	_params.push_back(new t_pppParam(oldParam));
	399	}
	400	}
	401
	402	//
	403	////////////////////////////////////////////////////////////////////////////
	404	const t_pppParlist& t_pppParlist::operator= (const t_pppParlist& p) {
	405
	406	_usedSystems.clear();
	407
	408	_usedSystems = p._usedSystems;
	409
	410	vector<t_pppParam*>::iterator it = _params.begin();
	411	while (it != _params.end()) {
	412	t_pppParam* par = *it;
	413	delete par;
	414	it = _params.erase(it);
	415	}
	416
	417	for (unsigned jj = 0; jj < p.params().size(); jj++) {
	418	t_pppParam* parFrom = p.params()[jj];
	419	_params.push_back(new t_pppParam(parFrom));
	420	}
	421	return *this;
	422	}
	423
	424	//
	425	////////////////////////////////////////////////////////////////////////////
[9419]	426	t_irc t_pppParlist::set(const bncTime& epoTime, const std::vector<t_pppSatObs*>& obsVector,
[8956]	427	const QMap<char, t_pppRefSat*>& refSatMap) {
[7237]	428
	429	// Remove some Parameters
	430	// ----------------------
	431	vector<t_pppParam*>::iterator it = _params.begin();
	432	while (it != _params.end()) {
	433	t_pppParam* par = *it;
	434
	435	bool remove = false;
	436
	437	if (par->epoSpec()) {
	438	remove = true;
	439	}
	440
[8956]	441	else if (par->type() == t_pppParam::crdX \|\|
[7988]	442	par->type() == t_pppParam::crdY \|\|
	443	par->type() == t_pppParam::crdZ) {
[7973]	444	if (par->lastObsTime().valid() && (epoTime - par->lastObsTime() > 60.0)) {
[7237]	445	remove = true;
	446	}
	447	}
[9419]	448
[8956]	449	else if (par->type() == t_pppParam::amb) {
[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	}
[9419]	458	else {
	459	if (par->lastObsTime().valid() && (epoTime - par->lastObsTime() > 60.0)) {
	460	remove = true;
	461	}
[8956]	462	}
	463	}
[7237]	464
[9447]	465	else if (par->type() == t_pppParam::ion) {
[9527]	466	if (par->lastObsTime().valid() && (epoTime - par->lastObsTime() > 60.0)) {
	467	remove = true;
[9447]	468	}
	469	}
[7237]	470	if (remove) {
[9508]	471	#ifdef BNC_DEBUG_PPP
[9527]	472	LOG << "remove0 " << par->toString() << std::endl;
[9508]	473	#endif
[7237]	474	delete par;
	475	it = _params.erase(it);
	476	}
	477	else {
	478	++it;
	479	}
	480	}
	481
	482	// Check whether parameters have observations
	483	// ------------------------------------------
	484	for (unsigned ii = 0; ii < _params.size(); ii++) {
	485	t_pppParam* par = _params[ii];
	486	if (par->prn() == 0) {
	487	par->setLastObsTime(epoTime);
	488	if (par->firstObsTime().undef()) {
	489	par->setFirstObsTime(epoTime);
	490	}
	491	}
	492	else {
	493	for (unsigned jj = 0; jj < obsVector.size(); jj++) {
	494	const t_pppSatObs* satObs = obsVector[jj];
	495	if (satObs->prn() == par->prn()) {
	496	par->setLastObsTime(epoTime);
	497	if (par->firstObsTime().undef()) {
	498	par->setFirstObsTime(epoTime);
	499	}
	500	break;
	501	}
	502	}
	503	}
	504	}
	505
[9527]	506
[9419]	507	if (OPT->_obsModelType == OPT->DCMcodeBias \|\|
	508	OPT->_obsModelType == OPT->DCMphaseBias) {
[9527]	509	// Check if ambiguity parameters have observations
	510	// -----------------------------------------------
[9419]	511	vector<t_pppParam*>::iterator it = _params.begin();
[9527]	512	QList<t_prn> lostSats;
[9419]	513	while (it != _params.end()) {
	514	t_pppParam* par = *it;
[9527]	515	if ((par->type() == t_pppParam::amb) &&
[9528]	516	(!par->lastObsTime().valid() \|\| (epoTime - par->lastObsTime() > 0.0))) {
[9508]	517	#ifdef BNC_DEBUG_PPP
[9527]	518	LOG << "remove1 " << par->toString() << std::endl;
[9508]	519	#endif
[9527]	520	lostSats.append(par->prn());
[9419]	521	delete par;
	522	it = _params.erase(it);
	523	}
	524	else {
	525	++it;
	526	}
	527	}
[9527]	528	// remove respective iono parameters
	529	// ---------------------------------
	530	it = _params.begin();
	531	while (it != _params.end()) {
	532	t_pppParam* par = *it;
	533	if ((par->type() == t_pppParam::ion) &&
[9528]	534	(lostSats.contains(par->prn()) \|\| (epoTime - par->lastObsTime() > 0.0))) {
[9527]	535	#ifdef BNC_DEBUG_PPP
	536	LOG << "remove1 " << par->toString() << std::endl;
	537	#endif
	538	delete par;
	539	it = _params.erase(it);
	540	}
	541	else {
	542	++it;
	543	}
	544	}
[9419]	545	}
	546
	547	// check which systems have observations
	548	// -------------------------------------
	549	_usedSystems.clear();
	550	for (unsigned jj = 0; jj < obsVector.size(); jj++) {
	551	const t_pppSatObs* satObs = obsVector[jj];
	552	char sys = satObs->prn().system();
	553	if (!_usedSystems.contains(sys)) {
	554	_usedSystems.append(sys);
	555	}
	556	}
	557
[9498]	558	if (_usedSystems.size() > 1 &&
	559	!_usedSystems.contains('G')) { // required to setup ISB w. r. t. GPS
	560	return failure;
	561	}
	562
[7237]	563	// Required Set of Parameters
	564	// --------------------------
	565	vector<t_pppParam*> required;
	566
	567	// Coordinates
	568	// -----------
	569	required.push_back(new t_pppParam(t_pppParam::crdX, t_prn(), t_lc::dummy));
	570	required.push_back(new t_pppParam(t_pppParam::crdY, t_prn(), t_lc::dummy));
	571	required.push_back(new t_pppParam(t_pppParam::crdZ, t_prn(), t_lc::dummy));
	572
[9386]	573	// Receiver Code Biases
	574	// --------------------
	575	if (OPT->_obsModelType == OPT->DCMcodeBias) {
[9494]	576	std::vector<t_lc::type> lc;
[9419]	577	if (_usedSystems.contains('G')) {
[9494]	578	lc = OPT->LCs('G');
	579	if (std::find(lc.begin(), lc.end(), t_lc::c1) != lc.end()) {
	580	required.push_back(new t_pppParam(t_pppParam::cBiasG1, t_prn(), t_lc::c1));
	581	}
	582	if (std::find(lc.begin(), lc.end(), t_lc::c2) != lc.end()) {
	583	required.push_back(new t_pppParam(t_pppParam::cBiasG2, t_prn(), t_lc::c2));
	584	}
[9386]	585	}
[9419]	586	if (_usedSystems.contains('R')) {
[9494]	587	lc = OPT->LCs('R');
	588	if (std::find(lc.begin(), lc.end(), t_lc::c1) != lc.end()) {
	589	required.push_back(new t_pppParam(t_pppParam::cBiasR1, t_prn(), t_lc::c1));
	590	}
	591	if (std::find(lc.begin(), lc.end(), t_lc::c2) != lc.end()) {
	592	required.push_back(new t_pppParam(t_pppParam::cBiasR2, t_prn(), t_lc::c2));
	593	}
[9386]	594	}
[9419]	595	if (_usedSystems.contains('E')) {
[9494]	596	lc = OPT->LCs('E');
	597	if (std::find(lc.begin(), lc.end(), t_lc::c1) != lc.end()) {
	598	required.push_back(new t_pppParam(t_pppParam::cBiasE1, t_prn(), t_lc::c1));
	599	}
	600	if (std::find(lc.begin(), lc.end(), t_lc::c2) != lc.end()) {
	601	required.push_back(new t_pppParam(t_pppParam::cBiasE2, t_prn(), t_lc::c2));
	602	}
[9386]	603	}
[9419]	604	if (_usedSystems.contains('C')) {
[9494]	605	lc = OPT->LCs('C');
	606	if (std::find(lc.begin(), lc.end(), t_lc::c1) != lc.end()) {
	607	required.push_back(new t_pppParam(t_pppParam::cBiasC1, t_prn(), t_lc::c1));
	608	}
	609	if (std::find(lc.begin(), lc.end(), t_lc::c2) != lc.end()) {
	610	required.push_back(new t_pppParam(t_pppParam::cBiasC2, t_prn(), t_lc::c2));
	611	}
[9386]	612	}
	613	}
	614
	615	// Receiver Phase Biases
	616	// ---------------------
	617	if ((OPT->_obsModelType == OPT->DCMphaseBias) \|\|
	618	(OPT->_obsModelType == OPT->PPPRTK) ) {
[9494]	619	std::vector<t_lc::type> lc;
[9419]	620	if (_usedSystems.contains('G')) {
[9494]	621	lc = OPT->LCs('G');
	622	if (std::find(lc.begin(), lc.end(), t_lc::l1) != lc.end()) {
	623	required.push_back(new t_pppParam(t_pppParam::pBiasG1, t_prn(), t_lc::l1));
	624	}
	625	if (std::find(lc.begin(), lc.end(), t_lc::l2) != lc.end()) {
	626	required.push_back(new t_pppParam(t_pppParam::pBiasG2, t_prn(), t_lc::l2));
	627	}
[9386]	628	}
[9419]	629	if (_usedSystems.contains('R')) {
[9494]	630	lc = OPT->LCs('R');
	631	if (std::find(lc.begin(), lc.end(), t_lc::l1) != lc.end()) {
	632	required.push_back(new t_pppParam(t_pppParam::pBiasR1, t_prn(), t_lc::l1));
	633	}
	634	if (std::find(lc.begin(), lc.end(), t_lc::l2) != lc.end()) {
	635	required.push_back(new t_pppParam(t_pppParam::pBiasR2, t_prn(), t_lc::l2));
	636	}
	637
[9419]	638	}
	639	if (_usedSystems.contains('E')) {
[9494]	640	lc = OPT->LCs('E');
	641	if (std::find(lc.begin(), lc.end(), t_lc::l1) != lc.end()) {
	642	required.push_back(new t_pppParam(t_pppParam::pBiasE1, t_prn(), t_lc::l1));
	643	}
	644	if (std::find(lc.begin(), lc.end(), t_lc::l2) != lc.end()) {
	645	required.push_back(new t_pppParam(t_pppParam::pBiasE2, t_prn(), t_lc::l2));
	646	}
[9386]	647	}
[9419]	648	if (_usedSystems.contains('C')) {
[9494]	649	lc = OPT->LCs('C');
	650	if (std::find(lc.begin(), lc.end(), t_lc::l1) != lc.end()) {
	651	required.push_back(new t_pppParam(t_pppParam::pBiasC1, t_prn(), t_lc::l1));
	652	}
	653	if (std::find(lc.begin(), lc.end(), t_lc::l2) != lc.end()) {
	654	required.push_back(new t_pppParam(t_pppParam::pBiasC2, t_prn(), t_lc::l2));
	655	}
[9386]	656	}
	657	}
[9419]	658
[7237]	659	// Receiver Clock
	660	// --------------
	661	required.push_back(new t_pppParam(t_pppParam::clkR, t_prn(), t_lc::dummy));
	662
[8905]	663	// GPS-GLONASS Clock Offset
[7237]	664	// ------------------------
[9498]	665	if (_usedSystems.contains('G') && _usedSystems.contains('R')) {
	666	required.push_back(new t_pppParam(t_pppParam::offGR, t_prn(), t_lc::dummy));
	667	}
[7237]	668
[9419]	669	//GPS-Galileo Clock Offset
[9288]	670	// ------------------------
[9498]	671	if (_usedSystems.contains('G') && _usedSystems.contains('E')) {
	672	required.push_back(new t_pppParam(t_pppParam::offGE, t_prn(), t_lc::dummy));
	673	}
[9288]	674
[8993]	675	// GPS-BDS Clock Offset
	676	// ------------------------
[9498]	677	if (_usedSystems.contains('G') && _usedSystems.contains('C')) {
	678	required.push_back(new t_pppParam(t_pppParam::offGC, t_prn(), t_lc::dummy));
	679	}
[8993]	680
[7237]	681	// Troposphere
	682	// -----------
	683	if (OPT->estTrp()) {
	684	required.push_back(new t_pppParam(t_pppParam::trp, t_prn(), t_lc::dummy));
	685	}
	686
[8905]	687	// Ionosphere
	688	// ----------
	689	if (OPT->_obsModelType == OPT->UncombPPP \|\|
	690	OPT->_obsModelType == OPT->DCMcodeBias \|\|
	691	OPT->_obsModelType == OPT->DCMphaseBias ) {
	692	for (unsigned jj = 0; jj < obsVector.size(); jj++) {
[9386]	693	const t_pppSatObs* satObs = obsVector[jj];
[8905]	694	required.push_back(new t_pppParam(t_pppParam::ion, satObs->prn(), t_lc::dummy));
	695	}
	696	}
[7237]	697	// Ambiguities
	698	// -----------
	699	for (unsigned jj = 0; jj < obsVector.size(); jj++) {
[9419]	700	const t_pppSatObs* satObs = obsVector[jj];
[8905]	701	if ((OPT->_obsModelType == OPT->IF) \|\|
	702	(OPT->_obsModelType == OPT->PPPRTK) \|\|
	703	(OPT->_obsModelType == OPT->UncombPPP) \|\|
	704	(OPT->_obsModelType == OPT->DCMcodeBias && !satObs->isReference()) \|\|
	705	(OPT->_obsModelType == OPT->DCMphaseBias && !satObs->isReference()) ) {
	706	const vector<t_lc::type>& ambLCs = OPT->ambLCs(satObs->prn().system());
	707	for (unsigned ii = 0; ii < ambLCs.size(); ii++) {
	708	required.push_back(new t_pppParam(t_pppParam::amb, satObs->prn(), ambLCs[ii], &obsVector));
	709	}
[7237]	710	}
	711	}
	712
	713	// Check if all required parameters are present
	714	// --------------------------------------------
	715	for (unsigned ii = 0; ii < required.size(); ii++) {
	716	t_pppParam* parReq = required[ii];
	717
	718	bool found = false;
	719	for (unsigned jj = 0; jj < _params.size(); jj++) {
	720	t_pppParam* parOld = _params[jj];
	721	if (parOld->isEqual(parReq)) {
	722	found = true;
	723	break;
	724	}
	725	}
	726	if (found) {
	727	delete parReq;
	728	}
	729	else {
[9508]	730	#ifdef BNC_DEBUG_PPP
	731	LOG << "push_back parReq " << parReq->toString() << std::endl;
	732	#endif
[7237]	733	_params.push_back(parReq);
	734	}
	735	}
	736
	737	// Set Parameter Indices
	738	// ---------------------
	739	sort(_params.begin(), _params.end(), t_pppParam::sortFunction);
	740
	741	for (unsigned ii = 0; ii < _params.size(); ii++) {
	742	t_pppParam* par = _params[ii];
	743	par->setIndex(ii);
	744	for (unsigned jj = 0; jj < obsVector.size(); jj++) {
	745	const t_pppSatObs* satObs = obsVector[jj];
	746	if (satObs->prn() == par->prn()) {
	747	par->setAmbEleSat(satObs->eleSat());
	748	par->stepAmbNumEpo();
	749	}
	750	}
	751	}
	752
	753	return success;
	754	}
	755
	756	//
	757	////////////////////////////////////////////////////////////////////////////
	758	void t_pppParlist::printResult(const bncTime& epoTime, const SymmetricMatrix& QQ,
	759	const ColumnVector& xx) const {
	760
	761	string epoTimeStr = string(epoTime);
	762	const t_pppStation* sta = PPP_CLIENT->staRover();
	763
	764	LOG << endl;
	765
	766	t_pppParam* parX = 0;
	767	t_pppParam* parY = 0;
	768	t_pppParam* parZ = 0;
[9504]	769	vector<t_pppParam*>::const_iterator it = _params.begin();
	770	while (it != _params.end()) {
	771	t_pppParam* par = *it;
[7237]	772	if (par->type() == t_pppParam::crdX) {
	773	parX = par;
	774	}
	775	else if (par->type() == t_pppParam::crdY) {
	776	parY = par;
	777	}
	778	else if (par->type() == t_pppParam::crdZ) {
	779	parZ = par;
	780	}
	781	else {
	782	int ind = par->indexNew();
	783	double apr = (par->type() == t_pppParam::trp) ?
	784	t_tropo::delay_saast(sta->xyzApr(), M_PI/2.0) : par->x0();
	785	LOG << epoTimeStr << ' ' << par->toString() << ' '
	786	<< setw(10) << setprecision(4) << apr << ' '
	787	<< showpos << setw(10) << setprecision(4) << xx[ind] << noshowpos << " +- "
	788	<< setw(8) << setprecision(4) << sqrt(QQ[ind][ind]);
	789	if (par->type() == t_pppParam::amb) {
	790	LOG << " el = " << setw(6) << setprecision(2) << par->ambEleSat() * 180.0 / M_PI
	791	<< " epo = " << setw(4) << par->ambNumEpo();
	792	}
	793	LOG << endl;
	794	}
[9504]	795	++it;
[7237]	796	}
	797
	798	if (parX && parY && parZ) {
	799
	800	ColumnVector xyz(3);
	801	xyz[0] = xx[parX->indexNew()];
	802	xyz[1] = xx[parY->indexNew()];
	803	xyz[2] = xx[parZ->indexNew()];
	804
	805	ColumnVector neu(3);
	806	xyz2neu(sta->ellApr().data(), xyz.data(), neu.data());
	807
	808	SymmetricMatrix QQxyz = QQ.SymSubMatrix(1,3);
	809
	810	SymmetricMatrix QQneu(3);
	811	covariXYZ_NEU(QQxyz, sta->ellApr().data(), QQneu);
	812
	813	LOG << epoTimeStr << ' ' << sta->name()
	814	<< " X = " << setprecision(4) << sta->xyzApr()[0] + xyz[0] << " +- "
	815	<< setprecision(4) << sqrt(QQxyz[0][0])
	816
	817	<< " Y = " << setprecision(4) << sta->xyzApr()[1] + xyz[1] << " +- "
	818	<< setprecision(4) << sqrt(QQxyz[1][1])
	819
	820	<< " Z = " << setprecision(4) << sta->xyzApr()[2] + xyz[2] << " +- "
	821	<< setprecision(4) << sqrt(QQxyz[2][2])
	822
	823	<< " dN = " << setprecision(4) << neu[0] << " +- "
	824	<< setprecision(4) << sqrt(QQneu[0][0])
	825
	826	<< " dE = " << setprecision(4) << neu[1] << " +- "
	827	<< setprecision(4) << sqrt(QQneu[1][1])
	828
	829	<< " dU = " << setprecision(4) << neu[2] << " +- "
	830	<< setprecision(4) << sqrt(QQneu[2][2])
	831
	832	<< endl;
	833	}
	834	}
	835
[9525]	836	//
	837	////////////////////////////////////////////////////////////////////////////
[9527]	838	void t_pppParlist::printParams(const bncTime& epoTime) {
[9526]	839
	840	for (unsigned iPar = 0; iPar < _params.size(); iPar++) {
[9527]	841	LOG << _params[iPar]->toString()
	842	<< "\t lastObsTime().valid() \t" << _params[iPar]->lastObsTime().valid()
	843	<< "\t epoTime - par->lastObsTime() \t" << (epoTime - _params[iPar]->lastObsTime())
	844	<< endl;
[9525]	845	}
	846	}
	847

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

Download in other formats:

Original Format