bufr2synop 0.24.0
bufr2tac_x04.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_x04.c
22 \brief decodes the descriptors with X = 04 (date and time)
23 */
24#include "bufr2tac.h"
25
26/*!
27 \fn int time_period_duration (struct bufr2tac_subset_state *s )
28 \brief Get time period duration in seconds
29 \param s pinter to struct \ref bufr2tac_subset_state
30
31 Returns -1 if no duration is computed. Otherwise returns time duration in seconds
32*/
33int time_period_duration ( struct bufr2tac_subset_state *s )
34{
35 if ( s->k_itval == ( s->k_jtval + 1 ) )
36 {
37 // two consecutive time period displacements
38 if ( ( s->itmask & DESCRIPTOR_VALUE_MISSING ) == 0 &&
39 ( s->jtmask & DESCRIPTOR_VALUE_MISSING ) == 0 )
40 {
41 return ( abs ( s->itval - s->jtval ) );
42 }
43 else if ( ( s->itmask & DESCRIPTOR_VALUE_MISSING ) &&
44 ( s->jtmask & DESCRIPTOR_VALUE_MISSING ) )
45 {
46 return 0;
47 }
48 else if ( ( s->itmask & DESCRIPTOR_VALUE_MISSING ) == 0 &&
49 ( s->jtmask & DESCRIPTOR_VALUE_MISSING ) )
50 {
51 return ( abs ( s->itval ) );
52 }
53 else if ( ( s->jtmask & DESCRIPTOR_VALUE_MISSING ) == 0 &&
54 ( s->itmask & DESCRIPTOR_VALUE_MISSING ) )
55 {
56 return -1;
57 }
58 }
59
60 // just a single time period displacement
61 if ( ( s->itmask & DESCRIPTOR_VALUE_MISSING ) == 0 )
62 {
63 return ( abs ( s->itval ) );
64 }
65 else
66 {
67 return 0;
68 }
69}
70
71/*!
72 \fn int hour_rounded(struct synop_chunks *syn)
73 \brief Get the rounded hour of a given date
74 \param syn pointer to the \ref synop_chunks struct
75
76 It returns the rounded hour if >= 0. If < 0 problems
77*/
78int hour_rounded ( struct synop_chunks *syn )
79{
80 time_t t;
81 struct tm tim;
82 char aux[32];
83
84 sprintf ( aux, "%s%s%s%s%s", syn->e.YYYY,syn->e.MM,syn->e.DD,syn->e.HH, syn->e.mm );
85 memset ( &tim, 0, sizeof ( struct tm ) );
86 if ( strlen ( aux ) == 12 )
87 {
88 strptime ( aux, "%Y%m%d%H%M", &tim );
89 t = mktime ( &tim );
90 t += 1800;
91 gmtime_r ( &t, &tim );
92 return tim.tm_hour;
93 }
94 else if ( syn->e.mm[0] == 0 && syn->e.HH[0] )
95 {
96 return atoi ( syn->e.HH );
97 }
98 else
99 return -1;
100}
101
102/*!
103 \fn int syn_parse_x04 ( struct synop_chunks *syn, struct bufr2tac_subset_state *s )
104 \brief Parse a expanded descriptor with X = 04
105 \param syn pointer to a struct \ref synop_chunks where to set the results
106 \param s pointer to a struct \ref bufr2tac_subset_state where is stored needed information in sequential analysis
107
108 It returns 0 if success, 1 if problems when processing. If a descriptor is not processed returns 0 anyway
109*/
110int syn_parse_x04 ( struct synop_chunks *syn, struct bufr2tac_subset_state *s )
111{
112 switch ( s->a->desc.y )
113 {
114 case 1: // 0 04 001 .Year
115 if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
116 {
117 return 0;
118 }
119 else if ( s->ival < 2000 || s->ival > 2050 )
120 {
121 if ( BUFR2TAC_DEBUG_LEVEL > 0 )
122 bufr2tac_set_error ( s, 2, "syn_parse_x04()", "Bad year" );
123 return 1;
124 }
125 sprintf ( syn->e.YYYY, "%04d", s->ival );
126 s->mask |= SUBSET_MASK_HAVE_YEAR;
127 break;
128
129 case 2: // 0 04 002 . Month
130 if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
131 {
132 return 0;
133 }
134 sprintf ( syn->e.MM, "%02d", s->ival );
135 s->mask |= SUBSET_MASK_HAVE_MONTH;
136 break;
137
138 case 3: // 0 04 003 . Day of month
139 if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
140 {
141 return 0;
142 }
143 sprintf ( syn->e.DD, "%02d", s->ival );
144 s->mask |= SUBSET_MASK_HAVE_DAY;
145 break;
146
147 case 4: // 0 04 004 . Hour
148 if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
149 {
150 return 0;
151 }
152 sprintf ( syn->e.HH, "%02d", s->ival );
153 s->mask |= SUBSET_MASK_HAVE_HOUR;
154 break;
155
156 case 5: // 0 04 005 . Minute
157 if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
158 {
159 return 0;
160 }
161 sprintf ( syn->e.mm, "%02d", s->ival );
162 s->mask |= SUBSET_MASK_HAVE_MINUTE;
163 break;
164
165 // store latest displacement in seconds
166 case 23: // 0 04 023 . Time period of displacement (days)
167 if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
168 {
169 s->k_jtval = s->k_itval;
170 s->jtval = s->itval;
171 s->jtmask = s->itmask;
172 s->k_itval = s->i;
173 s->itval = 0;
174 return 0;
175 }
176 s->k_jtval = s->k_itval;
177 s->jtval = s->itval;
178 s->jtmask = s->itmask;
179 s->k_itval = s->i;
180 s->itmask = s->a->mask;
181 s->itval = s->ival * 86400;
182 break;
183
184 case 24: // 0 04 024 . Time period of displacement (hours)
185 if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
186 {
187 s->k_jtval = s->k_itval;
188 s->jtval = s->itval;
189 s->jtmask = s->itmask;
190 s->k_itval = s->i;
191 s->itval = 0;
192 return 0;
193 }
194 s->k_jtval = s->k_itval;
195 s->jtval = s->itval;
196 s->jtmask = s->itmask;
197 s->k_itval = s->i;
198 s->itmask = s->a->mask;
199 s->itval = s->ival * 3600;
200 break;
201
202 case 25: // 0 04 025 Time period of displacement (minutes)
203 if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
204 {
205 s->k_jtval = s->k_itval;
206 s->jtval = s->itval;
207 s->jtmask = s->itmask;
208 s->k_itval = s->i;
209 s->itval = 0;
210 return 0;
211 }
212 s->k_jtval = s->k_itval;
213 s->jtval = s->itval;
214 s->jtmask = s->itmask;
215 s->k_itval = s->i;
216 s->itmask = s->a->mask;
217 s->itval = s->ival * 60;
218 break;
219
220 case 26: // 0 04 026 . Time period of displacement (seconds)
221 if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
222 {
223 s->k_jtval = s->k_itval;
224 s->jtval = s->itval;
225 s->jtmask = s->itmask;
226 s->k_itval = s->i;
227 s->itval = 0;
228 return 0;
229 }
230 s->k_jtval = s->k_itval;
231 s->jtval = s->itval;
232 s->jtmask = s->itmask;
233 s->k_itval = s->i;
234 s->itmask = s->a->mask;
235 s->itval = s->ival;
236 break;
237
238 default:
239 if ( BUFR2TAC_DEBUG_LEVEL > 1 && ( s->a->mask & DESCRIPTOR_VALUE_MISSING ) == 0 )
240 bufr2tac_set_error ( s, 0, "syn_parse_x04()", "Descriptor not parsed" );
241 break;
242 }
243 return 0;
244}
245
246/*!
247 \fn int buoy_parse_x04 ( struct buoy_chunks *b, struct bufr2tac_subset_state *s )
248 \brief Parse a expanded descriptor with X = 04
249 \param b pointer to a struct \ref buoy_chunks where to set the results
250 \param s pointer to a struct \ref bufr2tac_subset_state where is stored needed information in sequential analysis
251
252 It returns 0 if success, 1 if problems when processing. If a descriptor is not processed returns 0 anyway
253*/
254int buoy_parse_x04 ( struct buoy_chunks *b, struct bufr2tac_subset_state *s )
255{
256
257 switch ( s->a->desc.y )
258 {
259 case 1: // 0 04 001 . Year
260 if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
261 {
262 return 0;
263 }
264 else if ( s->ival < 2000 || s->ival > 2050 )
265 {
266 if ( BUFR2TAC_DEBUG_LEVEL > 0 )
267 bufr2tac_set_error ( s, 2, "buoy_parse_x04()", "Bad year" );
268 return 1;
269 }
270
271 if ( b->e.YYYY[0] == 0 )
272 {
273 sprintf ( b->e.YYYY, "%04d", s->ival );
274 }
275 s->mask |= SUBSET_MASK_HAVE_YEAR;
276 break;
277
278 case 2: // 0 04 002 . Month
279 if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
280 {
281 return 0;
282 }
283 if ( b->e.MM[0] == 0 )
284 {
285 sprintf ( b->e.MM, "%02d", s->ival );
286 }
287 s->mask |= SUBSET_MASK_HAVE_MONTH;
288 break;
289
290 case 3: // 0 04 003 . Day of month
291 if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
292 {
293 return 0;
294 }
295 if ( b->e.DD[0] == 0 )
296 {
297 sprintf ( b->e.DD, "%02d", s->ival );
298 }
299 s->mask |= SUBSET_MASK_HAVE_DAY;
300 //sprintf(b->s0.YY, "%02d", (int) sq->sequence[is].val);
301 break;
302
303 case 4: // 0 04 004 . Hour
304 if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
305 {
306 return 0;
307 }
308 if ( b->e.HH[0] == 0 )
309 {
310 sprintf ( b->e.HH, "%02d", s->ival );
311 }
312 s->mask |= SUBSET_MASK_HAVE_HOUR;
313 //sprintf(b->s0.GG, "%02d", (int) sq->sequence[is].val);
314 break;
315
316 case 5: // 0 04 005 . Minute
317 if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
318 {
319 return 0;
320 }
321 if ( b->e.mm[0] == 0 )
322 {
323 sprintf ( b->e.mm, "%02d", s->ival );
324 }
325 s->mask |= SUBSET_MASK_HAVE_MINUTE;
326 break;
327
328 // store latest displacement in seconds
329 case 23: // 0 04 023 . Time period of displacement (days)
330 if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
331 {
332 s->k_jtval = s->k_itval;
333 s->jtval = s->itval;
334 s->k_itval = s->i;
335 s->itval = 0;
336 return 0;
337 }
338 s->k_jtval = s->k_itval;
339 s->jtval = s->itval;
340 s->k_itval = s->i;
341 s->itval = s->ival * 86400;
342 break;
343
344 case 24: // 0 04 024 . Time period of displacement (hours)
345 if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
346 {
347 s->k_jtval = s->k_itval;
348 s->jtval = s->itval;
349 s->k_itval = s->i;
350 s->itval = 0;
351 return 0;
352 }
353 s->k_jtval = s->k_itval;
354 s->jtval = s->itval;
355 s->k_itval = s->i;
356 s->itval = s->ival * 3600;
357 break;
358
359 case 25: // 0 04 025 . Time period of displacement (minutes)
360 if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
361 {
362 s->k_jtval = s->k_itval;
363 s->jtval = s->itval;
364 s->k_itval = s->i;
365 s->itval = 0;
366 return 0;
367 }
368 s->k_jtval = s->k_itval;
369 s->jtval = s->itval;
370 s->k_itval = s->i;
371 s->itval = s->ival * 60;
372 break;
373
374 case 26: // 0 04 026 . Time period of displacement (seconds)
375 if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
376 {
377 s->k_jtval = s->k_itval;
378 s->jtval = s->itval;
379 s->k_itval = s->i;
380 s->itval = 0;
381 return 0;
382 }
383 s->k_jtval = s->k_itval;
384 s->jtval = s->itval;
385 s->k_itval = s->i;
386 s->itval = s->ival;
387 break;
388
389 default:
390 if ( BUFR2TAC_DEBUG_LEVEL > 1 && ( s->a->mask & DESCRIPTOR_VALUE_MISSING ) == 0 )
391 bufr2tac_set_error ( s, 0, "buoy_parse_x04()", "Descriptor not parsed" );
392 break;
393 }
394 return 0;
395}
396
397/*!
398 \fn int climat_parse_x04 ( struct climat_chunks *c, struct bufr2tac_subset_state *s )
399 \brief Parse a expanded descriptor with X = 04
400 \param c pointer to a struct \ref climat_chunks where to set the results
401 \param s pointer to a struct \ref bufr2tac_subset_state where is stored needed information in sequential analysis
402
403 It returns 0 if success, 1 if problems when processing. If a descriptor is not processed returns 0 anyway
404*/
405int climat_parse_x04 ( struct climat_chunks *c, struct bufr2tac_subset_state *s )
406{
407 if ( c == NULL )
408 {
409 return 1;
410 }
411
412
413 switch ( s->a->desc.y )
414 {
415 case 1: // 0 04 001 .Year
416 if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
417 {
418 return 0;
419 }
420 else if ( s->ival < 2000 || s->ival > 2050 )
421 {
422 if ( BUFR2TAC_DEBUG_LEVEL > 0 )
423 bufr2tac_set_error ( s, 2, "climat_parse_x04()", "Bad year" );
424 return 1;
425 }
426
427 if ( s->i && ( s->a1->desc.x == 4 ) && ( s->a1->desc.y == 1 ) )
428 {
429 // this is the final year of a normal period
430 s->is_normal = 1;
431 sprintf ( c->s2.YcYc, "%02d", s->ival % 100 );
432 // then we fill the begin from tatest descriptor
433 sprintf ( c->s2.YbYb, "%02d", ( int ) s->a1->val % 100 );
434 }
435 else if ( c->e.YYYY[0] == '\0' )
436 {
437 sprintf ( c->e.YYYY, "%04d", s->ival );
438 s->mask |= SUBSET_MASK_HAVE_YEAR;
439 sprintf ( c->s0.JJJ, "%03d", abs ( s->ival ) % 1000 );
440 c->mask |= CLIMAT_SEC0;
441 }
442 break;
443
444 case 2: // 0 04 002 . Month
445 if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
446 {
447 return 0;
448 }
449 sprintf ( c->e.MM, "%02d", s->ival );
450 s->mask |= SUBSET_MASK_HAVE_MONTH;
451 sprintf ( c->s0.MM, "%02d", s->ival );
452 c->mask |= CLIMAT_SEC0;
453 break;
454
455 case 3: // 0 04 003 . Day of month
456 if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
457 {
458 return 0;
459 }
460 if ( c->e.DD[0] == 0 )
461 {
462 sprintf ( c->e.DD, "%02d", s->ival );
463 }
464 if ( s->a1->desc.x == 8 && s->a1->desc.y == 53 )
465 {
466 s->more_days = s->isq_val;
467 }
468 s->day = s->ival;
469 s->mask |= SUBSET_MASK_HAVE_DAY;
470 break;
471
472 case 4: // 0 04 004 . Hour
473 if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
474 {
475 return 0;
476 }
477 if ( c->e.HH[0] == 0 )
478 {
479 sprintf ( c->e.HH, "%02d", s->ival );
480 }
481 s->mask |= SUBSET_MASK_HAVE_HOUR;
482 break;
483
484 case 5: // 0 04 005 . Minute
485 if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
486 {
487 return 0;
488 }
489 if ( c->e.mm[0] == 0 )
490 {
491 sprintf ( c->e.mm, "%02d", s->ival );
492 }
493 s->mask |= SUBSET_MASK_HAVE_MINUTE;
494 break;
495
496 case 22: // 0 04 022 . Num month. Case of sec2 with normals
497 if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
498 {
499 return 0;
500 }
501 s->month = s->ival;
502 break;
503
504 case 23: // 0 04 023 . Num days in month
505 if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
506 {
507 return 0;
508 }
509 if ( s->nday == 0 )
510 {
511 s->nday = s->ival;
512 }
513 break;
514
515 case 51: // 0 04 051 . Principal time of daily reading of maximum
516 if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
517 {
518 return 0;
519 }
520 sprintf ( c->s4.GxGx, "%02d", s->ival );
521 s->mask |= CLIMAT_SEC4;
522 break;
523
524 case 52: // 0 04 052 . Principal time of daily reading of minimum
525 if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
526 {
527 return 0;
528 }
529 sprintf ( c->s4.GnGn, "%02d", s->ival );
530 s->mask |= CLIMAT_SEC4;
531 break;
532
533 case 53: // 0 04 053 . Number of days with precipitation equal to or more than 1 mm
534 if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
535 {
536 return 0;
537 }
538 if ( s->is_normal == 0 )
539 {
540 sprintf ( c->s1.nrnr, "%02d", s->ival );
541 s->mask |= CLIMAT_SEC1;
542 }
543 else
544 {
545 sprintf ( c->s2.nrnr, "%02d", s->ival );
546 s->mask |= CLIMAT_SEC2;
547 }
548 break;
549
550
551 case 74: // 0 04 074 . (UTC - LST)
552 if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
553 {
554 return 0;
555 }
556 s->dift = s->ival;
557 break;
558
559 default:
560 if ( BUFR2TAC_DEBUG_LEVEL > 1 && ( s->a->mask & DESCRIPTOR_VALUE_MISSING ) == 0 )
561 bufr2tac_set_error ( s, 0, "climat_parse_x04()", "Descriptor not parsed" );
562 break;
563 }
564 return 0;
565}
566
567/*!
568 \fn int temp_parse_x04 ( struct temp_chunks *t, struct bufr2tac_subset_state *s )
569 \brief Parse a expanded descriptor with X = 04
570 \param t pointer to a struct \ref temp_chunks where to set the results
571 \param s pointer to a struct \ref bufr2tac_subset_state where is stored needed information in sequential analysis
572
573 It returns 0 if success, 1 if problems when processing. If a descriptor is not processed returns 0 anyway
574*/
575int temp_parse_x04 ( struct temp_chunks *t, struct bufr2tac_subset_state *s )
576{
577 switch ( s->a->desc.y )
578 {
579 case 1: // 0 04 001 . Year
580 if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
581 {
582 return 0;
583 }
584 else if ( s->ival < 2000 || s->ival > 2050 )
585 {
586 if ( BUFR2TAC_DEBUG_LEVEL > 0 )
587 bufr2tac_set_error ( s, 2, "temp_parse_x04()", "Bad year" );
588 return 1;
589 }
590 if ( t->a.e.YYYY[0] == 0 )
591 {
592 sprintf ( t->a.e.YYYY, "%04d", s->ival );
593 sprintf ( t->b.e.YYYY, "%04d", s->ival );
594 sprintf ( t->c.e.YYYY, "%04d", s->ival );
595 sprintf ( t->d.e.YYYY, "%04d", s->ival );
596 }
597 s->mask |= SUBSET_MASK_HAVE_YEAR;
598 break;
599
600 case 2: // 0 04 002 . Month
601 if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
602 {
603 return 0;
604 }
605 if ( t->a.e.MM[0] == 0 )
606 {
607 sprintf ( t->a.e.MM, "%02d", s->ival );
608 sprintf ( t->b.e.MM, "%02d", s->ival );
609 sprintf ( t->c.e.MM, "%02d", s->ival );
610 sprintf ( t->d.e.MM, "%02d", s->ival );
611 }
612 s->mask |= SUBSET_MASK_HAVE_MONTH;
613 break;
614
615 case 3: // 0 04 003 . Day of month
616 if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
617 {
618 return 0;
619 }
620 if ( t->a.e.DD[0] == 0 )
621 {
622 sprintf ( t->a.e.DD, "%02d", s->ival );
623 sprintf ( t->b.e.DD, "%02d", s->ival );
624 sprintf ( t->c.e.DD, "%02d", s->ival );
625 sprintf ( t->d.e.DD, "%02d", s->ival );
626 }
627 s->mask |= SUBSET_MASK_HAVE_DAY;
628 //sprintf(t->s0.YY, "%02d", (int) sq->sequence[is].val);
629 break;
630
631 case 4: // 0 04 004 . Hour
632 if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
633 {
634 return 0;
635 }
636 if ( t->a.e.HH[0] == 0 )
637 {
638 sprintf ( t->a.e.HH, "%02d", s->ival );
639 sprintf ( t->b.e.HH, "%02d", s->ival );
640 sprintf ( t->c.e.HH, "%02d", s->ival );
641 sprintf ( t->d.e.HH, "%02d", s->ival );
642 sprintf ( t->a.s7.GG, "%02d", s->ival );
643 sprintf ( t->b.s7.GG, "%02d", s->ival );
644 sprintf ( t->c.s7.GG, "%02d", s->ival );
645 sprintf ( t->d.s7.GG, "%02d", s->ival );
646 }
647 s->mask |= SUBSET_MASK_HAVE_HOUR;
648 //sprintf(t->s0.GG, "%02d", (int) sq->sequence[is].val);
649 break;
650
651 case 5: // 0 04 005 . Minute
652 if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
653 {
654 return 0;
655 }
656 if ( t->a.e.mm[0] == 0 )
657 {
658 sprintf ( t->a.e.mm, "%02d", s->ival );
659 sprintf ( t->b.e.mm, "%02d", s->ival );
660 sprintf ( t->c.e.mm, "%02d", s->ival );
661 sprintf ( t->d.e.mm, "%02d", s->ival );
662 sprintf ( t->a.s7.gg, "%02d", s->ival );
663 sprintf ( t->b.s7.gg, "%02d", s->ival );
664 sprintf ( t->c.s7.gg, "%02d", s->ival );
665 sprintf ( t->d.s7.gg, "%02d", s->ival );
666 }
667 s->mask |= SUBSET_MASK_HAVE_MINUTE;
668 break;
669
670 case 6: // 0 04 006 . Second
671 if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
672 {
673 return 0;
674 }
675 if ( t->a.e.ss[0] == 0 )
676 {
677 sprintf ( t->a.e.ss, "%02d", s->ival );
678 sprintf ( t->b.e.ss, "%02d", s->ival );
679 sprintf ( t->c.e.ss, "%02d", s->ival );
680 sprintf ( t->d.e.ss, "%02d", s->ival );
681 }
682 s->mask |= SUBSET_MASK_HAVE_SECOND;
683 break;
684
685 case 86: // 0 04 086 . Long time period or displacement (since launch time)
686
687 // s->rep is used to check what type of point we are dealing from
688 // see repliator 0 31 001 and 0 31 002 to understand it better
689 // Because this is the first descriptor in a sequence for a point, we use this
690 // descriptor to set properly the current index
691 if ( s->rep > 0 )
692 {
693 // case of Temperature, humidty ... point
694 if ( ( int ) s->r->n < s->rep )
695 {
696 // Because of there are bufr reports with a lot of not significant points
697 // we only collect the first one and significant points, i.e. those that flags are non zero
698 // When flags are zero we just overwrite points
699 if ( s->r->n < ( RAW_TEMP_NMAX_POINTS ) &&
700 ( s->r->n == 0 || s->r->raw[s->r->n - 1].flags ) )
701 {
702 s->r->n += 1; // Here we update the index
703 }
704 }
705 s->r->raw[s->r->n - 1].dt = s->ival;
706 }
707 else
708 {
709 // case of wind shear point
710 if ( ( int ) s->w->n < s->itval )
711 {
712 s->w->n += 1;
713 }
714 s->w->raw[s->w->n - 1].dt = s->ival;
715 }
716 break;
717
718 default:
719 if ( BUFR2TAC_DEBUG_LEVEL > 1 && ( s->a->mask & DESCRIPTOR_VALUE_MISSING ) == 0 )
720 bufr2tac_set_error ( s, 0, "temp_parse_x04()", "Descriptor not parsed" );
721 break;
722 }
723 return 0;
724}
BUFR2TAC_DEBUG_LEVEL
int BUFR2TAC_DEBUG_LEVEL
Definition: bufr2tac.c:31
bufr2tac.h
Include header file for binary bufr2tac.
SUBSET_MASK_HAVE_MONTH
#define SUBSET_MASK_HAVE_MONTH
Bit mask to mark a struct bufr_subset_sequence_data having observation month.
Definition: bufr2tac.h:146
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_MINUTE
#define SUBSET_MASK_HAVE_MINUTE
Bit mask to mark a struct bufr_subset_sequence_data having observation minute.
Definition: bufr2tac.h:164
SUBSET_MASK_HAVE_SECOND
#define SUBSET_MASK_HAVE_SECOND
Bit mask to mark a struct bufr_subset_sequence_data having observation second.
Definition: bufr2tac.h:170
SUBSET_MASK_HAVE_YEAR
#define SUBSET_MASK_HAVE_YEAR
Bit mask to mark a struct bufr_subset_sequence_data having observation year.
Definition: bufr2tac.h:140
SUBSET_MASK_HAVE_DAY
#define SUBSET_MASK_HAVE_DAY
Bit mask to mark a struct bufr_subset_sequence_data having observation day in a month.
Definition: bufr2tac.h:152
SUBSET_MASK_HAVE_HOUR
#define SUBSET_MASK_HAVE_HOUR
Bit mask to mark a struct bufr_subset_sequence_data having observation hour.
Definition: bufr2tac.h:158
syn_parse_x04
int syn_parse_x04(struct synop_chunks *syn, struct bufr2tac_subset_state *s)
Parse a expanded descriptor with X = 04.
Definition: bufr2tac_x04.c:110
time_period_duration
int time_period_duration(struct bufr2tac_subset_state *s)
Get time period duration in seconds.
Definition: bufr2tac_x04.c:33
temp_parse_x04
int temp_parse_x04(struct temp_chunks *t, struct bufr2tac_subset_state *s)
Parse a expanded descriptor with X = 04.
Definition: bufr2tac_x04.c:575
hour_rounded
int hour_rounded(struct synop_chunks *syn)
Get the rounded hour of a given date.
Definition: bufr2tac_x04.c:78
buoy_parse_x04
int buoy_parse_x04(struct buoy_chunks *b, struct bufr2tac_subset_state *s)
Parse a expanded descriptor with X = 04.
Definition: bufr2tac_x04.c:254
climat_parse_x04
int climat_parse_x04(struct climat_chunks *c, struct bufr2tac_subset_state *s)
Parse a expanded descriptor with X = 04.
Definition: bufr2tac_x04.c:405
DESCRIPTOR_VALUE_MISSING
#define DESCRIPTOR_VALUE_MISSING
Bit mask for a missing value in a struct bufr_atom_data.
Definition: bufrdeco.h:140
CLIMAT_SEC0
#define CLIMAT_SEC0
mask bit meaning section 0 of climat is solicited to or parsed with success
Definition: metclimat.h:32
CLIMAT_SEC4
#define CLIMAT_SEC4
mask bit meaning section 4 of climat is solicited to or parsed with success
Definition: metclimat.h:52
CLIMAT_SEC2
#define CLIMAT_SEC2
mask bit meaning section 2 of climat is solicited to or parsed with success
Definition: metclimat.h:42
CLIMAT_SEC1
#define CLIMAT_SEC1
mask bit meaning section 1 of climat is solicited to or parsed with success
Definition: metclimat.h:37
RAW_TEMP_NMAX_POINTS
#define RAW_TEMP_NMAX_POINTS
maximum number of raw points points
Definition: mettemp.h:144
bufr2tac_subset_state
stores information needed to parse a sequential list of expanded descriptors for a subset
Definition: bufr2tac.h:246
bufr2tac_subset_state::k_itval
size_t k_itval
Definition: bufr2tac.h:258
bufr2tac_subset_state::w
struct temp_raw_wind_shear_data * w
Definition: bufr2tac.h:286
bufr2tac_subset_state::a1
struct bufr_atom_data * a1
Definition: bufr2tac.h:250
bufr2tac_subset_state::day
int day
Definition: bufr2tac.h:277
bufr2tac_subset_state::itmask
int itmask
Definition: bufr2tac.h:257
bufr2tac_subset_state::i
size_t i
Definition: bufr2tac.h:251
bufr2tac_subset_state::a
struct bufr_atom_data * a
Definition: bufr2tac.h:249
bufr2tac_subset_state::is_normal
int is_normal
Definition: bufr2tac.h:281
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::month
int month
Definition: bufr2tac.h:280
bufr2tac_subset_state::mask
int mask
Definition: bufr2tac.h:282
bufr2tac_subset_state::nday
int nday
Definition: bufr2tac.h:279
bufr2tac_subset_state::more_days
int more_days
Definition: bufr2tac.h:278
bufr2tac_subset_state::jtval
int jtval
Definition: bufr2tac.h:259
bufr2tac_subset_state::ival
int ival
Definition: bufr2tac.h:254
bufr2tac_subset_state::itval
int itval
Definition: bufr2tac.h:256
bufr2tac_subset_state::dift
int dift
Definition: bufr2tac.h:276
bufr2tac_subset_state::isq_val
int isq_val
Definition: bufr2tac.h:263
bufr2tac_subset_state::k_jtval
size_t k_jtval
Definition: bufr2tac.h:261
bufr2tac_subset_state::jtmask
int jtmask
Definition: bufr2tac.h:260
bufr_atom_data::mask
uint32_t mask
Definition: bufrdeco.h:437
bufr_atom_data::desc
struct bufr_descriptor desc
Definition: bufrdeco.h:436
bufr_atom_data::val
double val
Definition: bufrdeco.h:440
bufr_descriptor::x
uint8_t x
Definition: bufrdeco.h:411
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::e
struct report_date_ext e
Definition: metbuoy.h:199
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::e
struct report_date_ext e
Definition: metclimat.h:215
climat_chunks::s1
struct climat_sec1 s1
Definition: metclimat.h:218
climat_chunks::s0
struct climat_sec0 s0
Definition: metclimat.h:217
climat_chunks::mask
int mask
Definition: metclimat.h:214
climat_chunks::s2
struct climat_sec2 s2
Definition: metclimat.h:219
climat_sec0::JJJ
char JJJ[4]
Definition: metclimat.h:71
climat_sec0::MM
char MM[4]
Definition: metclimat.h:70
climat_sec1::nrnr
char nrnr[4]
Definition: metclimat.h:94
climat_sec2::nrnr
char nrnr[4]
Definition: metclimat.h:124
climat_sec2::YbYb
char YbYb[4]
Definition: metclimat.h:111
climat_sec2::YcYc
char YcYc[4]
Definition: metclimat.h:112
climat_sec4::GnGn
char GnGn[4]
Definition: metclimat.h:189
climat_sec4::GxGx
char GxGx[4]
Definition: metclimat.h:188
report_date_ext::ss
char ss[4]
Definition: metcommon.h:38
report_date_ext::mm
char mm[4]
Definition: metcommon.h:37
report_date_ext::HH
char HH[4]
Definition: metcommon.h:36
report_date_ext::DD
char DD[4]
Definition: metcommon.h:35
report_date_ext::MM
char MM[4]
Definition: metcommon.h:34
report_date_ext::YYYY
char YYYY[6]
Definition: metcommon.h:33
synop_chunks
contains all possible substrings from a synop report is parsed with success
Definition: metsynop.h:293
synop_chunks::e
struct report_date_ext e
Definition: metsynop.h:295
temp_a::e
struct report_date_ext e
Definition: mettemp.h:454
temp_a::s7
struct temp_sec7 s7
Definition: mettemp.h:459
temp_b::s7
struct temp_sec7 s7
Definition: mettemp.h:473
temp_b::e
struct report_date_ext e
Definition: mettemp.h:469
temp_c::e
struct report_date_ext e
Definition: mettemp.h:484
temp_c::s7
struct temp_sec7 s7
Definition: mettemp.h:489
temp_chunks
Store the whole TEMP report.
Definition: mettemp.h:511
temp_chunks::c
struct temp_c c
Definition: mettemp.h:517
temp_chunks::d
struct temp_d d
Definition: mettemp.h:518
temp_chunks::b
struct temp_b b
Definition: mettemp.h:516
temp_chunks::a
struct temp_a a
Definition: mettemp.h:515
temp_d::s7
struct temp_sec7 s7
Definition: mettemp.h:503
temp_d::e
struct report_date_ext e
Definition: mettemp.h:499
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::dt
int dt
Definition: mettemp.h:196
temp_raw_point_data::flags
int flags
Definition: mettemp.h:197
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::dt
int dt
Definition: mettemp.h:224
temp_sec7::GG
char GG[4]
Definition: mettemp.h:408
temp_sec7::gg
char gg[4]
Definition: mettemp.h:409
Generated by doxygen 1.9.5