source: ntrip/trunk/BNC/src/satObs.cpp@ 11047

Last change on this file since 11047 was 11047, checked in by stuerze, 17 hours ago

updates regarding RTCM-SSR and some ovarall improvements
File size: 24.4 KB
Line 
1#include <iostream>
2#include <iomanip>
3#include <sstream>
4#include <cstdlib>
5#include <newmatio.h>
6
7#include "satObs.h"
8
9using namespace std;
10
11// Constructor
12////////////////////////////////////////////////////////////////////////////
13t_clkCorr::t_clkCorr() {
14 _updateInt = 0;
15 _iod = 0;
16 _dClk = 0.0;
17 _dotDClk = 0.0;
18 _dotDotDClk = 0.0;
19}
20
21//
22////////////////////////////////////////////////////////////////////////////
23void t_clkCorr::writeEpoch(ostream* out, const QList<t_clkCorr>& corrList) {
24 if (!out || corrList.size() == 0) {
25 return;
26 }
27 out->setf(ios::fixed);
28 bncTime epoTime;
29 QListIterator<t_clkCorr> it(corrList);
30 while (it.hasNext()) {
31 const t_clkCorr& corr = it.next();
32 if (!epoTime.valid()) {
33 epoTime = corr._time;
34 *out << "> CLOCK " << epoTime.datestr(' ') << ' ' << epoTime.timestr(1, ' ') << " "
35 << corr._updateInt << " "
36 << corrList.size() << ' ' << corr._staID << endl;
37 }
38 *out << corr._prn.toString() << ' ' << setw(11) << corr._iod << ' '
39 << setw(10) << setprecision(4) << corr._dClk * t_CST::c << ' ' // m
40 << setw(10) << setprecision(4) << corr._dotDClk * t_CST::c * 1.e3 << ' ' // m/s => mm/s
41 << setw(10) << setprecision(4) << corr._dotDotDClk * t_CST::c * 1.e3 << endl; // m/s² => mm/s²
42 }
43 out->flush();
44}
45
46//
47////////////////////////////////////////////////////////////////////////////
48void t_clkCorr::readEpoch(const string& epoLine, istream& inStream, QList<t_clkCorr>& corrList) {
49 bncTime epoTime;
50 unsigned int updateInt;
51 int numCorr;
52 string staID;
53 if (t_corrSSR::readEpoLine(epoLine, epoTime, updateInt, numCorr, staID) != t_corrSSR::clkCorr) {
54 return;
55 }
56 for (int ii = 0; ii < numCorr; ii++) {
57 t_clkCorr corr;
58 corr._time = epoTime;
59 corr._updateInt = updateInt;
60 corr._staID = staID;
61
62 string line;
63 getline(inStream, line);
64 istringstream in(line.c_str());
65
66 in >> corr._prn >> corr._iod >> corr._dClk >> corr._dotDClk >> corr._dotDotDClk;
67
68 char sys = corr._prn.system();
69 int num = corr._prn.number();
70 int flag = t_corrSSR::getSsrNavTypeFlag(sys, num);
71 corr._prn.setFlag(flag);
72
73 corr._dClk /= (t_CST::c);
74 corr._dotDClk /= (t_CST::c * 1.e3);
75 corr._dotDotDClk /= (t_CST::c * 1.e3);
76
77 corrList.push_back(corr);
78 }
79}
80
81// Constructor
82////////////////////////////////////////////////////////////////////////////
83t_orbCorr::t_orbCorr() {
84 _updateInt = 0;
85 _iod = 0;
86 _system = 'R';
87 _xr.ReSize(3);
88 _xr = 0.0;
89 _dotXr.ReSize(3);
90 _dotXr = 0.0;
91 _ssrFormat = ssrUnknown;
92}
93
94//
95////////////////////////////////////////////////////////////////////////////
96void t_orbCorr::writeEpoch(ostream* out, const QList<t_orbCorr>& corrList) {
97 if (!out || corrList.size() == 0) {
98 return;
99 }
100 out->setf(ios::fixed);
101 bncTime epoTime;
102 QListIterator<t_orbCorr> it(corrList);
103 while (it.hasNext()) {
104 const t_orbCorr& corr = it.next();
105 if (!epoTime.valid()) {
106 epoTime = corr._time;
107 *out << "> ORBIT " << epoTime.datestr(' ') << ' ' << epoTime.timestr(1, ' ') << " "
108 << corr._updateInt << " "
109 << corrList.size() << ' ' << corr._staID << endl;
110 *out << " " << static_cast<int>(corr._ssrFormat) << endl;
111 }
112 *out << corr._prn.toString() << ' ' << setw(11) << corr._iod << ' '
113 << setw(10) << setprecision(4) << corr._xr[0] << ' '
114 << setw(10) << setprecision(4) << corr._xr[1] << ' '
115 << setw(10) << setprecision(4) << corr._xr[2] << " "
116 << setw(10) << setprecision(4) << corr._dotXr[0] * 1.e3 << ' ' // m/s => mm/s
117 << setw(10) << setprecision(4) << corr._dotXr[1] * 1.e3 << ' ' // m/s => mm/s
118 << setw(10) << setprecision(4) << corr._dotXr[2] * 1.e3 << endl; // m/s => mm/s
119 }
120 out->flush();
121}
122
123//
124////////////////////////////////////////////////////////////////////////////
125void t_orbCorr::readEpoch(const string& epoLine, istream& inStream, QList<t_orbCorr>& corrList) {
126 bncTime epoTime;
127 unsigned int updateInt;
128 int numCorr;
129 string staID;
130 if (t_corrSSR::readEpoLine(epoLine, epoTime, updateInt, numCorr, staID) != t_corrSSR::orbCorr) {
131 return;
132 }
133
134 e_ssrFormat ssrFormat = ssrUnknown;
135
136 // TEMPORARY BACKWARD COMPATIBILITY - remove later on:
137 // .ssr files written before the SSR format line (a single integer) was
138 // added after the "> ORBIT" epoch line don't have it - their first line
139 // is already the first satellite. Such a line is kept (firstLine) and
140 // processed as the first correction below, with ssrFormat unknown.
141 // To revert: read the format line unconditionally again, i.e. drop the
142 // "only one integer on the line" test and the firstLine handling in the
143 // loop below.
144 string firstLine;
145 getline(inStream, firstLine);
146 {
147 istringstream in(firstLine.c_str());
148 int ssrFormatInt = 0;
149 string rest;
150 if ((in >> ssrFormatInt) && !(in >> rest)) { // format line
151 ssrFormat = static_cast<e_ssrFormat>(ssrFormatInt);
152 firstLine.clear();
153 }
154 }
155
156 for (int ii = 0; ii < numCorr; ii++) {
157 t_orbCorr corr;
158 corr._time = epoTime;
159 corr._updateInt = updateInt;
160 corr._staID = staID;
161 corr._ssrFormat = ssrFormat;
162
163 string line;
164 if (ii == 0 && !firstLine.empty()) { // TEMPORARY BACKWARD COMPATIBILITY, see above
165 line = firstLine;
166 }
167 else {
168 getline(inStream, line);
169 }
170 istringstream in(line.c_str());
171
172 in >> corr._prn >> corr._iod >> corr._xr[0] >> corr._xr[1] >> corr._xr[2] >> corr._dotXr[0] >> corr._dotXr[1] >> corr._dotXr[2];
173
174 char sys = corr._prn.system();
175 int num = corr._prn.number();
176 int flag = t_corrSSR::getSsrNavTypeFlag(sys, num);
177 corr._prn.setFlag(flag);
178
179 corr._dotXr[0] /= 1.e3; // mm/s => m/s
180 corr._dotXr[1] /= 1.e3; // mm/s => m/s
181 corr._dotXr[2] /= 1.e3; // mm/s => m/s
182
183 corrList.push_back(corr);
184 }
185}
186
187// Constructor
188////////////////////////////////////////////////////////////////////////////
189t_URA::t_URA() {
190 _updateInt = 0;
191 _iod = 0;
192 _ura = 0.0;
193}
194
195//
196////////////////////////////////////////////////////////////////////////////
197void t_URA::writeEpoch(ostream* out, const QList<t_URA>& corrList) {
198 if (!out || corrList.size() == 0) {
199 return;
200 }
201 out->setf(ios::fixed);
202 bncTime epoTime;
203 QListIterator<t_URA> it(corrList);
204 while (it.hasNext()) {
205 const t_URA& corr = it.next();
206 if (!epoTime.valid()) {
207 epoTime = corr._time;
208 *out << "> URA " << epoTime.datestr(' ') << ' ' << epoTime.timestr(1, ' ') << " "
209 << corr._updateInt << " "
210 << corrList.size() << ' ' << corr._staID << endl;
211 }
212 *out << corr._prn.toString() << ' ' << setw(11) << corr._iod << ' '
213 << setw(10) << setprecision(4) << corr._ura << endl;
214 }
215 out->flush();
216}
217
218//
219////////////////////////////////////////////////////////////////////////////
220void t_URA::readEpoch(const string& epoLine, istream& inStream, QList<t_URA>& corrList) {
221 bncTime epoTime;
222 unsigned int updateInt;
223 int numCorr;
224 string staID;
225 if (t_corrSSR::readEpoLine(epoLine, epoTime, updateInt, numCorr, staID) != t_corrSSR::URA) {
226 return;
227 }
228 for (int ii = 0; ii < numCorr; ii++) {
229 t_URA corr;
230 corr._time = epoTime;
231 corr._updateInt = updateInt;
232 corr._staID = staID;
233
234 string line;
235 getline(inStream, line);
236 istringstream in(line.c_str());
237
238 in >> corr._prn >> corr._iod >> corr._ura;
239
240 char sys = corr._prn.system();
241 int num = corr._prn.number();
242 int flag = t_corrSSR::getSsrNavTypeFlag(sys, num);
243 corr._prn.setFlag(flag);
244
245 corrList.push_back(corr);
246 }
247}
248
249//
250////////////////////////////////////////////////////////////////////////////
251void t_satCodeBias::writeEpoch(ostream* out, const QList<t_satCodeBias>& biasList) {
252 if (!out || biasList.size() == 0) {
253 return;
254 }
255 out->setf(ios::fixed);
256 bncTime epoTime;
257 QListIterator<t_satCodeBias> it(biasList);
258 while (it.hasNext()) {
259 const t_satCodeBias& satCodeBias = it.next();
260 if (!epoTime.valid()) {
261 epoTime = satCodeBias._time;
262 *out << "> CODE_BIAS " << epoTime.datestr(' ') << ' ' << epoTime.timestr(1, ' ') << " "
263 << satCodeBias._updateInt << " "
264 << biasList.size() << ' ' << satCodeBias._staID << ' '
265 << satCodeBias._ssrIOD << ' ' << satCodeBias._ssrProviderID << endl;
266 }
267 *out << satCodeBias._prn.toString() << " " << setw(2) << satCodeBias._bias.size();
268 for (unsigned ii = 0; ii < satCodeBias._bias.size(); ii++) {
269 const t_frqCodeBias& frqCodeBias = satCodeBias._bias[ii];
270 *out << " " << frqCodeBias._rnxType2ch << ' '
271 << setw(10) << setprecision(4) << frqCodeBias._value;
272 }
273 *out << endl;
274 }
275 out->flush();
276}
277
278//
279////////////////////////////////////////////////////////////////////////////
280void t_satCodeBias::readEpoch(const string& epoLine, istream& inStream, QList<t_satCodeBias>& biasList) {
281 bncTime epoTime;
282 unsigned int updateInt;
283 int numSat;
284 string staID;
285 if (t_corrSSR::readEpoLine(epoLine, epoTime, updateInt, numSat, staID) != t_corrSSR::codeBias) {
286 return;
287 }
288 int ssrIOD, ssrProviderID;
289 t_corrSSR::readSsrIOD(epoLine, ssrIOD, ssrProviderID);
290 for (int ii = 0; ii < numSat; ii++) {
291 t_satCodeBias satCodeBias;
292 satCodeBias._time = epoTime;
293 satCodeBias._updateInt = updateInt;
294 satCodeBias._staID = staID;
295 satCodeBias._ssrIOD = ssrIOD;
296 satCodeBias._ssrProviderID = ssrProviderID;
297
298 string line;
299 getline(inStream, line);
300 istringstream in(line.c_str());
301
302 int numBias;
303 in >> satCodeBias._prn >> numBias;
304
305 char sys = satCodeBias._prn.system();
306 int num = satCodeBias._prn.number();
307 int flag = t_corrSSR::getSsrNavTypeFlag(sys, num);
308 satCodeBias._prn.setFlag(flag);
309
310 while (in.good()) {
311 t_frqCodeBias frqCodeBias;
312 in >> frqCodeBias._rnxType2ch >> frqCodeBias._value;
313 if (!frqCodeBias._rnxType2ch.empty()) {
314 satCodeBias._bias.push_back(frqCodeBias);
315 }
316 }
317
318 biasList.push_back(satCodeBias);
319 }
320}
321
322//
323////////////////////////////////////////////////////////////////////////////
324void t_satPhaseBias::writeEpoch(ostream* out, const QList<t_satPhaseBias>& biasList) {
325 if (!out || biasList.size() == 0) {
326 return;
327 }
328 out->setf(ios::fixed);
329 bncTime epoTime;
330 QListIterator<t_satPhaseBias> it(biasList);
331 while (it.hasNext()) {
332 const t_satPhaseBias& satPhaseBias = it.next();
333 if (!epoTime.valid()) {
334 epoTime = satPhaseBias._time;
335 *out << "> PHASE_BIAS " << epoTime.datestr(' ') << ' ' << epoTime.timestr(1, ' ') << " "
336 << satPhaseBias._updateInt << " "
337 << biasList.size() << ' ' << satPhaseBias._staID << ' '
338 << satPhaseBias._ssrIOD << ' ' << satPhaseBias._ssrProviderID << endl;
339
340 if (satPhaseBias._ssrFormat == e_ssrFormat::ssrRtcmNew) {
341 *out << " " << static_cast<int>(satPhaseBias._ssrFormat) << " "
342 << satPhaseBias._satYawInfoInd << " "
343 << satPhaseBias._extPBPhaseInd << endl;
344 }
345 else {
346 *out << " " << static_cast<int>(satPhaseBias._ssrFormat) << " "
347 << satPhaseBias._dispBiasConsistInd << " "
348 << satPhaseBias._MelbWuebConsistInd << endl;
349 }
350 }
351 if (satPhaseBias._ssrFormat == e_ssrFormat::ssrRtcmNew) {
352 *out << satPhaseBias._prn.toString() << ' '
353 << setw(12) << setprecision(8) << satPhaseBias._yaw * 180.0 / M_PI << ' '
354 << setw(12) << setprecision(8) << satPhaseBias._yawRate * 180.0 / M_PI << " "
355 << setw(2) << satPhaseBias._bias.size();
356 for (unsigned ii = 0; ii < satPhaseBias._bias.size(); ii++) {
357 const t_frqPhaseBias& frqPhaseBias = satPhaseBias._bias[ii];
358 *out << " " << frqPhaseBias._rnxType2ch << ' '
359 << setw(10) << setprecision(4) << frqPhaseBias._value << ' '
360 << setw(3) << frqPhaseBias._fixIndicator << ' '
361 << setw(3) << frqPhaseBias._fixWideLaneIndicator << ' '
362 << setw(3) << frqPhaseBias._jumpCounter;
363 }
364 *out << endl;
365 }
366 else {
367 *out << satPhaseBias._prn.toString() << ' '
368 << setw(12) << setprecision(8) << satPhaseBias._yaw * 180.0 / M_PI << ' '
369 << setw(12) << setprecision(8) << satPhaseBias._yawRate * 180.0 / M_PI << " "
370 << setw(2) << satPhaseBias._bias.size();
371 for (unsigned ii = 0; ii < satPhaseBias._bias.size(); ii++) {
372 const t_frqPhaseBias& frqPhaseBias = satPhaseBias._bias[ii];
373 *out << " " << frqPhaseBias._rnxType2ch << ' '
374 << setw(10) << setprecision(4) << frqPhaseBias._value << ' '
375 << setw(3) << frqPhaseBias._fixIndicator << ' '
376 << setw(3) << frqPhaseBias._fixWideLaneIndicator << ' '
377 << setw(3) << frqPhaseBias._jumpCounter;
378 }
379 *out << endl;
380 }
381 }
382 out->flush();
383}
384
385//
386////////////////////////////////////////////////////////////////////////////
387void t_satPhaseBias::readEpoch(const string& epoLine, istream& inStream, QList<t_satPhaseBias>& biasList) {
388 bncTime epoTime;
389 unsigned int updateInt;
390 int numSat;
391 string staID;
392 unsigned int metadata1;
393 unsigned int metadata2;
394 e_ssrFormat ssrFormat = ssrUnknown;
395 if (t_corrSSR::readEpoLine(epoLine, epoTime, updateInt, numSat, staID) != t_corrSSR::phaseBias) {
396 return;
397 }
398 int ssrIOD, ssrProviderID;
399 t_corrSSR::readSsrIOD(epoLine, ssrIOD, ssrProviderID);
400 for (int ii = 0; ii <= numSat; ii++) {
401 t_satPhaseBias satPhaseBias;
402 satPhaseBias._time = epoTime;
403 satPhaseBias._updateInt = updateInt;
404 satPhaseBias._staID = staID;
405 satPhaseBias._ssrIOD = ssrIOD;
406 satPhaseBias._ssrProviderID = ssrProviderID;
407
408 string line;
409 getline(inStream, line);
410 istringstream in(line.c_str());
411
412 if (ii == 0) {
413 int ssrFormatInt = 0;
414 in >> ssrFormatInt >> metadata1 >> metadata2;
415 ssrFormat = static_cast<e_ssrFormat>(ssrFormatInt);
416 continue;
417 }
418 satPhaseBias._ssrFormat = ssrFormat;
419 switch (ssrFormat) {
420 case e_ssrFormat::ssrRtcmNew:
421 satPhaseBias._satYawInfoInd = metadata1;
422 satPhaseBias._extPBPhaseInd = metadata2;
423 break;
424 case e_ssrFormat::ssrRtcmOld:
425 case e_ssrFormat::ssrUnknown:
426 satPhaseBias._dispBiasConsistInd = metadata1;
427 satPhaseBias._MelbWuebConsistInd = metadata2;
428 break;
429 }
430 int numBias;
431 double yawDeg, yawDegRate;
432 in >> satPhaseBias._prn >> yawDeg >> yawDegRate >> numBias;
433 satPhaseBias._yaw = yawDeg * M_PI / 180.0;
434 satPhaseBias._yawRate = yawDegRate * M_PI / 180.0;
435
436 char sys = satPhaseBias._prn.system();
437 int num = satPhaseBias._prn.number();
438 int flag = t_corrSSR::getSsrNavTypeFlag(sys, num);
439 satPhaseBias._prn.setFlag(flag);
440
441 while (in.good()) {
442 t_frqPhaseBias frqPhaseBias;
443 in >> frqPhaseBias._rnxType2ch >> frqPhaseBias._value >> frqPhaseBias._fixIndicator >> frqPhaseBias._fixWideLaneIndicator >> frqPhaseBias._jumpCounter;
444 if (!frqPhaseBias._rnxType2ch.empty()) {
445 satPhaseBias._bias.push_back(frqPhaseBias);
446 }
447 }
448
449 biasList.push_back(satPhaseBias);
450 }
451}
452
453//
454////////////////////////////////////////////////////////////////////////////
455void t_vTec::write(ostream* out, const t_vTec& vTec) {
456 if (!out || vTec._layers.size() == 0) {
457 return;
458 }
459 out->setf(ios::fixed);
460 bncTime epoTime = vTec._time;
461 *out << "> VTEC " << epoTime.datestr(' ') << ' ' << epoTime.timestr(1, ' ') << " "
462 << vTec._updateInt << " "
463 << vTec._layers.size() << ' ' << vTec._staID << endl;
464 for (unsigned ii = 0; ii < vTec._layers.size(); ii++) {
465 const t_vTecLayer& layer = vTec._layers[ii];
466 *out << setw(2) << ii + 1 << ' '
467 << setw(2) << layer._C.Nrows() - 1 << ' '
468 << setw(2) << layer._C.Ncols() - 1 << ' '
469 << setw(10) << setprecision(1) << layer._height << endl
470 << setw(10) << setprecision(4) << layer._C
471 << setw(10) << setprecision(4) << layer._S;
472 }
473 out->flush();
474}
475
476//
477////////////////////////////////////////////////////////////////////////////
478void t_vTec::read(const string& epoLine, istream& inStream, t_vTec& vTec) {
479 bncTime epoTime;
480 unsigned int updateInt;
481 int numLayers;
482 string staID;
483 if (t_corrSSR::readEpoLine(epoLine, epoTime, updateInt, numLayers, staID) != t_corrSSR::vTec) {
484 return;
485 }
486 if (numLayers <= 0) {
487 return;
488 }
489 vTec._time = epoTime;
490 vTec._updateInt = updateInt;
491 vTec._staID = staID;
492 for (int ii = 0; ii < numLayers; ii++) {
493 t_vTecLayer layer;
494
495 string line;
496 getline(inStream, line);
497 istringstream in(line.c_str());
498
499 int dummy, maxDeg, maxOrd;
500 in >> dummy >> maxDeg >> maxOrd >> layer._height;
501
502 layer._C.ReSize(maxDeg + 1, maxOrd + 1);
503 layer._S.ReSize(maxDeg + 1, maxOrd + 1);
504
505 for (int iDeg = 0; iDeg <= maxDeg; iDeg++) {
506 for (int iOrd = 0; iOrd <= maxOrd; iOrd++) {
507 inStream >> layer._C[iDeg][iOrd];
508 }
509 }
510 for (int iDeg = 0; iDeg <= maxDeg; iDeg++) {
511 for (int iOrd = 0; iOrd <= maxOrd; iOrd++) {
512 inStream >> layer._S[iDeg][iOrd];
513 }
514 }
515
516 vTec._layers.push_back(layer);
517 }
518}
519
520//
521////////////////////////////////////////////////////////////////////////////
522void t_satAntenna::writeEpoch(ostream* out, const QList<t_satAntenna>& antList) {
523 if (!out || antList.size() == 0) {
524 return;
525 }
526 out->setf(ios::fixed);
527 bncTime epoTime;
528 QListIterator<t_satAntenna> it(antList);
529 while (it.hasNext()) {
530 const t_satAntenna& satAntenna = it.next();
531 if (!epoTime.valid()) {
532 epoTime = satAntenna._time;
533 *out << "> SAT_ANTENNA " << epoTime.datestr(' ') << ' ' << epoTime.timestr(1, ' ') << " "
534 << 0 << " " << antList.size() << ' ' << satAntenna._staID << endl;
535 }
536 // header fields are genuinely per system (e.g. GPS/GLONASS/Galileo carry
537 // different maximumOffNadirAngle), so they are written per satellite
538 // rather than once per epoch like t_satPhaseBias's metadata line
539 *out << satAntenna._prn.toString() << ' '
540 << setw(4) << satAntenna._ssrProviderID << ' '
541 << setw(2) << satAntenna._satelliteAntennaIOD << ' '
542 << setw(1) << satAntenna._phaseCenterInfoInd << ' '
543 << setw(1) << satAntenna._groupDelayInfoInd << ' '
544 << setw(1) << satAntenna._nadirAngleDependentCorrInd << ' '
545 << setw(2) << satAntenna._maximumOffNadirAngle << ' '
546 << setw(2) << satAntenna._nadirAngleRangeExtension << " "
547 << setw(2) << satAntenna._freq.size();
548 for (unsigned ii = 0; ii < satAntenna._freq.size(); ii++) {
549 const t_frqAntenna& frqAntenna = satAntenna._freq[ii];
550 *out << " " << frqAntenna._frqType << ' '
551 << frqAntenna._nadirCorrectionIndicator << ' '
552 << setw(10) << setprecision(4) << frqAntenna._nadirCorrection;
553 for (unsigned jj = 0; jj < frqAntenna._nadirAngleCorrection.size(); jj++) {
554 *out << ' ' << setw(9) << setprecision(4) << frqAntenna._nadirAngleCorrection[jj];
555 }
556 }
557 *out << endl;
558 }
559 out->flush();
560}
561
562//
563////////////////////////////////////////////////////////////////////////////
564void t_satAntenna::readEpoch(const string& epoLine, istream& inStream, QList<t_satAntenna>& antList) {
565 bncTime epoTime;
566 unsigned int updateInt;
567 int numSat;
568 string staID;
569 if (t_corrSSR::readEpoLine(epoLine, epoTime, updateInt, numSat, staID) != t_corrSSR::satAntenna) {
570 return;
571 }
572 for (int ii = 0; ii < numSat; ii++) {
573 t_satAntenna satAntenna;
574 satAntenna._time = epoTime;
575 satAntenna._staID = staID;
576
577 string line;
578 getline(inStream, line);
579 istringstream in(line.c_str());
580
581 int numFreq;
582 in >> satAntenna._prn
583 >> satAntenna._ssrProviderID
584 >> satAntenna._satelliteAntennaIOD
585 >> satAntenna._phaseCenterInfoInd
586 >> satAntenna._groupDelayInfoInd
587 >> satAntenna._nadirAngleDependentCorrInd
588 >> satAntenna._maximumOffNadirAngle
589 >> satAntenna._nadirAngleRangeExtension
590 >> numFreq;
591
592 char sys = satAntenna._prn.system();
593 int num = satAntenna._prn.number();
594 int flag = t_corrSSR::getSsrNavTypeFlag(sys, num);
595 satAntenna._prn.setFlag(flag);
596
597 unsigned int numAngles = satAntenna._nadirAngleDependentCorrInd ?
598 satAntenna._maximumOffNadirAngle + 1 : 0;
599
600 for (int jj = 0; jj < numFreq; jj++) {
601 t_frqAntenna frqAntenna;
602 in >> frqAntenna._frqType >> frqAntenna._nadirCorrectionIndicator >> frqAntenna._nadirCorrection;
603 for (unsigned kk = 0; kk < numAngles; kk++) {
604 string valStr; // may be "nan" (invalid value), which operator>> can't parse
605 in >> valStr;
606 frqAntenna._nadirAngleCorrection.push_back(strtod(valStr.c_str(), 0));
607 }
608 satAntenna._freq.push_back(frqAntenna);
609 }
610
611 antList.push_back(satAntenna);
612 }
613}
614
615//
616////////////////////////////////////////////////////////////////////////////
617void t_metaData::write(ostream* out, const t_metaData& md) {
618 if (!out || md._entries.size() == 0) {
619 return;
620 }
621 out->setf(ios::fixed);
622 bncTime epoTime = md._time;
623 *out << "> META_DATA " << epoTime.datestr(' ') << ' ' << epoTime.timestr(1, ' ') << " "
624 << 0 << " " << md._entries.size() << ' ' << md._staID << endl;
625 *out << md._ssrIOD << ' ' << md._providerID << ' ' << md._solutionID << endl;
626 for (unsigned ii = 0; ii < md._entries.size(); ii++) {
627 const t_metaDataEntry& entry = md._entries[ii];
628 *out << setw(2) << entry._typeIndicator << ' '
629 << setw(1) << entry._applicationIndicator << ' '
630 << setw(1) << entry._nonDefaultIndicator << ' '
631 << setw(2) << entry._nonDefaultIdentifier << ' '
632 << setw(1) << entry._dataIODIndicator << ' '
633 << setw(3) << entry._dataIOD << endl;
634 }
635 out->flush();
636}
637
638//
639////////////////////////////////////////////////////////////////////////////
640void t_metaData::read(const string& epoLine, istream& inStream, t_metaData& md) {
641 bncTime epoTime;
642 unsigned int updateInt;
643 int numEntries;
644 string staID;
645 if (t_corrSSR::readEpoLine(epoLine, epoTime, updateInt, numEntries, staID) != t_corrSSR::metaData) {
646 return;
647 }
648 if (numEntries <= 0) {
649 return;
650 }
651 md._time = epoTime;
652 md._staID = staID;
653
654 string line;
655 getline(inStream, line);
656 istringstream inHdr(line.c_str());
657 inHdr >> md._ssrIOD >> md._providerID >> md._solutionID;
658
659 for (int ii = 0; ii < numEntries; ii++) {
660 getline(inStream, line);
661 istringstream in(line.c_str());
662 t_metaDataEntry entry;
663 in >> entry._typeIndicator >> entry._applicationIndicator >> entry._nonDefaultIndicator
664 >> entry._nonDefaultIdentifier >> entry._dataIODIndicator >> entry._dataIOD;
665 md._entries.push_back(entry);
666 }
667}
668
669//
670////////////////////////////////////////////////////////////////////////////
671t_corrSSR::e_type t_corrSSR::readEpoLine(const string& line, bncTime& epoTime,
672 unsigned int& updateInt, int& numEntries,
673 string& staID) {
674
675 istringstream inLine(line.c_str());
676
677 char epoChar;
678 string typeString;
679 int year, month, day, hour, min;
680 double sec;
681
682 inLine >> epoChar >> typeString >> year >> month >> day >> hour >> min >> sec >> updateInt >> numEntries >> staID;
683
684 if (epoChar == '>') {
685 epoTime.set(year, month, day, hour, min, sec);
686 if (typeString == "CLOCK") {
687 return clkCorr;
688 }
689 else if (typeString == "ORBIT") {
690 return orbCorr;
691 }
692 else if (typeString == "CODE_BIAS") {
693 return codeBias;
694 }
695 else if (typeString == "PHASE_BIAS") {
696 return phaseBias;
697 }
698 else if (typeString == "VTEC") {
699 return vTec;
700 }
701 else if (typeString == "URA") {
702 return URA;
703 }
704 else if (typeString == "META_DATA") {
705 return metaData;
706 }
707 else if (typeString == "SAT_ANTENNA") {
708 return satAntenna;
709 }
710 }
711
712 return unknown;
713}
714
715// Optional SSR IOD and Provider ID trailing the staID in CODE_BIAS and
716// PHASE_BIAS epoch lines (older files don't have them: -1 = unknown)
717////////////////////////////////////////////////////////////////////////////
718void t_corrSSR::readSsrIOD(const string& line, int& ssrIOD, int& ssrProviderID) {
719 istringstream inLine(line.c_str());
720 string hlp;
721 for (int ii = 0; ii < 11; ii++) { // '>', type, 6 x date/time, updateInt, numEntries, staID
722 inLine >> hlp;
723 }
724 if (!(inLine >> ssrIOD >> ssrProviderID)) {
725 ssrIOD = -1;
726 ssrProviderID = -1;
727 }
728}
729
730// Set NAV type to force NAVtype usage according SSR standard
731/////////////////////////////////////////////////////////////
732t_eph::e_type t_corrSSR::getSsrNavTypeFlag(char sys, int num) {
733
734 t_eph::e_type flag = t_eph::undefined;
735
736 switch (sys) {
737 case 'G':
738 case 'J':
739 case 'I': // not part of the SSR standard
740 flag = t_eph::LNAV;
741 break;
742 case 'R':
743 flag = t_eph::FDMA_M;
744 break;
745 case 'E':
746 flag = t_eph::INAV;
747 break;
748 case 'C':
749 if (num < 6) { // GEO
750 flag = t_eph::D2;
751 }
752 else if (num > 58 && num < 63) { // GEO
753 flag = t_eph::D2;
754 }
755 else {
756 flag = t_eph::D1;
757 }
758 break;
759 case 'S':
760 flag = t_eph::SBASL1;
761 break;
762 }
763
764 return flag;
765}
Note: See TracBrowser for help on using the repository browser.