Context Navigation

pppParlist.cpp@ 9511

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

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

Download in other formats:

Original Format