Context Navigation

pppParlist.cpp@ 9486

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

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

Download in other formats:

Original Format