Context Navigation

pppParlist.cpp@ 10387

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

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

Download in other formats:

Original Format