Rinex3ObsOther_T.cpp
Go to the documentation of this file.
1 //==============================================================================
2 //
3 // This file is part of GNSSTk, the ARL:UT GNSS Toolkit.
4 //
5 // The GNSSTk is free software; you can redistribute it and/or modify
6 // it under the terms of the GNU Lesser General Public License as published
7 // by the Free Software Foundation; either version 3.0 of the License, or
8 // any later version.
9 //
10 // The GNSSTk is distributed in the hope that it will be useful,
11 // but WITHOUT ANY WARRANTY; without even the implied warranty of
12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 // GNU Lesser General Public License for more details.
14 //
15 // You should have received a copy of the GNU Lesser General Public
16 // License along with GNSSTk; if not, write to the Free Software Foundation,
17 // Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
18 //
19 // This software was developed by Applied Research Laboratories at the
20 // University of Texas at Austin.
21 // Copyright 2004-2022, The Board of Regents of The University of Texas System
22 //
23 //==============================================================================
24 
25 //==============================================================================
26 //
27 // This software was developed by Applied Research Laboratories at the
28 // University of Texas at Austin, under contract to an agency or agencies
29 // within the U.S. Department of Defense. The U.S. Government retains all
30 // rights to use, duplicate, distribute, disclose, or release this software.
31 //
32 // Pursuant to DoD Directive 523024
33 //
34 // DISTRIBUTION STATEMENT A: This software has been approved for public
35 // release, distribution is unlimited.
36 //
37 //==============================================================================
38 
39 #include "Rinex3ObsStream.hpp"
40 #include "Rinex3ObsHeader.hpp"
41 #include "Rinex3ObsData.hpp"
42 #include "TestUtil.hpp"
43 #include <iostream>
44 #include <string>
45 
46 using namespace std;
47 
52 class Rinex3ObsOther_T
53 {
54 public:
57  unsigned phaseShiftTest();
60  unsigned obsIDVersionTest();
63  unsigned channelNumTest();
66  unsigned ionoDelayTest();
68  unsigned reopenTest();
70  void setObs(gnsstk::TestUtil& testFramework, const std::string& system,
71  gnsstk::Rinex3ObsHeader& hdr, gnsstk::Rinex3ObsData& rod);
73  void fillHeader302(gnsstk::Rinex3ObsHeader& hdr);
75  void fillHeader304(gnsstk::Rinex3ObsHeader& hdr);
76 };
77 
78 
79 unsigned Rinex3ObsOther_T ::
80 phaseShiftTest()
81 {
82  TUDEF("Rinex3ObsHeader", "writeHeaderRecords (PHASE SHIFT)");
83 
84  std::string outfn = gnsstk::getPathTestTemp() + gnsstk::getFileSep() +
85  "rinex3ObsTest_v304_PHASE_SHIFT.out";
86  std::string expfn = gnsstk::getPathData() + gnsstk::getFileSep() +
87  "rinex3ObsTest_v304_PHASE_SHIFT.exp";
88 
89  gnsstk::Rinex3ObsStream strm(outfn, std::ios::out | std::ios::trunc);
90  gnsstk::Rinex3ObsHeader hdr;
91  gnsstk::RinexObsID roidInvalid("GC1C",gnsstk::Rinex3ObsBase::currentVersion);
92  gnsstk::RinexObsID roidValid("GL1C", gnsstk::Rinex3ObsBase::currentVersion);
93  gnsstk::SatID sid(7, gnsstk::SatelliteSystem::GPS);
94  strm.exceptions(std::fstream::failbit);
95  // Not setting most of the header fields because they're not being tested.
96  // Basically, the phase shift record for "GL1C" should be
97  // present in the header, but the phase shift record for "GC1C"
98  // should not.
99  hdr.sysPhaseShift["G"][roidInvalid][sid] = 23.456;
100  hdr.sysPhaseShift["G"][roidValid][sid] = 54.321;
101  hdr.date = "20200512 181734 UTC";
102  hdr.preserveDate = true;
103  hdr.version = 3.04;
104  hdr.valid |= gnsstk::Rinex3ObsHeader::validVersion;
105  hdr.valid |= gnsstk::Rinex3ObsHeader::validRunBy;
106  hdr.valid |= gnsstk::Rinex3ObsHeader::validMarkerName;
107  hdr.valid |= gnsstk::Rinex3ObsHeader::validObserver;
108  hdr.valid |= gnsstk::Rinex3ObsHeader::validReceiver;
109  hdr.valid |= gnsstk::Rinex3ObsHeader::validAntennaType;
110  hdr.valid |= gnsstk::Rinex3ObsHeader::validAntennaPosition;
111  hdr.valid |= gnsstk::Rinex3ObsHeader::validAntennaDeltaHEN;
112  hdr.valid |= gnsstk::Rinex3ObsHeader::validFirstTime;
113  hdr.valid |= gnsstk::Rinex3ObsHeader::validMarkerNumber;
114  hdr.valid |= gnsstk::Rinex3ObsHeader::validInterval;
115  hdr.valid |= gnsstk::Rinex3ObsHeader::validSystemNumObs;
116  hdr.valid |= gnsstk::Rinex3ObsHeader::validSystemPhaseShift;
117  hdr.validEoH = true;
118  TUCATCH(strm << hdr);
119  TUCMPFILE(expfn, outfn, 0);
120  TURETURN();
121 }
122 
123 
124 unsigned Rinex3ObsOther_T ::
125 channelNumTest()
126 {
127  // Note that Rinex3ObsData is also being tested
128  TUDEF("Rinex3ObsHeader", "writeHeaderRecords (SYS / # / OBS TYPES)");
129 
130  std::string outfn = gnsstk::getPathTestTemp() + gnsstk::getFileSep() +
131  "rinex3ObsTest_v304_SYS_NUM_OBS_TYPES.out";
132  std::string expfn = gnsstk::getPathData() + gnsstk::getFileSep() +
133  "rinex3ObsTest_v304_SYS_NUM_OBS_TYPES.exp";
134 
135  // abbreviate.
136  double cv = gnsstk::Rinex3ObsBase::currentVersion;
137  gnsstk::Rinex3ObsStream strm(outfn, std::ios::out | std::ios::trunc);
138  gnsstk::Rinex3ObsHeader hdr;
139  gnsstk::RinexObsID roidValid("GL1C", cv);
140  gnsstk::SatID sid(7, gnsstk::SatelliteSystem::GPS);
141  strm.exceptions(std::fstream::failbit);
142  // Not setting most of the header fields because they're not being tested.
143  hdr.mapObsTypes["G"].push_back(gnsstk::RinexObsID("GC1C", cv));
144  hdr.mapObsTypes["G"].push_back(gnsstk::RinexObsID("GL1C", cv));
145  hdr.mapObsTypes["G"].push_back(gnsstk::RinexObsID("GD1C", cv));
146  hdr.mapObsTypes["G"].push_back(gnsstk::RinexObsID("GS1C", cv));
147  hdr.mapObsTypes["G"].push_back(gnsstk::RinexObsID("GC1S", cv));
148  hdr.mapObsTypes["G"].push_back(gnsstk::RinexObsID("GL1S", cv));
149  hdr.mapObsTypes["G"].push_back(gnsstk::RinexObsID("GD1S", cv));
150  hdr.mapObsTypes["G"].push_back(gnsstk::RinexObsID("GS1S", cv));
151  hdr.mapObsTypes["G"].push_back(gnsstk::RinexObsID("GC1L", cv));
152  hdr.mapObsTypes["G"].push_back(gnsstk::RinexObsID("GL1L", cv));
153  hdr.mapObsTypes["G"].push_back(gnsstk::RinexObsID("GD1L", cv));
154  hdr.mapObsTypes["G"].push_back(gnsstk::RinexObsID("GS1L", cv));
155  hdr.mapObsTypes["G"].push_back(gnsstk::RinexObsID("GC1X", cv));
156  hdr.mapObsTypes["G"].push_back(gnsstk::RinexObsID("GL1X", cv));
157  hdr.mapObsTypes["G"].push_back(gnsstk::RinexObsID("GD1X", cv));
158  hdr.mapObsTypes["G"].push_back(gnsstk::RinexObsID("GS1X", cv));
159  hdr.mapObsTypes["G"].push_back(gnsstk::RinexObsID("GC1P", cv));
160  hdr.mapObsTypes["G"].push_back(gnsstk::RinexObsID("GL1P", cv));
161  hdr.mapObsTypes["G"].push_back(gnsstk::RinexObsID("GD1P", cv));
162  hdr.mapObsTypes["G"].push_back(gnsstk::RinexObsID("GS1P", cv));
163  hdr.mapObsTypes["G"].push_back(gnsstk::RinexObsID("GC1W", cv));
164  hdr.mapObsTypes["G"].push_back(gnsstk::RinexObsID("GL1W", cv));
165  hdr.mapObsTypes["G"].push_back(gnsstk::RinexObsID("GD1W", cv));
166  hdr.mapObsTypes["G"].push_back(gnsstk::RinexObsID("GS1W", cv));
167  hdr.mapObsTypes["G"].push_back(gnsstk::RinexObsID("GC1Y", cv));
168  hdr.mapObsTypes["G"].push_back(gnsstk::RinexObsID("GL1Y", cv));
169  hdr.mapObsTypes["G"].push_back(gnsstk::RinexObsID("GD1Y", cv));
170  hdr.mapObsTypes["G"].push_back(gnsstk::RinexObsID("GS1Y", cv));
171  hdr.mapObsTypes["G"].push_back(gnsstk::RinexObsID("GC1M", cv));
172  hdr.mapObsTypes["G"].push_back(gnsstk::RinexObsID("GL1M", cv));
173  hdr.mapObsTypes["G"].push_back(gnsstk::RinexObsID("GD1M", cv));
174  hdr.mapObsTypes["G"].push_back(gnsstk::RinexObsID("GS1M", cv));
175  hdr.mapObsTypes["G"].push_back(gnsstk::RinexObsID("GL1N", cv));
176  hdr.mapObsTypes["G"].push_back(gnsstk::RinexObsID("GD1N", cv));
177  hdr.mapObsTypes["G"].push_back(gnsstk::RinexObsID("GS1N", cv));
178  // now have fun with channels
179  TUCATCH(hdr.mapObsTypes["G"].push_back(gnsstk::RinexObsID("GX1 ", cv)));
180  TUTHROW(hdr.mapObsTypes["G"].push_back(gnsstk::RinexObsID("GX2Y", cv)));
181  // This should not appear in the header as it is redundant, but
182  // it is still valid as an ObsID.
183  gnsstk::RinexObsID forced(gnsstk::ObservationType::Channel, gnsstk::CarrierBand::L1,
184  gnsstk::TrackingCode::CA);
185  TUCATCH(hdr.mapObsTypes["G"].push_back(forced));
186  hdr.sysPhaseShift["G"][roidValid][sid] = 54.321;
187  hdr.date = "20200512 181734 UTC";
188  hdr.preserveDate = true;
189  hdr.version = cv;
190  hdr.valid |= gnsstk::Rinex3ObsHeader::validVersion;
191  hdr.valid |= gnsstk::Rinex3ObsHeader::validRunBy;
192  hdr.valid |= gnsstk::Rinex3ObsHeader::validMarkerName;
193  hdr.valid |= gnsstk::Rinex3ObsHeader::validObserver;
194  hdr.valid |= gnsstk::Rinex3ObsHeader::validReceiver;
195  hdr.valid |= gnsstk::Rinex3ObsHeader::validAntennaType;
196  hdr.valid |= gnsstk::Rinex3ObsHeader::validAntennaPosition;
197  hdr.valid |= gnsstk::Rinex3ObsHeader::validAntennaDeltaHEN;
198  hdr.valid |= gnsstk::Rinex3ObsHeader::validFirstTime;
199  hdr.valid |= gnsstk::Rinex3ObsHeader::validMarkerNumber;
200  hdr.valid |= gnsstk::Rinex3ObsHeader::validInterval;
201  hdr.valid |= gnsstk::Rinex3ObsHeader::validSystemNumObs;
202  hdr.valid |= gnsstk::Rinex3ObsHeader::validSystemPhaseShift;
203  hdr.validEoH = true;
204  TUCATCH(strm << hdr);
205  gnsstk::Rinex3ObsData rod;
206  gnsstk::RinexDatum data;
207  data.dataBlank = false;
208  data.lliBlank = true;
209  data.ssiBlank = true;
210  rod.time = gnsstk::CivilTime(2020,3,11,12,0,0,gnsstk::TimeSystem::GPS);
211  rod.epochFlag = 0;
212  rod.numSVs = 1;
213  rod.clockOffset = 0;
214  const gnsstk::Rinex3ObsHeader::RinexObsVec &rov(hdr.mapObsTypes["G"]);
215  // set a data value for each observable including the redundant
216  // channel number, which should get printed out as concatenated
217  // two-digit numbers.
218  for (unsigned i = 0; i < rov.size(); i++)
219  {
220  data.data++;
221  rod.setObs(data, sid, rov[i], hdr);
222  }
223  TUCATCH(strm << rod);
224  TUCMPFILE(expfn, outfn, 0);
225  TURETURN();
226 }
227 
228 
229 unsigned Rinex3ObsOther_T ::
230 ionoDelayTest()
231 {
232  // Note that Rinex3ObsData is also being tested
233  TUDEF("Rinex3ObsHeader", "writeHeaderRecords (SYS / # / OBS TYPES)");
234 
235  std::string outfn = gnsstk::getPathTestTemp() + gnsstk::getFileSep() +
236  "rinex3ObsTest_v304_IonoDelay.out";
237  std::string expfn = gnsstk::getPathData() + gnsstk::getFileSep() +
238  "rinex3ObsTest_v304_IonoDelay.exp";
239 
240  // abbreviate.
241  double cv = gnsstk::Rinex3ObsBase::currentVersion;
242  gnsstk::Rinex3ObsStream strm(outfn, std::ios::out | std::ios::trunc);
243  gnsstk::Rinex3ObsHeader hdr;
244  gnsstk::RinexObsID roidValid("GL1C", cv);
245  gnsstk::SatID sid(7, gnsstk::SatelliteSystem::GPS);
246  strm.exceptions(std::fstream::failbit);
247  // Not setting most of the header fields because they're not being tested.
248  TUCATCH(hdr.mapObsTypes["G"].push_back(gnsstk::RinexObsID("GC1C", cv)));
249  TUCATCH(hdr.mapObsTypes["G"].push_back(gnsstk::RinexObsID("GL1C", cv)));
250  TUCATCH(hdr.mapObsTypes["G"].push_back(gnsstk::RinexObsID("GD1C", cv)));
251  TUCATCH(hdr.mapObsTypes["G"].push_back(gnsstk::RinexObsID("GS1C", cv)));
252  TUCATCH(hdr.mapObsTypes["G"].push_back(gnsstk::RinexObsID("GI1 ", cv)));
253  TUCATCH(hdr.mapObsTypes["G"].push_back(gnsstk::RinexObsID("GC2C", cv)));
254  TUCATCH(hdr.mapObsTypes["G"].push_back(gnsstk::RinexObsID("GL2C", cv)));
255  TUCATCH(hdr.mapObsTypes["G"].push_back(gnsstk::RinexObsID("GD2C", cv)));
256  TUCATCH(hdr.mapObsTypes["G"].push_back(gnsstk::RinexObsID("GS2C", cv)));
257  TUCATCH(hdr.mapObsTypes["G"].push_back(gnsstk::RinexObsID("GI2 ", cv)));
258  TUCATCH(hdr.mapObsTypes["R"].push_back(gnsstk::RinexObsID("RC3I", cv)));
259  TUCATCH(hdr.mapObsTypes["R"].push_back(gnsstk::RinexObsID("RL3I", cv)));
260  TUCATCH(hdr.mapObsTypes["R"].push_back(gnsstk::RinexObsID("RD3I", cv)));
261  TUCATCH(hdr.mapObsTypes["R"].push_back(gnsstk::RinexObsID("RS3I", cv)));
262  TUCATCH(hdr.mapObsTypes["R"].push_back(gnsstk::RinexObsID("RI3 ", cv)));
263  TUCATCH(hdr.mapObsTypes["R"].push_back(gnsstk::RinexObsID("RC4A", cv)));
264  TUCATCH(hdr.mapObsTypes["R"].push_back(gnsstk::RinexObsID("RL4A", cv)));
265  TUCATCH(hdr.mapObsTypes["R"].push_back(gnsstk::RinexObsID("RD4A", cv)));
266  TUCATCH(hdr.mapObsTypes["R"].push_back(gnsstk::RinexObsID("RS4A", cv)));
267  TUCATCH(hdr.mapObsTypes["R"].push_back(gnsstk::RinexObsID("RI4 ", cv)));
268  TUCATCH(hdr.mapObsTypes["E"].push_back(gnsstk::RinexObsID("EC5I", cv)));
269  TUCATCH(hdr.mapObsTypes["E"].push_back(gnsstk::RinexObsID("EL5I", cv)));
270  TUCATCH(hdr.mapObsTypes["E"].push_back(gnsstk::RinexObsID("ED5I", cv)));
271  TUCATCH(hdr.mapObsTypes["E"].push_back(gnsstk::RinexObsID("ES5I", cv)));
272  TUCATCH(hdr.mapObsTypes["E"].push_back(gnsstk::RinexObsID("EI5 ", cv)));
273  TUCATCH(hdr.mapObsTypes["E"].push_back(gnsstk::RinexObsID("EC6A", cv)));
274  TUCATCH(hdr.mapObsTypes["E"].push_back(gnsstk::RinexObsID("EL6A", cv)));
275  TUCATCH(hdr.mapObsTypes["E"].push_back(gnsstk::RinexObsID("ED6A", cv)));
276  TUCATCH(hdr.mapObsTypes["E"].push_back(gnsstk::RinexObsID("ES6A", cv)));
277  TUCATCH(hdr.mapObsTypes["E"].push_back(gnsstk::RinexObsID("EI6 ", cv)));
278  TUCATCH(hdr.mapObsTypes["E"].push_back(gnsstk::RinexObsID("EC7I", cv)));
279  TUCATCH(hdr.mapObsTypes["E"].push_back(gnsstk::RinexObsID("EL7I", cv)));
280  TUCATCH(hdr.mapObsTypes["E"].push_back(gnsstk::RinexObsID("ED7I", cv)));
281  TUCATCH(hdr.mapObsTypes["E"].push_back(gnsstk::RinexObsID("ES7I", cv)));
282  TUCATCH(hdr.mapObsTypes["E"].push_back(gnsstk::RinexObsID("EI7 ", cv)));
283  TUCATCH(hdr.mapObsTypes["E"].push_back(gnsstk::RinexObsID("EC8I", cv)));
284  TUCATCH(hdr.mapObsTypes["E"].push_back(gnsstk::RinexObsID("EL8I", cv)));
285  TUCATCH(hdr.mapObsTypes["E"].push_back(gnsstk::RinexObsID("ED8I", cv)));
286  TUCATCH(hdr.mapObsTypes["E"].push_back(gnsstk::RinexObsID("ES8I", cv)));
287  TUCATCH(hdr.mapObsTypes["E"].push_back(gnsstk::RinexObsID("EI8 ", cv)));
288  TUCATCH(hdr.mapObsTypes["I"].push_back(gnsstk::RinexObsID("IC9A", cv)));
289  TUCATCH(hdr.mapObsTypes["I"].push_back(gnsstk::RinexObsID("IL9A", cv)));
290  TUCATCH(hdr.mapObsTypes["I"].push_back(gnsstk::RinexObsID("ID9A", cv)));
291  TUCATCH(hdr.mapObsTypes["I"].push_back(gnsstk::RinexObsID("IS9A", cv)));
292  TUCATCH(hdr.mapObsTypes["I"].push_back(gnsstk::RinexObsID("II9 ", cv)));
293  // now have fun with decoding
294  TUTHROW(hdr.mapObsTypes["G"].push_back(gnsstk::RinexObsID("GI2Y", cv)));
295  // This should not appear in the header as it is redundant, but
296  // it is still valid as an ObsID.
297  gnsstk::RinexObsID forced(gnsstk::ObservationType::Iono, gnsstk::CarrierBand::L1,
298  gnsstk::TrackingCode::CA);
299  TUCATCH(hdr.mapObsTypes["G"].push_back(forced));
300  hdr.sysPhaseShift["G"][roidValid][sid] = 54.321;
301  hdr.date = "20200512 181734 UTC";
302  hdr.preserveDate = true;
303  hdr.version = 3.04;
304  hdr.valid |= gnsstk::Rinex3ObsHeader::validVersion;
305  hdr.valid |= gnsstk::Rinex3ObsHeader::validRunBy;
306  hdr.valid |= gnsstk::Rinex3ObsHeader::validMarkerName;
307  hdr.valid |= gnsstk::Rinex3ObsHeader::validObserver;
308  hdr.valid |= gnsstk::Rinex3ObsHeader::validReceiver;
309  hdr.valid |= gnsstk::Rinex3ObsHeader::validAntennaType;
310  hdr.valid |= gnsstk::Rinex3ObsHeader::validAntennaPosition;
311  hdr.valid |= gnsstk::Rinex3ObsHeader::validAntennaDeltaHEN;
312  hdr.valid |= gnsstk::Rinex3ObsHeader::validFirstTime;
313  hdr.valid |= gnsstk::Rinex3ObsHeader::validMarkerNumber;
314  hdr.valid |= gnsstk::Rinex3ObsHeader::validInterval;
315  hdr.valid |= gnsstk::Rinex3ObsHeader::validSystemNumObs;
316  hdr.valid |= gnsstk::Rinex3ObsHeader::validSystemPhaseShift;
317  hdr.valid |= gnsstk::Rinex3ObsHeader::validGlonassSlotFreqNo;
318  hdr.valid |= gnsstk::Rinex3ObsHeader::validGlonassCodPhsBias;
319  hdr.validEoH = true;
320  TUCATCH(strm << hdr);
321  gnsstk::Rinex3ObsData rod;
322  rod.time = gnsstk::CivilTime(2020,3,11,12,0,0,gnsstk::TimeSystem::GPS);
323  rod.epochFlag = 0;
324  rod.numSVs = 1;
325  rod.clockOffset = 0;
326  for (const auto& motIter : hdr.mapObsTypes)
327  {
328  setObs(testFramework, motIter.first, hdr, rod);
329  }
330  TUCSM("operator<<");
331  TUCATCH(strm << rod);
332  TUCMPFILE(expfn, outfn, 0);
333  TURETURN();
334 }
335 
336 
337 void Rinex3ObsOther_T ::
338 setObs(gnsstk::TestUtil& testFramework, const std::string& system,
339  gnsstk::Rinex3ObsHeader& hdr, gnsstk::Rinex3ObsData& rod)
340 {
341  gnsstk::RinexSatID sid;
342  gnsstk::RinexDatum data;
343  data.dataBlank = false;
344  data.lliBlank = true;
345  data.ssiBlank = true;
346  sid.fromString(system + "07");
347  const gnsstk::Rinex3ObsHeader::RinexObsVec &rov(hdr.mapObsTypes[system]);
348  // set a data value for each observable including the redundant
349  // channel number, which should get printed out as concatenated
350  // two-digit numbers.
351  for (unsigned i = 0; i < rov.size(); i++)
352  {
353  data.data++;
354  TUCSM("setObs(" + rov[i].asString() + ")");
355  TUCATCH(rod.setObs(data, sid, rov[i], hdr));
356  }
357 }
358 
359 
360 unsigned Rinex3ObsOther_T ::
361 obsIDVersionTest()
362 {
363  TUDEF("Rinex3ObsHeader", "writeHeaderRecords");
364 
365  std::string outtmpl = gnsstk::getPathTestTemp() + gnsstk::getFileSep() +
366  "rinex3ObsIDHeaderTest_v";
367  std::string exptmpl = gnsstk::getPathData() + gnsstk::getFileSep() +
368  "rinex3ObsIDHeaderTest_v";
369 
370  // test writing a header containing 3.02 obs to a 3.02 file
371  try
372  {
373  gnsstk::Rinex3ObsStream strm(outtmpl + "302.out",
374  std::ios::out | std::ios::trunc);
375  gnsstk::Rinex3ObsHeader hdr;
376  strm.exceptions(std::fstream::failbit);
377  fillHeader302(hdr);
378  TUCATCH(strm << hdr);
379  TUCMPFILE(exptmpl + "302.exp", outtmpl + "302.out", 0);
380  }
381  catch (gnsstk::Exception& exc)
382  {
383  cerr << exc;
384  TUFAIL("Exception");
385  }
386  catch (std::exception& exc)
387  {
388  cerr << "caught " << exc.what() << endl;
389  TUFAIL("Exception");
390  }
391  catch (...)
392  {
393  TUFAIL("Unknown exception");
394  }
395 
396  // test writing a header containing 3.02 obs to a 3.04 file
397  try
398  {
399  gnsstk::Rinex3ObsStream strm(outtmpl + "304.out",
400  std::ios::out | std::ios::trunc);
401  gnsstk::Rinex3ObsHeader hdr;
402  strm.exceptions(std::fstream::failbit);
403  fillHeader302(hdr);
404  hdr.version = 3.04;
405  TUCATCH(strm << hdr);
406  TUCMPFILE(exptmpl + "304.exp", outtmpl + "304.out", 0);
407  }
408  catch (gnsstk::Exception& exc)
409  {
410  cerr << exc;
411  TUFAIL("Exception");
412  }
413  catch (std::exception& exc)
414  {
415  cerr << "caught " << exc.what() << endl;
416  TUFAIL("Exception");
417  }
418  catch (...)
419  {
420  TUFAIL("Unknown exception");
421  }
422 
423  // test writing a header containing 3.04 obs to a 3.02 file
424  try
425  {
426  gnsstk::Rinex3ObsStream strm(outtmpl + "302b.out",
427  std::ios::out | std::ios::trunc);
428  gnsstk::Rinex3ObsHeader hdr;
429  strm.exceptions(std::fstream::failbit);
430  fillHeader304(hdr);
431  hdr.version = 3.02;
432  TUCATCH(strm << hdr);
433  TUCMPFILE(exptmpl + "302.exp", outtmpl + "302b.out", 0);
434  }
435  catch (gnsstk::Exception& exc)
436  {
437  cerr << exc;
438  TUFAIL("Exception");
439  }
440  catch (std::exception& exc)
441  {
442  cerr << "caught " << exc.what() << endl;
443  TUFAIL("Exception");
444  }
445  catch (...)
446  {
447  TUFAIL("Unknown exception");
448  }
449 
450  // test writing a header containing 3.04 obs to a 3.04 file
451  try
452  {
453  gnsstk::Rinex3ObsStream strm(outtmpl + "304b.out",
454  std::ios::out | std::ios::trunc);
455  gnsstk::Rinex3ObsHeader hdr;
456  strm.exceptions(std::fstream::failbit);
457  fillHeader304(hdr);
458  hdr.version = 3.04;
459  TUCATCH(strm << hdr);
460  TUCMPFILE(exptmpl + "304.exp", outtmpl + "304b.out", 0);
461  }
462  catch (gnsstk::Exception& exc)
463  {
464  cerr << exc;
465  TUFAIL("Exception");
466  }
467  catch (std::exception& exc)
468  {
469  cerr << "caught " << exc.what() << endl;
470  TUFAIL("Exception");
471  }
472  catch (...)
473  {
474  TUFAIL("Unknown exception");
475  }
476  TURETURN();
477 }
478 
479 
480 void Rinex3ObsOther_T ::
481 fillHeader302(gnsstk::Rinex3ObsHeader& hdr)
482 {
483  gnsstk::SatID sid(7, gnsstk::SatelliteSystem::BeiDou);
484  hdr.date = "20200512 181734 UTC";
485  hdr.preserveDate = true;
486  hdr.version = 3.02;
487  hdr.mapObsTypes["C"].push_back(gnsstk::RinexObsID("CC1I", 3.02));
488  hdr.mapObsTypes["C"].push_back(gnsstk::RinexObsID("CL1I", 3.02));
489  hdr.mapObsTypes["C"].push_back(gnsstk::RinexObsID("CD1I", 3.02));
490  hdr.mapObsTypes["C"].push_back(gnsstk::RinexObsID("CS1I", 3.02));
491  hdr.mapObsTypes["C"].push_back(gnsstk::RinexObsID("CC1Q", 3.02));
492  hdr.mapObsTypes["C"].push_back(gnsstk::RinexObsID("CL1Q", 3.02));
493  hdr.mapObsTypes["C"].push_back(gnsstk::RinexObsID("CD1Q", 3.02));
494  hdr.mapObsTypes["C"].push_back(gnsstk::RinexObsID("CS1Q", 3.02));
495  hdr.mapObsTypes["C"].push_back(gnsstk::RinexObsID("CC7X", 3.02));
496  hdr.mapObsTypes["C"].push_back(gnsstk::RinexObsID("CL7X", 3.02));
497  hdr.mapObsTypes["C"].push_back(gnsstk::RinexObsID("CD7X", 3.02));
498  hdr.mapObsTypes["C"].push_back(gnsstk::RinexObsID("CS7X", 3.02));
499  hdr.mapObsTypes["C"].push_back(gnsstk::RinexObsID("CC1X", 3.02));
500  hdr.mapObsTypes["C"].push_back(gnsstk::RinexObsID("CL1X", 3.02));
501  hdr.mapObsTypes["C"].push_back(gnsstk::RinexObsID("CD1X", 3.02));
502  hdr.mapObsTypes["C"].push_back(gnsstk::RinexObsID("CS1X", 3.02));
503  hdr.sysPhaseShift["C"][gnsstk::RinexObsID("CL1I", 3.02)][sid] = 2.345;
504  hdr.sysPhaseShift["C"][gnsstk::RinexObsID("CL1Q", 3.02)][sid] = 6.789;
505  hdr.sysPhaseShift["C"][gnsstk::RinexObsID("CL7X", 3.02)][sid] = 8.765;
506  hdr.sysPhaseShift["C"][gnsstk::RinexObsID("CL1X", 3.02)][sid] = 0.123;
507  hdr.sysSfacMap["C"][gnsstk::RinexObsID("CC1I", 3.02)] = 1;
508  hdr.sysSfacMap["C"][gnsstk::RinexObsID("CL1I", 3.02)] = 10;
509  hdr.sysSfacMap["C"][gnsstk::RinexObsID("CD1I", 3.02)] = 100;
510  hdr.sysSfacMap["C"][gnsstk::RinexObsID("CS1I", 3.02)] = 1000;
511  hdr.sysSfacMap["C"][gnsstk::RinexObsID("CC1Q", 3.02)] = 1;
512  hdr.sysSfacMap["C"][gnsstk::RinexObsID("CL1Q", 3.02)] = 10;
513  hdr.sysSfacMap["C"][gnsstk::RinexObsID("CD1Q", 3.02)] = 100;
514  hdr.sysSfacMap["C"][gnsstk::RinexObsID("CS1Q", 3.02)] = 1000;
515  hdr.sysSfacMap["C"][gnsstk::RinexObsID("CC7X", 3.02)] = 1;
516  hdr.sysSfacMap["C"][gnsstk::RinexObsID("CL7X", 3.02)] = 10;
517  hdr.sysSfacMap["C"][gnsstk::RinexObsID("CD7X", 3.02)] = 100;
518  hdr.sysSfacMap["C"][gnsstk::RinexObsID("CS7X", 3.02)] = 1000;
519  hdr.sysSfacMap["C"][gnsstk::RinexObsID("CC1X", 3.02)] = 1;
520  hdr.sysSfacMap["C"][gnsstk::RinexObsID("CL1X", 3.02)] = 10;
521  hdr.sysSfacMap["C"][gnsstk::RinexObsID("CD1X", 3.02)] = 100;
522  hdr.sysSfacMap["C"][gnsstk::RinexObsID("CS1X", 3.02)] = 1000;
523  hdr.valid |= gnsstk::Rinex3ObsHeader::validVersion;
524  hdr.valid |= gnsstk::Rinex3ObsHeader::validRunBy;
525  hdr.valid |= gnsstk::Rinex3ObsHeader::validMarkerName;
526  hdr.valid |= gnsstk::Rinex3ObsHeader::validMarkerType;
527  hdr.valid |= gnsstk::Rinex3ObsHeader::validObserver;
528  hdr.valid |= gnsstk::Rinex3ObsHeader::validReceiver;
529  hdr.valid |= gnsstk::Rinex3ObsHeader::validAntennaType;
530  hdr.valid |= gnsstk::Rinex3ObsHeader::validAntennaPosition;
531  hdr.valid |= gnsstk::Rinex3ObsHeader::validAntennaDeltaHEN;
532  hdr.valid |= gnsstk::Rinex3ObsHeader::validSystemNumObs;
533  hdr.valid |= gnsstk::Rinex3ObsHeader::validFirstTime;
534  hdr.valid |= gnsstk::Rinex3ObsHeader::validSystemPhaseShift;
535  hdr.valid |= gnsstk::Rinex3ObsHeader::validSystemScaleFac;
536  hdr.validEoH = true;
537 }
538 
539 
540 void Rinex3ObsOther_T ::
541 fillHeader304(gnsstk::Rinex3ObsHeader& hdr)
542 {
543  gnsstk::SatID sid(7, gnsstk::SatelliteSystem::BeiDou);
544  hdr.date = "20200512 181734 UTC";
545  hdr.preserveDate = true;
546  hdr.version = 3.04;
547  hdr.mapObsTypes["C"].push_back(gnsstk::RinexObsID("CC2I", 3.04));
548  hdr.mapObsTypes["C"].push_back(gnsstk::RinexObsID("CL2I", 3.04));
549  hdr.mapObsTypes["C"].push_back(gnsstk::RinexObsID("CD2I", 3.04));
550  hdr.mapObsTypes["C"].push_back(gnsstk::RinexObsID("CS2I", 3.04));
551  hdr.mapObsTypes["C"].push_back(gnsstk::RinexObsID("CC2Q", 3.04));
552  hdr.mapObsTypes["C"].push_back(gnsstk::RinexObsID("CL2Q", 3.04));
553  hdr.mapObsTypes["C"].push_back(gnsstk::RinexObsID("CD2Q", 3.04));
554  hdr.mapObsTypes["C"].push_back(gnsstk::RinexObsID("CS2Q", 3.04));
555  hdr.mapObsTypes["C"].push_back(gnsstk::RinexObsID("CC7X", 3.04));
556  hdr.mapObsTypes["C"].push_back(gnsstk::RinexObsID("CL7X", 3.04));
557  hdr.mapObsTypes["C"].push_back(gnsstk::RinexObsID("CD7X", 3.04));
558  hdr.mapObsTypes["C"].push_back(gnsstk::RinexObsID("CS7X", 3.04));
559  hdr.mapObsTypes["C"].push_back(gnsstk::RinexObsID("CC2X", 3.04));
560  hdr.mapObsTypes["C"].push_back(gnsstk::RinexObsID("CL2X", 3.04));
561  hdr.mapObsTypes["C"].push_back(gnsstk::RinexObsID("CD2X", 3.04));
562  hdr.mapObsTypes["C"].push_back(gnsstk::RinexObsID("CS2X", 3.04));
563  hdr.sysPhaseShift["C"][gnsstk::RinexObsID("CL2I", 3.04)][sid] = 2.345;
564  hdr.sysPhaseShift["C"][gnsstk::RinexObsID("CL2Q", 3.04)][sid] = 6.789;
565  hdr.sysPhaseShift["C"][gnsstk::RinexObsID("CL7X", 3.04)][sid] = 8.765;
566  hdr.sysPhaseShift["C"][gnsstk::RinexObsID("CL2X", 3.04)][sid] = 0.123;
567  hdr.sysSfacMap["C"][gnsstk::RinexObsID("CC2I", 3.04)] = 1;
568  hdr.sysSfacMap["C"][gnsstk::RinexObsID("CL2I", 3.04)] = 10;
569  hdr.sysSfacMap["C"][gnsstk::RinexObsID("CD2I", 3.04)] = 100;
570  hdr.sysSfacMap["C"][gnsstk::RinexObsID("CS2I", 3.04)] = 1000;
571  hdr.sysSfacMap["C"][gnsstk::RinexObsID("CC2Q", 3.04)] = 1;
572  hdr.sysSfacMap["C"][gnsstk::RinexObsID("CL2Q", 3.04)] = 10;
573  hdr.sysSfacMap["C"][gnsstk::RinexObsID("CD2Q", 3.04)] = 100;
574  hdr.sysSfacMap["C"][gnsstk::RinexObsID("CS2Q", 3.04)] = 1000;
575  hdr.sysSfacMap["C"][gnsstk::RinexObsID("CC7X", 3.04)] = 1;
576  hdr.sysSfacMap["C"][gnsstk::RinexObsID("CL7X", 3.04)] = 10;
577  hdr.sysSfacMap["C"][gnsstk::RinexObsID("CD7X", 3.04)] = 100;
578  hdr.sysSfacMap["C"][gnsstk::RinexObsID("CS7X", 3.04)] = 1000;
579  hdr.sysSfacMap["C"][gnsstk::RinexObsID("CC2X", 3.04)] = 1;
580  hdr.sysSfacMap["C"][gnsstk::RinexObsID("CL2X", 3.04)] = 10;
581  hdr.sysSfacMap["C"][gnsstk::RinexObsID("CD2X", 3.04)] = 100;
582  hdr.sysSfacMap["C"][gnsstk::RinexObsID("CS2X", 3.04)] = 1000;
583  hdr.valid |= gnsstk::Rinex3ObsHeader::validVersion;
584  hdr.valid |= gnsstk::Rinex3ObsHeader::validRunBy;
585  hdr.valid |= gnsstk::Rinex3ObsHeader::validMarkerName;
586  hdr.valid |= gnsstk::Rinex3ObsHeader::validMarkerType;
587  hdr.valid |= gnsstk::Rinex3ObsHeader::validObserver;
588  hdr.valid |= gnsstk::Rinex3ObsHeader::validReceiver;
589  hdr.valid |= gnsstk::Rinex3ObsHeader::validAntennaType;
590  hdr.valid |= gnsstk::Rinex3ObsHeader::validAntennaPosition;
591  hdr.valid |= gnsstk::Rinex3ObsHeader::validAntennaDeltaHEN;
592  hdr.valid |= gnsstk::Rinex3ObsHeader::validSystemNumObs;
593  hdr.valid |= gnsstk::Rinex3ObsHeader::validFirstTime;
594  hdr.valid |= gnsstk::Rinex3ObsHeader::validSystemPhaseShift;
595  hdr.valid |= gnsstk::Rinex3ObsHeader::validSystemScaleFac;
596  hdr.validEoH = true;
597 }
598 
599 
600 unsigned Rinex3ObsOther_T ::
601 reopenTest()
602 {
603  TUDEF("Rinex3ObsOther", "open");
604  gnsstk::Rinex3ObsStream uut;
605  gnsstk::Rinex3ObsData data;
606  std::string inp1 = gnsstk::getPathData() + gnsstk::getFileSep() +
607  "arlm200a.15o";
608  std::string inp2 = gnsstk::getPathData() + gnsstk::getFileSep() +
609  "mixed211.05o";
610  // read and verify the 1st header
611  TUCATCH(uut.open(inp1.c_str(), ios::in));
612  TUASSERTE(bool, true, static_cast<bool>(uut));
613  TUCATCH(uut >> data);
614  TUASSERTE(bool, true, static_cast<bool>(uut));
615  TUASSERTE(std::string, "ARL1", uut.header.markerName);
616  uut.close();
617  // read and verify the 2nd header using the same stream.
618  TUCATCH(uut.open(inp2.c_str(), ios::in));
619  TUASSERTE(bool, true, static_cast<bool>(uut));
620  TUCATCH(uut >> data);
621  TUASSERTE(bool, true, static_cast<bool>(uut));
622  TUASSERTE(std::string, "A 9080", uut.header.markerName);
623  TURETURN();
624 }
625 
626 
627 int main()
628 {
629  unsigned errorTotal = 0;
630  Rinex3ObsOther_T testClass;
631 
632  errorTotal += testClass.phaseShiftTest();
633  errorTotal += testClass.channelNumTest();
634  errorTotal += testClass.ionoDelayTest();
635  errorTotal += testClass.obsIDVersionTest();
636  errorTotal += testClass.reopenTest();
637  cout << "Total Failures for " << __FILE__ << ": " << errorTotal << endl;
638  return errorTotal;
639 }
gnsstk::Rinex3ObsHeader::validSystemNumObs
@ validSystemNumObs
SYS / # / OBS TYPES.
Definition: Rinex3ObsHeader.hpp:268
TUCSM
#define TUCSM(METHOD)
Definition: TestUtil.hpp:59
gnsstk::Rinex3ObsHeader::validAntennaDeltaHEN
@ validAntennaDeltaHEN
ANTENNA: DELTA H/E/N.
Definition: Rinex3ObsHeader.hpp:260
gnsstk::RinexDatum
Storage for single RINEX OBS data measurements.
Definition: RinexDatum.hpp:55
gnsstk::Rinex3ObsHeader::validRunBy
@ validRunBy
PGM / RUN BY / DATE.
Definition: Rinex3ObsHeader.hpp:251
gnsstk::Rinex3ObsStream::open
virtual void open(const char *fn, std::ios::openmode mode)
Definition: Rinex3ObsStream.cpp:80
gnsstk::RinexSatID::fromString
void fromString(const std::string &s)
Definition: RinexSatID.cpp:122
TUCATCH
#define TUCATCH(STATEMENT)
Definition: TestUtil.hpp:193
gnsstk::Rinex3ObsHeader::preserveDate
bool preserveDate
Definition: Rinex3ObsHeader.hpp:497
gnsstk::Rinex3ObsHeader::valid
Fields valid
bits set when header rec.s present & valid
Definition: Rinex3ObsHeader.hpp:544
gnsstk::Rinex3ObsHeader
Definition: Rinex3ObsHeader.hpp:155
TUASSERTE
#define TUASSERTE(TYPE, EXP, GOT)
Definition: TestUtil.hpp:81
Rinex3ObsOther_T::obsIDVersionTest
unsigned obsIDVersionTest()
Definition: Rinex3ObsOther_T.cpp:361
TUFAIL
#define TUFAIL(MSG)
Definition: TestUtil.hpp:228
gnsstk::Rinex3ObsHeader::validReceiver
@ validReceiver
REC # / TYPE / VERS.
Definition: Rinex3ObsHeader.hpp:257
gnsstk::Rinex3ObsHeader::validGlonassSlotFreqNo
@ validGlonassSlotFreqNo
GLONASS SLOT / FRQ #.
Definition: Rinex3ObsHeader.hpp:279
gnsstk::SatID
Definition: SatID.hpp:89
gnsstk::ObservationType::Channel
@ Channel
Channel number.
gnsstk::StringUtils::asString
std::string asString(IonexStoreStrategy e)
Convert a IonexStoreStrategy to a whitespace-free string name.
Definition: IonexStoreStrategy.cpp:46
Rinex3ObsOther_T::fillHeader302
void fillHeader302(gnsstk::Rinex3ObsHeader &hdr)
Fill a v3.02 header with data for the obsIDVersionTest method.
Definition: Rinex3ObsOther_T.cpp:481
gnsstk::Rinex3ObsData::numSVs
short numSVs
Definition: Rinex3ObsData.hpp:109
gnsstk::Rinex3ObsBase::currentVersion
static const GNSSTK_EXPORT double currentVersion
Definition: Rinex3ObsBase.hpp:72
gnsstk::Rinex3ObsHeader::validAntennaPosition
@ validAntennaPosition
APPROX POSITION XYZ.
Definition: Rinex3ObsHeader.hpp:259
gnsstk::Rinex3ObsHeader::validGlonassCodPhsBias
@ validGlonassCodPhsBias
GLONASS COD/PHS/BIS.
Definition: Rinex3ObsHeader.hpp:280
gnsstk::Rinex3ObsHeader::validAntennaType
@ validAntennaType
ANT # / TYPE.
Definition: Rinex3ObsHeader.hpp:258
TUTHROW
#define TUTHROW(STATEMENT)
Definition: TestUtil.hpp:211
gnsstk::Rinex3ObsData::epochFlag
short epochFlag
Definition: Rinex3ObsData.hpp:104
gnsstk::Rinex3ObsHeader::mapObsTypes
RinexObsMap mapObsTypes
SYS / # / OBS TYPES.
Definition: Rinex3ObsHeader.hpp:519
Rinex3ObsOther_T::channelNumTest
unsigned channelNumTest()
Definition: Rinex3ObsOther_T.cpp:125
gnsstk::Exception
Definition: Exception.hpp:151
gnsstk::Rinex3ObsStream::header
Rinex3ObsHeader header
The header for this file.
Definition: Rinex3ObsStream.hpp:110
gnsstk::SatelliteSystem::GPS
@ GPS
gnsstk::TrackingCode::CA
@ CA
Legacy GPS civil code.
Rinex3ObsOther_T::ionoDelayTest
unsigned ionoDelayTest()
Definition: Rinex3ObsOther_T.cpp:230
gnsstk::Rinex3ObsData::setObs
virtual void setObs(const RinexDatum &data, const RinexSatID &svID, const RinexObsID &obsID, const Rinex3ObsHeader &hdr)
Definition: Rinex3ObsData.cpp:266
gnsstk::Rinex3ObsData::time
CommonTime time
Time corresponding to the observations.
Definition: Rinex3ObsData.hpp:91
TestUtil.hpp
main
int main()
Definition: Rinex3ObsOther_T.cpp:627
TURETURN
#define TURETURN()
Definition: TestUtil.hpp:232
gnsstk::Rinex3ObsHeader::validFirstTime
@ validFirstTime
TIME OF FIRST OBS.
Definition: Rinex3ObsHeader.hpp:272
gnsstk::Rinex3ObsHeader::version
double version
RINEX 3 version/type.
Definition: Rinex3ObsHeader.hpp:481
gnsstk::Rinex3ObsHeader::validVersion
@ validVersion
RINEX VERSION / TYPE.
Definition: Rinex3ObsHeader.hpp:249
gnsstk::Rinex3ObsHeader::validInterval
@ validInterval
INTERVAL.
Definition: Rinex3ObsHeader.hpp:271
gnsstk::Rinex3ObsData
Definition: Rinex3ObsData.hpp:75
Rinex3ObsHeader.hpp
gnsstk::Rinex3ObsHeader::markerName
std::string markerName
MARKER NAME.
Definition: Rinex3ObsHeader.hpp:499
Rinex3ObsOther_T::phaseShiftTest
unsigned phaseShiftTest()
Definition: Rinex3ObsOther_T.cpp:80
gnsstk::Rinex3ObsHeader::validMarkerType
@ validMarkerType
MARKER TYPE.
Definition: Rinex3ObsHeader.hpp:255
gnsstk::CarrierBand::L1
@ L1
GPS L1, Galileo E1, SBAS L1, QZSS L1, BeiDou L1.
gnsstk::Rinex3ObsHeader::RinexObsVec
std::vector< RinexObsID > RinexObsVec
Vector of obervables.
Definition: Rinex3ObsHeader.hpp:338
gnsstk::Rinex3ObsHeader::validSystemScaleFac
@ validSystemScaleFac
SYSTEM SCALE FACTOR.
Definition: Rinex3ObsHeader.hpp:277
gnsstk::RinexObsID
Definition: RinexObsID.hpp:102
Rinex3ObsData.hpp
TUDEF
#define TUDEF(CLASS, METHOD)
Definition: TestUtil.hpp:56
gnsstk::Rinex3ObsHeader::validObserver
@ validObserver
OBSERVER / AGENCY.
Definition: Rinex3ObsHeader.hpp:256
gnsstk::Rinex3ObsHeader::validSystemPhaseShift
@ validSystemPhaseShift
SYS / PHASE SHIFT.
Definition: Rinex3ObsHeader.hpp:278
TUCMPFILE
#define TUCMPFILE(F1, F2, SKIP)
Definition: TestUtil.hpp:170
gnsstk::Rinex3ObsStream
Definition: Rinex3ObsStream.hpp:65
example3.data
data
Definition: example3.py:22
gnsstk::Rinex3ObsData::clockOffset
double clockOffset
optional clock offset in seconds
Definition: Rinex3ObsData.hpp:112
gnsstk::CivilTime
Definition: CivilTime.hpp:55
Rinex3ObsStream.hpp
Rinex3ObsOther_T::reopenTest
unsigned reopenTest()
Make sure reusing a stream object doesn't break.
Definition: Rinex3ObsOther_T.cpp:601
Rinex3ObsOther_T::setObs
void setObs(gnsstk::TestUtil &testFramework, const std::string &system, gnsstk::Rinex3ObsHeader &hdr, gnsstk::Rinex3ObsData &rod)
generic filling of generic data.
Definition: Rinex3ObsOther_T.cpp:338
gnsstk::Rinex3ObsHeader::validMarkerNumber
@ validMarkerNumber
MARKER NUMBER.
Definition: Rinex3ObsHeader.hpp:254
Rinex3ObsOther_T::fillHeader304
void fillHeader304(gnsstk::Rinex3ObsHeader &hdr)
Fill a v3.04 header with data for the obsIDVersionTest method.
Definition: Rinex3ObsOther_T.cpp:541
gnsstk::RinexSatID
Definition: RinexSatID.hpp:63
gnsstk::TimeSystem::GPS
@ GPS
GPS system time.
std
Definition: Angle.hpp:142
gnsstk::Rinex3ObsHeader::sysPhaseShift
SysPhsShftMap sysPhaseShift
SYS / PHASE SHIFT.
Definition: Rinex3ObsHeader.hpp:530
gnsstk::Rinex3ObsHeader::date
std::string date
when program was run
Definition: Rinex3ObsHeader.hpp:493
gnsstk::Rinex3ObsHeader::sysSfacMap
SysScaleFacMap sysSfacMap
SYS / SCALE FACTOR.
Definition: Rinex3ObsHeader.hpp:529
gnsstk::Rinex3ObsHeader::validEoH
bool validEoH
true if found END OF HEADER
Definition: Rinex3ObsHeader.hpp:546
gnsstk::SatelliteSystem::BeiDou
@ BeiDou
aka Compass
gnsstk::ObservationType::Iono
@ Iono
Ionospheric delay.
gnsstk::Rinex3ObsHeader::validMarkerName
@ validMarkerName
MARKER NAME.
Definition: Rinex3ObsHeader.hpp:253
gnsstk::TestUtil
Definition: TestUtil.hpp:265
Rinex3ObsOther_T
Definition: Rinex3ObsOther_T.cpp:52

gnsstk
Author(s):
autogenerated on Wed Oct 25 2023 02:40:41