Context Navigation

pppParlist.cpp@ 10158

Last change on this file since 10158 was 10034, checked in by stuerze, 19 months ago

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.0 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;
[10034]	64	case clkR:
[7237]	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) {
[10034]	76	double offGlo = 0;
	77	if (_prn.system() == 'R' && tLC != t_lc::MW) {
	78	offGlo = PPP_CLIENT->offGlo();
	79	}
	80	double offGal = 0;
	81	if (_prn.system() == 'E' && tLC != t_lc::MW) {
	82	offGal = PPP_CLIENT->offGal();
	83	}
	84	double offBds = 0;
	85	if (_prn.system() == 'C' && tLC != t_lc::MW) {
	86	offBds = PPP_CLIENT->offBds();
	87	}
	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;
[10034]	94	case offGlo:
	95	_epoSpec = true;
	96	_sigma0 = OPT->_aprSigClk;
	97	_x0 = PPP_CLIENT->offGlo();
	98	break;
	99	case offGal:
	100	_epoSpec = true;
	101	_sigma0 = OPT->_aprSigClk;
	102	_x0 = PPP_CLIENT->offGal();
	103	break;
	104	case offBds:
	105	_epoSpec = true;
	106	_sigma0 = OPT->_aprSigClk;
	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();
[10034]	170	case clkR:
[9548]	171	if (tLC == t_lc::GIM) {return 0.0;}
[10034]	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;
[10034]	176	case offGal:
[10003]	177	if (tLC == t_lc::GIM) {return 0.0;}
	178	return (obs->prn().system() == 'E') ? 1.0 : 0.0;
[10034]	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) {
	196	return obs->lambda(t_lc::l1) * phaseCoeff[t_lc::toFreq(obs->prn().system(),t_lc::l1)];
	197	}
	198	else if (_tLC == t_lc::l2) {
	199	return obs->lambda(t_lc::l2) * phaseCoeff[t_lc::toFreq(obs->prn().system(),t_lc::l2)];
	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) {
	215	return ionoCoeff[t_lc::toFreq(obs->prn().system(),t_lc::c1)];
[7237]	216	}
[8905]	217	else if (tLC == t_lc::c2) {
	218	return ionoCoeff[t_lc::toFreq(obs->prn().system(),t_lc::c2)];
[7237]	219	}
[8905]	220	else if (tLC == t_lc::l1) {
	221	return ionoCoeff[t_lc::toFreq(obs->prn().system(),t_lc::l1)];
[7237]	222	}
[8905]	223	else if (tLC == t_lc::l2) {
	224	return ionoCoeff[t_lc::toFreq(obs->prn().system(),t_lc::l2)];
	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;
[10034]	298	case clkR:
	299	ss << "REC_CLK ";
[7237]	300	break;
[10034]	301	case offGlo:
	302	ss << "OFF_GLO ";
[7237]	303	break;
[10034]	304	case offGal:
	305	ss << "OFF_GAL ";
[10003]	306	break;
[10034]	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	_usedSystems.clear();
	348
[10034]	349	for (unsigned ii = 0; ii < _params.size(); ii++) {
	350	delete _params[ii];
[7237]	351	}
	352	}
	353
	354	//
	355	////////////////////////////////////////////////////////////////////////////
[10034]	356	t_irc t_pppParlist::set(const bncTime& epoTime, const std::vector<t_pppSatObs*>& obsVector) {
[9504]	357
[7237]	358	// Remove some Parameters
	359	// ----------------------
	360	vector<t_pppParam*>::iterator it = _params.begin();
	361	while (it != _params.end()) {
	362	t_pppParam* par = *it;
	363
	364	bool remove = false;
	365
	366	if (par->epoSpec()) {
	367	remove = true;
	368	}
	369
[10034]	370	else if (par->type() == t_pppParam::amb \|\|
	371	par->type() == t_pppParam::ion \|\|
	372	par->type() == t_pppParam::crdX \|\|
[7988]	373	par->type() == t_pppParam::crdY \|\|
	374	par->type() == t_pppParam::crdZ) {
[7973]	375	if (par->lastObsTime().valid() && (epoTime - par->lastObsTime() > 60.0)) {
[7237]	376	remove = true;
	377	}
	378	}
[9419]	379
[7237]	380	if (remove) {
[9508]	381	#ifdef BNC_DEBUG_PPP
[10018]	382	// LOG << "remove0 " << par->toString() << std::endl;
[9508]	383	#endif
[7237]	384	delete par;
	385	it = _params.erase(it);
	386	}
	387	else {
	388	++it;
	389	}
	390	}
	391
[9532]	392	// check which systems have observations
	393	// -------------------------------------
	394	_usedSystems.clear();
	395	for (unsigned jj = 0; jj < obsVector.size(); jj++) {
	396	const t_pppSatObs* satObs = obsVector[jj];
[9533]	397	char sys = satObs->prn().system();
[9532]	398	if (!_usedSystems.contains(sys)) {
	399	_usedSystems.append(sys);
	400	}
	401	}
	402
[7237]	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
[10034]	427	if (OPT->_obsModelType == OPT->PPPRTK \|\| OPT->_pseudoObsIono) {
[9419]	428	vector<t_pppParam*>::iterator it = _params.begin();
	429	while (it != _params.end()) {
	430	t_pppParam* par = *it;
[9532]	431	// Check if systems have to be presented per biases
[9535]	432	// ----------------------------------------------
[10034]	433	if (( par->type() == t_pppParam::cBiasG1 \|\|
[9532]	434	par->type() == t_pppParam::cBiasG2 \|\|
	435	par->type() == t_pppParam::pBiasG1 \|\|
	436	par->type() == t_pppParam::pBiasG2) && !usedSystems().contains('G')) {
[9534]	437	#ifdef BNC_DEBUG_PPP
[10031]	438	//LOG << "remove1 " << par->toString() << std::endl;
[9534]	439	#endif
[9548]	440	delete par;
	441	it = _params.erase(it);
[9532]	442	}
[9561]	443	else if ((par->type() == t_pppParam::cBiasR1 \|\|
	444	par->type() == t_pppParam::cBiasR2 \|\|
	445	par->type() == t_pppParam::pBiasR1 \|\|
	446	par->type() == t_pppParam::pBiasR2) && !usedSystems().contains('R')) {
	447	#ifdef BNC_DEBUG_PPP
[10031]	448	//LOG << "remove1 " << par->toString() << std::endl;
[9561]	449	#endif
	450	delete par;
	451	it = _params.erase(it);
	452	}
[9532]	453	else if ((par->type() == t_pppParam::cBiasE1 \|\|
	454	par->type() == t_pppParam::cBiasE2 \|\|
	455	par->type() == t_pppParam::pBiasE1 \|\|
	456	par->type() == t_pppParam::pBiasE2) && !usedSystems().contains('E')) {
[9534]	457	#ifdef BNC_DEBUG_PPP
[10031]	458	//LOG << "remove1 " << par->toString() << std::endl;
[9534]	459	#endif
[9548]	460	delete par;
	461	it = _params.erase(it);
[9532]	462	}
	463	else if ((par->type() == t_pppParam::cBiasC1 \|\|
	464	par->type() == t_pppParam::cBiasC2 \|\|
	465	par->type() == t_pppParam::pBiasC1 \|\|
[9548]	466	par->type() == t_pppParam::pBiasC2) && !usedSystems().contains('C')) {
[9534]	467	#ifdef BNC_DEBUG_PPP
[10031]	468	//LOG << "remove1 " << par->toString() << std::endl;
[9534]	469	#endif
[9548]	470	delete par;
	471	it = _params.erase(it);
[9532]	472	}
[9419]	473	else {
	474	++it;
	475	}
	476	}
	477	}
	478
[7237]	479	// Required Set of Parameters
	480	// --------------------------
	481	vector<t_pppParam*> required;
	482
	483	// Coordinates
	484	// -----------
	485	required.push_back(new t_pppParam(t_pppParam::crdX, t_prn(), t_lc::dummy));
	486	required.push_back(new t_pppParam(t_pppParam::crdY, t_prn(), t_lc::dummy));
	487	required.push_back(new t_pppParam(t_pppParam::crdZ, t_prn(), t_lc::dummy));
	488
[10034]	489	// Receiver Clock
	490	// --------------
	491	required.push_back(new t_pppParam(t_pppParam::clkR, t_prn(), t_lc::dummy));
	492
	493	// GLONASS Clock Offset
	494	// --------------------
	495	if ( _usedSystems.contains('R') &&
	496	(_usedSystems.contains('G') \|\| _usedSystems.contains('E') \|\| _usedSystems.contains('C'))) {
	497	required.push_back(new t_pppParam(t_pppParam::offGlo, t_prn(), t_lc::dummy));
	498	}
	499
	500	// Galileo Clock Offset
	501	// --------------------
	502	if (_usedSystems.contains('E') && _usedSystems.contains('G')) {
	503	required.push_back(new t_pppParam(t_pppParam::offGal, t_prn(), t_lc::dummy));
	504	}
	505
	506	// BDS Clock Offset
	507	// ----------------
	508	if (_usedSystems.contains('C') && (_usedSystems.contains('G') \|\| _usedSystems.contains('E'))) {
	509	required.push_back(new t_pppParam(t_pppParam::offBds, t_prn(), t_lc::dummy));
	510	}
	511
	512	// Troposphere
	513	// -----------
	514	if (OPT->estTrp()) {
	515	required.push_back(new t_pppParam(t_pppParam::trp, t_prn(), t_lc::dummy));
	516	}
	517
	518	// Ionosphere
	519	// ----------
	520	if (OPT->_obsModelType == OPT->UncombPPP) {
	521	for (unsigned jj = 0; jj < obsVector.size(); jj++) {
	522	const t_pppSatObs* satObs = obsVector[jj];
	523	required.push_back(new t_pppParam(t_pppParam::ion, satObs->prn(), t_lc::dummy));
	524	}
	525	}
	526	// Ambiguities
	527	// -----------
	528	for (unsigned jj = 0; jj < obsVector.size(); jj++) {
	529	const t_pppSatObs* satObs = obsVector[jj];
	530	const vector<t_lc::type>& ambLCs = OPT->ambLCs(satObs->prn().system());
	531	for (unsigned ii = 0; ii < ambLCs.size(); ii++) {
	532	required.push_back(new t_pppParam(t_pppParam::amb, satObs->prn(), ambLCs[ii], &obsVector));
	533	}
	534	}
	535
[9386]	536	// Receiver Code Biases
	537	// --------------------
[10034]	538	if (OPT->_obsModelType == OPT->PPPRTK) {
[9494]	539	std::vector<t_lc::type> lc;
[9419]	540	if (_usedSystems.contains('G')) {
[9494]	541	lc = OPT->LCs('G');
	542	if (std::find(lc.begin(), lc.end(), t_lc::c1) != lc.end()) {
	543	required.push_back(new t_pppParam(t_pppParam::cBiasG1, t_prn(), t_lc::c1));
	544	}
	545	if (std::find(lc.begin(), lc.end(), t_lc::c2) != lc.end()) {
	546	required.push_back(new t_pppParam(t_pppParam::cBiasG2, t_prn(), t_lc::c2));
	547	}
[9663]	548	}
[9561]	549	if (_usedSystems.contains('R')) {
	550	lc = OPT->LCs('R');
	551	if (std::find(lc.begin(), lc.end(), t_lc::c1) != lc.end()) {
	552	required.push_back(new t_pppParam(t_pppParam::cBiasR1, t_prn(), t_lc::c1));
	553	}
	554	if (std::find(lc.begin(), lc.end(), t_lc::c2) != lc.end()) {
	555	required.push_back(new t_pppParam(t_pppParam::cBiasR2, t_prn(), t_lc::c2));
	556	}
[9663]	557	}
[9419]	558	if (_usedSystems.contains('E')) {
[9494]	559	lc = OPT->LCs('E');
	560	if (std::find(lc.begin(), lc.end(), t_lc::c1) != lc.end()) {
	561	required.push_back(new t_pppParam(t_pppParam::cBiasE1, t_prn(), t_lc::c1));
	562	}
	563	if (std::find(lc.begin(), lc.end(), t_lc::c2) != lc.end()) {
	564	required.push_back(new t_pppParam(t_pppParam::cBiasE2, t_prn(), t_lc::c2));
	565	}
[9386]	566	}
[9419]	567	if (_usedSystems.contains('C')) {
[9494]	568	lc = OPT->LCs('C');
	569	if (std::find(lc.begin(), lc.end(), t_lc::c1) != lc.end()) {
	570	required.push_back(new t_pppParam(t_pppParam::cBiasC1, t_prn(), t_lc::c1));
	571	}
	572	if (std::find(lc.begin(), lc.end(), t_lc::c2) != lc.end()) {
	573	required.push_back(new t_pppParam(t_pppParam::cBiasC2, t_prn(), t_lc::c2));
	574	}
[9386]	575	}
	576	}
[10034]	577	if (OPT->_pseudoObsIono) {
	578	std::vector<t_lc::type> lc;
	579	if (_usedSystems.contains('G')) {
	580	lc = OPT->LCs('G');
	581	if (std::find(lc.begin(), lc.end(), t_lc::c2) != lc.end()) {
	582	required.push_back(new t_pppParam(t_pppParam::cBiasG2, t_prn(), t_lc::c2));
	583	}
	584	}
	585	if (_usedSystems.contains('R')) {
	586	lc = OPT->LCs('R');
	587	if (std::find(lc.begin(), lc.end(), t_lc::c2) != lc.end()) {
	588	required.push_back(new t_pppParam(t_pppParam::cBiasR2, t_prn(), t_lc::c2));
	589	}
	590	}
	591	if (_usedSystems.contains('E')) {
	592	lc = OPT->LCs('E');
	593	if (std::find(lc.begin(), lc.end(), t_lc::c2) != lc.end()) {
	594	required.push_back(new t_pppParam(t_pppParam::cBiasE2, t_prn(), t_lc::c2));
	595	}
	596	}
	597	if (_usedSystems.contains('C')) {
	598	lc = OPT->LCs('C');
	599	if (std::find(lc.begin(), lc.end(), t_lc::c2) != lc.end()) {
	600	required.push_back(new t_pppParam(t_pppParam::cBiasC2, t_prn(), t_lc::c2));
	601	}
	602	}
	603	}
[9386]	604
	605	// Receiver Phase Biases
	606	// ---------------------
[10034]	607	if (OPT->_obsModelType == OPT->PPPRTK) {
[9494]	608	std::vector<t_lc::type> lc;
[9419]	609	if (_usedSystems.contains('G')) {
[9494]	610	lc = OPT->LCs('G');
	611	if (std::find(lc.begin(), lc.end(), t_lc::l1) != lc.end()) {
	612	required.push_back(new t_pppParam(t_pppParam::pBiasG1, t_prn(), t_lc::l1));
	613	}
	614	if (std::find(lc.begin(), lc.end(), t_lc::l2) != lc.end()) {
	615	required.push_back(new t_pppParam(t_pppParam::pBiasG2, t_prn(), t_lc::l2));
	616	}
[9663]	617	}
[9561]	618	if (_usedSystems.contains('R')) {
	619	lc = OPT->LCs('R');
	620	if (std::find(lc.begin(), lc.end(), t_lc::l1) != lc.end()) {
	621	required.push_back(new t_pppParam(t_pppParam::pBiasR1, t_prn(), t_lc::l1));
	622	}
	623	if (std::find(lc.begin(), lc.end(), t_lc::l2) != lc.end()) {
	624	required.push_back(new t_pppParam(t_pppParam::pBiasR2, t_prn(), t_lc::l2));
	625	}
[9663]	626	}
[9419]	627	if (_usedSystems.contains('E')) {
[9494]	628	lc = OPT->LCs('E');
	629	if (std::find(lc.begin(), lc.end(), t_lc::l1) != lc.end()) {
	630	required.push_back(new t_pppParam(t_pppParam::pBiasE1, t_prn(), t_lc::l1));
	631	}
	632	if (std::find(lc.begin(), lc.end(), t_lc::l2) != lc.end()) {
	633	required.push_back(new t_pppParam(t_pppParam::pBiasE2, t_prn(), t_lc::l2));
	634	}
[9386]	635	}
[9419]	636	if (_usedSystems.contains('C')) {
[9494]	637	lc = OPT->LCs('C');
	638	if (std::find(lc.begin(), lc.end(), t_lc::l1) != lc.end()) {
	639	required.push_back(new t_pppParam(t_pppParam::pBiasC1, t_prn(), t_lc::l1));
	640	}
	641	if (std::find(lc.begin(), lc.end(), t_lc::l2) != lc.end()) {
	642	required.push_back(new t_pppParam(t_pppParam::pBiasC2, t_prn(), t_lc::l2));
	643	}
[9386]	644	}
	645	}
[9419]	646
[7237]	647	// Check if all required parameters are present
	648	// --------------------------------------------
	649	for (unsigned ii = 0; ii < required.size(); ii++) {
	650	t_pppParam* parReq = required[ii];
	651
	652	bool found = false;
	653	for (unsigned jj = 0; jj < _params.size(); jj++) {
	654	t_pppParam* parOld = _params[jj];
	655	if (parOld->isEqual(parReq)) {
	656	found = true;
	657	break;
	658	}
	659	}
	660	if (found) {
	661	delete parReq;
	662	}
	663	else {
[9508]	664	#ifdef BNC_DEBUG_PPP
[10031]	665	//LOG << "push_back parReq " << parReq->toString() << std::endl;
[9508]	666	#endif
[7237]	667	_params.push_back(parReq);
	668	}
	669	}
	670
	671	// Set Parameter Indices
	672	// ---------------------
	673	sort(_params.begin(), _params.end(), t_pppParam::sortFunction);
	674
	675	for (unsigned ii = 0; ii < _params.size(); ii++) {
	676	t_pppParam* par = _params[ii];
	677	par->setIndex(ii);
	678	for (unsigned jj = 0; jj < obsVector.size(); jj++) {
	679	const t_pppSatObs* satObs = obsVector[jj];
	680	if (satObs->prn() == par->prn()) {
	681	par->setAmbEleSat(satObs->eleSat());
	682	par->stepAmbNumEpo();
	683	}
	684	}
	685	}
	686
	687	return success;
	688	}
	689
	690	//
	691	////////////////////////////////////////////////////////////////////////////
	692	void t_pppParlist::printResult(const bncTime& epoTime, const SymmetricMatrix& QQ,
	693	const ColumnVector& xx) const {
	694
	695	string epoTimeStr = string(epoTime);
	696	const t_pppStation* sta = PPP_CLIENT->staRover();
	697
	698	LOG << endl;
	699
	700	t_pppParam* parX = 0;
	701	t_pppParam* parY = 0;
	702	t_pppParam* parZ = 0;
[10034]	703	for (unsigned ii = 0; ii < _params.size(); ii++) {
	704	t_pppParam* par = _params[ii];
[7237]	705	if (par->type() == t_pppParam::crdX) {
	706	parX = par;
	707	}
	708	else if (par->type() == t_pppParam::crdY) {
	709	parY = par;
	710	}
	711	else if (par->type() == t_pppParam::crdZ) {
	712	parZ = par;
	713	}
	714	else {
	715	int ind = par->indexNew();
	716	double apr = (par->type() == t_pppParam::trp) ?
	717	t_tropo::delay_saast(sta->xyzApr(), M_PI/2.0) : par->x0();
	718	LOG << epoTimeStr << ' ' << par->toString() << ' '
	719	<< setw(10) << setprecision(4) << apr << ' '
	720	<< showpos << setw(10) << setprecision(4) << xx[ind] << noshowpos << " +- "
	721	<< setw(8) << setprecision(4) << sqrt(QQ[ind][ind]);
	722	if (par->type() == t_pppParam::amb) {
	723	LOG << " el = " << setw(6) << setprecision(2) << par->ambEleSat() * 180.0 / M_PI
	724	<< " epo = " << setw(4) << par->ambNumEpo();
	725	}
	726	LOG << endl;
	727	}
	728	}
	729
	730	if (parX && parY && parZ) {
	731
	732	ColumnVector xyz(3);
	733	xyz[0] = xx[parX->indexNew()];
	734	xyz[1] = xx[parY->indexNew()];
	735	xyz[2] = xx[parZ->indexNew()];
	736
	737	ColumnVector neu(3);
	738	xyz2neu(sta->ellApr().data(), xyz.data(), neu.data());
	739
	740	SymmetricMatrix QQxyz = QQ.SymSubMatrix(1,3);
	741
	742	SymmetricMatrix QQneu(3);
	743	covariXYZ_NEU(QQxyz, sta->ellApr().data(), QQneu);
	744
	745	LOG << epoTimeStr << ' ' << sta->name()
	746	<< " X = " << setprecision(4) << sta->xyzApr()[0] + xyz[0] << " +- "
	747	<< setprecision(4) << sqrt(QQxyz[0][0])
	748
	749	<< " Y = " << setprecision(4) << sta->xyzApr()[1] + xyz[1] << " +- "
	750	<< setprecision(4) << sqrt(QQxyz[1][1])
	751
	752	<< " Z = " << setprecision(4) << sta->xyzApr()[2] + xyz[2] << " +- "
	753	<< setprecision(4) << sqrt(QQxyz[2][2])
	754
	755	<< " dN = " << setprecision(4) << neu[0] << " +- "
	756	<< setprecision(4) << sqrt(QQneu[0][0])
	757
	758	<< " dE = " << setprecision(4) << neu[1] << " +- "
	759	<< setprecision(4) << sqrt(QQneu[1][1])
	760
	761	<< " dU = " << setprecision(4) << neu[2] << " +- "
	762	<< setprecision(4) << sqrt(QQneu[2][2])
	763
	764	<< endl;
	765	}
[9545]	766	return;
[7237]	767	}
	768
[9525]	769	//
	770	////////////////////////////////////////////////////////////////////////////
[9527]	771	void t_pppParlist::printParams(const bncTime& epoTime) {
[9526]	772
	773	for (unsigned iPar = 0; iPar < _params.size(); iPar++) {
[9527]	774	LOG << _params[iPar]->toString()
	775	<< "\t lastObsTime().valid() \t" << _params[iPar]->lastObsTime().valid()
	776	<< "\t epoTime - par->lastObsTime() \t" << (epoTime - _params[iPar]->lastObsTime())
	777	<< endl;
[9525]	778	}
	779	}
	780

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

Download in other formats:

Original Format