Context Navigation

pppParlist.cpp@ 10254

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

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

Download in other formats:

Original Format