Context Navigation

pppParlist.cpp@ 9559

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

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

Download in other formats:

Original Format