bufr2synop 0.24.0
Functions
bufr2tac_x11.c File Reference

decodes the descriptors with X = 11 (wind) More...

#include "bufr2tac.h"
Include dependency graph for bufr2tac_x11.c:

Go to the source code of this file.

Functions

char * secs_to_tt (char *tt, int secs)
 get tt code from seconds More...
 
char * wind_to_dndnfnfnfn (char *target, double dd, double ff)
 
int syn_parse_x11 (struct synop_chunks *syn, struct bufr2tac_subset_state *s)
 Parse a expanded descriptor with X = 11. More...
 
int buoy_parse_x11 (struct buoy_chunks *b, struct bufr2tac_subset_state *s)
 Parse a expanded descriptor with X = 11. More...
 
int climat_parse_x11 (struct climat_chunks *c, struct bufr2tac_subset_state *s)
 Parse a expanded descriptor with X = 11. More...
 
int temp_parse_x11 (struct temp_chunks *t, struct bufr2tac_subset_state *s)
 Parse a expanded descriptor with X = 11. More...
 

Detailed Description

decodes the descriptors with X = 11 (wind)

Definition in file bufr2tac_x11.c.

Function Documentation

◆ buoy_parse_x11()

int buoy_parse_x11 ( struct buoy_chunks *  b,
struct bufr2tac_subset_state *  s 
)

Parse a expanded descriptor with X = 11.

Parameters
bpointer to a struct buoy_chunks where to set the results
spointer to a struct bufr2tac_subset_state where is stored needed information in sequential analysis

It returns 0 if success, 1 if problems when processing. If a descriptor is not processed returns 0 anyway

Definition at line 387 of file bufr2tac_x11.c.

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}
BUFR2TAC_DEBUG_LEVEL
int BUFR2TAC_DEBUG_LEVEL
Definition: bufr2tac.c:31
bufr2tac_set_error
int bufr2tac_set_error(struct bufr2tac_subset_state *s, int severity, char *origin, char *explanation)
Definition: bufr2tac_error.c:59
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
bufr2tac_subset_state::a
struct bufr_atom_data * a
Definition: bufr2tac.h:249
bufr2tac_subset_state::val
double val
Definition: bufr2tac.h:255
bufr2tac_subset_state::ival
int ival
Definition: bufr2tac.h:254
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::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

References bufr2tac_subset_state::a, BUFR2TAC_DEBUG_LEVEL, bufr2tac_set_error(), BUOY_SEC1, buoy_sec1::dd, bufr_atom_data::desc, DESCRIPTOR_VALUE_MISSING, buoy_sec1::ff, buoy_sec1::fff, bufr2tac_subset_state::ival, buoy_sec0::iw, bufr_atom_data::mask, buoy_chunks::mask, buoy_chunks::s0, buoy_chunks::s1, bufr2tac_subset_state::val, and bufr_descriptor::y.

Referenced by parse_subset_as_buoy().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ climat_parse_x11()

int climat_parse_x11 ( struct climat_chunks *  c,
struct bufr2tac_subset_state *  s 
)

Parse a expanded descriptor with X = 11.

Parameters
cpointer to a struct climat_chunks where to set the results
spointer to a struct bufr2tac_subset_state where is stored needed information in sequential analysis

It returns 0 if success, 1 if problems when processing. If a descriptor is not processed returns 0 anyway

Definition at line 454 of file bufr2tac_x11.c.

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}
CLIMAT_SEC4
#define CLIMAT_SEC4
mask bit meaning section 4 of climat is solicited to or parsed with success
Definition: metclimat.h:52
bufr2tac_subset_state::day
int day
Definition: bufr2tac.h:277
bufr2tac_subset_state::isq_val
int isq_val
Definition: bufr2tac.h:263
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

References bufr2tac_subset_state::a, BUFR2TAC_DEBUG_LEVEL, bufr2tac_set_error(), CLIMAT_SEC4, bufr2tac_subset_state::day, bufr_atom_data::desc, DESCRIPTOR_VALUE_MISSING, climat_sec4::fxfxfx, bufr2tac_subset_state::isq_val, climat_sec4::iw, bufr_atom_data::mask, climat_chunks::mask, climat_chunks::s4, bufr2tac_subset_state::val, bufr_descriptor::y, and climat_sec4::yfx.

Referenced by parse_subset_as_climat().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ secs_to_tt()

char * secs_to_tt ( char *  tt,
int  secs 
)

get tt code from seconds

Parameters
ttstring with the resulting table code
secssecond

returns the pointer to tt

Definition at line 34 of file bufr2tac_x11.c.

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}

Referenced by syn_parse_x11(), and syn_parse_x20().

Here is the caller graph for this function:

◆ syn_parse_x11()

int syn_parse_x11 ( struct synop_chunks *  syn,
struct bufr2tac_subset_state *  s 
)

Parse a expanded descriptor with X = 11.

Parameters
synpointer to a struct synop_chunks where to set the results
spointer to a struct bufr2tac_subset_state where is stored needed information in sequential analysis

It returns 0 if success, 1 if problems when processing. If a descriptor is not processed returns 0 anyway

Definition at line 116 of file bufr2tac_x11.c.

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}
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
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
secs_to_tt
char * secs_to_tt(char *tt, int secs)
get tt code from seconds
Definition: bufr2tac_x11.c:34
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::SnSn
int SnSn
Definition: bufr2tac.h:283
bufr2tac_subset_state::mask
int mask
Definition: bufr2tac.h:282
bufr2tac_subset_state::itval
int itval
Definition: bufr2tac.h:256
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::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

References bufr2tac_subset_state::a, BUFR2TAC_DEBUG_LEVEL, bufr2tac_set_error(), synop_sec3::d9, synop_sec5::d9, synop_sec1::dd, bufr_atom_data::desc, DESCRIPTOR_VALUE_MISSING, synop_sec1::ff, synop_sec1::fff, bufr2tac_subset_state::itval, bufr2tac_subset_state::ival, synop_sec0::iw, bufr_atom_data::mask, bufr2tac_subset_state::mask, synop_chunks::mask, data9::misc, data9::n, synop_chunks::s0, synop_chunks::s1, synop_chunks::s3, synop_chunks::s5, secs_to_tt(), bufr2tac_subset_state::SnSn, misc3::SpSp, misc3::spsp, SUBSET_MASK_HAVE_GUST, SUBSET_MASK_HAVE_GUST10, SYNOP_NMISC, SYNOP_SEC1, SYNOP_SEC3, SYNOP_SEC5, bufr2tac_subset_state::val, and bufr_descriptor::y.

Referenced by parse_subset_as_synop().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ temp_parse_x11()

int temp_parse_x11 ( struct temp_chunks *  t,
struct bufr2tac_subset_state *  s 
)

Parse a expanded descriptor with X = 11.

Parameters
tpointer to a struct temp_chunks where to set the results
spointer to a struct bufr2tac_subset_state where is stored needed information in sequential analysis

It returns 0 if success, 1 if problems when processing. If a descriptor is not processed returns 0 anyway

Definition at line 500 of file bufr2tac_x11.c.

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}
MISSING_REAL
#define MISSING_REAL
The missing default value for real values.
Definition: bufrdeco.h:78
bufr2tac_subset_state::w
struct temp_raw_wind_shear_data * w
Definition: bufr2tac.h:286
bufr2tac_subset_state::r
struct temp_raw_data * r
Definition: bufr2tac.h:285
bufr2tac_subset_state::rep
int rep
Definition: bufr2tac.h:252
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

References bufr2tac_subset_state::a, BUFR2TAC_DEBUG_LEVEL, bufr2tac_set_error(), temp_raw_point_data::dd, bufr_atom_data::desc, DESCRIPTOR_VALUE_MISSING, temp_raw_point_data::ff, bufr_atom_data::mask, MISSING_REAL, temp_raw_data::n, temp_raw_wind_shear_data::n, bufr2tac_subset_state::r, temp_raw_data::raw, temp_raw_wind_shear_data::raw, bufr2tac_subset_state::rep, bufr2tac_subset_state::val, bufr2tac_subset_state::w, temp_raw_wind_shear_point::ws_abv, temp_raw_wind_shear_point::ws_blw, and bufr_descriptor::y.

Referenced by parse_subset_as_temp().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ wind_to_dndnfnfnfn()

char * wind_to_dndnfnfnfn ( char *  target,
double  dd,
double  ff 
)

Definition at line 93 of file bufr2tac_x11.c.

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}

References MISSING_REAL.

Referenced by parse_temp_raw_data().

Here is the caller graph for this function:
Generated by doxygen 1.9.5