bufr2synop 0.24.0
bufr2tac_x11.c
Go to the documentation of this file.
1/***************************************************************************
2 * Copyright (C) 2013-2022 by Guillermo Ballester Valor *
3 * gbv@ogimet.com *
4 * *
5 * This program is free software; you can redistribute it and/or modify *
6 * it under the terms of the GNU General Public License as published by *
7 * the Free Software Foundation; either version 2 of the License, or *
8 * (at your option) any later version. *
9 * *
10 * This program 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 General Public License for more details. *
14 * *
15 * You should have received a copy of the GNU General Public License *
16 * along with this program; if not, write to the *
17 * Free Software Foundation, Inc., *
18 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
19 ***************************************************************************/
20/*!
21 \file bufr2tac_x11.c
22 \brief decodes the descriptors with X = 11 (wind)
23 */
24#include "bufr2tac.h"
25
26/*!
27 \fn char * secs_to_tt(char *tt, int secs)
28 \brief get tt code from seconds
29 \param tt string with the resulting table code
30 \param secs second
31
32 returns the pointer to \a tt
33*/
34char * secs_to_tt ( char *tt, int secs )
35{
36 int i;
37
38 if ( secs < 0 )
39 {
40 i = ( -secs ) / 360;
41 }
42 else
43 {
44 i = ( secs ) / 360;
45 }
46
47 if ( i <= 60 )
48 {
49 sprintf ( tt, "%02d", i );
50 }
51 else if ( i < 700 )
52 {
53 sprintf ( tt, "61" );
54 }
55 else if ( i < 800 )
56 {
57 sprintf ( tt, "62" );
58 }
59 else if ( i < 900 )
60 {
61 sprintf ( tt, "63" );
62 }
63 else if ( i < 1000 )
64 {
65 sprintf ( tt, "64" );
66 }
67 else if ( i < 1100 )
68 {
69 sprintf ( tt, "65" );
70 }
71 else if ( i < 1200 )
72 {
73 sprintf ( tt, "66" );
74 }
75 else if ( i < 1800 )
76 {
77 sprintf ( tt, "67" );
78 }
79 else
80 {
81 sprintf ( tt, "68" );
82 }
83 return tt;
84}
85
86/*!
87 \fn char * wind_to_dndnfnfnfn( char target, double dd, double ff)
88 \brief sets dndnfnfnfn item in a temp report
89 \param target string set as resul
90 \param dd wind direction (degrees)
91 \param vv wind speed
92*/
93char * wind_to_dndnfnfnfn ( char * target, double dd, double ff )
94{
95 int ix;
96
97 if ( dd == MISSING_REAL || ff == MISSING_REAL )
98 {
99 strcpy ( target, "/////" );
100 return target;
101 }
102
103 ix = ( int ) ( ( dd + 2.5 ) / 5 ) * 5 * 100 + ( int ) ( ff + 0.5 );
104 sprintf ( target, "%05d", ix );
105 return target;
106}
107
108/*!
109 \fn int syn_parse_x11 ( struct synop_chunks *syn, struct bufr2tac_subset_state *s )
110 \brief Parse a expanded descriptor with X = 11
111 \param syn pointer to a struct \ref synop_chunks where to set the results
112 \param s pointer to a struct \ref bufr2tac_subset_state where is stored needed information in sequential analysis
113
114 It returns 0 if success, 1 if problems when processing. If a descriptor is not processed returns 0 anyway
115*/
116int syn_parse_x11 ( struct synop_chunks *syn, struct bufr2tac_subset_state *s )
117{
118
119 if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
120 {
121 return 0;
122 }
123
124 switch ( s->a->desc.y )
125 {
126 case 1: // 0 11 001 . Wind direction
127 case 11: // 0 11 011 . Wind direction at 10 meters
128 sprintf ( syn->s1.dd, "%02d", abs((s->ival + 5 ) / 10) % 100 );
129 syn->mask |= SYNOP_SEC1;
130 break;
131
132 case 2: // 0 11 002 . Wind speed
133 case 12: // 0 11 012 . Wind speed at 10 meters
134 if ( syn->s0.iw[0] == '4' )
135 {
136 s->val *= 1.94384449;
137 }
138 if ( s->val < 100.0 )
139 {
140 sprintf ( syn->s1.ff, "%02d", ( int ) ( s->val + 0.5 ) );
141 }
142 else
143 {
144 sprintf ( syn->s1.ff,"99" );
145 sprintf ( syn->s1.fff, "%03d", ( int ) ( s->val + 0.5 ) );
146 }
147 syn->mask |= SYNOP_SEC1;
148 break;
149
150 case 41: // 0 11 041 . Max wind gust speed
151 if ( syn->s3.d9.n == SYNOP_NMISC )
152 {
153 return 0; // No more groups space
154 }
155
156 if ( s->itval == -600 )
157 {
158 if ( syn->mask & SUBSET_MASK_HAVE_GUST10 )
159 {
160 break; // Already have gust for 10 minutes
161 }
162 sprintf ( syn->s3.d9.misc[syn->s3.d9.n].SpSp, "910" );
163 s->SnSn = 910;
164 if ( syn->s0.iw[0] == '4' )
165 {
166 s->val *= 1.94384449; // original value was in m/s. So it change to knots
167 }
168 if ( s->val < 100.0 )
169 {
170 sprintf ( syn->s3.d9.misc[syn->s3.d9.n].spsp, "%02d", ( int ) ( s->val + 0.5 ) );
171 }
172 else
173 {
174 // Case more than 99 knots
175 sprintf ( syn->s3.d9.misc[syn->s3.d9.n].spsp,"99" );
176 syn->s3.d9.n++;
177 sprintf ( syn->s3.d9.misc[syn->s3.d9.n].SpSp, "00" );
178 sprintf ( syn->s3.d9.misc[syn->s3.d9.n].spsp, "%03d", ( int ) ( s->val + 0.5 ) );
179 }
180 syn->s3.d9.n++;
181 syn->mask |= SUBSET_MASK_HAVE_GUST10;
182 syn->mask |= SYNOP_SEC3;
183 }
184 else if ( s->itval )
185 {
186 if ( s->mask & SUBSET_MASK_HAVE_GUST )
187 {
188 sprintf ( syn->s5.d9.misc[syn->s5.d9.n].SpSp, "907" );
189 secs_to_tt ( syn->s5.d9.misc[syn->s5.d9.n].spsp, s->itval );
190 syn->s5.d9.n++;
191 sprintf ( syn->s5.d9.misc[syn->s5.d9.n].SpSp, "911" );
192 s->SnSn = 911;
193 if ( syn->s0.iw[0] == '4' )
194 {
195 s->val *= 1.94384449;
196 }
197 if ( s->val < 100.0 )
198 {
199 sprintf ( syn->s5.d9.misc[syn->s5.d9.n].spsp, "%02d", ( int ) ( s->val + 0.5 ) );
200 }
201 else
202 {
203 sprintf ( syn->s5.d9.misc[syn->s5.d9.n].spsp,"99" );
204 syn->s5.d9.n++;
205 sprintf ( syn->s5.d9.misc[syn->s5.d9.n].SpSp, "00" );
206 sprintf ( syn->s5.d9.misc[syn->s5.d9.n].spsp, "%03d", ( int ) ( s->val + 0.5 ) );
207 }
208 syn->s5.d9.n++;
209 syn->mask |= SYNOP_SEC5;
210 }
211 else
212 {
213 sprintf ( syn->s3.d9.misc[syn->s3.d9.n].SpSp, "907" );
214 secs_to_tt ( syn->s3.d9.misc[syn->s3.d9.n].spsp, s->itval );
215 syn->s3.d9.n++;
216 sprintf ( syn->s3.d9.misc[syn->s3.d9.n].SpSp, "911" );
217 s->SnSn = 911;
218 if ( syn->s0.iw[0] == '4' )
219 {
220 s->val *= 1.94384449;
221 }
222 if ( s->val < 100.0 )
223 {
224 sprintf ( syn->s3.d9.misc[syn->s3.d9.n].spsp, "%02d", ( int ) ( s->val + 0.5 ) );
225 }
226 else
227 {
228 sprintf ( syn->s3.d9.misc[syn->s3.d9.n].spsp,"99" );
229 syn->s3.d9.n++;
230 sprintf ( syn->s3.d9.misc[syn->s3.d9.n].SpSp, "00" );
231 sprintf ( syn->s3.d9.misc[syn->s3.d9.n].spsp, "%03d", ( int ) ( s->val + 0.5 ) );
232 }
233 syn->s3.d9.n++;
234 syn->mask |= SYNOP_SEC3;
235 s->mask |= SUBSET_MASK_HAVE_GUST;
236 }
237 }
238 break;
239
240 case 42: // 0 11 042 . Max wind speed (10-minutes mean)
241 if ( syn->s3.d9.n == SYNOP_NMISC )
242 {
243 return 0;
244 }
245 sprintf ( syn->s3.d9.misc[syn->s3.d9.n].SpSp, "907" );
246 secs_to_tt ( syn->s3.d9.misc[syn->s3.d9.n].spsp, s->itval );
247 syn->s3.d9.n++;
248 sprintf ( syn->s3.d9.misc[syn->s3.d9.n].SpSp, "912" );
249 s->SnSn = 912;
250 if ( syn->s0.iw[0] == '4' )
251 {
252 s->val *= 1.94384449;
253 }
254 if ( s->val < 100.0 )
255 {
256 sprintf ( syn->s3.d9.misc[syn->s3.d9.n].spsp, "%02d", ( int ) ( s->val + 0.5 ) );
257 }
258 else
259 {
260 sprintf ( syn->s3.d9.misc[syn->s3.d9.n].spsp,"99" );
261 syn->s3.d9.n++;
262 sprintf ( syn->s3.d9.misc[syn->s3.d9.n].SpSp, "00" );
263 sprintf ( syn->s3.d9.misc[syn->s3.d9.n].spsp, "%03d", ( int ) ( s->val + 0.5 ) );
264 }
265 syn->s3.d9.n++;
266 syn->mask |= SYNOP_SEC3;
267 break;
268
269 case 43: // 0 11 043 . Max wind gust direction
270 if ( BUFR2TAC_DEBUG_LEVEL > 1 && (s->a->mask & DESCRIPTOR_VALUE_MISSING) == 0 )
271 bufr2tac_set_error ( s, 0, "syn_parse_x11()", "Descriptor not parsed" );
272 break;
273
274 case 84: // 0 11 084 . Wind speed in knots
275 if ( syn->s0.iw[0] == '1' )
276 {
277 s->val /= 1.94384449;
278 }
279 if ( s->val < 100.0 )
280 {
281 sprintf ( syn->s1.ff, "%02d", ( int ) ( s->val + 0.5 ) );
282 }
283 else
284 {
285 sprintf ( syn->s1.ff,"99" );
286 sprintf ( syn->s1.fff, "%03d", ( int ) ( s->val + 0.5 ) );
287 }
288 syn->mask |= SYNOP_SEC1;
289 break;
290
291 case 86: // 0 11 086 . Max wind speed in knots
292 if ( syn->s3.d9.n == SYNOP_NMISC )
293 {
294 return 0;
295 }
296 if ( s->itval == -600 )
297 {
298 sprintf ( syn->s3.d9.misc[syn->s3.d9.n].SpSp, "910" );
299 if ( syn->s0.iw[0] == '1' )
300 {
301 s->val /= 1.94384449; // original values in knots. passed to m/s
302 }
303 if ( s->val < 100.0 )
304 {
305 sprintf ( syn->s3.d9.misc[syn->s3.d9.n].spsp, "%02d", ( int ) ( s->val + 0.5 ) );
306 }
307 else
308 {
309 sprintf ( syn->s3.d9.misc[syn->s3.d9.n].spsp,"99" );
310 syn->s3.d9.n++;
311 sprintf ( syn->s3.d9.misc[syn->s3.d9.n].SpSp, "00" );
312 sprintf ( syn->s3.d9.misc[syn->s3.d9.n].spsp, "%03d", ( int ) ( s->val + 0.5 ) );
313 }
314 syn->mask |= SYNOP_SEC3;
315 syn->s3.d9.n++;
316 }
317 else if ( s->itval )
318 {
319 if ( s->mask & SUBSET_MASK_HAVE_GUST )
320 {
321 sprintf ( syn->s5.d9.misc[syn->s5.d9.n].SpSp, "907" );
322 secs_to_tt ( syn->s5.d9.misc[syn->s5.d9.n].spsp, s->itval );
323 syn->s5.d9.n++;
324 sprintf ( syn->s5.d9.misc[syn->s5.d9.n].SpSp, "911" );
325 if ( syn->s0.iw[0] == '1' )
326 {
327 s->val /= 1.94384449;
328 }
329 if ( s->val < 100.0 )
330 {
331 sprintf ( syn->s5.d9.misc[syn->s5.d9.n].spsp, "%02d", ( int ) ( s->val + 0.5 ) );
332 }
333 else
334 {
335 sprintf ( syn->s5.d9.misc[syn->s5.d9.n].spsp,"99" );
336 syn->s5.d9.n++;
337 sprintf ( syn->s5.d9.misc[syn->s5.d9.n].SpSp, "00" );
338 sprintf ( syn->s5.d9.misc[syn->s5.d9.n].spsp, "%03d", ( int ) ( s->val + 0.5 ) );
339 }
340 syn->s5.d9.n++;
341 syn->mask |= SYNOP_SEC5;
342 }
343 else
344 {
345 sprintf ( syn->s3.d9.misc[syn->s3.d9.n].SpSp, "907" );
346 secs_to_tt ( syn->s3.d9.misc[syn->s3.d9.n].spsp, s->itval );
347 syn->s3.d9.n++;
348 sprintf ( syn->s3.d9.misc[syn->s3.d9.n].SpSp, "911" );
349 if ( syn->s0.iw[0] == '1' )
350 {
351 s->val /= 1.94384449;
352 }
353 if ( s->val < 100.0 )
354 {
355 sprintf ( syn->s3.d9.misc[syn->s3.d9.n].spsp, "%02d", ( int ) ( s->val + 0.5 ) );
356 }
357 else
358 {
359 sprintf ( syn->s3.d9.misc[syn->s3.d9.n].spsp,"99" );
360 syn->s3.d9.n++;
361 sprintf ( syn->s3.d9.misc[syn->s3.d9.n].SpSp, "00" );
362 sprintf ( syn->s3.d9.misc[syn->s3.d9.n].spsp, "%03d", ( int ) ( s->val + 0.5 ) );
363 }
364 syn->s3.d9.n++;
365 syn->mask |= SYNOP_SEC3;
366 s->mask |= SUBSET_MASK_HAVE_GUST;
367 }
368 }
369 break;
370
371 default:
372 if ( BUFR2TAC_DEBUG_LEVEL > 1 && (s->a->mask & DESCRIPTOR_VALUE_MISSING) == 0 )
373 bufr2tac_set_error ( s, 0, "syn_parse_x11()", "Descriptor not parsed" );
374 break;
375 }
376 return 0;
377}
378
379/*!
380 \fn int buoy_parse_x11 ( struct buoy_chunks *b, struct bufr2tac_subset_state *s )
381 \brief Parse a expanded descriptor with X = 11
382 \param b pointer to a struct \ref buoy_chunks where to set the results
383 \param s pointer to a struct \ref bufr2tac_subset_state where is stored needed information in sequential analysis
384
385 It returns 0 if success, 1 if problems when processing. If a descriptor is not processed returns 0 anyway
386*/
387int buoy_parse_x11 ( struct buoy_chunks *b, struct bufr2tac_subset_state *s )
388{
389
390 if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
391 {
392 return 0;
393 }
394
395 switch ( s->a->desc.y )
396 {
397 case 1: // 0 11 001 . Wind direction
398 case 11: // 0 11 011 . Wind direction at 10m
399 sprintf ( b->s1.dd, "%02d", abs((s->ival + 5 ) / 10) % 100 );
400 b->mask |= BUOY_SEC1;
401 break;
402
403 case 2: // 0 11 002 . Wind speed
404 case 12: // 0 11 012 . Wind speed at 10 meters
405 if ( b->s0.iw[0] == '4' )
406 {
407 s->val *= 1.94384449;
408 }
409 if ( s->val < 100.0 )
410 {
411 sprintf ( b->s1.ff, "%02d", ( int ) ( s->val + 0.5 ) );
412 }
413 else
414 {
415 sprintf ( b->s1.ff,"99" );
416 sprintf ( b->s1.fff, "%03d", ( int ) ( s->val + 0.5 ) );
417 }
418 b->mask |= BUOY_SEC1;
419 break;
420
421 case 84: // 0 11 084 (wind in knots)
422 if ( b->s0.iw[0] == '1' )
423 {
424 s->val /= 1.94384449;
425 }
426 if ( s->val < 100.0 )
427 {
428 sprintf ( b->s1.ff, "%02d", ( int ) ( s->val + 0.5 ) );
429 }
430 else
431 {
432 sprintf ( b->s1.ff,"99" );
433 sprintf ( b->s1.fff, "%03d", ( int ) ( s->val + 0.5 ) );
434 }
435 b->mask |= BUOY_SEC1;
436 break;
437
438 default:
439 if ( BUFR2TAC_DEBUG_LEVEL > 1 && (s->a->mask & DESCRIPTOR_VALUE_MISSING) == 0 )
440 bufr2tac_set_error ( s, 0, "buoy_parse_x11()", "Descriptor not parsed" );
441 break;
442 }
443 return 0;
444}
445
446/*!
447 \fn int climat_parse_x11 ( struct climat_chunks *c, struct bufr2tac_subset_state *s )
448 \brief Parse a expanded descriptor with X = 11
449 \param c pointer to a struct \ref climat_chunks where to set the results
450 \param s pointer to a struct \ref bufr2tac_subset_state where is stored needed information in sequential analysis
451
452 It returns 0 if success, 1 if problems when processing. If a descriptor is not processed returns 0 anyway
453*/
454int climat_parse_x11 ( struct climat_chunks *c, struct bufr2tac_subset_state *s )
455{
456
457 if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
458 {
459 return 0;
460 }
461
462 switch ( s->a->desc.y )
463 {
464 case 46: // 0 11 046 . Maximum wind speed
465 if ( c->s4.iw[0] == '4' )
466 {
467 sprintf ( c->s4.fxfxfx, "%03d", ( int ) ( s->val * 10.0 * 1.94384449 + 0.5 ) );
468 }
469 else
470 {
471 sprintf ( c->s4.fxfxfx, "%03d", ( int ) ( s->val * 10.0 + 0.5 ) );
472 }
473 if ( s->isq_val == 0 )
474 {
475 sprintf ( c->s4.yfx, "%02d", s->day );
476 }
477 else
478 {
479 sprintf ( c->s4.yfx, "%02d", (s->day + 50) % 100 );
480 }
481 c->mask |= CLIMAT_SEC4;
482 break;
483
484 default:
485 if ( BUFR2TAC_DEBUG_LEVEL > 1 && (s->a->mask & DESCRIPTOR_VALUE_MISSING) == 0 )
486 bufr2tac_set_error ( s, 0, "climat_parse_x11()", "Descriptor not parsed" );
487 break;
488 }
489 return 0;
490}
491
492/*!
493 \fn int temp_parse_x11 ( struct temp_chunks *t, struct bufr2tac_subset_state *s )
494 \brief Parse a expanded descriptor with X = 11
495 \param t pointer to a struct \ref temp_chunks where to set the results
496 \param s pointer to a struct \ref bufr2tac_subset_state where is stored needed information in sequential analysis
497
498 It returns 0 if success, 1 if problems when processing. If a descriptor is not processed returns 0 anyway
499*/
500int temp_parse_x11 ( struct temp_chunks *t, struct bufr2tac_subset_state *s )
501{
502
503 if ( t == NULL )
504 {
505 return 1;
506 }
507
508 switch ( s->a->desc.y )
509 {
510 case 1: // 0 11 001. Wind direction
511 if ( s->rep > 0 && s->r->n > 0 )
512 {
513 if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
514 {
515 s->r->raw[s->r->n - 1].dd = MISSING_REAL;
516 }
517 else
518 {
519 s->r->raw[s->r->n - 1].dd = s->val;
520 }
521 }
522 break;
523
524 case 2: // 0 11 002. Wind speed
525 if ( s->rep > 0 && s->r->n > 0 )
526 {
527 if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
528 {
529 s->r->raw[s->r->n - 1].ff = MISSING_REAL;
530 }
531 else
532 {
533 s->r->raw[s->r->n - 1].ff = s->val;
534 }
535 }
536 break;
537
538 case 61: // 0 11 061. Absolute wind shear in 1 km layer below
539 if ( s->w->n > 0 )
540 {
541 if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
542 {
543 s->w->raw[s->w->n - 1].ws_blw = MISSING_REAL;
544 }
545 else
546 {
547 s->w->raw[s->w->n - 1].ws_blw = s->val;
548 }
549 }
550 break;
551
552 case 62: // 0 11 062. Absolute wind shear in 1 km layer above
553 if ( s->w->n > 0 )
554 {
555 if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
556 {
557 s->w->raw[s->w->n - 1].ws_abv = MISSING_REAL;
558 }
559 else
560 {
561 s->w->raw[s->w->n - 1].ws_abv = s->val;
562 }
563 }
564 break;
565
566 default:
567 if ( BUFR2TAC_DEBUG_LEVEL > 1 && (s->a->mask & DESCRIPTOR_VALUE_MISSING) == 0 )
568 bufr2tac_set_error ( s, 0, "temp_parse_x11()", "Descriptor not parsed" );
569 break;
570 }
571 return 0;
572}
BUFR2TAC_DEBUG_LEVEL
int BUFR2TAC_DEBUG_LEVEL
Definition: bufr2tac.c:31
bufr2tac.h
Include header file for binary bufr2tac.
SUBSET_MASK_HAVE_GUST
#define SUBSET_MASK_HAVE_GUST
Bit mask to mark a struct bufr_subset_sequence_data having wind gust observation other than 10 minute...
Definition: bufr2tac.h:176
bufr2tac_set_error
int bufr2tac_set_error(struct bufr2tac_subset_state *s, int severity, char *origin, char *explanation)
Definition: bufr2tac_error.c:59
SUBSET_MASK_HAVE_GUST10
#define SUBSET_MASK_HAVE_GUST10
Bit mask to mark a struct bufr_subset_sequence_data having wind gust observation other than 10 minute...
Definition: bufr2tac.h:182
temp_parse_x11
int temp_parse_x11(struct temp_chunks *t, struct bufr2tac_subset_state *s)
Parse a expanded descriptor with X = 11.
Definition: bufr2tac_x11.c:500
syn_parse_x11
int syn_parse_x11(struct synop_chunks *syn, struct bufr2tac_subset_state *s)
Parse a expanded descriptor with X = 11.
Definition: bufr2tac_x11.c:116
secs_to_tt
char * secs_to_tt(char *tt, int secs)
get tt code from seconds
Definition: bufr2tac_x11.c:34
buoy_parse_x11
int buoy_parse_x11(struct buoy_chunks *b, struct bufr2tac_subset_state *s)
Parse a expanded descriptor with X = 11.
Definition: bufr2tac_x11.c:387
wind_to_dndnfnfnfn
char * wind_to_dndnfnfnfn(char *target, double dd, double ff)
Definition: bufr2tac_x11.c:93
climat_parse_x11
int climat_parse_x11(struct climat_chunks *c, struct bufr2tac_subset_state *s)
Parse a expanded descriptor with X = 11.
Definition: bufr2tac_x11.c:454
MISSING_REAL
#define MISSING_REAL
The missing default value for real values.
Definition: bufrdeco.h:78
DESCRIPTOR_VALUE_MISSING
#define DESCRIPTOR_VALUE_MISSING
Bit mask for a missing value in a struct bufr_atom_data.
Definition: bufrdeco.h:140
BUOY_SEC1
#define BUOY_SEC1
mask bit meaning section 1 of buoy is solicited to or parsed with success
Definition: metbuoy.h:38
CLIMAT_SEC4
#define CLIMAT_SEC4
mask bit meaning section 4 of climat is solicited to or parsed with success
Definition: metclimat.h:52
SYNOP_NMISC
#define SYNOP_NMISC
number of misc3 struct to store the parsed results of 9SpSpspsp groups
Definition: metsynop.h:84
SYNOP_SEC1
#define SYNOP_SEC1
mask bit meaning section 1 or synop is solicited to or parsed with success
Definition: metsynop.h:39
SYNOP_SEC3
#define SYNOP_SEC3
mask bit meaning section 3 or synop is solicited to or parsed with success
Definition: metsynop.h:49
SYNOP_SEC5
#define SYNOP_SEC5
mask bit meaning section 5 or synop is solicited to or parsed with success
Definition: metsynop.h:59
bufr2tac_subset_state
stores information needed to parse a sequential list of expanded descriptors for a subset
Definition: bufr2tac.h:246
bufr2tac_subset_state::w
struct temp_raw_wind_shear_data * w
Definition: bufr2tac.h:286
bufr2tac_subset_state::day
int day
Definition: bufr2tac.h:277
bufr2tac_subset_state::a
struct bufr_atom_data * a
Definition: bufr2tac.h:249
bufr2tac_subset_state::SnSn
int SnSn
Definition: bufr2tac.h:283
bufr2tac_subset_state::r
struct temp_raw_data * r
Definition: bufr2tac.h:285
bufr2tac_subset_state::rep
int rep
Definition: bufr2tac.h:252
bufr2tac_subset_state::mask
int mask
Definition: bufr2tac.h:282
bufr2tac_subset_state::val
double val
Definition: bufr2tac.h:255
bufr2tac_subset_state::ival
int ival
Definition: bufr2tac.h:254
bufr2tac_subset_state::itval
int itval
Definition: bufr2tac.h:256
bufr2tac_subset_state::isq_val
int isq_val
Definition: bufr2tac.h:263
bufr_atom_data::mask
uint32_t mask
Definition: bufrdeco.h:437
bufr_atom_data::desc
struct bufr_descriptor desc
Definition: bufrdeco.h:436
bufr_descriptor::y
uint8_t y
Definition: bufrdeco.h:412
buoy_chunks
contains all possible substrings from a synop report is parsed with success
Definition: metbuoy.h:197
buoy_chunks::mask
int mask
Definition: metbuoy.h:198
buoy_chunks::s1
struct buoy_sec1 s1
Definition: metbuoy.h:202
buoy_chunks::s0
struct buoy_sec0 s0
Definition: metbuoy.h:201
buoy_sec0::iw
char iw[2]
Definition: metbuoy.h:77
buoy_sec1::fff
char fff[4]
Definition: metbuoy.h:95
buoy_sec1::dd
char dd[4]
Definition: metbuoy.h:93
buoy_sec1::ff
char ff[4]
Definition: metbuoy.h:94
climat_chunks
contains all possible substrings from a synop report is parsed with success
Definition: metclimat.h:213
climat_chunks::s4
struct climat_sec4 s4
Definition: metclimat.h:221
climat_chunks::mask
int mask
Definition: metclimat.h:214
climat_sec4::iw
char iw[2]
Definition: metclimat.h:182
climat_sec4::yfx
char yfx[4]
Definition: metclimat.h:184
climat_sec4::fxfxfx
char fxfxfx[4]
Definition: metclimat.h:183
data9::misc
struct misc3 misc[SYNOP_NMISC]
Definition: metsynop.h:210
data9::n
size_t n
Definition: metsynop.h:209
misc3::spsp
char spsp[4]
Definition: metsynop.h:204
misc3::SpSp
char SpSp[4]
Definition: metsynop.h:203
synop_chunks
contains all possible substrings from a synop report is parsed with success
Definition: metsynop.h:293
synop_chunks::s1
struct synop_sec1 s1
Definition: metsynop.h:298
synop_chunks::s3
struct synop_sec3 s3
Definition: metsynop.h:300
synop_chunks::s5
struct synop_sec5 s5
Definition: metsynop.h:302
synop_chunks::mask
int mask
Definition: metsynop.h:294
synop_chunks::s0
struct synop_sec0 s0
Definition: metsynop.h:297
synop_sec0::iw
char iw[2]
Definition: metsynop.h:100
synop_sec1::ff
char ff[4]
Definition: metsynop.h:129
synop_sec1::fff
char fff[4]
Definition: metsynop.h:130
synop_sec1::dd
char dd[4]
Definition: metsynop.h:128
synop_sec3::d9
struct data9 d9
Definition: metsynop.h:260
synop_sec5::d9
struct data9 d9
Definition: metsynop.h:286
temp_chunks
Store the whole TEMP report.
Definition: mettemp.h:511
temp_raw_data::raw
struct temp_raw_point_data raw[TEMP_NMAX_POINTS *4]
Definition: mettemp.h:215
temp_raw_data::n
size_t n
Definition: mettemp.h:214
temp_raw_point_data::dd
double dd
Definition: mettemp.h:204
temp_raw_point_data::ff
double ff
Definition: mettemp.h:205
temp_raw_wind_shear_data::raw
struct temp_raw_wind_shear_point raw[TEMP_NMAX_POINTS]
Definition: mettemp.h:240
temp_raw_wind_shear_data::n
size_t n
Definition: mettemp.h:239
temp_raw_wind_shear_point::ws_blw
double ws_blw
Definition: mettemp.h:229
temp_raw_wind_shear_point::ws_abv
double ws_abv
Definition: mettemp.h:230
Generated by doxygen 1.9.5