source: ntrip/trunk/BNC/src/bncantex.cpp@ 9512

Last change on this file since 9512 was 9481, checked in by stuerze, 3 years ago

minor changes
File size: 12.8 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: bncAntex
30 *
31 * Purpose: Antenna Phase Centers and Variations from ANTEX File
32 *
33 * Author: L. Mervart
34 *
35 * Created: 26-Jan-2011
36 *
37 * Changes:
38 *
39 * -----------------------------------------------------------------------*/
40
41#include <iostream>
42#include <newmatio.h>
43
44#include "bncantex.h"
45#include "pppModel.h"
46
47using namespace std;
48
49// Constructor
50////////////////////////////////////////////////////////////////////////////
51bncAntex::bncAntex() {
52}
53
54// Constructor
55////////////////////////////////////////////////////////////////////////////
56bncAntex::bncAntex(const char* fileName) {
57 readFile(QString(fileName));
58}
59
60// Destructor
61////////////////////////////////////////////////////////////////////////////
62bncAntex::~bncAntex() {
63 QMapIterator<QString, t_antMap*> it(_maps);
64 while (it.hasNext()) {
65 it.next();
66 delete it.value();
67 }
68}
69
70// Print
71////////////////////////////////////////////////////////////////////////////
72void bncAntex::print() const {
73 QMapIterator<QString, t_antMap*> itAnt(_maps);
74 while (itAnt.hasNext()) {
75 itAnt.next();
76 t_antMap* map = itAnt.value();
77 cout << map->antName.toLatin1().data() << endl;
78 cout << " " << map->zen1 << " " << map->zen2 << " " << map->dZen << endl;
79 QMapIterator<t_frequency::type, t_frqMap*> itFrq(map->frqMap);
80 while (itFrq.hasNext()) {
81 itFrq.next();
82 const t_frqMap* frqMap = itFrq.value();
83 cout << " " << frqMap->neu[0] << " "
84 << frqMap->neu[1] << " "
85 << frqMap->neu[2] << endl;
86 cout << " " << frqMap->pattern.t();
87 }
88 cout << endl;
89 }
90}
91
92// Print
93////////////////////////////////////////////////////////////////////////////
94QString bncAntex::pcoSinexString(const std::string& antName, t_frequency::type frqType) {
95
96 if (antName.find("NULLANTENNA") != string::npos) {
97 return QString(" ------ ------ ------");
98 }
99
100 QString antNameQ = antName.c_str();
101 if (_maps.find(antNameQ) == _maps.end()) {
102 return QString(" ------ ------ ------");
103 }
104
105 t_antMap* map = _maps[antNameQ];
106 if (map->frqMap.find(frqType) == map->frqMap.end()) {
107 return QString(" ------ ------ ------");
108 }
109
110 t_frqMap* frqMap = map->frqMap[frqType];
111
112 QString u, n,e;
113 u.sprintf("%+6.4f" ,frqMap->neu[2]); if (u.mid(1,1) == "0") {u.remove(1,1);}
114 n.sprintf("%+6.4f" ,frqMap->neu[0]); if (n.mid(1,1) == "0") {n.remove(1,1);}
115 e.sprintf("%+6.4f" ,frqMap->neu[1]); if (e.mid(1,1) == "0") {e.remove(1,1);}
116
117 return QString(" %1 %2 %3").arg(u).arg(n).arg(e);
118}
119
120// Read ANTEX File
121////////////////////////////////////////////////////////////////////////////
122t_irc bncAntex::readFile(const QString& fileName) {
123
124 QFile inFile(fileName);
125 inFile.open(QIODevice::ReadOnly | QIODevice::Text);
126
127 QTextStream in(&inFile);
128
129 t_antMap* newAntMap = 0;
130 t_frqMap* newFrqMap = 0;
131
132 while ( !in.atEnd() ) {
133 QString line = in.readLine();
134
135 // Start of Antenna
136 // ----------------
137 if (line.indexOf("START OF ANTENNA") == 60) {
138 if (newAntMap) {
139 delete newAntMap;
140 return failure;
141 }
142 else {
143 delete newAntMap;
144 newAntMap = new t_antMap();
145 }
146 }
147
148 // End of Antenna
149 // --------------
150 else if (line.indexOf("END OF ANTENNA") == 60) {
151 if (newAntMap) {
152 if (_maps.contains(newAntMap->antName)) {
153 delete _maps[newAntMap->antName];
154 }
155 _maps[newAntMap->antName] = newAntMap;
156 newAntMap = 0;
157 }
158 else {
159 delete newAntMap;
160 return failure;
161 }
162 }
163
164 // Antenna Reading in Progress
165 // ---------------------------
166 else if (newAntMap) {
167 if (line.indexOf("TYPE / SERIAL NO") == 60) {
168 if (line.indexOf("BLOCK I") == 0 ||
169 line.indexOf("GLONASS") == 0 ||
170 line.indexOf("QZSS") == 0 ||
171 line.indexOf("BEIDOU") == 0 ||
172 line.indexOf("GALILEO") == 0 ||
173 line.indexOf("IRNSS") == 0 ){
174 newAntMap->antName = line.mid(20,3);
175 }
176 else {
177 newAntMap->antName = line.mid(0,20);
178 }
179 }
180 else if (line.indexOf("ZEN1 / ZEN2 / DZEN") == 60) {
181 QTextStream inLine(&line, QIODevice::ReadOnly);
182 inLine >> newAntMap->zen1 >> newAntMap->zen2 >> newAntMap->dZen;
183 }
184
185 // Start of Frequency
186 // ------------------
187 else if (line.indexOf("START OF FREQUENCY") == 60) {
188 if (newFrqMap) {
189 delete newFrqMap;
190 delete newAntMap;
191 return failure;
192 }
193 else {
194 newFrqMap = new t_frqMap();
195 }
196 }
197
198 // End of Frequency
199 // ----------------
200 else if (line.indexOf("END OF FREQUENCY") == 60) {
201 if (newFrqMap) {
202 t_frequency::type frqType = t_frequency::dummy;
203 // GPS
204 if (line.indexOf("G01") == 3) {
205 frqType = t_frequency::G1;
206 }
207 else if (line.indexOf("G02") == 3) {
208 frqType = t_frequency::G2;
209 }
210 else if (line.indexOf("G05") == 3) {
211 frqType = t_frequency::G5;
212 }
213 // GLONASS
214 else if (line.indexOf("R01") == 3) {
215 frqType = t_frequency::R1;
216 }
217 else if (line.indexOf("R02") == 3) {
218 frqType = t_frequency::R2;
219 }
220 // Galileo
221 else if (line.indexOf("E01") == 3) {
222 frqType = t_frequency::E1;
223 }
224 else if (line.indexOf("E05") == 3) {
225 frqType = t_frequency::E5;
226 }
227 else if (line.indexOf("E06") == 3) {
228 frqType = t_frequency::E6;
229 }
230 else if (line.indexOf("E07") == 3) {
231 frqType = t_frequency::E7;
232 }
233 else if (line.indexOf("E08") == 3) {
234 frqType = t_frequency::E8;
235 }
236 // QZSS
237 else if (line.indexOf("J01") == 3) {
238 frqType = t_frequency::J1;
239 }
240 else if (line.indexOf("J02") == 3) {
241 frqType = t_frequency::J2;
242 }
243 else if (line.indexOf("J05") == 3) {
244 frqType = t_frequency::J5;
245 }
246 else if (line.indexOf("J06") == 3) {
247 frqType = t_frequency::J6;
248 }
249 // BDS
250 else if (line.indexOf("C01") == 3) {
251 frqType = t_frequency::C1;
252 }
253 else if (line.indexOf("C02") == 3) {
254 frqType = t_frequency::C2;
255 }
256 else if (line.indexOf("C06") == 3) {
257 frqType = t_frequency::C6;
258 }
259 else if (line.indexOf("C07") == 3) {
260 frqType = t_frequency::C7;
261 }
262 if (frqType != t_frequency::dummy) {
263 if (newAntMap->frqMap.find(frqType) != newAntMap->frqMap.end()) {
264 delete newAntMap->frqMap[frqType];
265 }
266 newAntMap->frqMap[frqType] = newFrqMap;
267 }
268 else {
269 delete newFrqMap;
270 }
271 newFrqMap = 0;
272 }
273 else {
274 delete newAntMap;
275 return failure;
276 }
277 }
278
279 // Frequency Reading in Progress
280 // -----------------------------
281 else if (newFrqMap) {
282 if (line.indexOf("NORTH / EAST / UP") == 60) {
283 QTextStream inLine(&line, QIODevice::ReadOnly);
284 inLine >> newFrqMap->neu[0] >> newFrqMap->neu[1] >> newFrqMap->neu[2];
285 newFrqMap->neu[0] *= 1e-3;
286 newFrqMap->neu[1] *= 1e-3;
287 newFrqMap->neu[2] *= 1e-3;
288 }
289 else if (line.indexOf("NOAZI") == 3) {
290 QTextStream inLine(&line, QIODevice::ReadOnly);
291 int nPat = int((newAntMap->zen2-newAntMap->zen1)/newAntMap->dZen) + 1;
292 newFrqMap->pattern.ReSize(nPat);
293 QString dummy;
294 inLine >> dummy;
295 for (int ii = 0; ii < nPat; ii++) {
296 inLine >> newFrqMap->pattern[ii];
297 }
298 newFrqMap->pattern *= 1e-3;
299 }
300 }
301 }
302 }
303 inFile.close();
304 delete newFrqMap;
305 delete newAntMap;
306
307 return success;
308}
309
310// Satellite Antenna Offset
311////////////////////////////////////////////////////////////////////////////
312t_irc bncAntex::satCoMcorrection(const QString& prn, double Mjd,
313 const ColumnVector& xSat, ColumnVector& dx) {
314
315 t_frequency::type frqType = t_frequency::dummy;
316
317 if (prn[0] == 'G') {
318 frqType = t_frequency::G1;
319 }
320 else if (prn[0] == 'R') {
321 frqType = t_frequency::R1;
322 }
323 else if (prn[0] == 'E') {
324 frqType = t_frequency::E1;
325 }
326 else if (prn[0] == 'C') {
327 frqType = t_frequency::C2;
328 }
329 else if (prn[0] == 'S') {
330 frqType = t_frequency::S1;
331 }
332 else if (prn[0] == 'J') {
333 frqType = t_frequency::J1;
334 }
335 else if (prn[0] == 'I') {
336 frqType = t_frequency::I5;
337 }
338
339 QMap<QString, t_antMap*>::const_iterator it = _maps.find(prn.mid(0,3));
340 if (it != _maps.end()) {
341 t_antMap* map = it.value();
342 if (map->frqMap.find(frqType) != map->frqMap.end()) {
343
344 double* neu = map->frqMap[frqType]->neu;
345
346 // Unit Vectors sz, sy, sx
347 // -----------------------
348 ColumnVector sz = -xSat;
349 sz /= sqrt(DotProduct(sz,sz));
350
351 ColumnVector xSun = BNC_PPP::t_astro::Sun(Mjd);
352 xSun /= sqrt(DotProduct(xSun,xSun));
353
354 ColumnVector sy = crossproduct(sz, xSun);
355 sy /= sqrt(DotProduct(sy,sy));
356
357 ColumnVector sx = crossproduct(sy, sz);
358
359 dx[0] = sx[0] * neu[0] + sy[0] * neu[1] + sz[0] * neu[2];
360 dx[1] = sx[1] * neu[0] + sy[1] * neu[1] + sz[1] * neu[2];
361 dx[2] = sx[2] * neu[0] + sy[2] * neu[1] + sz[2] * neu[2];
362
363 return success;
364 }
365 }
366
367 return failure;
368}
369
370//
371////////////////////////////////////////////////////////////////////////////
372double bncAntex::satCorr(const QString& prn, t_frequency::type frqType,
373 double elTx, double azTx, bool& found) const {
374
375 if (_maps.find(prn.mid(0,3)) == _maps.end()) {
376 found = false;
377 return 0.0;
378 };
379
380 t_antMap* map = _maps[prn.mid(0,3)];
381
382 if (map->frqMap.find(frqType) == map->frqMap.end()) {
383 found = false;
384 return 0.0;
385 };
386
387 t_frqMap* frqMap = map->frqMap[frqType];
388
389 double var = 0.0;
390 if (frqMap->pattern.ncols() > 0) {
391 double zenDiff = 999.999;
392 double zenTx = 90.0 - elTx * 180.0 / M_PI;
393 unsigned iZen = 0;
394 for (double zen = map->zen1; zen <= map->zen2; zen += map->dZen) {
395 iZen += 1;
396 double newZenDiff = fabs(zen - zenTx);
397 if (newZenDiff < zenDiff) {
398 zenDiff = newZenDiff;
399 var = frqMap->pattern(iZen);
400 }
401 }
402 }
403
404 found = true;
405 return var - frqMap->neu[0] * cos(azTx)*cos(elTx)
406 - frqMap->neu[1] * sin(azTx)*cos(elTx)
407 - frqMap->neu[2] * sin(elTx);
408
409}
410
411//
412////////////////////////////////////////////////////////////////////////////
413double bncAntex::rcvCorr(const string& antName, t_frequency::type frqType,
414 double eleSat, double azSat, bool& found) const {
415
416 if (antName.find("NULLANTENNA") != string::npos) {
417 found = true;
418 return 0.0;
419 }
420
421 QString antNameQ = antName.c_str();
422
423 if (_maps.find(antNameQ) == _maps.end()) {
424 found = false;
425 return 0.0;
426 }
427
428 t_antMap* map = _maps[antNameQ];
429 if (map->frqMap.find(frqType) == map->frqMap.end()) {
430 found = false;
431 return 0.0;
432 }
433
434 t_frqMap* frqMap = map->frqMap[frqType];
435
436 double var = 0.0;
437 if (frqMap->pattern.ncols() > 0) {
438 double zenDiff = 999.999;
439 double zenSat = 90.0 - eleSat * 180.0 / M_PI;
440 unsigned iZen = 0;
441 for (double zen = map->zen1; zen <= map->zen2; zen += map->dZen) {
442 iZen += 1;
443 double newZenDiff = fabs(zen - zenSat);
444 if (newZenDiff < zenDiff) {
445 zenDiff = newZenDiff;
446 var = frqMap->pattern(iZen);
447 }
448 }
449 }
450
451 found = true;
452 return var - frqMap->neu[0] * cos(azSat)*cos(eleSat)
453 - frqMap->neu[1] * sin(azSat)*cos(eleSat)
454 - frqMap->neu[2] * sin(eleSat);
455
456}
Note: See TracBrowser for help on using the repository browser.