Context Navigation

pppParlist.cpp@ 10628

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

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

Download in other formats:

Original Format