source: ntrip/trunk/BNC/src/PPP_SSR_I/pppClient.cpp@ 6967

Last change on this file since 6967 was 6967, checked in by stuerze, 11 years ago

minor changes in order to allow GPSonly PPP (SSR I) and to consider the chosen options regarding the usage of observations from additional systems

  • Property svn:keywords set to Author Date Id Rev URL;svn:eol-style=native
  • Property svn:mime-type set to text/plain
File size: 11.3 KB
Line 
1// Part of BNC, a utility for retrieving decoding and
2// converting GNSS data streams from NTRIP broadcasters.
3//
4// Copyright (C) 2007
5// German Federal Agency for Cartography and Geodesy (BKG)
6// http://www.bkg.bund.de
7// Czech Technical University Prague, Department of Geodesy
8// http://www.fsv.cvut.cz
9//
10// Email: euref-ip@bkg.bund.de
11//
12// This program is free software; you can redistribute it and/or
13// modify it under the terms of the GNU General Public License
14// as published by the Free Software Foundation, version 2.
15//
16// This program is distributed in the hope that it will be useful,
17// but WITHOUT ANY WARRANTY; without even the implied warranty of
18// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19// GNU General Public License for more details.
20//
21// You should have received a copy of the GNU General Public License
22// along with this program; if not, write to the Free Software
23// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
24
25/* -------------------------------------------------------------------------
26 * BKG NTRIP Client
27 * -------------------------------------------------------------------------
28 *
29 * Class: t_pppClient
30 *
31 * Purpose: Precise Point Positioning
32 *
33 * Author: L. Mervart
34 *
35 * Created: 21-Nov-2009
36 *
37 * Changes:
38 *
39 * -----------------------------------------------------------------------*/
40
41#include <newmatio.h>
42#include <iomanip>
43#include <sstream>
44
45#include "pppClient.h"
46#include "bncephuser.h"
47#include "bncutils.h"
48
49using namespace BNC_PPP;
50using namespace std;
51
52// Constructor
53////////////////////////////////////////////////////////////////////////////
54t_pppClient::t_pppClient(const t_pppOptions* opt) {
55
56 _opt = new t_pppOptions(*opt);
57 _filter = new t_pppFilter(this);
58 _epoData = new t_epoData();
59 _log = new ostringstream();
60 _ephUser = new bncEphUser(false);
61}
62
63// Destructor
64////////////////////////////////////////////////////////////////////////////
65t_pppClient::~t_pppClient() {
66 delete _filter;
67 delete _epoData;
68 delete _opt;
69 delete _ephUser;
70 delete _log;
71}
72
73//
74////////////////////////////////////////////////////////////////////////////
75void t_pppClient::processEpoch(const vector<t_satObs*>& satObs, t_output* output) {
76
77 // Convert and store observations
78 // ------------------------------
79 _epoData->clear();
80 for (unsigned ii = 0; ii < satObs.size(); ii++) {
81 const t_satObs* obs = satObs[ii];
82 t_satData* satData = new t_satData();
83
84 if (_epoData->tt.undef()) {
85 _epoData->tt = obs->_time;
86 }
87
88 satData->tt = obs->_time;
89 satData->prn = QString(obs->_prn.toInternalString().c_str());
90 satData->slipFlag = false;
91 satData->P1 = 0.0;
92 satData->P2 = 0.0;
93 satData->P5 = 0.0;
94 satData->L1 = 0.0;
95 satData->L2 = 0.0;
96 satData->L5 = 0.0;
97 for (unsigned ifrq = 0; ifrq < obs->_obs.size(); ifrq++) {
98 t_frqObs* frqObs = obs->_obs[ifrq];
99 if (frqObs->_rnxType2ch[0] == '1') {
100 if (frqObs->_codeValid) satData->P1 = frqObs->_code;
101 if (frqObs->_phaseValid) satData->L1 = frqObs->_phase;
102 if (frqObs->_slip) satData->slipFlag = true;
103 }
104 else if (frqObs->_rnxType2ch[0] == '2') {
105 if (frqObs->_codeValid) satData->P2 = frqObs->_code;
106 if (frqObs->_phaseValid) satData->L2 = frqObs->_phase;
107 if (frqObs->_slip) satData->slipFlag = true;
108 }
109 else if (frqObs->_rnxType2ch[0] == '5') {
110 if (frqObs->_codeValid) satData->P5 = frqObs->_code;
111 if (frqObs->_phaseValid) satData->L5 = frqObs->_phase;
112 if (frqObs->_slip) satData->slipFlag = true;
113 }
114 }
115 putNewObs(satData);
116 }
117
118 // Data Pre-Processing
119 // -------------------
120 QMutableMapIterator<QString, t_satData*> it(_epoData->satData);
121 while (it.hasNext()) {
122 it.next();
123 QString prn = it.key();
124 t_satData* satData = it.value();
125
126 if (cmpToT(satData) != success) {
127 delete satData;
128 it.remove();
129 continue;
130 }
131 }
132
133 // Filter Solution
134 // ---------------
135 if (_filter->update(_epoData) == success) {
136 output->_error = false;
137 output->_epoTime = _filter->time();
138 output->_xyzRover[0] = _filter->x();
139 output->_xyzRover[1] = _filter->y();
140 output->_xyzRover[2] = _filter->z();
141 copy(&_filter->Q().data()[0], &_filter->Q().data()[6], output->_covMatrix);
142 output->_neu[0] = _filter->neu()[0];
143 output->_neu[1] = _filter->neu()[1];
144 output->_neu[2] = _filter->neu()[2];
145 output->_numSat = _filter->numSat();
146 output->_pDop = _filter->PDOP();
147 output->_trp0 = _filter->trp0();
148 output->_trp = _filter->trp();
149 }
150 else {
151 output->_error = true;
152 }
153
154 output->_log = _log->str();
155 delete _log; _log = new ostringstream();
156}
157
158//
159////////////////////////////////////////////////////////////////////////////
160void t_pppClient::putNewObs(t_satData* satData) {
161
162 // Set Observations GPS
163 // --------------------
164 if (satData->system() == 'G') {
165 if (satData->P1 != 0.0 && satData->P2 != 0.0 &&
166 satData->L1 != 0.0 && satData->L2 != 0.0 ) {
167 t_frequency::type fType1 = t_lc::toFreq(satData->system(), t_lc::l1);
168 t_frequency::type fType2 = t_lc::toFreq(satData->system(), t_lc::l2);
169 double f1 = t_CST::freq(fType1, 0);
170 double f2 = t_CST::freq(fType2, 0);
171 double a1 = f1 * f1 / (f1 * f1 - f2 * f2);
172 double a2 = - f2 * f2 / (f1 * f1 - f2 * f2);
173 satData->L1 = satData->L1 * t_CST::c / f1;
174 satData->L2 = satData->L2 * t_CST::c / f2;
175 satData->P3 = a1 * satData->P1 + a2 * satData->P2;
176 satData->L3 = a1 * satData->L1 + a2 * satData->L2;
177 satData->lambda3 = a1 * t_CST::c / f1 + a2 * t_CST::c / f2;
178 satData->lkA = a1;
179 satData->lkB = a2;
180 _epoData->satData[satData->prn] = satData;
181 }
182 else {
183 delete satData;
184 }
185 }
186
187 // Set Observations Glonass
188 // ------------------------
189 if (satData->system() == 'R' && _opt->useSystem('R')) {
190 if (satData->P1 != 0.0 && satData->P2 != 0.0 &&
191 satData->L1 != 0.0 && satData->L2 != 0.0 ) {
192
193 int channel = 0;
194 if (satData->system() == 'R') {
195 const t_eph* eph = _ephUser->ephLast(satData->prn);
196 if (eph) {
197 channel = eph->slotNum();
198 }
199 else {
200 delete satData;
201 return;
202 }
203 }
204
205 t_frequency::type fType1 = t_lc::toFreq(satData->system(), t_lc::l1);
206 t_frequency::type fType2 = t_lc::toFreq(satData->system(), t_lc::l2);
207 double f1 = t_CST::freq(fType1, channel);
208 double f2 = t_CST::freq(fType2, channel);
209 double a1 = f1 * f1 / (f1 * f1 - f2 * f2);
210 double a2 = - f2 * f2 / (f1 * f1 - f2 * f2);
211 satData->L1 = satData->L1 * t_CST::c / f1;
212 satData->L2 = satData->L2 * t_CST::c / f2;
213 satData->P3 = a1 * satData->P1 + a2 * satData->P2;
214 satData->L3 = a1 * satData->L1 + a2 * satData->L2;
215 satData->lambda3 = a1 * t_CST::c / f1 + a2 * t_CST::c / f2;
216 satData->lkA = a1;
217 satData->lkB = a2;
218 _epoData->satData[satData->prn] = satData;
219 }
220 else {
221 delete satData;
222 }
223 }
224
225 // Set Observations Galileo
226 // ------------------------
227 else if (satData->system() == 'E' && _opt->useSystem('E')) {
228 if (satData->P1 != 0.0 && satData->P5 != 0.0 &&
229 satData->L1 != 0.0 && satData->L5 != 0.0 ) {
230 double f1 = t_CST::freq(t_frequency::E1, 0);
231 double f5 = t_CST::freq(t_frequency::E5, 0);
232 double a1 = f1 * f1 / (f1 * f1 - f5 * f5);
233 double a5 = - f5 * f5 / (f1 * f1 - f5 * f5);
234 satData->L1 = satData->L1 * t_CST::c / f1;
235 satData->L5 = satData->L5 * t_CST::c / f5;
236 satData->P3 = a1 * satData->P1 + a5 * satData->P5;
237 satData->L3 = a1 * satData->L1 + a5 * satData->L5;
238 satData->lambda3 = a1 * t_CST::c / f1 + a5 * t_CST::c / f5;
239 satData->lkA = a1;
240 satData->lkB = a5;
241 _epoData->satData[satData->prn] = satData;
242 }
243 else {
244 delete satData;
245 }
246 }
247}
248
249//
250////////////////////////////////////////////////////////////////////////////
251void t_pppClient::putOrbCorrections(const std::vector<t_orbCorr*>& corr) {
252 for (unsigned ii = 0; ii < corr.size(); ii++) {
253 QString prn = QString(corr[ii]->_prn.toInternalString().c_str());
254 t_eph* eLast = _ephUser->ephLast(prn);
255 t_eph* ePrev = _ephUser->ephPrev(prn);
256 if (eLast && eLast->IOD() == corr[ii]->_iod) {
257 eLast->setOrbCorr(corr[ii]);
258 }
259 else if (ePrev && ePrev->IOD() == corr[ii]->_iod) {
260 ePrev->setOrbCorr(corr[ii]);
261 }
262 }
263}
264
265//
266////////////////////////////////////////////////////////////////////////////
267void t_pppClient::putClkCorrections(const std::vector<t_clkCorr*>& corr) {
268 for (unsigned ii = 0; ii < corr.size(); ii++) {
269 QString prn = QString(corr[ii]->_prn.toInternalString().c_str());
270 t_eph* eLast = _ephUser->ephLast(prn);
271 t_eph* ePrev = _ephUser->ephPrev(prn);
272 if (eLast && eLast->IOD() == corr[ii]->_iod) {
273 eLast->setClkCorr(corr[ii]);
274 }
275 else if (ePrev && ePrev->IOD() == corr[ii]->_iod) {
276 ePrev->setClkCorr(corr[ii]);
277 }
278 }
279}
280
281//
282//////////////////////////////////////////////////////////////////////////////
283void t_pppClient::putCodeBiases(const std::vector<t_satCodeBias*>& /* satCodeBias */) {
284}
285
286//
287//////////////////////////////////////////////////////////////////////////////
288void t_pppClient::putEphemeris(const t_eph* eph) {
289 const t_ephGPS* ephGPS = dynamic_cast<const t_ephGPS*>(eph);
290 const t_ephGlo* ephGlo = dynamic_cast<const t_ephGlo*>(eph);
291 const t_ephGal* ephGal = dynamic_cast<const t_ephGal*>(eph);
292 const t_ephBDS* ephBDS = dynamic_cast<const t_ephBDS*>(eph);
293 if (ephGPS) {
294 _ephUser->putNewEph(new t_ephGPS(*ephGPS), true);
295 }
296 else if (ephGlo) {
297 _ephUser->putNewEph(new t_ephGlo(*ephGlo), true);
298 }
299 else if (ephGal) {
300 _ephUser->putNewEph(new t_ephGal(*ephGal), true);
301 }
302 else if (ephBDS) {
303 _ephUser->putNewEph(new t_ephBDS(*ephBDS), true);
304 }
305}
306
307// Satellite Position
308////////////////////////////////////////////////////////////////////////////
309t_irc t_pppClient::getSatPos(const bncTime& tt, const QString& prn,
310 ColumnVector& xc, ColumnVector& vv) {
311
312 t_eph* eLast = _ephUser->ephLast(prn);
313 t_eph* ePrev = _ephUser->ephPrev(prn);
314 if (eLast && eLast->getCrd(tt, xc, vv, _opt->useOrbClkCorr()) == success) {
315 return success;
316 }
317 else if (ePrev && ePrev->getCrd(tt, xc, vv, _opt->useOrbClkCorr()) == success) {
318 return success;
319 }
320 return failure;
321}
322
323// Correct Time of Transmission
324////////////////////////////////////////////////////////////////////////////
325t_irc t_pppClient::cmpToT(t_satData* satData) {
326
327 double prange = satData->P3;
328 if (prange == 0.0) {
329 return failure;
330 }
331
332 double clkSat = 0.0;
333 for (int ii = 1; ii <= 10; ii++) {
334
335 bncTime ToT = satData->tt - prange / t_CST::c - clkSat;
336
337 ColumnVector xc(4);
338 ColumnVector vv(3);
339 if (getSatPos(ToT, satData->prn, xc, vv) != success) {
340 return failure;
341 }
342
343 double clkSatOld = clkSat;
344 clkSat = xc(4);
345
346 if ( fabs(clkSat-clkSatOld) * t_CST::c < 1.e-4 ) {
347 satData->xx = xc.Rows(1,3);
348 satData->vv = vv;
349 satData->clk = clkSat * t_CST::c;
350 return success;
351 }
352 }
353
354 return failure;
355}
356
Note: See TracBrowser for help on using the repository browser.