bufr2tac.h File Reference

Include header file for binary bufr2tac. More...

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <getopt.h>
#include <time.h>
#include <math.h>
#include <sys/stat.h>
#include "bufrdeco.h"
#include "metsynop.h"
#include "metbuoy.h"
#include "mettemp.h"
#include "metclimat.h"

Include dependency graph for bufr2tac.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	bufr2tac_error
	Store an error/warning/info and its severity. More...
struct	bufr2tac_error_stack
	A stack of structs bufr2tac_error. More...
struct	bufr2tac_subset_state
	stores information needed to parse a sequential list of expanded descriptors for a subset More...
struct	met_geo
	Geographic meta information. More...
struct	metreport
	all the information for a meteorological report in WMO text format from a BUFR file More...

Macros
#define	_GNU_SOURCE
#define	SUBSET_MASK_LATITUDE_SOUTH   (1)
	Bit mask to mark a struct bufr_subset_sequence_data with south latitude. More...
#define	SUBSET_MASK_LONGITUDE_WEST   (2)
	Bit mask to mark a struct bufr_subset_sequence_data with west longitude. More...
#define	SUBSET_MASK_HAVE_TYPE_STATION   (4)
	Bit mask to mark a struct bufr_subset_sequence_data having type station information. More...
#define	SUBSET_MASK_HAVE_NO_SIGNIFICANT_WW   (8)
	Bit mask to mark a struct bufr_subset_sequence_data without WW information. More...
#define	SUBSET_MASK_HAVE_NO_SIGNIFICANT_W1   (16)
	Bit mask to mark a struct bufr_subset_sequence_data without W1 information. More...
#define	SUBSET_MASK_HAVE_NO_SIGNIFICANT_W2   (32)
	Bit mask to mark a struct bufr_subset_sequence_data without W1 information. More...
#define	SUBSET_MASK_HAVE_LATITUDE   (64)
	Bit mask to mark a struct bufr_subset_sequence_data having latitude. More...
#define	SUBSET_MASK_HAVE_LONGITUDE   (128)
	Bit mask to mark a struct bufr_subset_sequence_data having longitude. More...
#define	SUBSET_MASK_HAVE_ALTITUDE   (256)
	Bit mask to mark a struct bufr_subset_sequence_data having altitude. More...
#define	SUBSET_MASK_HAVE_NAME   (512)
	Bit mask to mark a struct bufr_subset_sequence_data having station name. More...
#define	SUBSET_MASK_HAVE_COUNTRY   (1024)
	Bit mask to mark a struct bufr_subset_sequence_data having country name. More...
#define	SUBSET_MASK_HAVE_YEAR   (2048)
	Bit mask to mark a struct bufr_subset_sequence_data having observation year. More...
#define	SUBSET_MASK_HAVE_MONTH   (4096)
	Bit mask to mark a struct bufr_subset_sequence_data having observation month. More...
#define	SUBSET_MASK_HAVE_DAY   (8192)
	Bit mask to mark a struct bufr_subset_sequence_data having observation day in a month. More...
#define	SUBSET_MASK_HAVE_HOUR   (16384)
	Bit mask to mark a struct bufr_subset_sequence_data having observation hour. More...
#define	SUBSET_MASK_HAVE_MINUTE   (32768)
	Bit mask to mark a struct bufr_subset_sequence_data having observation minute. More...
#define	SUBSET_MASK_HAVE_SECOND   (65536)
	Bit mask to mark a struct bufr_subset_sequence_data having observation second. More...
#define	SUBSET_MASK_HAVE_GUST   (131072)
	Bit mask to mark a struct bufr_subset_sequence_data having wind gust observation other than 10 minutes. More...
#define	SUBSET_MASK_HAVE_GUST10   ( 2 * 131072)
	Bit mask to mark a struct bufr_subset_sequence_data having wind gust observation other than 10 minutes. More...
#define	SUBSET_MASK_HAVE_WIGOS_ID   ( 4 * 131072)
	Bit mask to mark if a subset has a WIGOS ID. More...
#define	BUFR2TAC_ERROR_STACK_DIM   16
	set de dimension of a struct bufr2tac_error_stack More...
#define	BUFR2TAC_ERROR_DESCRIPTION_LENGTH   1024
	set de dimension of member description of a struct bufr2tac_error More...
#define	REPORT_LENGTH   (16384)
#define	PRINT_BITMASK_WIGOS   (1)
	Bit mask to member print_mask in struct metreport to print WIGOS Identifier. More...
#define	PRINT_BITMASK_GEO   (2)
	Bit mask to member print_mask in struct metreport to print geographic position. More...
#define	bufr_subset_sequence_data   bufrdeco_subset_sequence_data
	To use bufrdeco library with legacy old code using ECMWF library which is not used currently. More...

Functions
char *	bufr2tac_get_version (char *version, size_t dversion, char *build, size_t dbuild, char *builder, size_t dbuilder, int *version_major, int *version_minor, int *version_patch)
int	bufr2tac_push_error (struct bufr2tac_error_stack *e, int severity, char *description)
int	bufr2tac_clean_error_stack (struct bufr2tac_error_stack *e)
int	bufr2tac_set_error (struct bufr2tac_subset_state *s, int severity, char *origin, char *explanation)
int	bufr2tac_print_error (struct bufr2tac_error_stack *e)
int	bufr2tac_set_debug_level (int level)
void	bufr2tac_clean_buoy_chunks (struct buoy_chunks *b)
	cleans a buoy_chunks struct More...
void	bufr2tac_clean_synop_chunks (struct synop_chunks *s)
void	bufr2tac_clean_temp_chunks (struct temp_chunks *t)
	cleans a buoy_chunks struct More...
void	bufr2tac_clean_climat_chunks (struct climat_chunks *c)
	cleans a climat_chunks struct More...
void	bufr2tac_clean_metreport (struct metreport *m)
int	set_environment (char *default_bufrtables, char *bufrtables_dir)
int	integer_to_descriptor (struct bufr_descriptor *d, int id)
	parse an integer with a descriptor fom bufr ECWMF libary More...
int	descriptor_to_integer (int *id, struct bufr_descriptor *d)
	parse a descriptor and sets an integer in the decimal formas fxxyyy More...
unsigned int	three_bytes_to_uint (const unsigned char *source)
	returns the integer value from an array of three bytes, most significant first More...
char *	charray_to_string (char *s, unsigned char *buf, size_t size)
	get a null termitated c-string from an array of unsigned chars More...
char *	adjust_string (char *s)
	Supress trailing blanks of a string. More...
char *	get_explained_table_val (char *expl, size_t dim, char tablec[MAXLINES_TABLEC][92], size_t nlines_tablec, struct bufr_descriptor *d, int ival)
char *	get_explained_flag_val (char *expl, size_t dim, char tablec[MAXLINES_TABLEC][92], size_t nlines_tablec, struct bufr_descriptor *d, unsigned long ival)
char *	get_ecmwf_tablename (char *target, char type, char *bufrtables_dir, int ksec1[40])
	Get the complete pathname of a table file needed by a bufr message. More...
int	parse_subset_as_buoy (struct metreport *m, struct bufr2tac_subset_state *s, struct bufr_subset_sequence_data *sq, char *err)
int	parse_subset_as_synop (struct metreport *m, struct bufr2tac_subset_state *s, struct bufr_subset_sequence_data *sq, char *err)
	parses a subset sequence as an Land fixed SYNOP FM-12, SHIP FM-13 or SYNOP-mobil FM-14 report More...
int	parse_subset_as_temp (struct metreport *m, struct bufr2tac_subset_state *s, struct bufr_subset_sequence_data *sq, char *err)
int	parse_subset_as_climat (struct metreport *m, struct bufr2tac_subset_state *s, struct bufr_subset_sequence_data *sq, char *err)
int	YYYYMMDDHHmm_to_met_datetime (struct met_datetime *t, const char *source)
	Parse the string YYYYMMDDHHmm[ss] and set a struct met_datetime. More...
int	round_met_datetime_to_hour (struct met_datetime *target, struct met_datetime *source)
int	synop_YYYYMMDDHHmm_to_YYGG (struct synop_chunks *syn)
	Sets YYGG from YYYYMMDDHHmm extended group. More...
char *	met_datetime_to_YYGG (char *target, struct met_datetime *t)
	Get YYGG from a struct met_datetime. More...
int	buoy_YYYYMMDDHHmm_to_JMMYYGGgg (struct buoy_chunks *b)
	Sets YYGG from YYYYMMDDHHmm extended group. More...
int	check_date_from_future (struct metreport *m)
	Check a estructure metreport not from future. More...
char *	guess_WMO_region (char *A1, char *Reg, const char *II, const char *iii)
	get WMO region A1 and Reg items from II and iii (WMO index) More...
char *	guess_WMO_region_synop (struct synop_chunks *syn)
	Try to find WMO region if it is not already set and WMO Block and number index are known. More...
char *	guess_WMO_region_temp (struct temp_chunks *temp)
int	read_table_c (char tablec[MAXLINES_TABLEC][92], size_t *nlines_tablec, char *bufrtables_dir, int ksec1[40])
int	parse_subset_sequence (struct metreport *m, struct bufr_subset_sequence_data *sq, struct bufr2tac_subset_state *st, int *kdtlst, size_t nlst, int *ksec1, char *err)
	Parse a sequence of expanded descriptors for a subset. More...
int	find_descriptor (int *haystack, size_t nlst, int needle)
	Try to find a descriptor in an array. More...
int	find_descriptor_interval (int *haystack, size_t nlst, int needlemin, int needlemax)
int	bufr_set_environment (char *default_bufrtables, char *bufrtables_dir)
	set the environment vars needed to work properly with ECMWF bufrdc library More...
int	guess_gts_header (struct gts_header *h, const char *f)
	Guess the WMO GTS header from filename. More...
int	read_bufr (unsigned char *bufr, char *filename, int *length)
	read a bufr file as an array of unsigned chars More...
int	time_period_duration (struct bufr2tac_subset_state *s)
	Get time period duration in seconds. More...
int	hour_rounded (struct synop_chunks *syn)
	Get the rounded hour of a given date. More...
char *	latlon_to_MMM (char *target, double lat, double lon)
	convert latitude and longitude to a MMM string More...
char *	kelvin_to_TTTT (char *target, double T)
	converts a kelvin temperature value into a TTTT string More...
char *	kelvin_to_snTTT (char *target, double T)
	converts a kelvin temperature value into a snTTT string More...
char *	kelvin_to_snTT (char *target, double T)
	converts a kelvin temperature value into a snTT string More...
char *	kelvin_to_TT (char *target, double T)
	converts a kelvin temperature value into a TT string More...
char *	kelvin_to_TTTa (char *target, double T)
	Set temperature TTTa. More...
char *	dewpoint_depression_to_DnDn (char *target, double T, double Td)
	Set DnDn (dewpoint depression) More...
char *	m_to_h (char *target, double h)
	converts the altitude of cloud layer into h string code More...
char *	m_to_hh (char *target, double h)
	converts the altitude of cloud layer into hh string code More...
char *	m_to_9h (char *target, double h)
	converts the altitude of cloud layer into 9h string code More...
char *	m_to_RR (char *target, double m)
	Convert distance (m) in RR code (3570) More...
char *	pascal_to_ppp (char *target, double P)
	Converts pascal values (variation) into a ppp string. More...
char *	pascal_to_pnpnpn (char *target, double P)
char *	pascal_to_PPPP (char *target, double P)
	Converts pascal values into a PPPP string. More...
char *	percent_to_okta (char *target, double perc)
	Converts percent cloud cover into okta. More...
char *	prec_to_RRR (char *target, double r)
	converts a precipitation in Kg/m2 into a RRR string More...
char *	prec_to_RRRR24 (char *target, double r)
	converts a precipitation in Kg/m2 into a RRRR24 string More...
char *	secs_to_tt (char *tt, int secs)
	get tt code from seconds More...
char *	vism_to_VV (char *target, double V)
	Convert horizontal visibilty in meters to a VV string. More...
char *	recent_snow_to_ss (char *target, double r)
	converts recent snow in m to ss (code table 3870) More...
char *	total_snow_depth_to_sss (char *target, double r)
	converts tatal snow depth in m to sss (code table 3889) More...
char *	wind_to_dndnfnfnfn (char *target, double dd, double ff)
char *	grad_to_D (char *D, double grad)
	Converts true direction in grads to D (code table 0700) More...
char *	grad_to_ec (char *target, double grad)
	Converts elevation in grads to ec (code table 1004) More...
int	check_kj_m2 (double val)
	Check if a radiation value can be wrote in Kj/m2 using up to 4 chars. More...
int	check_j_cm2 (double val)
	Check if a radiation value can be wrote in J/cm2 using up to 4 chars. More...
size_t	print_geo (char **geo, size_t lmax, struct metreport *m)
size_t	print_wigos_id (char **wid, size_t lmax, struct metreport *m)
int	print_synop_report (struct metreport *m)
	prints a synop into a string More...
size_t	print_synop_sec0 (char **sec0, size_t lmax, struct synop_chunks *syn)
	Prints the synop section 0 (header) More...
size_t	print_synop_sec1 (char **sec1, size_t lmax, struct synop_chunks *syn)
	Prints the synop section 1. More...
size_t	print_synop_sec2 (char **sec2, size_t lmax, struct synop_chunks *syn)
	Prints the synop section 2. More...
size_t	print_synop_sec3 (char **sec3, size_t lmax, struct synop_chunks *syn)
	Prints the synop section 3. More...
size_t	print_synop_wigos_id (char **wid, size_t lmax, struct synop_chunks *syn)
int	print_buoy_report (struct metreport *m)
	prints a buoy into a string More...
size_t	print_buoy_sec0 (char **sec0, size_t lmax, struct buoy_chunks *b)
	Prints the buoy section 1. More...
size_t	print_buoy_sec1 (char **sec1, size_t lmax, struct buoy_chunks *b)
	Prints the buoy section 1. More...
size_t	print_buoy_sec2 (char **sec2, size_t lmax, struct buoy_chunks *b)
	Prints the buoy section 1. More...
size_t	print_buoy_sec3 (char **sec3, size_t lmax, struct buoy_chunks *b)
	Prints the buoy section 3. More...
size_t	print_buoy_wigos_id (char **wid, size_t lmax, struct buoy_chunks *b)
int	print_climat_report (struct metreport *m)
	prints a climat into a string More...
size_t	print_climat_sec0 (char **sec0, size_t lmax, struct climat_chunks *cl)
	Prints the climat section 0 (header) More...
size_t	print_climat_sec1 (char **sec1, size_t lmax, struct climat_chunks *cl)
	Prints the climat section 1. More...
size_t	print_climat_sec2 (char **sec2, size_t lmax, struct climat_chunks *cl)
	Prints the climat section 2. More...
size_t	print_climat_sec3 (char **sec3, size_t lmax, struct climat_chunks *cl)
	Prints the climat section 3. More...
size_t	print_climat_sec4 (char **sec4, size_t lmax, struct climat_chunks *cl)
	Prints the climat section 4. More...
size_t	print_climat_wigos_id (char **wid, size_t lmax, struct climat_chunks *cl)
int	print_temp_report (struct metreport *m)
	print the four parts of a decoded TEMP report from a BUFR file into strings More...
int	print_temp_a (struct metreport *m)
	Prints the part A of a TEMP report into a string. More...
size_t	print_temp_a_sec1 (char **sec1, size_t lmax, struct temp_chunks *t)
	Prints the section 1 of part A of a TEMP report. More...
size_t	print_temp_a_sec2 (char **sec2, size_t lmax, struct temp_chunks *t)
	Prints the section 2 of part A of a TEMP report. More...
size_t	print_temp_a_sec3 (char **sec3, size_t lmax, struct temp_chunks *t)
	Prints the section 3 of part A of a TEMP report. More...
size_t	print_temp_a_sec4 (char **sec4, size_t lmax, struct temp_chunks *t)
	Prints the section 4 of part A of a TEMP report. More...
size_t	print_temp_a_sec7 (char **sec7, size_t lmax, struct temp_chunks *t)
	Prints the section 7 of part A of a TEMP report. More...
int	print_temp_b (struct metreport *m)
	Prints the part B of a TEMP report into a string. More...
size_t	print_temp_b_sec1 (char **sec1, size_t lmax, struct temp_chunks *t)
	Prints the section 1 of part B of a TEMP report. More...
size_t	print_temp_b_sec5 (char **sec5, size_t lmax, struct temp_chunks *t)
	Prints the section 5 of part B of a TEMP report. More...
size_t	print_temp_b_sec6 (char **sec6, size_t lmax, struct temp_chunks *t)
	Prints the section 6 of part B of a TEMP report. More...
size_t	print_temp_b_sec7 (char **sec7, size_t lmax, struct temp_chunks *t)
	Prints the section 7 of part B of a TEMP report. More...
size_t	print_temp_b_sec8 (char **sec8, size_t lmax, struct temp_chunks *t)
	Prints the section 8 of part B of a TEMP report. More...
int	print_temp_c (struct metreport *m)
	Prints the part C of a TEMP report into a string. More...
size_t	print_temp_c_sec1 (char **sec1, size_t lmax, struct temp_chunks *t)
	Prints the section 1 of part C of a TEMP report. More...
size_t	print_temp_c_sec2 (char **sec2, size_t lmax, struct temp_chunks *t)
	Prints the section 2 of part C of a TEMP report. More...
size_t	print_temp_c_sec3 (char **sec3, size_t lmax, struct temp_chunks *t)
	Prints the section 3 of part C of a TEMP report. More...
size_t	print_temp_c_sec4 (char **sec4, size_t lmax, struct temp_chunks *t)
	Prints the section 4 of part C of a TEMP report. More...
size_t	print_temp_c_sec7 (char **sec7, size_t lmax, struct temp_chunks *t)
	Prints the section 7 of part C of a TEMP report. More...
int	print_temp_d (struct metreport *m)
	Prints the part D of a TEMP report into a string. More...
size_t	print_temp_d_sec1 (char **sec1, size_t lmax, struct temp_chunks *t)
	Prints the section 1 of part D of a TEMP report. More...
size_t	print_temp_d_sec5 (char **sec5, size_t lmax, struct temp_chunks *t)
	Prints the section 5 of part D of a TEMP report. More...
size_t	print_temp_d_sec6 (char **sec6, size_t lmax, struct temp_chunks *t)
	Prints the section 6 of part D of a TEMP report. More...
size_t	print_temp_d_sec7 (char **sec7, size_t lmax, struct temp_chunks *t)
	Prints the section 7 of part D of a TEMP report. More...
size_t	print_temp_d_sec8 (char **sec8, size_t lmax, struct temp_chunks *t)
size_t	print_temp_wigos_id (char **wid, size_t lmax, struct temp_chunks *t)
int	parse_temp_raw_data (struct temp_chunks *t, struct temp_raw_data *r)
	parse a struct temp_raw_data to fill chunks in a struct temp_chunks More...
int	parse_temp_raw_wind_shear_data (struct temp_chunks *t, struct temp_raw_wind_shear_data *w)
int	print_temp_raw_data (struct temp_raw_data *r)
	Prints for debug a struct temp_raw_data. More...
int	print_temp_raw_wind_shear_data (struct temp_raw_wind_shear_data *w)
	Prints for debug a struct temp_raw_data. More...
int	print_csv (FILE *f, struct metreport *m)
	prints a struct metreport in labeled csv format More...
int	print_json (FILE *f, struct metreport *m)
	prints a struct metreport in json format More...
int	print_xml (FILE *f, struct metreport *m)
	prints a struct metreport in xml format More...
int	print_plain (FILE *f, struct metreport *m)
	Print in a file the report decoded to Traditional Alphanumeric Code in plain text format. A line per report. More...
int	print_html (FILE *f, struct metreport *m)
	Print in a file the report decoded to Traditional Alphanumeric Code in plain html format. A line per report. More...
int	syn_parse_x01 (struct synop_chunks *syn, struct bufr2tac_subset_state *s)
	Parse a expanded descriptor with X = 01. More...
int	syn_parse_x02 (struct synop_chunks *syn, struct bufr2tac_subset_state *s)
	Parse a expanded descriptor with X = 02. More...
int	syn_parse_x04 (struct synop_chunks *syn, struct bufr2tac_subset_state *s)
	Parse a expanded descriptor with X = 04. More...
int	syn_parse_x05 (struct synop_chunks *syn, struct bufr2tac_subset_state *s)
	Parse a expanded descriptor with X = 05. More...
int	syn_parse_x06 (struct synop_chunks *syn, struct bufr2tac_subset_state *s)
	Parse a expanded descriptor with X = 06. More...
int	syn_parse_x07 (struct synop_chunks *syn, struct bufr2tac_subset_state *s)
	Parse a expanded descriptor with X = 07. More...
int	syn_parse_x08 (struct synop_chunks *syn, struct bufr2tac_subset_state *s)
	Parse a expanded descriptor with X = 08. More...
int	syn_parse_x10 (struct synop_chunks *syn, struct bufr2tac_subset_state *s)
	Parse a expanded descriptor with X = 10. More...
int	syn_parse_x11 (struct synop_chunks *syn, struct bufr2tac_subset_state *s)
	Parse a expanded descriptor with X = 11. More...
int	syn_parse_x12 (struct synop_chunks *syn, struct bufr2tac_subset_state *s)
	Parse a expanded descriptor with X = 12. More...
int	syn_parse_x13 (struct synop_chunks *syn, struct bufr2tac_subset_state *s)
	Parse a expanded descriptor with X = 13. More...
int	syn_parse_x14 (struct synop_chunks *syn, struct bufr2tac_subset_state *s)
	Parse a expanded descriptor with X = 14. More...
int	syn_parse_x20 (struct synop_chunks *syn, struct bufr2tac_subset_state *s)
	Parse a expanded descriptor with X = 20. More...
int	syn_parse_x22 (struct synop_chunks *syn, struct bufr2tac_subset_state *s)
	Parse a expanded descriptor with X = 01. More...
int	syn_parse_x31 (struct synop_chunks *syn, struct bufr2tac_subset_state *s)
	Parse a expanded descriptor with X = 31. More...
int	buoy_parse_x01 (struct buoy_chunks *b, struct bufr2tac_subset_state *s)
	Parse a expanded descriptor with X = 01. More...
int	buoy_parse_x02 (struct buoy_chunks *b, struct bufr2tac_subset_state *s)
	Parse a expanded descriptor with X = 02. More...
int	buoy_parse_x04 (struct buoy_chunks *b, struct bufr2tac_subset_state *s)
	Parse a expanded descriptor with X = 04. More...
int	buoy_parse_x05 (struct buoy_chunks *b, struct bufr2tac_subset_state *s)
	Parse a expanded descriptor with X = 05. More...
int	buoy_parse_x06 (struct buoy_chunks *b, struct bufr2tac_subset_state *s)
	Parse a expanded descriptor with X = 06. More...
int	buoy_parse_x07 (struct buoy_chunks *b, struct bufr2tac_subset_state *s)
	Parse a expanded descriptor with X = 07. More...
int	buoy_parse_x08 (struct buoy_chunks *b, struct bufr2tac_subset_state *s)
	Parse a expanded descriptor with X = 08. More...
int	buoy_parse_x10 (struct buoy_chunks *b, struct bufr2tac_subset_state *s)
	Parse a expanded descriptor with X = 10. More...
int	buoy_parse_x11 (struct buoy_chunks *b, struct bufr2tac_subset_state *s)
	Parse a expanded descriptor with X = 11. More...
int	buoy_parse_x12 (struct buoy_chunks *b, struct bufr2tac_subset_state *s)
	Parse a expanded descriptor with X = 12. More...
int	buoy_parse_x13 (struct buoy_chunks *b, struct bufr2tac_subset_state *s)
	Parse a expanded descriptor with X = 13. More...
int	buoy_parse_x14 (struct buoy_chunks *b, struct bufr2tac_subset_state *s)
	Parse a expanded descriptor with X = 14. More...
int	buoy_parse_x20 (struct buoy_chunks *b, struct bufr2tac_subset_state *s)
	Parse a expanded descriptor with X = 20. More...
int	buoy_parse_x22 (struct buoy_chunks *b, struct bufr2tac_subset_state *s)
	Parse a expanded descriptor with X = 22. More...
int	buoy_parse_x31 (struct buoy_chunks *b, struct bufr2tac_subset_state *s)
	Parse a expanded descriptor with X = 31. More...
int	buoy_parse_x33 (struct buoy_chunks *b, struct bufr2tac_subset_state *s)
	Parse a expanded descriptor with X = 33. More...
int	climat_parse_x01 (struct climat_chunks *c, struct bufr2tac_subset_state *s)
	Parse a expanded descriptor with X = 01. More...
int	climat_parse_x02 (struct climat_chunks *c, struct bufr2tac_subset_state *s)
	Parse a expanded descriptor with X = 02. More...
int	climat_parse_x04 (struct climat_chunks *c, struct bufr2tac_subset_state *s)
	Parse a expanded descriptor with X = 04. More...
int	climat_parse_x05 (struct climat_chunks *c, struct bufr2tac_subset_state *s)
	Parse a expanded descriptor with X = 05. More...
int	climat_parse_x06 (struct climat_chunks *c, struct bufr2tac_subset_state *s)
	Parse a expanded descriptor with X = 06. More...
int	climat_parse_x07 (struct climat_chunks *c, struct bufr2tac_subset_state *s)
int	climat_parse_x08 (struct climat_chunks *c, struct bufr2tac_subset_state *s)
	Parse a expanded descriptor with X = 08. More...
int	climat_parse_x10 (struct climat_chunks *c, struct bufr2tac_subset_state *s)
	Parse a expanded descriptor with X = 10. More...
int	climat_parse_x11 (struct climat_chunks *c, struct bufr2tac_subset_state *s)
	Parse a expanded descriptor with X = 11. More...
int	climat_parse_x12 (struct climat_chunks *c, struct bufr2tac_subset_state *s)
	Parse a expanded descriptor with X = 12. More...
int	climat_parse_x13 (struct climat_chunks *c, struct bufr2tac_subset_state *s)
	Parse a expanded descriptor with X = 13. More...
int	climat_parse_x14 (struct climat_chunks *c, struct bufr2tac_subset_state *s)
	Parse a expanded descriptor with X = 14. More...
int	climat_parse_x20 (struct climat_chunks *c, struct bufr2tac_subset_state *s)
int	climat_parse_x22 (struct climat_chunks *c, struct bufr2tac_subset_state *s)
int	climat_parse_x31 (struct climat_chunks *c, struct bufr2tac_subset_state *s)
int	climat_parse_x33 (struct climat_chunks *c, struct bufr2tac_subset_state *s)
int	temp_parse_x01 (struct temp_chunks *t, struct bufr2tac_subset_state *s)
	Parse a expanded descriptor with X = 01. More...
int	temp_parse_x02 (struct temp_chunks *t, struct bufr2tac_subset_state *s)
	Parse a expanded descriptor with X = 02. More...
int	temp_parse_x04 (struct temp_chunks *t, struct bufr2tac_subset_state *s)
	Parse a expanded descriptor with X = 04. More...
int	temp_parse_x05 (struct temp_chunks *t, struct bufr2tac_subset_state *s)
int	temp_parse_x06 (struct temp_chunks *t, struct bufr2tac_subset_state *s)
int	temp_parse_x07 (struct temp_chunks *t, struct bufr2tac_subset_state *s)
int	temp_parse_x08 (struct temp_chunks *t, struct bufr2tac_subset_state *s)
	Parse a expanded descriptor with X = 08. More...
int	temp_parse_x10 (struct temp_chunks *t, struct bufr2tac_subset_state *s)
	Parse a expanded descriptor with X = 10. More...
int	temp_parse_x11 (struct temp_chunks *t, struct bufr2tac_subset_state *s)
	Parse a expanded descriptor with X = 11. More...
int	temp_parse_x12 (struct temp_chunks *t, struct bufr2tac_subset_state *s)
	Parse a expanded descriptor with X = 12. More...
int	temp_parse_x20 (struct temp_chunks *t, struct bufr2tac_subset_state *s)
	Parse a expanded descriptor with X = 20. More...
int	temp_parse_x22 (struct temp_chunks *t, struct bufr2tac_subset_state *s)
	Parse a expanded descriptor with X = 22. More...
int	temp_parse_x31 (struct temp_chunks *t, struct bufr2tac_subset_state *s)
	Parse a expanded descriptor with X = 31. More...
int	temp_parse_x33 (struct temp_chunks *t, struct bufr2tac_subset_state *s)
	Parse a expanded descriptor with X = 33. More...
int	bus012_ (int *, unsigned int *, int *, int *, int *, int *, int *)
int	buprs0_ (int *)
int	buprs1_ (int *)
int	buprs3_ (int *, int *, int *, int *, int *, int *, char **)
int	bufrex_ (int *, int *, int *, int *, int *, int *, int *, int *, int *, char **, char **, int *, double *, char **, int *)
int	busel_ (int *, int *, int *, int *, int *)
int	busel2_ (int *, int *, int *, char **, int *, char **, char **, char **, int *)
int	buukey_ (int *, int *, int *, int *, int *)
int	buprt_ (int *, int *, int *, int *, char **, char **, char **, int *, double *, int *, int *, int *)

Variables
int	BUFR2TAC_DEBUG_LEVEL

Detailed Description

Include header file for binary bufr2tac.

Definition in file bufr2tac.h.

Macro Definition Documentation

_GNU_SOURCE

#define _GNU_SOURCE

Definition at line 28 of file bufr2tac.h.

BUFR2TAC_ERROR_DESCRIPTION_LENGTH

#define BUFR2TAC_ERROR_DESCRIPTION_LENGTH   1024

set de dimension of member description of a struct bufr2tac_error

Definition at line 199 of file bufr2tac.h.

BUFR2TAC_ERROR_STACK_DIM

#define BUFR2TAC_ERROR_STACK_DIM   16

set de dimension of a struct bufr2tac_error_stack

Definition at line 194 of file bufr2tac.h.

bufr_subset_sequence_data

#define bufr_subset_sequence_data   bufrdeco_subset_sequence_data

To use bufrdeco library with legacy old code using ECMWF library which is not used currently.

Definition at line 220 of file bufr2tac.h.

PRINT_BITMASK_GEO

#define PRINT_BITMASK_GEO   (2)

Bit mask to member print_mask in struct metreport to print geographic position.

Definition at line 214 of file bufr2tac.h.

PRINT_BITMASK_WIGOS

#define PRINT_BITMASK_WIGOS   (1)

Bit mask to member print_mask in struct metreport to print WIGOS Identifier.

Definition at line 208 of file bufr2tac.h.

REPORT_LENGTH

#define REPORT_LENGTH   (16384)

Definition at line 202 of file bufr2tac.h.

SUBSET_MASK_HAVE_ALTITUDE

#define SUBSET_MASK_HAVE_ALTITUDE   (256)

Bit mask to mark a struct bufr_subset_sequence_data having altitude.

Definition at line 122 of file bufr2tac.h.

SUBSET_MASK_HAVE_COUNTRY

#define SUBSET_MASK_HAVE_COUNTRY   (1024)

Bit mask to mark a struct bufr_subset_sequence_data having country name.

Definition at line 134 of file bufr2tac.h.

SUBSET_MASK_HAVE_DAY

#define SUBSET_MASK_HAVE_DAY   (8192)

Bit mask to mark a struct bufr_subset_sequence_data having observation day in a month.

Definition at line 152 of file bufr2tac.h.

SUBSET_MASK_HAVE_GUST

#define SUBSET_MASK_HAVE_GUST   (131072)

Bit mask to mark a struct bufr_subset_sequence_data having wind gust observation other than 10 minutes.

Definition at line 176 of file bufr2tac.h.

SUBSET_MASK_HAVE_GUST10

#define SUBSET_MASK_HAVE_GUST10   ( 2 * 131072)

Bit mask to mark a struct bufr_subset_sequence_data having wind gust observation other than 10 minutes.

Definition at line 182 of file bufr2tac.h.

SUBSET_MASK_HAVE_HOUR

#define SUBSET_MASK_HAVE_HOUR   (16384)

Bit mask to mark a struct bufr_subset_sequence_data having observation hour.

Definition at line 158 of file bufr2tac.h.

SUBSET_MASK_HAVE_LATITUDE

#define SUBSET_MASK_HAVE_LATITUDE   (64)

Bit mask to mark a struct bufr_subset_sequence_data having latitude.

Definition at line 110 of file bufr2tac.h.

SUBSET_MASK_HAVE_LONGITUDE

#define SUBSET_MASK_HAVE_LONGITUDE   (128)

Bit mask to mark a struct bufr_subset_sequence_data having longitude.

Definition at line 116 of file bufr2tac.h.

SUBSET_MASK_HAVE_MINUTE

#define SUBSET_MASK_HAVE_MINUTE   (32768)

Bit mask to mark a struct bufr_subset_sequence_data having observation minute.

Definition at line 164 of file bufr2tac.h.

SUBSET_MASK_HAVE_MONTH

#define SUBSET_MASK_HAVE_MONTH   (4096)

Bit mask to mark a struct bufr_subset_sequence_data having observation month.

Definition at line 146 of file bufr2tac.h.

SUBSET_MASK_HAVE_NAME

#define SUBSET_MASK_HAVE_NAME   (512)

Bit mask to mark a struct bufr_subset_sequence_data having station name.

Definition at line 128 of file bufr2tac.h.

SUBSET_MASK_HAVE_NO_SIGNIFICANT_W1

#define SUBSET_MASK_HAVE_NO_SIGNIFICANT_W1   (16)

Bit mask to mark a struct bufr_subset_sequence_data without W1 information.

Definition at line 98 of file bufr2tac.h.

SUBSET_MASK_HAVE_NO_SIGNIFICANT_W2

#define SUBSET_MASK_HAVE_NO_SIGNIFICANT_W2   (32)

Bit mask to mark a struct bufr_subset_sequence_data without W1 information.

Definition at line 104 of file bufr2tac.h.

SUBSET_MASK_HAVE_NO_SIGNIFICANT_WW

#define SUBSET_MASK_HAVE_NO_SIGNIFICANT_WW   (8)

Bit mask to mark a struct bufr_subset_sequence_data without WW information.

Definition at line 92 of file bufr2tac.h.

SUBSET_MASK_HAVE_SECOND

#define SUBSET_MASK_HAVE_SECOND   (65536)

Bit mask to mark a struct bufr_subset_sequence_data having observation second.

Definition at line 170 of file bufr2tac.h.

SUBSET_MASK_HAVE_TYPE_STATION

#define SUBSET_MASK_HAVE_TYPE_STATION   (4)

Bit mask to mark a struct bufr_subset_sequence_data having type station information.

Definition at line 86 of file bufr2tac.h.

SUBSET_MASK_HAVE_WIGOS_ID

#define SUBSET_MASK_HAVE_WIGOS_ID   ( 4 * 131072)

Bit mask to mark if a subset has a WIGOS ID.

Definition at line 188 of file bufr2tac.h.

SUBSET_MASK_HAVE_YEAR

#define SUBSET_MASK_HAVE_YEAR   (2048)

Bit mask to mark a struct bufr_subset_sequence_data having observation year.

Definition at line 140 of file bufr2tac.h.

SUBSET_MASK_LATITUDE_SOUTH

#define SUBSET_MASK_LATITUDE_SOUTH   (1)

Bit mask to mark a struct bufr_subset_sequence_data with south latitude.

Definition at line 74 of file bufr2tac.h.

SUBSET_MASK_LONGITUDE_WEST

#define SUBSET_MASK_LONGITUDE_WEST   (2)

Bit mask to mark a struct bufr_subset_sequence_data with west longitude.

Definition at line 80 of file bufr2tac.h.

Function Documentation

adjust_string()

char * adjust_string

(

char *

s

)

Supress trailing blanks of a string.

Parameters

s	string to process

Definition at line 99 of file bufr2tac_utils.c.

{
  size_t l;
  l = strlen ( s );
  while ( l && s[--l] == ' ' )
    s[l] = '\0';
  return s;
}

Referenced by buoy_parse_x01(), climat_parse_x01(), syn_parse_x01(), and temp_parse_x01().

Here is the caller graph for this function:

bufr2tac_clean_buoy_chunks()

void bufr2tac_clean_buoy_chunks

(

struct buoy_chunks *

b

)

cleans a buoy_chunks struct

Parameters

b	pointer to the struct to clean

Definition at line 178 of file bufr2tac_mrproper.c.

{
  b->mask = 0;
  clean_report_date_ext ( & ( b->e ) );
  clean_wigos_id ( & ( b->wid ) );
  clean_buoy_sec0 ( & ( b->s0 ) );
  clean_buoy_sec1 ( & ( b->s1 ) );
  clean_buoy_sec2 ( & ( b->s2 ) );
  clean_buoy_sec3 ( & ( b->s3 ) );
  clean_buoy_sec4 ( & ( b->s4 ) );
 
  b->error[0] = '\0';
}

References clean_buoy_sec0(), clean_buoy_sec1(), clean_buoy_sec2(), clean_buoy_sec3(), clean_buoy_sec4(), clean_report_date_ext(), clean_wigos_id(), buoy_chunks::e, buoy_chunks::error, buoy_chunks::mask, buoy_chunks::s0, buoy_chunks::s1, buoy_chunks::s2, buoy_chunks::s3, buoy_chunks::s4, and buoy_chunks::wid.

Referenced by parse_subset_as_buoy().

Here is the call graph for this function:

Here is the caller graph for this function:

bufr2tac_clean_climat_chunks()

void bufr2tac_clean_climat_chunks

(

struct climat_chunks *

c

)

cleans a climat_chunks struct

Parameters

c	pointer to the struct to clean

Definition at line 262 of file bufr2tac_mrproper.c.

{
  c->mask = 0;
  clean_report_date_ext ( & ( c->e ) );
  clean_wigos_id ( & ( c->wid ) );
  clean_climat_sec0 ( & ( c->s0 ) );
  clean_climat_sec1 ( & ( c->s1 ) );
  clean_climat_sec2 ( & ( c->s2 ) );
  clean_climat_sec3 ( & ( c->s3 ) );
  clean_climat_sec4 ( & ( c->s4 ) );
  clean_climat_old ( & ( c->o ) );
  c->error[0] = '\0';
}

References clean_climat_old(), clean_climat_sec0(), clean_climat_sec1(), clean_climat_sec2(), clean_climat_sec3(), clean_climat_sec4(), clean_report_date_ext(), clean_wigos_id(), climat_chunks::e, climat_chunks::error, climat_chunks::mask, climat_chunks::o, climat_chunks::s0, climat_chunks::s1, climat_chunks::s2, climat_chunks::s3, climat_chunks::s4, and climat_chunks::wid.

Referenced by parse_subset_as_climat().

Here is the call graph for this function:

Here is the caller graph for this function:

bufr2tac_clean_error_stack()

int bufr2tac_clean_error_stack

(

struct bufr2tac_error_stack *

e

)

Definition at line 49 of file bufr2tac_error.c.

{
  if ( e != NULL )
    {
      memset ( e, 0, sizeof ( struct bufr2tac_error_stack ) );
      return 0;
    }
  return -1;
}

bufr2tac_clean_metreport()

void bufr2tac_clean_metreport

(

struct metreport *

m

)

Definition at line 276 of file bufr2tac_mrproper.c.

{
  if (m != NULL)
    memset(m, 0, sizeof (struct metreport));
}

Referenced by bufrtotac_parse_subset_sequence().

Here is the caller graph for this function:

bufr2tac_clean_synop_chunks()

void bufr2tac_clean_synop_chunks

(

struct synop_chunks *

s

)

Definition at line 104 of file bufr2tac_mrproper.c.

{
  syn->mask = 0;
  clean_report_date_ext ( & ( syn->e ) );
  clean_wigos_id ( & ( syn->wid ) );
  clean_syn_sec0 ( & ( syn->s0 ) );
  clean_syn_sec1 ( & ( syn->s1 ) );
  clean_syn_sec2 ( & ( syn->s2 ) );
  clean_syn_sec3 ( & ( syn->s3 ) );
  clean_syn_sec5 ( & ( syn->s5 ) );
 
  // default
  strcpy ( syn->s0.iw,"/" );
  strcpy ( syn->s1.ir,"/" );
  strcpy ( syn->s1.ix,"/" );
  strcpy ( syn->s1.h,"/" );
  strcpy ( syn->s1.VV,"//" );
  strcpy ( syn->s1.N,"/" );
  strcpy ( syn->s1.dd,"//" );
  strcpy ( syn->s1.ff,"//" );
 
  syn->error[0] = '\0';
}

References clean_report_date_ext(), clean_syn_sec0(), clean_syn_sec1(), clean_syn_sec2(), clean_syn_sec3(), clean_syn_sec5(), clean_wigos_id(), synop_sec1::dd, synop_chunks::e, synop_chunks::error, synop_sec1::ff, synop_sec1::h, synop_sec1::ir, synop_sec0::iw, synop_sec1::ix, synop_chunks::mask, synop_sec1::N, synop_chunks::s0, synop_chunks::s1, synop_chunks::s2, synop_chunks::s3, synop_chunks::s5, synop_sec1::VV, and synop_chunks::wid.

Referenced by parse_subset_as_synop().

Here is the call graph for this function:

Here is the caller graph for this function:

bufr2tac_clean_temp_chunks()

void bufr2tac_clean_temp_chunks

(

struct temp_chunks *

t

)

cleans a buoy_chunks struct

Parameters

t	pointer to the struct to clean

Definition at line 197 of file bufr2tac_mrproper.c.

{
  memset ( t, 0, sizeof ( struct temp_chunks ) );
}

Referenced by parse_subset_as_temp().

Here is the caller graph for this function:

bufr2tac_get_version()

char * bufr2tac_get_version	(	char *	version,
		size_t	dversion,
		char *	build,
		size_t	dbuild,
		char *	builder,
		size_t	dbuilder,
		int *	version_major,
		int *	version_minor,
		int *	version_patch
	)

Definition at line 48 of file bufr2tac.c.

{
  int major = 0, minor = 0, patch = 0;
  size_t used;
 
  if (version == NULL)
    return NULL;
  snprintf(version, dversion, "%s", VERSION);
  // default  
  sscanf(version, "%d.%d.%d", &major, &minor, &patch);
 
  if (build)
    {
       used = 0;
#if defined(__INTEL_COMPILER)
       used += snprintf(build + used, dbuild - used, "using INTEL C compiler icc %d.%d ", __INTEL_COMPILER, __INTEL_COMPILER_UPDATE);
#elif defined(__clang_version__) 
       used += snprintf(build + used, dbuild - used, "using clang C compiler ", __clang_version__);
#elif defined(__GNUC__) 
       used += snprintf(build + used, dbuild - used, "using GNU C compiler gcc %d.%d.%d ", __GNUC__ , __GNUC_MINOR__ , __GNUC_PATCHLEVEL__);
#elif defined(_MSC_VER) 
       used += snprintf(build + used, dbuild - used, "using MICROSOFT C compiler %d ", _MSC_VER);
#else
       used += snprintf(build + used, dbuild - used, "using an unknown C compiler ");
#endif
       snprintf(build + used, dbuild - used,"at %s %s",__DATE__,__TIME__);
    }
    
  if (builder)
#ifdef BUILD_USING_CMAKE
    strncpy(builder, "cmake", dbuilder);
#else
    strncpy(builder, "autotools", dbuilder);
#endif    
  if (version_major)
    *version_major = major;
  if (version_minor)
    *version_minor = minor;
  if (version_patch)
    *version_patch = patch;
  return version;  
}

References VERSION.

Referenced by bufrtotac_print_version().

Here is the caller graph for this function:

bufr2tac_print_error()

int bufr2tac_print_error

(

struct bufr2tac_error_stack *

e

)

Definition at line 87 of file bufr2tac_error.c.

{
  unsigned int i;
  if ( e->ne == 0 )
    {
      printf ( "# No info/warning/error \n" );
      return 0;
    }
 
  for ( i = 0; i < e->ne ; i++ )
    {
      if ( e->err[i].severity == 0 )
        printf ( "# INFO: " );
      else if ( e->err[i].severity == 1 )
        printf ( "# WARNING: " );
      else if ( e->err[i].severity == 2 )
        printf ( "# ERROR: " );
      else
        {
          printf ( "# %d\n", e->err[i].severity );
          return 1;
        }
      printf ( "%s\n", e->err[i].description );
    }
  if ( e->full > 0 )
    printf ( "# More debug info follows, stack of logs full\n" );
  return 0;
}

References bufr2tac_error::description, bufr2tac_error_stack::err, bufr2tac_error_stack::full, bufr2tac_error_stack::ne, and bufr2tac_error::severity.

Referenced by parse_subset_sequence().

Here is the caller graph for this function:

bufr2tac_push_error()

int bufr2tac_push_error	(	struct bufr2tac_error_stack *	e,
		int	severity,
		char *	description
	)

Definition at line 26 of file bufr2tac_error.c.

{
  // avoid segfaults
  if ( e == NULL )
    return -1; // Fatal error
 
  if ( e->ne < BUFR2TAC_ERROR_STACK_DIM )
    {
      e->err[e->ne].severity = severity;
      strcpy ( e->err[e->ne].description, description );
      ( e->ne )++;
      return 1;
    }
  else if ( e->ne == BUFR2TAC_ERROR_STACK_DIM )
    {
      // Do not pull error, but annotate the stack as rebased
      if ( e->full < severity )
        e->full = severity;
      return 0;
    }
  return -1; // bad e->ne
}

References BUFR2TAC_ERROR_STACK_DIM, bufr2tac_error::description, bufr2tac_error_stack::err, bufr2tac_error_stack::full, bufr2tac_error_stack::ne, and bufr2tac_error::severity.

Referenced by bufr2tac_set_error().

Here is the caller graph for this function:

bufr2tac_set_debug_level()

int bufr2tac_set_debug_level

(

int

level

)

Definition at line 93 of file bufr2tac.c.

{
  if (level < 0 || level > 2)
    return 1; // Bad debug level
  
  // Here we set 
  BUFR2TAC_DEBUG_LEVEL = level;
  return 0;  
}

References BUFR2TAC_DEBUG_LEVEL.

Referenced by bufrtotac_read_args().

Here is the caller graph for this function:

bufr2tac_set_error()

int bufr2tac_set_error	(	struct bufr2tac_subset_state *	s,
		int	severity,
		char *	origin,
		char *	explanation
	)

Definition at line 59 of file bufr2tac_error.c.

{
  char description[BUFR2TAC_ERROR_DESCRIPTION_LENGTH], *c;
 
  c = description;
  c += sprintf ( c, "%s: ", origin );
  c += sprintf ( c, " Descriptor: %u %02u %03u: \"%s\"",s->a->desc.f, s->a->desc.x, s->a->desc.y, s->a->name );
 
  if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
    {
      c+= sprintf ( c, " = MISSING. " );
    }
  else
    {
      if ( s->a->cval[0] )
        c += sprintf ( c, " = '%s'. ", s->a->cval );
      else if ( s->a->desc.x == 2 )
        c += sprintf ( c, " = '%s'. ", s->a->ctable );
      else
        c += sprintf ( c, " = %lf . ", s->a->val );
    }
 
  c += sprintf ( c, "%s", explanation );
 
 
  return bufr2tac_push_error ( &s->e, severity, description );
}

References bufr2tac_subset_state::a, BUFR2TAC_ERROR_DESCRIPTION_LENGTH, bufr2tac_push_error(), bufr_atom_data::ctable, bufr_atom_data::cval, bufr_atom_data::desc, DESCRIPTOR_VALUE_MISSING, bufr2tac_subset_state::e, bufr_descriptor::f, bufr_atom_data::mask, bufr_atom_data::name, bufr_atom_data::val, bufr_descriptor::x, and bufr_descriptor::y.

Referenced by buoy_parse_x01(), buoy_parse_x02(), buoy_parse_x04(), buoy_parse_x05(), buoy_parse_x06(), buoy_parse_x07(), buoy_parse_x08(), buoy_parse_x10(), buoy_parse_x11(), buoy_parse_x12(), buoy_parse_x13(), buoy_parse_x14(), buoy_parse_x20(), buoy_parse_x22(), buoy_parse_x31(), buoy_parse_x33(), climat_parse_x01(), climat_parse_x02(), climat_parse_x04(), climat_parse_x05(), climat_parse_x06(), climat_parse_x07(), climat_parse_x08(), climat_parse_x10(), climat_parse_x11(), climat_parse_x12(), climat_parse_x13(), climat_parse_x14(), syn_parse_x01(), syn_parse_x02(), syn_parse_x04(), syn_parse_x05(), syn_parse_x06(), syn_parse_x07(), syn_parse_x08(), syn_parse_x10(), syn_parse_x11(), syn_parse_x12(), syn_parse_x13(), syn_parse_x14(), syn_parse_x20(), syn_parse_x22(), syn_parse_x31(), temp_parse_x01(), temp_parse_x02(), temp_parse_x04(), temp_parse_x05(), temp_parse_x06(), temp_parse_x07(), temp_parse_x08(), temp_parse_x10(), temp_parse_x11(), temp_parse_x12(), temp_parse_x20(), temp_parse_x22(), temp_parse_x31(), and temp_parse_x33().

Here is the call graph for this function:

Here is the caller graph for this function:

bufr_set_environment()

int bufr_set_environment	(	char *	default_bufrtables,
		char *	bufrtables_dir
	)

set the environment vars needed to work properly with ECMWF bufrdc library

Parameters

default_bufrtables	defaut bufr tables dir. ususally '/usr/local/lib/bufrtables/'
bufrtables_dir	alternative char with bufr tables dir

During decoding Bufr table path and the names are printed. If user doeas not want that, set: VARIABLE PRINT_TABLE_NAMES=false

During decoding code/flag tables could be read if code figure meaning is needed. If user want to use code and flag tables set: VARIABLE USE TABLE C=true

Then we set the proper environment here

Definition at line 41 of file bufr2tac_env.c.

{
  int i;
  char aux[256], *c;
  struct stat s;
 
  i = stat ( default_bufrtables, &s );
 
  if ( putenv ( "PRINT_TABLE_NAMES=false" ) || putenv ( "USE_TABLE_C=true" ) )
    {
      fprintf ( stderr, "bufr2tac: Failure setting the environment\n" );
      exit ( EXIT_FAILURE );
    }
 
  /*
    Default path for Bufr Tables is hard coded in the software. To change the path set environmental variable
    BUFR_TABLES . The path must end with '/'
  */
  if ( bufrtables_dir[0] )
    {
      sprintf ( aux,"BUFR_TABLES=%s", bufrtables_dir );
      if ( putenv ( aux ) )
        {
          fprintf ( stderr, "bufr2tac: Failure setting the environment\n" );
          exit ( EXIT_FAILURE );
        }
    }
  else if ( ( c = getenv ( "BUFR_TABLES" ) ) != NULL )
    {
      strcpy ( bufrtables_dir, c ); // otherwise check if BUFRRABLES_DIR if is on environment
    }
  else if ( i == 0 && S_ISDIR ( s.st_mode ) ) // last chance, the default dir
    {
      strcpy ( bufrtables_dir, default_bufrtables );
      sprintf ( aux,"BUFR_TABLES=%s", bufrtables_dir );
      if ( putenv ( aux ) )
        {
          fprintf ( stderr, "bufr2tac: Failure setting the environment\n" );
          exit ( EXIT_FAILURE );
        }
    }
  else
    {
      fprintf ( stderr,"bufr2tac: Unable to find bufrtables directory\n" );
      fprintf ( stderr,"    Please set the proper enviromnet 'BUFR_TABLES=my_bufrtables_dir' or\n" );
      fprintf ( stderr,"    use '-t' argument . i. e.'-t my_bufrtables_dir/'\n" );
      exit ( EXIT_FAILURE );
    }
  return 0;
}

bufrex_()

int bufrex_	(	int *	,
		int *	,
		int *	,
		int *	,
		int *	,
		int *	,
		int *	,
		int *	,
		int *	,
		char **	,
		char **	,
		int *	,
		double *	,
		char **	,
		int *
	)

buoy_parse_x01()

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

Parse a expanded descriptor with X = 01.

Parameters

b	pointer to a struct synop_chunks where to set the results
s	pointer 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 205 of file bufr2tac_x01.c.

{
  char aux[80];
 
  if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
    return 0;
 
  switch ( s->a->desc.y )
    {
    case 3: // 0 01 003
      if ( s->ival > 0 )
        sprintf ( b->s0.A1, "%d", s->ival % 10 );
      else if ( s->ival == 0 )
        sprintf ( b->s0.A1, "7" );
      break;
 
    case 4: // 0 01 004
    case 20: // 0 01 004
      sprintf ( b->s0.bw, "%d", s->ival );
      break;
 
    case 5: // 0 01 005
      if ( s->ival < 1000 )
        sprintf ( b->s0.nbnbnb, "%03d", s->ival % 1000 );
      else
        sprintf ( b->s0.nbnbnb, "%05d", s->ival % 100000 ); // note this is a nnnnn extension
      break;
 
    case 15: // 0 01 015. Station or site name
      if ( strlen ( s->a->cval ) <= 80 )
        {
          strcpy ( aux, s->a->cval );
          adjust_string ( aux );
          strcpy ( s->name, aux );
          s->mask |= SUBSET_MASK_HAVE_NAME;
        }
      else if ( BUFR2TAC_DEBUG_LEVEL > 0 )
        {
          bufr2tac_set_error ( s, 1, "buoy_parse_x01()", "Station or site name length > 80. Cannot set s->name" );
        }
      break;
 
    case 87: // 0 01 087. WMO marine observing platform extended identifier
      // See https://community.wmo.int/rules-allocating-wmo-numbers
      // A1bwnnn is equivalent to A1Bwnnnnn when nnnnn < 1000
      if ( s->a->val < 100000000 )
        {
          sprintf ( aux, "%07.0lf", s->a->val );
          b->s0.A1[0] = aux[0];
          b->s0.A1[1] = 0;
          b->s0.bw[0] = aux[1];
          b->s0.bw[1] = 0;
          if ( ( ( int ) ( s->a->val ) % 100000 ) < 1000 )
            strcpy ( b->s0.nbnbnb, & aux[4] );
          else
            strcpy ( b->s0.nbnbnb, & aux[2] );
        }
      else if ( BUFR2TAC_DEBUG_LEVEL > 0 )
        {
          bufr2tac_set_error ( s, 1, "buoy_parse_x01()",
                               "WMO marine observing platform extended identifier >= 100000000. Cannot set s0.A1, s0.bw, s0.nbnbnb" );
        }
      break;
 
    case 101: // 0 01 101 . State identifier
      if ( strlen ( s->a->ctable ) <= 256 )
        {
          strcpy ( aux, s->a->ctable );
          adjust_string ( aux );
          strcpy ( s->country, aux );
          s->mask |= SUBSET_MASK_HAVE_COUNTRY;
        }
      else if ( BUFR2TAC_DEBUG_LEVEL > 0 )
        {
          bufr2tac_set_error ( s, 1, "buoy_parse_x01()", "State identifier length > 256. Cannot set s->country" );
        }
      break;
 
    case 125: // 0 01 125 . WIGOS identifier series
      b->wid.series = ( uint8_t ) s->ival;
      break;
 
    case 126: // 0 01 126 . WIGOS issuer of identifier
      b->wid.issuer = ( uint16_t ) s->ival;
      break;
 
    case 127: // 0 01 127 , WIGOS issue number
      b->wid.issue = ( uint16_t ) s->ival;
      break;
 
    case 128: // 0 01 128 . WIGOS local identifier (character)
      if ( strlen ( s->a->cval ) <= 16 )
        {
          adjust_string ( s->a->cval );
          if ( check_wigos_local_id ( s->a->cval ) )
            {
              bufr2tac_set_error ( s, 1, "buoy_parse_x01()","Bad WIGOS Local identifier" );
            }
          strcpy ( b->wid.local_id, s->a->cval );
          s->mask |= SUBSET_MASK_HAVE_WIGOS_ID ;
        }
      break;
 
    default:
      if ( BUFR2TAC_DEBUG_LEVEL > 1 && ( s->a->mask & DESCRIPTOR_VALUE_MISSING ) == 0 )
        bufr2tac_set_error ( s, 0, "buoy_parse_x01()", "Descriptor not parsed" );
      break;
    }
  return 0;
}

References bufr2tac_subset_state::a, buoy_sec0::A1, adjust_string(), BUFR2TAC_DEBUG_LEVEL, bufr2tac_set_error(), buoy_sec0::bw, check_wigos_local_id(), bufr2tac_subset_state::country, bufr_atom_data::ctable, bufr_atom_data::cval, bufr_atom_data::desc, DESCRIPTOR_VALUE_MISSING, wigos_id::issue, wigos_id::issuer, bufr2tac_subset_state::ival, wigos_id::local_id, bufr_atom_data::mask, bufr2tac_subset_state::mask, bufr2tac_subset_state::name, buoy_sec0::nbnbnb, buoy_chunks::s0, wigos_id::series, SUBSET_MASK_HAVE_COUNTRY, SUBSET_MASK_HAVE_NAME, SUBSET_MASK_HAVE_WIGOS_ID, bufr_atom_data::val, buoy_chunks::wid, 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:

buoy_parse_x02()

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

Parse a expanded descriptor with X = 02.

Parameters

b	pointer to a struct buoy_chunks where to set the results
s	pointer 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 83 of file bufr2tac_x02.c.

{
  char caux[16];
  if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
    return 0;
 
  switch ( s->a->desc.y )
    {
    case 1: // 0 02 001 . Type of station
      s->type = s->ival;
      s->mask |= SUBSET_MASK_HAVE_TYPE_STATION;
      break;
      
    case 2: // 0 02 002 . Type of instrumentation for wind measurement
      if ( s->ival & 4 )
        strcpy ( b->s0.iw, "4" );
      else
        strcpy ( b->s0.iw, "1" );
      break;
      
    case 31: // 0 02 031 . Duration and time of current measurement
      if ( b->s3.k3[0] == 0 && s->ival < 10 )
        {
          sprintf ( caux, "%d", s->ival );
          b->s3.k3[0] = caux[0];
          b->s3.k3[1] = 0;
        }
      b->mask |= BUOY_SEC3;
      break;
      
    case 33: // 0 02 033 . Method of salinity depth measure
      sprintf ( caux, "%d", s->ival );
      b->s3.k2[0] = caux[0];
      b->s3.k2[1] = 0;
      b->mask |= BUOY_SEC3;
      break;
      
    case 40: // 0 02 040 .Method of removing velocity and motion of platform from current
      if ( b->s3.k6[0] == 0 )
        {
          sprintf ( caux, "%d", s->ival );
          b->s3.k6[0] = caux[0];
          b->s3.k6[1] = 0;
        }
      b->mask |= BUOY_SEC3;
      break;
 
    default:
      if ( BUFR2TAC_DEBUG_LEVEL > 0 )
        bufr2tac_set_error ( s, 0, "buoy_parse_x02()", "Descriptor not parsed" );
      break;
    }
  return 0;
}

References bufr2tac_subset_state::a, BUFR2TAC_DEBUG_LEVEL, bufr2tac_set_error(), BUOY_SEC3, bufr_atom_data::desc, DESCRIPTOR_VALUE_MISSING, bufr2tac_subset_state::ival, buoy_sec0::iw, buoy_sec3::k2, buoy_sec3::k3, buoy_sec3::k6, bufr_atom_data::mask, bufr2tac_subset_state::mask, buoy_chunks::mask, buoy_chunks::s0, buoy_chunks::s3, SUBSET_MASK_HAVE_TYPE_STATION, bufr2tac_subset_state::type, 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:

buoy_parse_x04()

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

Parse a expanded descriptor with X = 04.

Parameters

b	pointer to a struct buoy_chunks where to set the results
s	pointer 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 254 of file bufr2tac_x04.c.

{
 
  switch ( s->a->desc.y )
    {
    case 1: // 0 04 001 . Year
      if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
        {
          return 0;
        }
      else if ( s->ival < 2000 || s->ival > 2050 )
        {
          if ( BUFR2TAC_DEBUG_LEVEL > 0 )
            bufr2tac_set_error ( s, 2, "buoy_parse_x04()", "Bad year" );
          return 1;
        }
 
      if ( b->e.YYYY[0] == 0 )
        {
          sprintf ( b->e.YYYY, "%04d", s->ival );
        }
      s->mask |= SUBSET_MASK_HAVE_YEAR;
      break;
 
    case 2: // 0 04 002 . Month
      if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
        {
          return 0;
        }
      if ( b->e.MM[0] == 0 )
        {
          sprintf ( b->e.MM, "%02d", s->ival );
        }
      s->mask |= SUBSET_MASK_HAVE_MONTH;
      break;
 
    case 3: // 0 04 003 . Day of month
      if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
        {
          return 0;
        }
      if ( b->e.DD[0] == 0 )
        {
          sprintf ( b->e.DD, "%02d", s->ival );
        }
      s->mask |= SUBSET_MASK_HAVE_DAY;
      //sprintf(b->s0.YY, "%02d", (int) sq->sequence[is].val);
      break;
 
    case 4: // 0 04 004 . Hour
      if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
        {
          return 0;
        }
      if ( b->e.HH[0] == 0 )
        {
          sprintf ( b->e.HH, "%02d", s->ival );
        }
      s->mask |= SUBSET_MASK_HAVE_HOUR;
      //sprintf(b->s0.GG, "%02d", (int) sq->sequence[is].val);
      break;
 
    case 5: // 0 04 005 . Minute
      if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
        {
          return 0;
        }
      if ( b->e.mm[0] == 0 )
        {
          sprintf ( b->e.mm, "%02d", s->ival );
        }
      s->mask |= SUBSET_MASK_HAVE_MINUTE;
      break;
 
    // store latest displacement in seconds
    case 23: // 0 04 023 . Time period of displacement (days)
      if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
        {
          s->k_jtval = s->k_itval;
          s->jtval = s->itval;
          s->k_itval = s->i;
          s->itval = 0;
          return 0;
        }
      s->k_jtval = s->k_itval;
      s->jtval = s->itval;
      s->k_itval = s->i;
      s->itval = s->ival * 86400;
      break;
 
    case 24: // 0 04 024 . Time period of displacement (hours)
      if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
        {
          s->k_jtval = s->k_itval;
          s->jtval = s->itval;
          s->k_itval = s->i;
          s->itval = 0;
          return 0;
        }
      s->k_jtval = s->k_itval;
      s->jtval = s->itval;
      s->k_itval = s->i;
      s->itval = s->ival * 3600;
      break;
 
    case 25: // 0 04 025 . Time period of displacement (minutes)
      if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
        {
          s->k_jtval = s->k_itval;
          s->jtval = s->itval;
          s->k_itval = s->i;
          s->itval = 0;
          return 0;
        }
      s->k_jtval = s->k_itval;
      s->jtval = s->itval;
      s->k_itval = s->i;
      s->itval = s->ival * 60;
      break;
 
    case 26: // 0 04 026 .  Time period of displacement (seconds)
      if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
        {
          s->k_jtval = s->k_itval;
          s->jtval = s->itval;
          s->k_itval = s->i;
          s->itval = 0;
          return 0;
        }
      s->k_jtval = s->k_itval;
      s->jtval = s->itval;
      s->k_itval = s->i;
      s->itval = s->ival;
      break;
 
    default:
      if ( BUFR2TAC_DEBUG_LEVEL > 1 && ( s->a->mask & DESCRIPTOR_VALUE_MISSING ) == 0 )
        bufr2tac_set_error ( s, 0, "buoy_parse_x04()", "Descriptor not parsed" );
      break;
    }
  return 0;
}

References bufr2tac_subset_state::a, BUFR2TAC_DEBUG_LEVEL, bufr2tac_set_error(), report_date_ext::DD, bufr_atom_data::desc, DESCRIPTOR_VALUE_MISSING, buoy_chunks::e, report_date_ext::HH, bufr2tac_subset_state::i, bufr2tac_subset_state::itval, bufr2tac_subset_state::ival, bufr2tac_subset_state::jtval, bufr2tac_subset_state::k_itval, bufr2tac_subset_state::k_jtval, bufr_atom_data::mask, bufr2tac_subset_state::mask, report_date_ext::MM, report_date_ext::mm, SUBSET_MASK_HAVE_DAY, SUBSET_MASK_HAVE_HOUR, SUBSET_MASK_HAVE_MINUTE, SUBSET_MASK_HAVE_MONTH, SUBSET_MASK_HAVE_YEAR, bufr_descriptor::y, and report_date_ext::YYYY.

Referenced by parse_subset_as_buoy().

Here is the call graph for this function:

Here is the caller graph for this function:

buoy_parse_x05()

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

Parse a expanded descriptor with X = 05.

Parameters

b	pointer to a struct buoy_chunks where to set the results
s	pointer 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 134 of file bufr2tac_x05.c.

{
  int ia;
 
  if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
    return 0;
 
  switch ( s->a->desc.y )
    {
    case 1: // 0 05 001 . Latitude (High accuracy)
    case 2: // 0 05 002 . Latitude (Coarse accuracy)
      if ( s->val < 0.0 )
        s->mask |= SUBSET_MASK_LATITUDE_SOUTH; // Sign for latitude
      s->mask |= SUBSET_MASK_HAVE_LATITUDE;
      ia = ( int ) ( fabs ( s->val ) * 1000.0 + 0.5 );
      sprintf ( b->s0.LaLaLaLaLa, "%05d",ia );
      s->lat = s->val;
      break;
 
    default:
      if ( BUFR2TAC_DEBUG_LEVEL > 1 && (s->a->mask & DESCRIPTOR_VALUE_MISSING) == 0 ) 
        bufr2tac_set_error ( s, 0, "buoy_parse_x05()", "Descriptor not parsed" );
      break;
    }
 
  return 0;
}

References bufr2tac_subset_state::a, BUFR2TAC_DEBUG_LEVEL, bufr2tac_set_error(), bufr_atom_data::desc, DESCRIPTOR_VALUE_MISSING, buoy_sec0::LaLaLaLaLa, bufr2tac_subset_state::lat, bufr_atom_data::mask, bufr2tac_subset_state::mask, buoy_chunks::s0, SUBSET_MASK_HAVE_LATITUDE, SUBSET_MASK_LATITUDE_SOUTH, 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:

buoy_parse_x06()

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

Parse a expanded descriptor with X = 06.

Parameters

b	pointer to a struct buoy_chunks where to set the results
s	pointer 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 129 of file bufr2tac_x06.c.

{
  int ia;
 
  if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
    return 0;
 
  switch ( s->a->desc.y )
    {
    case 1: // 0 06 001 . Longitude (High accuracy)
    case 2: // 0 06 002 . Longitude (Coarse accuracy)
      if ( s->val < 0.0 )
        s->mask |= SUBSET_MASK_LONGITUDE_WEST; // Sign for longitude
      s->mask |= SUBSET_MASK_HAVE_LONGITUDE;
      s->lon = s->val;
      ia = ( int ) ( fabs ( s->val ) * 1000.0 + 0.5 );
      sprintf ( b->s0.LoLoLoLoLoLo, "%06d",ia );
      break;
 
    default:
      if ( BUFR2TAC_DEBUG_LEVEL > 1 && (s->a->mask & DESCRIPTOR_VALUE_MISSING) == 0 ) 
        bufr2tac_set_error ( s, 0, "buoy_parse_x06()", "Descriptor not parsed" );
      break;
    }
  return 0;
}

References bufr2tac_subset_state::a, BUFR2TAC_DEBUG_LEVEL, bufr2tac_set_error(), bufr_atom_data::desc, DESCRIPTOR_VALUE_MISSING, buoy_sec0::LoLoLoLoLoLo, bufr2tac_subset_state::lon, bufr_atom_data::mask, bufr2tac_subset_state::mask, buoy_chunks::s0, SUBSET_MASK_HAVE_LONGITUDE, SUBSET_MASK_LONGITUDE_WEST, 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:

buoy_parse_x07()

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

Parse a expanded descriptor with X = 07.

Parameters

b	pointer to a struct buoy_chunks where to set the results
s	pointer 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 164 of file bufr2tac_x07.c.

{
 
  if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
    {
      return 0;
    }
 
  if ( b == NULL )
    {
      return 1;
    }
 
  switch ( s->a->desc.y )
    {
    case 62: // 0 07 062 Depth below sea/water surface
    case 63: // 0 07 063 Profundity below sea/water level
      if ( s->k_rep == ( s->i - 1 ) ) // Case of first layer after a replicator
        {
          s->layer = 0;
        }
      else
        {
          ( s->layer ) ++;
        }
      s->deep = ( int ) ( s->val + 0.5 );
      break;
 
    default:
      if ( BUFR2TAC_DEBUG_LEVEL > 1 && (s->a->mask & DESCRIPTOR_VALUE_MISSING) == 0 ) 
        bufr2tac_set_error ( s, 0, "buoy_parse_x07()", "Descriptor not parsed" );
      break;
    }
  return 0;
}

References bufr2tac_subset_state::a, BUFR2TAC_DEBUG_LEVEL, bufr2tac_set_error(), bufr2tac_subset_state::deep, bufr_atom_data::desc, DESCRIPTOR_VALUE_MISSING, bufr2tac_subset_state::i, bufr2tac_subset_state::k_rep, bufr2tac_subset_state::layer, bufr_atom_data::mask, 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:

buoy_parse_x08()

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

Parse a expanded descriptor with X = 08.

Parameters

b	pointer to a struct buoy_chunks where to set the results
s	pointer 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 121 of file bufr2tac_x08.c.

{
  if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
    {
      return 0;
    }
 
  if ( b == NULL )
    {
      return 1;
    }
 
  switch ( s->a->desc.y )
    {
    case 22:  // 0 08 022 . Total number
    case 23:  // 0 08 023 . First-order statistics
    case 24:  // 0 08 024 . Difference statistics
      if ( s->isq )
        {
          s->isq = 0;
        }
      else
        {
          s->isq = 1;
        }
      break;
 
    default:
      if ( BUFR2TAC_DEBUG_LEVEL > 1 && (s->a->mask & DESCRIPTOR_VALUE_MISSING) == 0 ) 
        bufr2tac_set_error ( s, 0, "buoy_parse_x08()", "Descriptor not parsed" );
      break;
    }
  return 0;
}

References bufr2tac_subset_state::a, BUFR2TAC_DEBUG_LEVEL, bufr2tac_set_error(), bufr_atom_data::desc, DESCRIPTOR_VALUE_MISSING, bufr2tac_subset_state::isq, bufr_atom_data::mask, 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:

buoy_parse_x10()

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

Parse a expanded descriptor with X = 10.

Parameters

b	pointer to a struct buoy_chunks where to set the results
s	pointer 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 161 of file bufr2tac_x10.c.

{
  char aux[16];
 
  if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
    {
      return 0;
    }
 
  switch ( s->a->desc.y )
    {
 
    case 4: // 0 10 004 . Pressure
      pascal_to_PPPP ( aux, s->val );
      strcpy ( b->s1.PoPoPoPo, aux );
      b->mask |= BUOY_SEC1;
      break;
 
    case 51: // 0 10 051 . Pressure reduced to mean sea level
      pascal_to_PPPP ( aux, s->val );
      strcpy ( b->s1.PPPP, aux );
      b->mask |= BUOY_SEC1;
      break;
 
    case 63: // 0 10 063 . Characteristic of pressure tendency
      sprintf ( b->s1.a, "%1d",s->ival );
      b->mask |= BUOY_SEC1;
      break;
 
    case 61: // 0 10 061 . 3-hour pressure change
      pascal_to_ppp ( aux, s->val );
      memcpy( b->s1.ppp, aux, 3 );
      b->s1.ppp[3] = 0;
      b->mask |= BUOY_SEC1;
      break;
 
    default:
      if ( BUFR2TAC_DEBUG_LEVEL > 1 && (s->a->mask & DESCRIPTOR_VALUE_MISSING) == 0 ) 
        bufr2tac_set_error ( s, 0, "buoy_parse_x10()", "Descriptor not parsed" );
      break;
    }
  return 0;
}

References bufr2tac_subset_state::a, buoy_sec1::a, BUFR2TAC_DEBUG_LEVEL, bufr2tac_set_error(), BUOY_SEC1, bufr_atom_data::desc, DESCRIPTOR_VALUE_MISSING, bufr2tac_subset_state::ival, bufr_atom_data::mask, buoy_chunks::mask, pascal_to_ppp(), pascal_to_PPPP(), buoy_sec1::PoPoPoPo, buoy_sec1::ppp, buoy_sec1::PPPP, 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:

buoy_parse_x11()

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

Parse a expanded descriptor with X = 11.

Parameters

b	pointer to a struct buoy_chunks where to set the results
s	pointer 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.

{
 
  if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
    {
      return 0;
    }
 
  switch ( s->a->desc.y )
    {
    case 1: // 0 11 001 . Wind direction
    case 11: // 0 11 011 . Wind direction at 10m
      sprintf ( b->s1.dd, "%02d", abs((s->ival + 5 ) / 10) % 100 );
      b->mask |= BUOY_SEC1;
      break;
    
    case 2: // 0 11 002 . Wind speed
    case 12: // 0 11 012 . Wind speed at 10 meters
      if ( b->s0.iw[0] == '4' )
        {
          s->val *= 1.94384449;
        }
      if ( s->val < 100.0 )
        {
          sprintf ( b->s1.ff, "%02d", ( int ) ( s->val + 0.5 ) );
        }
      else
        {
          sprintf ( b->s1.ff,"99" );
          sprintf ( b->s1.fff, "%03d", ( int ) ( s->val + 0.5 ) );
        }
      b->mask |= BUOY_SEC1;
      break;
 
    case 84: // 0 11 084  (wind in knots)
      if ( b->s0.iw[0] == '1' )
        {
          s->val /= 1.94384449;
        }
      if ( s->val < 100.0 )
        {
          sprintf ( b->s1.ff, "%02d", ( int ) ( s->val + 0.5 ) );
        }
      else
        {
          sprintf ( b->s1.ff,"99" );
          sprintf ( b->s1.fff, "%03d", ( int ) ( s->val + 0.5 ) );
        }
      b->mask |= BUOY_SEC1;
      break;
 
    default:
      if ( BUFR2TAC_DEBUG_LEVEL > 1 && (s->a->mask & DESCRIPTOR_VALUE_MISSING) == 0 ) 
        bufr2tac_set_error ( s, 0, "buoy_parse_x11()", "Descriptor not parsed" );
      break;
    }
  return 0;
}

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:

buoy_parse_x12()

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

Parse a expanded descriptor with X = 12.

Parameters

b	pointer to a struct buoy_chunks where to set the results
s	pointer 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 466 of file bufr2tac_x12.c.

{
  char aux[16];
 
  if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
    {
      return 0;
    }
 
  switch ( s->a->desc.y )
    {
    case 1: // 0 12 001 . Air temperature
    case 4: // 0 12 004 . Air temperatura at 2 m
    case 101: // 0 12 101 . Air temperature
    case 104: // 0 12 104 . Air temperature at 2 m
      if ( b->s1.TTT[0] == 0 )
        {
          if ( kelvin_to_snTTT ( aux, s->val ) )
            {
              b->s1.sn1[0] = aux[0];
              strcpy ( b->s1.TTT, aux + 1 );
              b->mask |= BUOY_SEC1;
            }
          else if ( BUFR2TAC_DEBUG_LEVEL > 0 )
            bufr2tac_set_error ( s, 1, "buoy_parse_x12()->kelvin_to_snTTT()", "Unspected parse problem" );
        }
      break;
    case 3: // 0 12 003 . Dewpoint temperature
    case 6: // 0 12 006 . Dewpoint temperature at 2 m
    case 103: // 0 12 103 . Dewpoint temperature
    case 106: // 0 12 106 . Dewpoint temperature at 2 m
      if ( b->s1.TdTdTd[0] == 0 )
        {
          if ( kelvin_to_snTTT ( aux, s->val ) )
            {
              b->s1.sn2[0] = aux[0];
              strcpy ( b->s1.TdTdTd, aux + 1 );
              b->mask |= BUOY_SEC1;
            }
          else if ( BUFR2TAC_DEBUG_LEVEL > 0 )
            bufr2tac_set_error ( s, 1, "buoy_parse_x12()->kelvin_to_snTTT()", "Unspected parse problem" );
        }
      break;
 
    default:
      if ( BUFR2TAC_DEBUG_LEVEL > 1 && (s->a->mask & DESCRIPTOR_VALUE_MISSING) == 0 ) 
        bufr2tac_set_error ( s, 0, "buoy_parse_x12()", "Descriptor not parsed" );
      break;
    }
  return 0;
}

References bufr2tac_subset_state::a, BUFR2TAC_DEBUG_LEVEL, bufr2tac_set_error(), BUOY_SEC1, bufr_atom_data::desc, DESCRIPTOR_VALUE_MISSING, kelvin_to_snTTT(), bufr_atom_data::mask, buoy_chunks::mask, buoy_chunks::s1, buoy_sec1::sn1, buoy_sec1::sn2, buoy_sec1::TdTdTd, buoy_sec1::TTT, 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:

buoy_parse_x13()

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

Parse a expanded descriptor with X = 13.

Parameters

b	pointer to a struct buoy_chunks where to set the results
s	pointer 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 877 of file bufr2tac_x13.c.

{
 
  if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
    {
      return 0;
    }
 
  if ( b == NULL )
    {
      return 1;
    }
 
 
  switch ( s->a->desc.y )
    {
    default:
      if ( BUFR2TAC_DEBUG_LEVEL > 1 && (s->a->mask & DESCRIPTOR_VALUE_MISSING) == 0 ) 
        bufr2tac_set_error ( s, 0, "buoy_parse_x13()", "Descriptor not parsed" );
      break;
    }
  return 0;
}

References bufr2tac_subset_state::a, BUFR2TAC_DEBUG_LEVEL, bufr2tac_set_error(), bufr_atom_data::desc, DESCRIPTOR_VALUE_MISSING, bufr_atom_data::mask, 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:

buoy_parse_x14()

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

Parse a expanded descriptor with X = 14.

Parameters

b	pointer to a struct buoy_chunks where to set the results
s	pointer 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 467 of file bufr2tac_x14.c.

{
  if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
    {
      return 0;
    }
 
  if ( b == NULL )
    {
      return 1;
    }
 
  switch ( s->a->desc.y )
    {
    default:
      if ( BUFR2TAC_DEBUG_LEVEL > 1 && (s->a->mask & DESCRIPTOR_VALUE_MISSING) == 0 ) 
        bufr2tac_set_error ( s, 0, "buoy_parse_x14()", "Descriptor not parsed" );
      break;
    }
  return 0;
}

References bufr2tac_subset_state::a, BUFR2TAC_DEBUG_LEVEL, bufr2tac_set_error(), bufr_atom_data::desc, DESCRIPTOR_VALUE_MISSING, bufr_atom_data::mask, 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:

buoy_parse_x20()

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

Parse a expanded descriptor with X = 20.

Parameters

b	pointer to a struct buoy_chunks where to set the results
s	pointer 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 1324 of file bufr2tac_x20.c.

{
  if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
    {
      return 0;
    }
 
  if ( b == NULL )
    {
      return 1;
    }
 
  switch ( s->a->desc.y )
    {
    default:
      if ( BUFR2TAC_DEBUG_LEVEL > 1 && (s->a->mask & DESCRIPTOR_VALUE_MISSING) == 0 ) 
        bufr2tac_set_error ( s, 0, "buoy_parse_x20()", "Descriptor not parsed" );
      break;
    }
  return 0;
}

References bufr2tac_subset_state::a, BUFR2TAC_DEBUG_LEVEL, bufr2tac_set_error(), bufr_atom_data::desc, DESCRIPTOR_VALUE_MISSING, bufr_atom_data::mask, 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:

buoy_parse_x22()

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

Parse a expanded descriptor with X = 22.

Parameters

b	pointer to a struct buoy_chunks where to set the results
s	pointer 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 148 of file bufr2tac_x22.c.

{
  char aux[16];
 
  if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
    return 0;
 
  switch ( s->a->desc.y )
    {
    case 4: // 0 22 004 Direction of current
      if ( s->layer < 32 ) // only 32 max layers
        {
          if ( b->s3.l2[s->layer].dd[0] == 0 )
            {
              sprintf ( b->s3.l2[s->layer].dd, "%02d", ( int ) ( s->val + 5.0 ) / 10 ) ;
              b->mask |= BUOY_SEC3;
            }
          if ( b->s3.l2[s->layer].zzzz[0] == 0 ) // also stores pendent deep
            {
              sprintf ( b->s3.l2[s->layer].zzzz, "%04d", s->deep );
              b->mask |= BUOY_SEC3;
            }
        }
      break;  
 
    case 12: // 0 22 012 wind wave period in seconds
    case 74: // 0 22 074 significant wave period in seconds    
      if ( b->s2.PwaPwa[0] == 0 )
        {
          sprintf ( b->s2.PwaPwa, "%02d", ( int ) ( s->val ) );
          b->mask |= BUOY_SEC2; // have sec2 data
          if ( b->s2.PwaPwaPwa[0] == 0 )
            sprintf ( b->s2.PwaPwaPwa, "%03d", ( int ) ( s->val * 10 + 0.5 ) );
 
        }
      break;
 
    case 22: // 0 22 022 wind wave heigh in meters
    case 70: // 0 22 070 significant wave height in meters    
      if ( b->s2.HwaHwa[0] == 0 )
        {
          sprintf ( b->s2.HwaHwa, "%02d", ( int ) ( s->val * 2.0 + 0.01 ) ); // 0.5 m units
          b->mask |= BUOY_SEC2; // have sec2 data
        }
      if ( b->s2.HwaHwaHwa[0] == 0 )
        {
          sprintf ( b->s2.HwaHwaHwa, "%03d", ( int ) ( s->val * 10.0 + 0.01 ) ); // 0.1 m units
          b->mask |= BUOY_SEC2; // have sec2 data
        }
      break;
 
    case 31: // 0 22 033 current speed
      if ( s->layer < 32 ) // only 32 max layers
        {
          if ( b->s3.l2[s->layer].dd[0] == 0 )
            {
              sprintf ( b->s3.l2[s->layer].dd, "%03d", ( int ) ( s->val * 100.0 + 0.5 ) ) ;
              b->mask |= BUOY_SEC3;
            }
          if ( b->s3.l2[s->layer].zzzz[0] == 0 ) // also stores pendent deep
            {
              sprintf ( b->s3.l2[s->layer].zzzz, "%04d", s->deep );
              b->mask |= BUOY_SEC3;
            }
        }
      break;
 
    case 42:
    case 43:
      if ( s->deep == 0 )
        {
          if ( b->s2.TwTwTw[0] == 0 )
            {
              if ( kelvin_to_snTTT ( aux, s->val ) )
                {
                  b->s2.sn[0] = aux[0];
                  strcpy ( b->s2.TwTwTw, aux + 1 );
                  b->mask |= BUOY_SEC2; // have sec2 data
                }
            }
        }
      if ( s->layer < 32 ) // only 32 max layers
        {
          if ( b->s3.l1[s->layer].TTTT[0] == 0 )
            {
              kelvin_to_TTTT ( b->s3.l1[s->layer].TTTT, s->val );
              b->mask |= BUOY_SEC3;
            }
          if ( b->s3.l1[s->layer].zzzz[0] == 0 ) // also stores pendent deep
            {
              sprintf ( b->s3.l1[s->layer].zzzz, "%04d", s->deep );
              b->mask |= BUOY_SEC3;
            }
        }
      break;
 
    case 45:
    case 49: // 0 22 049 Sea surface temperature
      if ( b->s2.TwTwTw[0] == 0 )
        {
          if ( kelvin_to_snTTT ( aux, s->val ) )
            {
              b->s2.sn[0] = aux[0];
              strcpy ( b->s2.TwTwTw, aux + 1 );
              b->mask |= BUOY_SEC2; // have sec2 data
            }
        }
      break;
 
    case 62: // 0 22 062 Salinity
      if ( s->layer < 32 ) // only 32 max layers
        {
          if ( b->s3.l1[s->layer].SSSS[0] == 0 )
            {
              sprintf ( b->s3.l1[s->layer].SSSS, "%04d", ( int ) ( s->val * 100.0 + 0.5 ) );
              b->mask |= BUOY_SEC3;
            }
          if ( b->s3.l1[s->layer].zzzz[0] == 0 ) // also stores pendent deep
            {
              sprintf ( b->s3.l1[s->layer].zzzz, "%04d", s->deep );
              b->mask |= BUOY_SEC3;
            }
        }
      break;
 
    default:
      if ( BUFR2TAC_DEBUG_LEVEL > 1 && (s->a->mask & DESCRIPTOR_VALUE_MISSING) == 0 ) 
        bufr2tac_set_error ( s, 0, "buoy_parse_x22()", "Descriptor not parsed" );
      break;
   }
  return 0;
}

References bufr2tac_subset_state::a, BUFR2TAC_DEBUG_LEVEL, bufr2tac_set_error(), BUOY_SEC2, BUOY_SEC3, b_sec3_layer2::dd, bufr2tac_subset_state::deep, bufr_atom_data::desc, DESCRIPTOR_VALUE_MISSING, buoy_sec2::HwaHwa, buoy_sec2::HwaHwaHwa, kelvin_to_snTTT(), kelvin_to_TTTT(), buoy_sec3::l1, buoy_sec3::l2, bufr2tac_subset_state::layer, bufr_atom_data::mask, buoy_chunks::mask, buoy_sec2::PwaPwa, buoy_sec2::PwaPwaPwa, buoy_chunks::s2, buoy_chunks::s3, buoy_sec2::sn, b_sec3_layer1::SSSS, b_sec3_layer1::TTTT, buoy_sec2::TwTwTw, bufr2tac_subset_state::val, bufr_descriptor::y, b_sec3_layer1::zzzz, and b_sec3_layer2::zzzz.

Referenced by parse_subset_as_buoy().

Here is the call graph for this function:

Here is the caller graph for this function:

buoy_parse_x31()

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

Parse a expanded descriptor with X = 31.

Parameters

b	pointer to a struct buoy_chunks where to set the results
s	pointer 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 81 of file bufr2tac_x31.c.

{
  if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
    {
      return 0;
    }
 
  if ( b == NULL )
    {
      return 1;
    }
 
  switch ( s->a->desc.y )
    {
    case 0: // 0 31 000 .  Short delayed descriptor replication factor
      // It is no meaning here
      break;
 
    case 1:
      s->rep = s->ival;
      s->k_rep = s->i;
      break;
 
    default:
      if ( BUFR2TAC_DEBUG_LEVEL > 1 && (s->a->mask & DESCRIPTOR_VALUE_MISSING) == 0 ) 
        bufr2tac_set_error ( s, 0, "buoy_parse_x31()", "Descriptor not parsed" );
      break;
    }
  return 0;
}

References bufr2tac_subset_state::a, BUFR2TAC_DEBUG_LEVEL, bufr2tac_set_error(), bufr_atom_data::desc, DESCRIPTOR_VALUE_MISSING, bufr2tac_subset_state::i, bufr2tac_subset_state::ival, bufr2tac_subset_state::k_rep, bufr_atom_data::mask, bufr2tac_subset_state::rep, 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:

buoy_parse_x33()

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

Parse a expanded descriptor with X = 33.

Parameters

b	pointer to a struct buoy_chunks where to set the results
s	pointer 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 34 of file bufr2tac_x33.c.

{
 
  if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
    return 0;
 
 
  switch ( s->a->desc.y )
    {
    case 20: // 0 33 020. Quality control indication of followinf value
      sprintf ( b->s0.Qt, "%d", s->ival );
      b->mask |= BUOY_SEC1;
      break;
 
    case 21: // 0 33 021. Quality control of following value
      sprintf ( b->s4.Qp, "%d", s->ival );
      b->mask |= BUOY_SEC1;
      break;
 
    case 22: // 0 33 022. Quality of buoy satellite transmission
      if ( s->ival == 0 )
        {
          if ( b->s0.Qt[0] == 0 )
            sprintf ( b->s0.Qt, "1" );
          if ( b->s1.Qd[0] == 0 )
            sprintf ( b->s1.Qd, "1" );
          if ( b->s2.Qd[0] == 0 )
            sprintf ( b->s2.Qd, "1" );
        }
      if ( s->ival == 2 )
        {
          if ( b->s0.Qt[0] == 0 )
            sprintf ( b->s0.Qt, "3" );
          if ( b->s1.Qd[0] == 0 )
            sprintf ( b->s1.Qd, "3" );
          if ( b->s2.Qd[0] == 0 )
            sprintf ( b->s2.Qd, "3" );
        }
      break;
 
    case 23: // 0 33 023 . Quality of buoy location
      sprintf ( b->s0.Ql, "%d", s->ival );
      sprintf ( b->s4.QL, "%d", s->ival );
      break;
 
    case 27: // 0 33 027. Location quality class (range of ratiuos of 66% confidence)
      sprintf ( b->s0.QA, "%d", s->ival );
      sprintf ( b->s4.QA, "%d", s->ival );
      break;
 
    default:
      if ( BUFR2TAC_DEBUG_LEVEL > 1 && (s->a->mask & DESCRIPTOR_VALUE_MISSING) == 0 ) 
        bufr2tac_set_error ( s, 0, "syn_parse_x33()", "Descriptor not parsed" );
      break;
    }
  return 0;
}

References bufr2tac_subset_state::a, BUFR2TAC_DEBUG_LEVEL, bufr2tac_set_error(), BUOY_SEC1, bufr_atom_data::desc, DESCRIPTOR_VALUE_MISSING, bufr2tac_subset_state::ival, bufr_atom_data::mask, buoy_chunks::mask, buoy_sec0::QA, buoy_sec4::QA, buoy_sec1::Qd, buoy_sec2::Qd, buoy_sec0::Ql, buoy_sec4::QL, buoy_sec4::Qp, buoy_sec0::Qt, buoy_chunks::s0, buoy_chunks::s1, buoy_chunks::s2, buoy_chunks::s4, 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:

buoy_YYYYMMDDHHmm_to_JMMYYGGgg()

int buoy_YYYYMMDDHHmm_to_JMMYYGGgg

(

struct buoy_chunks *

b

)

Sets YYGG from YYYYMMDDHHmm extended group.

Parameters

b	pointer to the target struct buoy_chunks

Definition at line 31 of file bufr2tac_buoy.c.

{
  char aux[20];
  time_t t;
  struct tm tim;
 
  if ( strlen ( b->e.YYYY ) &&
       strlen ( b->e.MM ) &&
       strlen ( b->e.DD ) &&
       strlen ( b->e.HH ) &&
       strlen ( b->e.MM ) )
    {
      sprintf ( aux,"%s%s%s%s%s", b->e.YYYY, b->e.MM, b->e.DD, b->e.HH, b->e.mm );
    }
 
  if ( strlen ( aux ) != 12 )
    {
      return 1;
    }
 
  memset ( &tim, 0, sizeof ( struct tm ) );
  strptime ( aux, "%Y%m%d%H%M", &tim );
 
  t = mktime ( &tim );
  gmtime_r ( &t, &tim );
  sprintf ( b->s0.YY, "%02d", tim.tm_mday );
  sprintf ( b->s0.GG, "%02d", tim.tm_hour );
  sprintf ( b->s0.MM, "%02d", (tim.tm_mon + 1) % 100 );
  sprintf ( b->s0.J, "%d", tim.tm_year % 10 );
  sprintf ( b->s0.gg, "%02d", tim.tm_min );
 
  return 0;
}

References report_date_ext::DD, buoy_chunks::e, buoy_sec0::GG, buoy_sec0::gg, report_date_ext::HH, buoy_sec0::J, buoy_sec0::MM, report_date_ext::MM, report_date_ext::mm, buoy_chunks::s0, buoy_sec0::YY, and report_date_ext::YYYY.

Referenced by parse_subset_as_buoy().

Here is the caller graph for this function:

buprs0_()

int buprs0_

(

int *

)

buprs1_()

int buprs1_

(

int *

)

buprs3_()

int buprs3_	(	int *	,
		int *	,
		int *	,
		int *	,
		int *	,
		int *	,
		char **
	)

buprt_()

int buprt_	(	int *	,
		int *	,
		int *	,
		int *	,
		char **	,
		char **	,
		char **	,
		int *	,
		double *	,
		int *	,
		int *	,
		int *
	)

bus012_()

int bus012_	(	int *	,
		unsigned int *	,
		int *	,
		int *	,
		int *	,
		int *	,
		int *
	)

busel2_()

int busel2_	(	int *	,
		int *	,
		int *	,
		char **	,
		int *	,
		char **	,
		char **	,
		char **	,
		int *
	)

busel_()

int busel_	(	int *	,
		int *	,
		int *	,
		int *	,
		int *
	)

buukey_()

int buukey_	(	int *	,
		int *	,
		int *	,
		int *	,
		int *
	)

charray_to_string()

char * charray_to_string	(	char *	s,
		unsigned char *	buf,
		size_t	size
	)

get a null termitated c-string from an array of unsigned chars

Parameters

s	resulting string
buf	pointer to first element in array
size	number of chars in array

Definition at line 85 of file bufr2tac_utils.c.

{
  // copy
  memcpy ( s , buf, size );
  // add final string mark
  s[size] = '\0';
  return s;
}

check_date_from_future()

int check_date_from_future

(

struct metreport *

m

)

Check a estructure metreport not from future.

Parameters

m	pointer to a struct metreport to check about date and time

It resturns 1 if date/time is from future, and likely wrong Returns 0 otherwise

Definition at line 292 of file bufr2tac_utils.c.

{
  time_t now;
 
  now = time ( NULL );
  if ( m->t.t > ( now + 1800 ) ) // Still 1/2 hour courtesy
    return 1;
  else
    return 0;
}

References metreport::t, and met_datetime::t.

Referenced by parse_subset_as_climat(), and parse_subset_as_synop().

Here is the caller graph for this function:

check_j_cm2()

int check_j_cm2

(

double

val

)

Check if a radiation value can be wrote in J/cm2 using up to 4 chars.

Parameters

val	radiation value in J/m2

Returns 1 if success, 0 otherwise

Definition at line 45 of file bufr2tac_x14.c.

{
  return ( fabs ( val ) < 1.0e8 ) ? 1 : 0;
}

Referenced by syn_parse_x14().

Here is the caller graph for this function:

check_kj_m2()

int check_kj_m2

(

double

val

)

Check if a radiation value can be wrote in Kj/m2 using up to 4 chars.

Parameters

val	radiation value in J/m2

Returns 1 if success, 0 otherwise

Definition at line 33 of file bufr2tac_x14.c.

{
  return ( fabs ( val ) < 1.0e7 ) ? 1 : 0;
}

Referenced by syn_parse_x14().

Here is the caller graph for this function:

climat_parse_x01()

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

Parse a expanded descriptor with X = 01.

Parameters

c	pointer to a struct climat_chunks where to set the results
s	pointer 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 324 of file bufr2tac_x01.c.

{
  char aux[80];
 
  if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
    return 0;
 
  switch ( s->a->desc.y )
    {
 
    case 1: // 0 01 001 . WMO block number
      sprintf ( c->s0.II, "%02d", s->ival );
      break;
 
    case 2: // 0 01 002 . WMO station number
      sprintf ( c->s0.iii, "%03d", s->ival );
      break;
 
    case 3: // 0 01 003 . WMO Region
      if ( s->ival == 1 )
        strcpy ( c->s0.Reg, "I" );
      else if ( s->ival == 2 )
        strcpy ( c->s0.Reg, "II" );
      else if ( s->ival == 3 )
        strcpy ( c->s0.Reg, "III" );
      else if ( s->ival == 4 )
        strcpy ( c->s0.Reg, "IV" );
      else if ( s->ival == 5 )
        strcpy ( c->s0.Reg, "V" );
      else if ( s->ival == 6 )
        strcpy ( c->s0.Reg, "VI" );
      break;
 
    case 15: // 0 01 015 . Station or site name
    case 18: // 0 01 018 . Short station or site name
    case 19: // 0 01 019 . Long station or site name
      if ( strlen ( s->a->cval ) <= 80 )
        {
          strcpy ( aux, s->a->cval );
          adjust_string ( aux );
          strcpy ( s->name, aux );
          s->mask |= SUBSET_MASK_HAVE_NAME;
        }
      else if ( BUFR2TAC_DEBUG_LEVEL > 0 )
        {
          bufr2tac_set_error ( s, 1, "climat_parse_x01()", "Station or site name length > 80. Cannot set s->name" );
        }
      break;
 
    case 125: // 0 01 125 . WIGOS identifier series
      c->wid.series = ( uint8_t ) s->ival;
      break;
 
    case 126: // 0 01 126 . WIGOS issuer of identifier
      c->wid.issuer = ( uint16_t ) s->ival;
      break;
 
    case 127: // 0 01 127 , WIGOS issue number
      c->wid.issue = ( uint16_t ) s->ival;
      break;
 
    case 128: // 0 01 128 . WIGOS local identifier (character)
      if ( strlen ( s->a->cval ) <= 16 )
        {
          strcpy ( c->wid.local_id, s->a->cval );
          if ( check_wigos_local_id ( s->a->cval ) )
            {
              bufr2tac_set_error ( s, 1, "climat_parse_x01()","Bad WIGOS Local identifier" );
            }
          s->mask |= SUBSET_MASK_HAVE_WIGOS_ID ;
        }
      break;
 
 
 
    default:
      if ( BUFR2TAC_DEBUG_LEVEL > 1 && ( s->a->mask & DESCRIPTOR_VALUE_MISSING ) == 0 )
        bufr2tac_set_error ( s, 0, "climat_parse_x01()", "Descriptor not parsed" );
      break;
    }
  return 0;
}

References bufr2tac_subset_state::a, adjust_string(), BUFR2TAC_DEBUG_LEVEL, bufr2tac_set_error(), check_wigos_local_id(), bufr_atom_data::cval, bufr_atom_data::desc, DESCRIPTOR_VALUE_MISSING, climat_sec0::II, climat_sec0::iii, wigos_id::issue, wigos_id::issuer, bufr2tac_subset_state::ival, wigos_id::local_id, bufr_atom_data::mask, bufr2tac_subset_state::mask, bufr2tac_subset_state::name, climat_sec0::Reg, climat_chunks::s0, wigos_id::series, SUBSET_MASK_HAVE_NAME, SUBSET_MASK_HAVE_WIGOS_ID, climat_chunks::wid, and bufr_descriptor::y.

Referenced by parse_subset_as_climat().

Here is the call graph for this function:

Here is the caller graph for this function:

climat_parse_x02()

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

Parse a expanded descriptor with X = 02.

Parameters

c	pointer to a struct climat_chunks where to set the results
s	pointer 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 146 of file bufr2tac_x02.c.

{
  if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
    return 0;
 
  if ( c == NULL )
    return 1;
 
  switch ( s->a->desc.y )
    {
    case 1: // 0 02 001 . Type of station
      s->type = s->ival;
      s->mask |= SUBSET_MASK_HAVE_TYPE_STATION;
      break;
 
    case 2: // 0 02 002 . Type of instrumentation for wind measurement
      if ( s->ival & 4 )
        strcpy ( c->s4.iw, "4" );
      else
        strcpy ( c->s4.iw, "1" );
      break;
 
    case 51: // 0 02 051 . Observing method for extreme temperatures
      sprintf ( c->s4.iy,"%d",s->ival );
      break;
    default:
      if ( BUFR2TAC_DEBUG_LEVEL > 0 )
        bufr2tac_set_error ( s, 0, "climat_parse_x02()", "Descriptor not parsed" );
      break;
    }
  return 0;
}

References bufr2tac_subset_state::a, BUFR2TAC_DEBUG_LEVEL, bufr2tac_set_error(), bufr_atom_data::desc, DESCRIPTOR_VALUE_MISSING, bufr2tac_subset_state::ival, climat_sec4::iw, climat_sec4::iy, bufr_atom_data::mask, bufr2tac_subset_state::mask, climat_chunks::s4, SUBSET_MASK_HAVE_TYPE_STATION, bufr2tac_subset_state::type, and bufr_descriptor::y.

Referenced by parse_subset_as_climat().

Here is the call graph for this function:

Here is the caller graph for this function:

climat_parse_x04()

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

Parse a expanded descriptor with X = 04.

Parameters

c	pointer to a struct climat_chunks where to set the results
s	pointer 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 405 of file bufr2tac_x04.c.

{
  if ( c == NULL )
    {
      return 1;
    }
 
 
  switch ( s->a->desc.y )
    {
    case 1: // 0 04 001 .Year
      if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
        {
          return 0;
        }
      else if ( s->ival < 2000 || s->ival > 2050 )
        {
          if ( BUFR2TAC_DEBUG_LEVEL > 0 )
            bufr2tac_set_error ( s, 2, "climat_parse_x04()", "Bad year" );
          return 1;
        }
 
      if ( s->i && ( s->a1->desc.x == 4 ) && ( s->a1->desc.y == 1 ) )
        {
          // this is the final year of a normal period
          s->is_normal = 1;
          sprintf ( c->s2.YcYc, "%02d", s->ival % 100 );
          // then we fill the begin from tatest descriptor
          sprintf ( c->s2.YbYb, "%02d", ( int ) s->a1->val % 100 );
        }
      else if ( c->e.YYYY[0] == '\0' )
        {
          sprintf ( c->e.YYYY, "%04d", s->ival );
          s->mask |= SUBSET_MASK_HAVE_YEAR;
          sprintf ( c->s0.JJJ, "%03d", abs ( s->ival ) % 1000 );
          c->mask |= CLIMAT_SEC0;
        }
      break;
 
    case 2: // 0 04 002 . Month
      if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
        {
          return 0;
        }
      sprintf ( c->e.MM, "%02d", s->ival );
      s->mask |= SUBSET_MASK_HAVE_MONTH;
      sprintf ( c->s0.MM, "%02d", s->ival );
      c->mask |= CLIMAT_SEC0;
      break;
 
    case 3: // 0 04 003 . Day of month
      if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
        {
          return 0;
        }
      if ( c->e.DD[0] == 0 )
        {
          sprintf ( c->e.DD, "%02d", s->ival );
        }
      if ( s->a1->desc.x == 8 && s->a1->desc.y == 53 )
        {
          s->more_days = s->isq_val;
        }
      s->day = s->ival;
      s->mask |= SUBSET_MASK_HAVE_DAY;
      break;
 
    case 4: // 0 04 004 . Hour
      if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
        {
          return 0;
        }
      if ( c->e.HH[0] == 0 )
        {
          sprintf ( c->e.HH, "%02d", s->ival );
        }
      s->mask |= SUBSET_MASK_HAVE_HOUR;
      break;
 
    case 5: // 0 04 005 . Minute
      if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
        {
          return 0;
        }
      if ( c->e.mm[0] == 0 )
        {
          sprintf ( c->e.mm, "%02d", s->ival );
        }
      s->mask |= SUBSET_MASK_HAVE_MINUTE;
      break;
 
    case 22: // 0 04 022 . Num month. Case of sec2 with normals
      if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
        {
          return 0;
        }
      s->month = s->ival;
      break;
 
    case 23: // 0 04 023 . Num days in month
      if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
        {
          return 0;
        }
      if ( s->nday == 0 )
        {
          s->nday = s->ival;
        }
      break;
 
    case 51: // 0 04 051 . Principal time of daily reading of maximum
      if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
        {
          return 0;
        }
      sprintf ( c->s4.GxGx, "%02d", s->ival );
      s->mask |= CLIMAT_SEC4;
      break;
 
    case 52: // 0 04 052 . Principal time of daily reading of minimum
      if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
        {
          return 0;
        }
      sprintf ( c->s4.GnGn, "%02d", s->ival );
      s->mask |= CLIMAT_SEC4;
      break;
 
    case 53: // 0 04 053 . Number of days with precipitation equal to or more than 1 mm
      if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
        {
          return 0;
        }
      if ( s->is_normal == 0 )
        {
          sprintf ( c->s1.nrnr, "%02d", s->ival );
          s->mask |= CLIMAT_SEC1;
        }
      else
        {
          sprintf ( c->s2.nrnr, "%02d", s->ival );
          s->mask |= CLIMAT_SEC2;
        }
      break;
 
 
    case 74: // 0 04 074 . (UTC - LST)
      if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
        {
          return 0;
        }
      s->dift = s->ival;
      break;
 
    default:
      if ( BUFR2TAC_DEBUG_LEVEL > 1 && ( s->a->mask & DESCRIPTOR_VALUE_MISSING ) == 0 )
        bufr2tac_set_error ( s, 0, "climat_parse_x04()", "Descriptor not parsed" );
      break;
    }
  return 0;
}

References bufr2tac_subset_state::a, bufr2tac_subset_state::a1, BUFR2TAC_DEBUG_LEVEL, bufr2tac_set_error(), CLIMAT_SEC0, CLIMAT_SEC1, CLIMAT_SEC2, CLIMAT_SEC4, bufr2tac_subset_state::day, report_date_ext::DD, bufr_atom_data::desc, DESCRIPTOR_VALUE_MISSING, bufr2tac_subset_state::dift, climat_chunks::e, climat_sec4::GnGn, climat_sec4::GxGx, report_date_ext::HH, bufr2tac_subset_state::i, bufr2tac_subset_state::is_normal, bufr2tac_subset_state::isq_val, bufr2tac_subset_state::ival, climat_sec0::JJJ, bufr_atom_data::mask, bufr2tac_subset_state::mask, climat_chunks::mask, climat_sec0::MM, report_date_ext::MM, report_date_ext::mm, bufr2tac_subset_state::month, bufr2tac_subset_state::more_days, bufr2tac_subset_state::nday, climat_sec1::nrnr, climat_sec2::nrnr, climat_chunks::s0, climat_chunks::s1, climat_chunks::s2, climat_chunks::s4, SUBSET_MASK_HAVE_DAY, SUBSET_MASK_HAVE_HOUR, SUBSET_MASK_HAVE_MINUTE, SUBSET_MASK_HAVE_MONTH, SUBSET_MASK_HAVE_YEAR, bufr_atom_data::val, bufr_descriptor::x, bufr_descriptor::y, climat_sec2::YbYb, climat_sec2::YcYc, and report_date_ext::YYYY.

Referenced by parse_subset_as_climat().

Here is the call graph for this function:

Here is the caller graph for this function:

climat_parse_x05()

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

Parse a expanded descriptor with X = 05.

Parameters

c	pointer to a struct climat_chunks where to set the results
s	pointer 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 170 of file bufr2tac_x05.c.

{
  if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
    return 0;
 
  // this is to avoid warning
  if ( c == NULL )
    return 1;
 
  switch ( s->a->desc.y )
    {
    case 1: // 0 05 001 . Latitude (High accuracy)
    case 2: // 0 05 002 . Latitude (Coarse accuracy)
      if ( s->val < 0.0 )
        s->mask |= SUBSET_MASK_LATITUDE_SOUTH; // Sign for latitude
      s->mask |= SUBSET_MASK_HAVE_LATITUDE;
      s->lat = s->val;
      break;
    default:
      if ( BUFR2TAC_DEBUG_LEVEL > 1 && (s->a->mask & DESCRIPTOR_VALUE_MISSING) == 0 ) 
        bufr2tac_set_error ( s, 0, "climat_parse_x05()", "Descriptor not parsed" );
      break;
    }
  return 0;
}

References bufr2tac_subset_state::a, BUFR2TAC_DEBUG_LEVEL, bufr2tac_set_error(), bufr_atom_data::desc, DESCRIPTOR_VALUE_MISSING, bufr2tac_subset_state::lat, bufr_atom_data::mask, bufr2tac_subset_state::mask, SUBSET_MASK_HAVE_LATITUDE, SUBSET_MASK_LATITUDE_SOUTH, bufr2tac_subset_state::val, and bufr_descriptor::y.

Referenced by parse_subset_as_climat().

Here is the call graph for this function:

Here is the caller graph for this function:

climat_parse_x06()

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

Parse a expanded descriptor with X = 06.

Parameters

c	pointer to a struct climat_chunks where to set the results
s	pointer 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 165 of file bufr2tac_x06.c.

{
  if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
    return 0;
 
  // this is to avoid warning
  if ( c == NULL )
    return 1;
 
  switch ( s->a->desc.y )
    {
    case 1: // 0 06 001 . Longitude (High accuracy)
    case 2: // 0 06 002 . Longitude (Coarse accuracy)
      if ( s->val < 0.0 )
        s->mask |= SUBSET_MASK_LONGITUDE_WEST; // Sign for longitude
      s->mask |= SUBSET_MASK_HAVE_LONGITUDE;
      s->lon = s->val;
      break;
 
    default:
      if ( BUFR2TAC_DEBUG_LEVEL > 1 && (s->a->mask & DESCRIPTOR_VALUE_MISSING) == 0 ) 
        bufr2tac_set_error ( s, 0, "climat_parse_x06()", "Descriptor not parsed" );
      break;
    }
  return 0;
}

References bufr2tac_subset_state::a, BUFR2TAC_DEBUG_LEVEL, bufr2tac_set_error(), bufr_atom_data::desc, DESCRIPTOR_VALUE_MISSING, bufr2tac_subset_state::lon, bufr_atom_data::mask, bufr2tac_subset_state::mask, SUBSET_MASK_HAVE_LONGITUDE, SUBSET_MASK_LONGITUDE_WEST, bufr2tac_subset_state::val, and bufr_descriptor::y.

Referenced by parse_subset_as_climat().

Here is the call graph for this function:

Here is the caller graph for this function:

climat_parse_x07()

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

Definition at line 208 of file bufr2tac_x07.c.

{
  if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
    {
      return 0;
    }
 
  // this is to avoid warning
  if ( c == NULL )
    {
      return 1;
    }
 
  switch ( s->a->desc.y )
    {
    case 1: // 0 07 001 . Heigh of station
    case 30: // 0 07 030 . Height of station ground above msl
    case 31: // 0 07 031 . Height of barometer above msl
      s->alt = s->val;
      break;
 
    case 32: // 0 07 032 . Pressure of standard level
      // Not a useful value for alphanumeric climat
      if ( BUFR2TAC_DEBUG_LEVEL > 0 )
        bufr2tac_set_error ( s, 0, "climat_parse_x07()", "Descriptor not parsed" );
      break;
 
    case 4: // Pressure of standard level
      // Not a useful value for alphanumeric climat
      if ( BUFR2TAC_DEBUG_LEVEL > 0 )
        bufr2tac_set_error ( s, 0, "climat_parse_x07()", "Descriptor not parsed" );
      break;
 
    default:
      if ( BUFR2TAC_DEBUG_LEVEL > 1 && (s->a->mask & DESCRIPTOR_VALUE_MISSING) == 0 ) 
        bufr2tac_set_error ( s, 0, "climat_parse_x07()", "Descriptor not parsed" );
      break;
    }
 
  return 0;
}

References bufr2tac_subset_state::a, bufr2tac_subset_state::alt, BUFR2TAC_DEBUG_LEVEL, bufr2tac_set_error(), bufr_atom_data::desc, DESCRIPTOR_VALUE_MISSING, bufr_atom_data::mask, bufr2tac_subset_state::val, and bufr_descriptor::y.

Referenced by parse_subset_as_climat().

Here is the call graph for this function:

Here is the caller graph for this function:

climat_parse_x08()

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

Parse a expanded descriptor with X = 08.

Parameters

c	pointer to a struct climat_chunks where to set the results
s	pointer 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 164 of file bufr2tac_x08.c.

{
  char caux[16];
  
  if ( c == NULL )
    {
      return 1;
    }
 
  switch ( s->a->desc.y )
    {
    case 20: // 0 08 020 . Total number of missing entities (days)
      if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
        {
          return 0;
        }
      if ( s->is_normal == 0 )
        {
          switch ( s->isq_val )
            {
            // days of missing data
            case 1: // pressure
              sprintf ( c->s1.mpmp, "%02d", s->ival );
              c->mask |= CLIMAT_SEC1;
              break;
            case 2: // temperature
              sprintf ( c->s1.mtmt, "%02d", s->ival );
              c->mask |= CLIMAT_SEC1;
              break;
            case 4: // vapour pressure
              sprintf ( c->s1.meme, "%02d", s->ival );
              c->mask |= CLIMAT_SEC1;
              break;
            case 5: // precipitation
              sprintf ( c->s1.mrmr, "%02d", s->ival );
              c->mask |= CLIMAT_SEC1;
              break;
            case 6: // sunshine duration
              sprintf ( c->s1.msms, "%02d", s->ival );
              c->mask |= CLIMAT_SEC1;
              break;
            case 7: // Maximum temperature
              if ( s->ival < 10 )
                {
                  sprintf ( caux, "%d", s->ival );
                  c->s1.mtx[0] = caux[0];
                  c->s1.mtx[1] = 0;
                }
              else
                {
                  c->s1.mtx[0] = '9';
                }
              c->mask |= CLIMAT_SEC1;
              break;
            case 8: // Minimum temperature
              if ( s->ival < 10 )
                {
                  sprintf ( caux, "%d", s->ival );
                  c->s1.mtn[0] = caux[0];
                  c->s1.mtn[1] = 0;
                }
              else
                {
                  c->s1.mtn[0] = '9';
                }
              c->mask |= CLIMAT_SEC1;
              break;
            default:
              break;
            }
        }
      else
        {
          switch ( s->isq_val )
            {
            // years of missing data
            case 1: // pressure
              sprintf ( c->s2.ypyp, "%02d", s->ival );
              c->mask |= CLIMAT_SEC2;
              break;
            case 2: // temperature
              sprintf ( c->s2.ytyt, "%02d", s->ival );
              c->mask |= CLIMAT_SEC2;
              break;
            case 3: // extreme temperature
              sprintf ( c->s2.ytxytx, "%02d", s->ival );
              c->mask |= CLIMAT_SEC2;
              break;
            case 4: // vapour pressure
              sprintf ( c->s2.yeye, "%02d", s->ival );
              c->mask |= CLIMAT_SEC2;
              break;
            case 5: // precipitation
              sprintf ( c->s2.yryr, "%02d", s->ival );
              c->mask |= CLIMAT_SEC2;
              break;
            case 6: // sunshine duration
              sprintf ( c->s2.ysys, "%02d", s->ival );
              c->mask |= CLIMAT_SEC2;
              break;
            default:
              break;
            }
        }
      break;
 
    case 22:
      if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
        {
          return 0;
        }
      switch ( s->isq_val )
        {
        case 0:
          sprintf ( c->s3.f10, "%02d", s->ival );
          c->mask |= CLIMAT_SEC3;
          break;
        case 1:
          sprintf ( c->s3.f20, "%02d", s->ival );
          c->mask |= CLIMAT_SEC3;
          break;
        case 2:
          sprintf ( c->s3.f30, "%02d", s->ival );
          c->mask |= CLIMAT_SEC3;
          break;
        case 3:
          sprintf ( c->s3.Tx0, "%02d", s->ival );
          c->mask |= CLIMAT_SEC3;
          break;
        case 4:
          sprintf ( c->s3.T25, "%02d", s->ival );
          c->mask |= CLIMAT_SEC3;
          break;
        case 5:
          sprintf ( c->s3.T30, "%02d", s->ival );
          c->mask |= CLIMAT_SEC3;
          break;
        case 6:
          sprintf ( c->s3.T35, "%02d", s->ival );
          c->mask |= CLIMAT_SEC3;
          break;
        case 7:
          sprintf ( c->s3.T40, "%02d", s->ival );
          c->mask |= CLIMAT_SEC3;
          break;
        case 8:
          sprintf ( c->s3.Tn0, "%02d", s->ival );
          c->mask |= CLIMAT_SEC3;
          break;
        case 10:
          sprintf ( c->s3.R01, "%02d", s->ival );
          c->mask |= CLIMAT_SEC3;
          break;
        case 11:
          sprintf ( c->s3.R05, "%02d", s->ival );
          c->mask |= CLIMAT_SEC3;
          break;
        case 12:
          sprintf ( c->s3.R10, "%02d", s->ival );
          c->mask |= CLIMAT_SEC3;
          break;
        case 13:
          sprintf ( c->s3.R50, "%02d", s->ival );
          c->mask |= CLIMAT_SEC3;
          break;
        case 14:
          sprintf ( c->s3.R100, "%02d", s->ival );
          c->mask |= CLIMAT_SEC3;
          break;
        case 15:
          sprintf ( c->s3.R150, "%02d", s->ival );
          c->mask |= CLIMAT_SEC3;
          break;
        case 16:
          sprintf ( c->s3.s00, "%02d", s->ival );
          c->mask |= CLIMAT_SEC3;
          break;
        case 17:
          sprintf ( c->s3.s01, "%02d", s->ival );
          c->mask |= CLIMAT_SEC3;
          break;
        case 18:
          sprintf ( c->s3.s10, "%02d", s->ival );
          c->mask |= CLIMAT_SEC3;
          break;
        case 19:
          sprintf ( c->s3.s50, "%02d", s->ival );
          c->mask |= CLIMAT_SEC3;
          break;
        case 20:
          sprintf ( c->s3.V1, "%02d", s->ival );
          c->mask |= CLIMAT_SEC3;
          break;
        case 21:
          sprintf ( c->s3.V2, "%02d", s->ival );
          c->mask |= CLIMAT_SEC3;
          break;
        case 22:
          sprintf ( c->s3.V3, "%02d", s->ival );
          c->mask |= CLIMAT_SEC3;
          break;
        case 23:
          sprintf ( c->s4.Dgr, "%02d", s->ival );
          c->mask |= CLIMAT_SEC4;
          break;
        case 24:
          sprintf ( c->s4.Dts, "%02d", s->ival );
          c->mask |= CLIMAT_SEC4;
          break;
        default:
          break;
        }
      break;
    
    case 23: // 0 08 023 . First-order statistics.
      if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
        {
          s->isq = 0;
          s->isq_val = 0;
        }
      else
        {
          s->isq = 1;
          s->isq_val = s->ival;
        }
      break;
 
    case 50: // 0 08 050 . Qualifier for number of missing values in calculation of statistic
    case 52: // 0 08 052 . Conditions for which number of days of occurrence follows
    case 53: // 0 08 053 . Day of occurrence qualifier (= 0; on 1 day only) (= 1; on 2 or more days)
      if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
        {
          s->isq = 0;
          s->isq_val = -1;
          return 0;
        }
      s->isq = 1;
      s->isq_val = s->ival;
      break;
 
    default:
      if ( BUFR2TAC_DEBUG_LEVEL > 1 && (s->a->mask & DESCRIPTOR_VALUE_MISSING) == 0 ) 
        bufr2tac_set_error ( s, 0, "climat_parse_x08()", "Descriptor not parsed" );
      break;
    }
 
  return 0;
}

References bufr2tac_subset_state::a, BUFR2TAC_DEBUG_LEVEL, bufr2tac_set_error(), CLIMAT_SEC1, CLIMAT_SEC2, CLIMAT_SEC3, CLIMAT_SEC4, bufr_atom_data::desc, DESCRIPTOR_VALUE_MISSING, climat_sec4::Dgr, climat_sec4::Dts, climat_sec3::f10, climat_sec3::f20, climat_sec3::f30, bufr2tac_subset_state::is_normal, bufr2tac_subset_state::isq, bufr2tac_subset_state::isq_val, bufr2tac_subset_state::ival, bufr_atom_data::mask, climat_chunks::mask, climat_sec1::meme, climat_sec1::mpmp, climat_sec1::mrmr, climat_sec1::msms, climat_sec1::mtmt, climat_sec1::mtn, climat_sec1::mtx, climat_sec3::R01, climat_sec3::R05, climat_sec3::R10, climat_sec3::R100, climat_sec3::R150, climat_sec3::R50, climat_sec3::s00, climat_sec3::s01, climat_chunks::s1, climat_sec3::s10, climat_chunks::s2, climat_chunks::s3, climat_chunks::s4, climat_sec3::s50, climat_sec3::T25, climat_sec3::T30, climat_sec3::T35, climat_sec3::T40, climat_sec3::Tn0, climat_sec3::Tx0, climat_sec3::V1, climat_sec3::V2, climat_sec3::V3, bufr_descriptor::y, climat_sec2::yeye, climat_sec2::ypyp, climat_sec2::yryr, climat_sec2::ysys, climat_sec2::ytxytx, and climat_sec2::ytyt.

Referenced by parse_subset_as_climat().

Here is the call graph for this function:

Here is the caller graph for this function:

climat_parse_x10()

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

Parse a expanded descriptor with X = 10.

Parameters

c	pointer to a struct climat_chunks where to set the results
s	pointer 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 214 of file bufr2tac_x10.c.

{
  char aux[16];
 
  if ( c == NULL || s == NULL )
    {
      return 1;
    }
 
  if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
    {
      return 0;
    }
 
  switch ( s->a->desc.y )
    {
    case 4: // 0 10 004 . Pressure
      if ( s->isq_val == 4 )
        {
          pascal_to_PPPP ( aux, s->val );
          if ( s->is_normal == 0 )
            {
              strcpy ( c->s1.PoPoPoPo, aux );
              c->mask |= CLIMAT_SEC1;
            }
          else
            {
              strcpy ( c->s2.PoPoPoPo, aux );
              c->mask |= CLIMAT_SEC2;
            }
        }
      break;
 
    case 9: // 0 10 009 . Heigh of geopotential
      if ( s->isq_val == 4 )
        {
          if ( s->is_normal == 0 )
            {
              sprintf ( c->s1.PPPP, "%04d", s->ival );
              c->mask |= CLIMAT_SEC1;
            }
          else
            {
              sprintf ( c->s1.PPPP, "%04d", s->ival );
              c->mask |= CLIMAT_SEC2;
            }
        }
      break;
 
    case 51: // 0 10 051 . Pressure reduced to mean sea level
      if ( s->isq_val == 4 )
        {
          pascal_to_PPPP ( aux, s->val );
          if ( s->is_normal == 0 )
            {
              strcpy ( c->s1.PPPP, aux );
              c->mask |= CLIMAT_SEC1;
            }
          else
            {
              strcpy ( c->s2.PPPP, aux );
              c->mask |= CLIMAT_SEC2;
            }
        }
      break;
 
    default:
      if ( BUFR2TAC_DEBUG_LEVEL > 1 && (s->a->mask & DESCRIPTOR_VALUE_MISSING) == 0 ) 
        bufr2tac_set_error ( s, 0, "climat_parse_x10()", "Descriptor not parsed" );
      break;
 
    }
  return 0;
}

References bufr2tac_subset_state::a, BUFR2TAC_DEBUG_LEVEL, bufr2tac_set_error(), CLIMAT_SEC1, CLIMAT_SEC2, bufr_atom_data::desc, DESCRIPTOR_VALUE_MISSING, bufr2tac_subset_state::is_normal, bufr2tac_subset_state::isq_val, bufr2tac_subset_state::ival, bufr_atom_data::mask, climat_chunks::mask, pascal_to_PPPP(), climat_sec1::PoPoPoPo, climat_sec2::PoPoPoPo, climat_sec1::PPPP, climat_sec2::PPPP, climat_chunks::s1, climat_chunks::s2, bufr2tac_subset_state::val, and bufr_descriptor::y.

Referenced by parse_subset_as_climat().

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

c	pointer to a struct climat_chunks where to set the results
s	pointer 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.

{
 
  if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
    {
      return 0;
    }
 
  switch ( s->a->desc.y )
    {
    case 46: // 0 11 046 . Maximum wind speed
      if ( c->s4.iw[0] == '4' )
        {
          sprintf ( c->s4.fxfxfx, "%03d", ( int ) ( s->val * 10.0 * 1.94384449 + 0.5 ) );
        }
      else
        {
          sprintf ( c->s4.fxfxfx, "%03d", ( int ) ( s->val * 10.0 + 0.5 ) );
        }
      if ( s->isq_val == 0 )
        {
          sprintf ( c->s4.yfx, "%02d", s->day );
        }
      else
        {
          sprintf ( c->s4.yfx, "%02d", (s->day + 50) % 100 );
        }
      c->mask |= CLIMAT_SEC4;
      break;
 
    default:
      if ( BUFR2TAC_DEBUG_LEVEL > 1 && (s->a->mask & DESCRIPTOR_VALUE_MISSING) == 0 ) 
        bufr2tac_set_error ( s, 0, "climat_parse_x11()", "Descriptor not parsed" );
      break;
    }
  return 0;
}

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:

climat_parse_x12()

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

Parse a expanded descriptor with X = 12.

Parameters

c	pointer to a struct climat_chunks where to set the results
s	pointer 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 526 of file bufr2tac_x12.c.

{
  char aux[16];
 
  if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
    {
      return 0;
    }
 
  if ( c == NULL )
    {
      return 1;
    }
 
  switch ( s->a->desc.y )
    {
    case 101:
      if ( s->is_normal == 0 )
        {
          if ( s->isq_val == 4 ) // mean value
            {
              if ( kelvin_to_snTTT ( aux, s->val ) )
                {
                  c->s1.s[0] = aux[0];
                  strcpy ( c->s1.TTT, aux + 1 );
                  c->mask |= CLIMAT_SEC1;
                }
              else if ( BUFR2TAC_DEBUG_LEVEL > 0 )
                bufr2tac_set_error ( s, 1, "climat_parse_x12()->kelvin_to_snTTT()", "Unspected parse problem" );
            }
          else if ( s->isq_val == 2 ) // maximum value
            {
              if ( kelvin_to_snTTT ( aux, s->val ) )
                {
                  c->s4.sax[0] = aux[0];
                  strcpy ( c->s4.Tax, aux + 1 );
                  if ( s->more_days == 0 )
                    {
                      sprintf ( c->s4.yax, "%02d", s->day );
                    }
                  else
                    {
                      sprintf ( c->s4.yax, "%02d", ( s->day + 50 ) % 100 );
                    }
                  c->mask |= CLIMAT_SEC4;
                }
              else if ( BUFR2TAC_DEBUG_LEVEL > 0 )
                bufr2tac_set_error ( s, 1, "climat_parse_x12()->kelvin_to_snTTT()", "Unspected parse problem" );
 
            }
          else if ( s->isq_val == 3 ) // minimum value
            {
              if ( kelvin_to_snTTT ( aux, s->val ) )
                {
                  c->s4.san[0] = aux[0];
                  strcpy ( c->s4.Tan, aux + 1 );
                  if ( s->more_days == 0 )
                    {
                      sprintf ( c->s4.yan, "%02d", s->day );
                    }
                  else
                    {
                      sprintf ( c->s4.yan, "%02d", ( s->day + 50 ) % 100 );
                    }
                  c->mask |= CLIMAT_SEC4;
                }
              else if ( BUFR2TAC_DEBUG_LEVEL > 0 )
                bufr2tac_set_error ( s, 1, "climat_parse_x12()->kelvin_to_snTTT()", "Unspected parse problem" );
            }
        }
      else
        {
          if ( c->s2.TTT[0] == 0 )
            {
              if ( kelvin_to_snTTT ( aux, s->val ) )
                {
                  c->s2.s[0] = aux[0];
                  strcpy ( c->s2.TTT, aux + 1 );
                  c->mask |= CLIMAT_SEC2;
                }
              else if ( BUFR2TAC_DEBUG_LEVEL > 0 )
                bufr2tac_set_error ( s, 1, "climat_parse_x12()->kelvin_to_snTTT()", "Unspected parse problem" );
            }
 
        }
      break;
 
    case 118: // 0 12 118 . Maximum temperature at heigh specified, past 24 h
      if ( s->is_normal == 0 )
        {
          if ( c->s1.TxTxTx[0] == 0 )
            {
              if ( kelvin_to_snTTT ( aux, s->val ) )
                {
                  c->s1.sx[0] = aux[0];
                  strcpy ( c->s1.TxTxTx, aux + 1 );
                  c->mask |= CLIMAT_SEC1;
                }
              else if ( BUFR2TAC_DEBUG_LEVEL > 0 )
                bufr2tac_set_error ( s, 1, "climat_parse_x12()->kelvin_to_snTTT()", "Unspected parse problem" );
            }
        }
      else
        {
          if ( c->s2.TxTxTx[0] == 0 )
            {
              if ( kelvin_to_snTTT ( aux, s->val ) )
                {
                  c->s2.sx[0] = aux[0];
                  strcpy ( c->s2.TxTxTx, aux + 1 );
                  c->mask |= CLIMAT_SEC2;
                }
              else if ( BUFR2TAC_DEBUG_LEVEL > 0 )
                bufr2tac_set_error ( s, 1, "climat_parse_x12()->kelvin_to_snTTT()", "Unspected parse problem" );
            }
        }
      break;
 
    case 119: // 0 12 119 . Minimum temperature at heigh specified, past 24 h
      if ( s->is_normal == 0 )
        {
          if ( c->s1.TnTnTn[0] == 0 )
            {
              if ( kelvin_to_snTTT ( aux, s->val ) )
                {
                  c->s1.sn[0] = aux[0];
                  strcpy ( c->s1.TnTnTn, aux + 1 );
                  c->mask |= CLIMAT_SEC1;
                }
              else if ( BUFR2TAC_DEBUG_LEVEL > 0 )
                bufr2tac_set_error ( s, 1, "climat_parse_x12()->kelvin_to_snTTT()", "Unspected parse problem" );
            }
        }
      else
        {
          if ( c->s2.TnTnTn[0] == 0 )
            {
              if ( kelvin_to_snTTT ( aux, s->val ) )
                {
                  c->s2.sn[0] = aux[0];
                  strcpy ( c->s2.TnTnTn, aux + 1 );
                  c->mask |= CLIMAT_SEC2;
                }
              else if ( BUFR2TAC_DEBUG_LEVEL > 0 )
                bufr2tac_set_error ( s, 1, "climat_parse_x12()->kelvin_to_snTTT()", "Unspected parse problem" );
            }
        }
      break;
 
    case 151: // 0 12 151 . Standard deviation of daily mean temperature
      sprintf ( aux, "%03d", ( int ) ( s->val * 10.0 + 0.5 ) );
      if ( s->is_normal == 0 )
        {
          strcpy ( c->s1.ststst, aux );
          c->mask |= CLIMAT_SEC1;
        }
      else
        {
          strcpy ( c->s2.ststst, aux );
          c->mask |= CLIMAT_SEC2;
        }
      break;
 
    case 152: // 0 12 152 . Highest daily mean temperature
      if ( s->a1->desc.x == 4 && s->a1->desc.y == 3 )
        {
          if ( kelvin_to_snTTT ( aux, s->val ) )
            {
              c->s4.sx[0] = aux[0];
              strcpy ( c->s4.Txd, aux + 1 );
            }
          else if ( BUFR2TAC_DEBUG_LEVEL > 0 )
            bufr2tac_set_error ( s, 1, "climat_parse_x12()->kelvin_to_snTTT()", "Unspected parse problem" );
 
          if ( s->isq_val == 0 )
            {
              sprintf ( c->s4.yx, "%02d", s->day );
            }
          else
            {
              sprintf ( c->s4.yx, "%02d", ( s->day + 50 ) % 100 );
            }
          c->mask |= CLIMAT_SEC4;
        }
      break;
 
    case 153: // 0 12 153 . Lowest daily mean temperature
      if ( s->a1->desc.x == 4 && s->a1->desc.y == 3 )
        {
          if ( kelvin_to_snTTT ( aux, s->val ) )
            {
              c->s4.sn[0] = aux[0];
              strcpy ( c->s4.Tnd, aux + 1 );
            }
          else if ( BUFR2TAC_DEBUG_LEVEL > 0 )
            bufr2tac_set_error ( s, 1, "climat_parse_x12()->kelvin_to_snTTT()", "Unspected parse problem" );
 
          if ( s->isq_val == 0 )
            {
              sprintf ( c->s4.yn, "%02d", s->day );
            }
          else
            {
              sprintf ( c->s4.yn, "%02d", ( s->day + 50 ) % 100 );
            }
          c->mask |= CLIMAT_SEC4;
        }
      break;
 
    default:
      if ( BUFR2TAC_DEBUG_LEVEL > 1 && (s->a->mask & DESCRIPTOR_VALUE_MISSING) == 0 ) 
        bufr2tac_set_error ( s, 0, "climat_parse_x12()", "Descriptor not parsed" );
      break;
    }
  return 0;
}

References bufr2tac_subset_state::a, bufr2tac_subset_state::a1, BUFR2TAC_DEBUG_LEVEL, bufr2tac_set_error(), CLIMAT_SEC1, CLIMAT_SEC2, CLIMAT_SEC4, bufr2tac_subset_state::day, bufr_atom_data::desc, DESCRIPTOR_VALUE_MISSING, bufr2tac_subset_state::is_normal, bufr2tac_subset_state::isq_val, kelvin_to_snTTT(), bufr_atom_data::mask, climat_chunks::mask, bufr2tac_subset_state::more_days, climat_sec1::s, climat_sec2::s, climat_chunks::s1, climat_chunks::s2, climat_chunks::s4, climat_sec4::san, climat_sec4::sax, climat_sec1::sn, climat_sec2::sn, climat_sec4::sn, climat_sec1::ststst, climat_sec2::ststst, climat_sec1::sx, climat_sec2::sx, climat_sec4::sx, climat_sec4::Tan, climat_sec4::Tax, climat_sec4::Tnd, climat_sec1::TnTnTn, climat_sec2::TnTnTn, climat_sec1::TTT, climat_sec2::TTT, climat_sec4::Txd, climat_sec1::TxTxTx, climat_sec2::TxTxTx, bufr2tac_subset_state::val, bufr_descriptor::x, bufr_descriptor::y, climat_sec4::yan, climat_sec4::yax, climat_sec4::yn, and climat_sec4::yx.

Referenced by parse_subset_as_climat().

Here is the call graph for this function:

Here is the caller graph for this function:

climat_parse_x13()

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

Parse a expanded descriptor with X = 13.

Parameters

c	pointer to a struct climat_chunks where to set the results
s	pointer 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 909 of file bufr2tac_x13.c.

{
 
  if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
    {
      return 0;
    }
 
  if ( c == NULL )
    {
      return 1;
    }
 
 
  switch ( s->a->desc.y )
    {
    case 4: // 0 13 004 . Mean vapor pressure in tenths of hectopascal
      if ( s->is_normal == 0 )
        {
          sprintf ( c->s1.eee,"%03d", ( int ) ( s->val * 0.1 + 0.5 ) );
          c->mask |= CLIMAT_SEC1;
        }
      else
        {
          sprintf ( c->s2.eee,"%03d", ( int ) ( s->val * 0.1 + 0.5 ) );
          c->mask |= CLIMAT_SEC2;
        }
      break;
 
    case 51: // 0 13 051 . Frequency group precipitation
      if ( s->ival >= 0 && s->ival <= 6 )
        {
          sprintf ( c->s1.Rd, "%d", s->ival );
        }
      break;
 
    case 52: // 0 13 052 . Highest daily amount of precipitation
      prec_to_RxRxRxRx ( c->s4.RxRxRxRx, s->val );
      if ( s->more_days == 0 )
        {
          sprintf ( c->s4.yr, "%02d", s->day );
        }
      else
        {
          sprintf ( c->s4.yr, "%02d", (s->day + 50) % 50 );
        }
      c->mask |= CLIMAT_SEC4;
      break;
 
    case 60: // 0 13 060 . Total acumulated precipitation
      if ( s->is_normal == 0 )
        {
          prec_to_RRRR ( c->s1.R1R1R1R1, s->val );
          c->mask |= CLIMAT_SEC1;
        }
      else
        {
          prec_to_RRRR ( c->s2.R1R1R1R1, s->val );
          c->mask |= CLIMAT_SEC2;
        }
      break;
 
    default:
      if ( BUFR2TAC_DEBUG_LEVEL > 1 && (s->a->mask & DESCRIPTOR_VALUE_MISSING) == 0 ) 
        bufr2tac_set_error ( s, 0, "climat_parse_x13()", "Descriptor not parsed" );
      break;
    }
  return 0;
}

References bufr2tac_subset_state::a, BUFR2TAC_DEBUG_LEVEL, bufr2tac_set_error(), CLIMAT_SEC1, CLIMAT_SEC2, CLIMAT_SEC4, bufr2tac_subset_state::day, bufr_atom_data::desc, DESCRIPTOR_VALUE_MISSING, climat_sec1::eee, climat_sec2::eee, bufr2tac_subset_state::is_normal, bufr2tac_subset_state::ival, bufr_atom_data::mask, climat_chunks::mask, bufr2tac_subset_state::more_days, prec_to_RRRR(), prec_to_RxRxRxRx(), climat_sec1::R1R1R1R1, climat_sec2::R1R1R1R1, climat_sec1::Rd, climat_sec4::RxRxRxRx, climat_chunks::s1, climat_chunks::s2, climat_chunks::s4, bufr2tac_subset_state::val, bufr_descriptor::y, and climat_sec4::yr.

Referenced by parse_subset_as_climat().

Here is the call graph for this function:

Here is the caller graph for this function:

climat_parse_x14()

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

Parse a expanded descriptor with X = 14.

Parameters

c	pointer to a struct climat_chunks where to set the results
s	pointer 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 497 of file bufr2tac_x14.c.

{
  if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
    {
      return 0;
    }
 
  if ( c == NULL )
    {
      return 1;
    }
 
  switch ( s->a->desc.y )
    {
    case 32: // 0 14 032 . Total sunshine
      if ( s->is_normal == 0 )
        {
          sprintf ( c->s1.S1S1S1, "%03d", s->ival );
          c->mask |= CLIMAT_SEC1;
        }
      else
        {
          sprintf ( c->s2.S1S1S1, "%03d", s->ival );
          c->mask |= CLIMAT_SEC2;
        }
      break;
 
    case 33: // 0 14 033 . total sunshine percentage
      sprintf ( c->s1.pspsps, "%03d", s->ival );
      c->mask |= CLIMAT_SEC1;
      break;
 
    default:
      if ( BUFR2TAC_DEBUG_LEVEL > 1 && (s->a->mask & DESCRIPTOR_VALUE_MISSING) == 0 ) 
        bufr2tac_set_error ( s, 0, "climat_parse_x14()", "Descriptor not parsed" );
      break;
    }
  return 0;
}

References bufr2tac_subset_state::a, BUFR2TAC_DEBUG_LEVEL, bufr2tac_set_error(), CLIMAT_SEC1, CLIMAT_SEC2, bufr_atom_data::desc, DESCRIPTOR_VALUE_MISSING, bufr2tac_subset_state::is_normal, bufr2tac_subset_state::ival, bufr_atom_data::mask, climat_chunks::mask, climat_sec1::pspsps, climat_chunks::s1, climat_sec1::S1S1S1, climat_sec2::S1S1S1, climat_chunks::s2, and bufr_descriptor::y.

Referenced by parse_subset_as_climat().

Here is the call graph for this function:

Here is the caller graph for this function:

climat_parse_x20()

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

climat_parse_x22()

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

climat_parse_x31()

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

climat_parse_x33()

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

descriptor_to_integer()

int descriptor_to_integer	(	int *	id,
		struct bufr_descriptor *	d
	)

parse a descriptor and sets an integer in the decimal formas fxxyyy

Parameters

id	pointer to target integer
d	pointer to a struct bufr_descriptor with the source

Definition at line 58 of file bufr2tac_utils.c.

{
  if ( d == NULL )
    return 1;
  *id = 100000 * d->f + 1000 * d->x + d->y;
  return 0;
}

References bufr_descriptor::f, bufr_descriptor::x, and bufr_descriptor::y.

Referenced by bufrtotac_parse_subset_sequence().

Here is the caller graph for this function:

dewpoint_depression_to_DnDn()

char * dewpoint_depression_to_DnDn	(	char *	target,
		double	T,
		double	Td
	)

Set DnDn (dewpoint depression)

Parameters

target	string to set as result
T	temperature (Kelvin)
Td	dewpoint (Kelvin)

Definition at line 179 of file bufr2tac_x12.c.

{
  int ix;
  double dpd = T - Td;
 
  if ( T == MISSING_REAL || Td == MISSING_REAL )
    {
      strcpy ( target, "//" );
      return target;
    }
 
  if ( dpd < 0.0 )
    {
      return NULL;
    }
 
  if ( dpd > 50.0 )
    {
      strcpy ( target, "//" );
      return target;
    }
 
  ix = ( int ) ( 10.0 * dpd );
 
  if ( ix >= 55 )
    {
      ix = 50 + ( ix + 5 ) / 10;
    }
  sprintf ( target, "%02d", ix );
 
  return target;
}

References MISSING_REAL.

Referenced by parse_temp_raw_data().

Here is the caller graph for this function:

find_descriptor()

int find_descriptor	(	int *	haystack,
		size_t	nlst,
		int	needle
	)

Try to find a descriptor in an array.

Parameters

haystack	array of integers as descriptors
nlst	number of descriptors in array
needle	descriptor to find

it returns 1 if found, 0 otherwise.

Definition at line 35 of file bufr2tac_sqparse.c.

{
  size_t i = 0;
  while ( ( i < nlst ) && ( haystack[i] != needle ) )
    {
      i++;
    }
  return ( i < nlst );
}

Referenced by parse_subset_sequence().

Here is the caller graph for this function:

find_descriptor_interval()

int find_descriptor_interval	(	int *	haystack,
		size_t	nlst,
		int	needlemin,
		int	needlemax
	)

Definition at line 59 of file bufr2tac_sqparse.c.

{
  size_t i = 0;
 
  while ( ( i < nlst ) && ( haystack[i] > needlemax || haystack[i] < needlemin ) )
    {
      i++;
    }
  return ( i < nlst );
}

Referenced by parse_subset_sequence().

Here is the caller graph for this function:

get_ecmwf_tablename()

char * get_ecmwf_tablename	(	char *	target,
		char	type,
		char *	bufrtables_dir,
		int	ksec1[40]
	)

Get the complete pathname of a table file needed by a bufr message.

Parameters

target	the resulting name
type	a char with type, i.e, 'B', 'C', or 'D'
bufrtables_dir	string with path to bufr file tables dir
ksec1	array of integer processed prevoiously by ecmwf bufr library In ECMWF library the name of a table file is Kssswwwwwxxxxxyyyzzz.TXT , where K - type of table, i.e, 'B', 'C', or 'D' sss - Master table number (zero for WMO meteorological tables) wwwww - Originating sub-centre xxxxx - Originating centre yyy - Version number of master table used zzz - Version number of local table used

If standard WMO tables are used, the Originating centre xxxxx will be set to

Definition at line 43 of file bufr2tac_tablec.c.

{
  if ( 0 )
    {
      if ( ksec1[13] != 0 ) // case of not WMO tables
        sprintf ( target,"%s%c%03d%05d%05d%03d%03d.TXT", bufrtables_dir, type, ksec1[13], ksec1[15], ksec1[2], ksec1[14], ksec1[7] );
      else
        sprintf ( target,"%s%c000%05d00000%03d%03d.TXT", bufrtables_dir, type, ksec1[15], ksec1[14], ksec1[7] );
    }
  else
    {
      //FIXME Some countries uses latest C tables instead of the version they said in bufr
      sprintf ( target,"%s%c0000000000000019000.TXT", bufrtables_dir, type );
    }
  return target;
}

Referenced by read_table_c().

Here is the caller graph for this function:

get_explained_flag_val()

char * get_explained_flag_val	(	char *	expl,
		size_t	dim,
		char	tablec[MAXLINES_TABLEC][92],
		size_t	nlines_tablec,
		struct bufr_descriptor *	d,
		unsigned long	ival
	)

Definition at line 181 of file bufr2tac_tablec.c.

{
  char *c, *s;
  unsigned long test, test0;
  unsigned long nb, nx, v,  nl;
  size_t i, j;
 
  // Find first line for descriptor
  for ( i = 0; i <  nlines_tablec; i++ )
    {
      if ( tablec[i][0] != d->c[0] ||
           tablec[i][1] != d->c[1] ||
           tablec[i][2] != d->c[2] ||
           tablec[i][3] != d->c[3] ||
           tablec[i][4] != d->c[4] ||
           tablec[i][5] != d->c[5] )
        continue;
      else
        break;
    }
 
  if ( i == nlines_tablec )
    {
      //printf("Descriptor %s No encontrado\n", d->c);
      return NULL;
    }
  //printf("Descriptor %s en linea %d\n", d->c, i);
 
  // reads the amount of possible bits
  if ( tablec[i][7] != ' ' )
    nb = strtol ( &tablec[i][7], &c, 10 );
  else
    return NULL;
 
  // read a value
  s = expl;
  s[0] = '\0';
 
  for ( j = 0, test0 = 2; j < nb && i < nlines_tablec ; i++ )
    {
      if ( tablec[i][12] != ' ' )
        {
          v = strtol ( &tablec[i][12], &c, 10 ); // v is the bit number
          j++;
 
          // case 0 with meaning
          if ( v == 0 )
            {
              test0 = 1;
              if ( ival == 0 )
                {
                  nl = strtol ( &tablec[i][21], &c, 10 );
                  if ( strlen ( expl ) && ( strlen ( expl ) + 1 ) < dim )
                    s += sprintf ( s, "|" );
                  s += sprintf ( s,"%s", &tablec[i][24] );
                  if ( nl > 1 )
                    {
                      for ( nx = 1 ; nx < nl; nx++ )
                        if ( ( strlen ( expl ) + strlen ( &tablec[i + nx][22] ) )  < dim )
                          {
                            s += sprintf ( s, "%s", &tablec[i + nx][22] );
                          }
                    }
                  return expl;
                }
            }
 
          test = test0 << ( nb - v );
 
          if ( v && ( test & ival ) != 0 )
            {
              // bit match
              // read how many lines for the descriptors
              nl = strtol ( &tablec[i][21], &c, 10 );
              if ( strlen ( expl ) && ( strlen ( expl ) + 1 ) < dim )
                s += sprintf ( s, "|" );
              s += sprintf ( s,"%s", &tablec[i][24] );
              if ( nl > 1 )
                {
                  for ( nx = 1 ; nx < nl; nx++ )
                    if ( ( strlen ( expl ) + strlen ( &tablec[i + nx][22] ) )  < dim )
                      {
                        s += sprintf ( s, "%s", &tablec[i + nx][22] );
                      }
                }
 
            }
          else
            continue;
        }
    }
 
  // if match then we have finished the search
 
  return expl;
}

References bufr_descriptor::c.

get_explained_table_val()

char * get_explained_table_val	(	char *	expl,
		size_t	dim,
		char	tablec[MAXLINES_TABLEC][92],
		size_t	nlines_tablec,
		struct bufr_descriptor *	d,
		int	ival
	)

Definition at line 103 of file bufr2tac_tablec.c.

{
  char *c;
  long nv, v,  nl;
  size_t i, j;
 
  // Find first line for descriptor
  for ( i = 0; i <  nlines_tablec; i++ )
    {
      if ( tablec[i][0] != d->c[0] ||
           tablec[i][1] != d->c[1] ||
           tablec[i][2] != d->c[2] ||
           tablec[i][3] != d->c[3] ||
           tablec[i][4] != d->c[4] ||
           tablec[i][5] != d->c[5] )
        continue;
      else
        break;
    }
 
  if ( i == nlines_tablec )
    {
      //printf("Descriptor %s No encontrado\n", d->c);
      return NULL;
    }
  //printf("Descriptor %s en linea %d\n", d->c, i);
 
  // reads the amount of possible values
  if ( tablec[i][7] != ' ' )
    nv = strtol ( &tablec[i][7], &c, 10 );
  else
    return NULL;
 
  // read a value
  for ( j = 0; ( long ) j < nv && i < nlines_tablec ; i++ )
    {
      if ( tablec[i][12] != ' ' )
        {
          v = strtol ( &tablec[i][12], &c, 10 );
          j++;
          if ( v != ival )
            continue;
          break;
        }
    }
 
  if ( ( long ) j == nv || i == nlines_tablec )
    return NULL; // Value not found
 
  // read how many lines for the descriptors
  nl = strtol ( &tablec[i][21], &c, 10 );
 
 
  // if match then we have finished the search
  strcpy ( expl, &tablec[i][24] );
  if ( nl > 1 )
    {
      for ( nv = 1 ; nv < nl; nv++ )
        if ( ( strlen ( expl ) + strlen ( &tablec[i + nv][22] ) ) < dim )
          strcat ( expl, &tablec[i + nv][22] );
    }
 
  return expl;
}

References bufr_descriptor::c.

grad_to_D()

char * grad_to_D	(	char *	D,
		double	grad
	)

Converts true direction in grads to D (code table 0700)

Parameters

grad	the true direction (degrees)
D	the resulting code

Definition at line 32 of file bufr2tac_x05.c.

{
  if ( grad >= 22.5 && grad < 67.5 )
    strcpy ( D, "1" );
  else if ( grad >= 67.5 && grad < 112.5 )
    strcpy ( D, "2" );
  else if ( grad >= 112.5 && grad < 157.5 )
    strcpy ( D, "3" );
  else if ( grad >= 157.5 && grad < 202.5 )
    strcpy ( D, "4" );
  else if ( grad >= 202.5 && grad < 247.5 )
    strcpy ( D, "5" );
  else if ( grad >= 247.5 && grad < 292.5 )
    strcpy ( D, "6" );
  else if ( grad >= 292.5 && grad < 337.5 )
    strcpy ( D, "7" );
  else if ( ( grad >= 337.5 && grad <= 360.0 ) ||
            ( grad >0.0 && grad < 22.5 ) )
    strcpy ( D, "8" );
  else if ( grad == 0.0 )
    strcpy ( D, "0" );
  else
    strcpy ( D, "9" );
  return D;
}

Referenced by syn_parse_x05(), and syn_parse_x20().

Here is the caller graph for this function:

grad_to_ec()

char * grad_to_ec	(	char *	target,
		double	grad
	)

Converts elevation in grads to ec (code table 1004)

Parameters

grad	the elevation angle (degrees)
target	the resulting code

Definition at line 32 of file bufr2tac_x07.c.

{
  if ( grad < 5.0 )
    strcpy ( target, "9" );
  else if ( grad < 6.5 )
    strcpy ( target, "8" );
  else if ( grad < 8.0 )
    strcpy ( target, "7" );
  else if ( grad < 10.5 )
    strcpy ( target, "6" );
  else if ( grad < 13.5 )
    strcpy ( target, "5" );
  else if ( grad < 17.5 )
    strcpy ( target, "4" );
  else if ( grad < 25.0 )
    strcpy ( target, "3" );
  else if ( grad < 40.0 )
    strcpy ( target, "2" );
  else if ( grad >= 45.0 )
    strcpy ( target, "1" );
  else
    strcpy ( target, "0" );
  return target;
}

Referenced by syn_parse_x07().

Here is the caller graph for this function:

guess_gts_header()

int guess_gts_header	(	struct gts_header *	h,
		const char *	f
	)

Guess the WMO GTS header from filename.

Parameters

h	pointer to a struct gts_header where to set the results
f	pathname of bufrfile

It returns 1 if guessed, 0 otherwise

This routine assume the filename format of a bufr file is

  YYYYMMDDHHmmss_BULLNN_ICAO_YYGGgg_ORD.bufr

where

 YYYYMMDDHHmmss

is the timestamp (UTC) of the file in GTS (as example, in NOAA gateway)

BULLNN is the bulletin identifier in GTS. It is a six chars lenght in the form T1 T2 A1 A2 N1 N2

  For observations, T1 is 'I'
  Possible values of T2 for T1 = 'I' are
     O   Oceanographic/limnographic (water properties)
     P   Pictorial
     S   Surface/sea level
     T   Text (plain language information)
     U   Upper air
     X   Other data types
     Z   Mixed data types


  For T1T2 = 'IS' Then A1:

     IS A 01–29 Routinely scheduled observations for n/a 000/006
                distribution from automatic (fixed or mobile)
                land stations (e.g. 0000, 0100, … or 0220, 0240,
                0300, …, or 0715, 0745, ... UTC)
     IS A 30–59 N-minute observations from automatic (fixed n/a 000/007
                or mobile) land stations
     IS B   Radar reports (parts A and B) RADOB 006/003
     IS C 01–45 Climatic observations from land stations CLIMAT 000/020
     IS C 46–59 Climatic observations from marine stations CLIMAT SHIP 001/0202009 edition
                ATTACHmENT II-5 I
     IS D   Radiological observation RADREP 010/001
     IS E   Ozone measurement at surface n/a 008/000
     IS F   Source of atmospherics SFAZI, SFLOC, SFAZU 000/030
     IS I 01–45 Intermediate synoptic observations from fixed SYNOP (SIxx) 000/001
            land stations 000/051
     IS I 46–59 Intermediate synoptic observations from mobile SYNOP mOBIL 000/004
            land stations
     IS M 01–45 Main synoptic observations from fixed land SYNOP (SMxx) 000/002
            stations 000/052
     IS M 46–59 Main synoptic observations from mobile land SYNOP mOBIL 000/005
             stations
     IS N 01–45 Synoptic observations from fixed land stations SYNOP (SNxx) 000/000
            at non-standard time (i.e. 0100, 0200, 0400,   000/050
            0500, ... UTC)
     IS N 46–59 Synoptic observations from mobile land stations SYNOP mOBIL 000/003
            at non-standard time (i.e. 0100, 0200, 0400,
            0500, ... UTC)
     IS R   Hydrologic reports HYDRA 000/040
     IS S 01–19 Synoptic observations from marine stations SHIP 001/000
     IS S 20–39 One-hour observations from automatic marine n/a 001/006
           stations
     IS S 40–59 N-minute observations from automatic marine n/a 001/007
           stations
     IS T 01–19 Tide gauge observations n/a 001/030
     IS T 20–39 Observed water level time series n/a 001/031
     IS V   Special aeronautical observations (SPECI) SPECI 000/011
     IS W   Aviation routine weather observations (mETAR) mETAR 000/010
     IS X   Other surface data IAC, IAC FLEET

  For T1T2 = 'IU'  then A1:
     IU A   Single level aircraft reports (automatic) AmDAR 004/000
     IU A   Single level aircraft reports (manual) AIREP/PIREP 004/001
     IU B   Single level balloon reports n/a
     IU C   (used for single level satellite-derived SAREP/SATOB 005/000
             reports – see Note 3)
     IU D   Dropsonde/Dropwindsondes TEmP DROP 002/007
     IU E   Ozone vertical sounding n/a 008/001
     IU I   Dispersal and transport analysis n/a 009/000
     IU J 01–19 Upper wind from fixed land stations (entire PILOT (parts A, 002/001
            sounding) B, C, D)
     IU J 20–39 Upper wind from mobile land stations (entire PILOT mOBIL 002/003
            sounding) (parts A, B, C, D)
     IU J 40–59 Upper wind from marine stations (entire PILOT SHIP 002/002
           sounding) (parts A, B, C, D)
     IU K 01–19 Radio soundings from fixed land stations TEmP (parts A, B) 002/004
           (up to 100 hPa)
     IU K 20–39 Radio soundings from mobile land stations TEmP mOBIL 002/006
          (up to 100 hPa) (parts A, B)
     IU K 40–59 Radio soundings from marine stations TEmP SHIP (parts A, B) 002/005
           (up to 100 hPa)
     IU M   Model derived sondes
     IU N   Rocketsondes
     IU O   Profiles of aircraft observations in ascending/ AmDAR 002/020
            descending
     IU P   Profilers PILOT 002/010
     IU Q   RASS temperature profilers TEmP 002/011
     IU R   (used for radiance data – see Note 3)
     IU S   01–19 Radiosondes/pibal reports from fixed land TEmP (parts A, B, C, D) 002/004
             stations (entire sounding)
     IU S 20–39 Radio soundings from mobile land stations TEmP mOBIL (parts A, 002/006
             (entire sounding) B, C, D)
     IU S 40–59 Radio soundings from marine stations TEmP SHIP (parts A, 002/005
             (entire sounding) B, C, D)
     IU T   (used for satellite-derived sondes – see Note 3) SATEm, SARAD, SATOB
     IU U 01–45 Monthly statistics of data from upper-air stations CLImAT TEmP 002/025
     IU U 46–59 Monthly statistics of data from marine stations CLImAT TEmP, SHIP 002/026
     IU W 01–19 Upper wind from fixed land stations (up to PILOT (parts A, B) 002/001
             100 hPa)
     IU W 20–39 Upper wind from mobile land stations (up to PILOT mOBIL 002/003
             100 hPa) (parts A, B)
     IU W 40–59 Upper wind from marine stations (up to PILOT SHIP 002/002
             100 hPa) (parts A, B)
     IU X   Other upper-air reports

  for T1T2 = 'IO' then  A1:
     IO B   Buoy observations BUOY 001/025
     IO I   Sea ice
     IO P   Sub-surface profiling floats TESAC 031/004
     IO R   Sea surface observations TRACKOB 031/001
     IO S   Sea surface and below soundings BATHY, TESAC 031/005
     IO T   Sea surface temperature
     IO W   Sea surface waves WAVEOB 031/002
     IO X   Other sea environmental

  About A2
     A   0 - 90W northern hemisphere
     B   90W - 180 northern hemisphere
     C   180 - 90E northern hemisphere
     D   90E - 0 northern hemisphere
     E   0 - 90W tropical belt
     F   90W - 180 tropical belt
     G   180 - 90E tropical belt
     H   90E - 0 tropical belt
     I   0 - 90W southern hemisphere
     J   90W - 180 southern hemisphere
     K   180 - 90E southern hemisphere
     L   90E - 0 southern hemisphere
     M   Lower left 10S 100E/upper right 70N 110W
     N   Northern hemisphere
     P   Area between 64.69N - 136.76W, 55.61N - 13.43W
     64.69N - 156.76W, 55.61N - 33.43W
     S   Southern hemisphere
     T   45W - 180 northern hemisphere
     U   Area between 21.0N - 128.1W, 36.0N - 130.9W
               21.1N - 113.0W, 36.2N - 110.5W
     V   Area between 30.3N - 83.7W, 51.0N - 68.9W
               19.8N - 64.5W, 33.3N - 47.1W
     X   Global Area (area not definable)


 ICAO is the ICAO index for release center.

 YYGGgg is the nominal release time (day, hour, minute) UTC

 ORD is the order sequence as RRA, RRB, CCA .... is optional

Definition at line 466 of file bufr2tac_utils.c.

{
  size_t nt;
  char aux[256], *tk[16], *c;
 
  // parse file name
  strcpy ( h->filename, f );
  strcpy ( aux, f );
 
  // check latest '/' in filename
  if ( ( c = strrchr ( aux,'/' ) ) == NULL )
    c = &aux[0];
  else
    c++;
 
  nt = tokenize_string ( tk, 16, c, strlen ( c ), "_. " );
  // parse filenames with format as example 'AAAAMMDDHHmmss_ISIE06_SBBR_012100_RRB.bufr'
 
  // 5 or 6 items
  if ( nt < 5 || nt > 6 )
    return 0;
 
  // extension bufr
  if ( strcmp ( tk[nt - 1],"bufr" ) )
    return 0;
 
  // item 0 the timestamp of file in NOAA GTS gateway
  if ( strlen ( tk[0] ) != 14 || strspn ( tk[0], "0123456789" ) != 14 )
    return 0;
  strcpy ( h->timestamp, tk[0] );
 
  // item 1
  if ( strlen ( tk[1] ) != 6 || strspn ( &tk[1][4],"0123456789" ) != 2 )
    return 0;
  strcpy ( h->bname, tk[1] );
 
  // item 2
  if ( strlen ( tk[2] ) != 4 )
    return 0;
  strcpy ( h->center, tk[2] );
 
  if ( strlen ( tk[3] ) != 6 || strspn ( tk[3], "0123456789" ) != 6 )
    return 0;
  strcpy ( h->dtrel, tk[3] );
 
  if ( nt == 5 )
    {
      strcpy ( h->order, "BBB" );
    }
  else
    {
      if ( strlen ( tk[4] ) == 3 )
        strcpy ( h->order, tk[4] );
      else
        return 0;
    }
 
  return 1;
}

References gts_header::bname, gts_header::center, gts_header::dtrel, gts_header::filename, gts_header::order, gts_header::timestamp, and tokenize_string().

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

guess_WMO_region()

char * guess_WMO_region	(	char *	A1,
		char *	Reg,
		const char *	II,
		const char *	iii
	)

get WMO region A1 and Reg items from II and iii (WMO index)

Parameters

A1	string woth resulting A1
Reg	string with resulting Reg
II	WMO block number
iii	WMO number

Definition at line 211 of file bufr2tac_utils.c.

{
  char aux[8];
 
  // filter bad inputs
  if ( II == NULL || iii == NULL )
    return NULL;
 
  if ( II[0] == 0 || iii[0] == 0 )
    return NULL;
 
  // aux string
  sprintf ( aux,"%s%s", II, iii );
 
  if ( ( II[0] == '0' && ( strstr ( aux,"042" ) != aux ) && ( strstr ( aux,"043" ) != aux )  &&
         ( strstr ( aux,"044" ) != aux )  && ( strstr ( aux,"0858" ) != aux ) && ( strstr ( aux,"0859" ) != aux ) ) ||
       II[0] == '1' || ( strstr ( aux,"201" ) == aux ) ||
       strcmp ( II,"22" ) == 0 || strcmp ( II,"26" ) == 0 || strcmp ( II,"27" ) == 0 ||
       strcmp ( II,"33" ) == 0 || strcmp ( II,"34" ) == 0 || strcmp ( II,"22" ) == 0 ||
       ( strstr ( aux,"201" ) == aux ) )
    {
      // Reg 6. Europe
      A1[0] = '6';
      strcpy ( Reg,"VI" );
    }
  else if ( II[0] == '6' || ( strstr ( aux,"0858" ) == aux ) || ( strstr ( aux,"0859" ) == aux ) )
    {
      // Reg 1. Africa
      A1[0] = '1';
      strcpy ( Reg,"I" );
    }
  else if ( II[0] == '5' || ( strcmp ( II,"49" ) == 0 ) || ( strcmp ( II,"21" ) == 0 ) ||
            ( strcmp ( II,"23" ) == 0 ) || ( strcmp ( II,"24" ) == 0 ) || ( strcmp ( II,"25" ) == 0 ) ||
            ( strcmp ( II,"28" ) == 0 ) || ( strcmp ( II,"29" ) == 0 ) || ( strcmp ( II,"30" ) == 0 ) ||
            ( strcmp ( II,"31" ) == 0 ) || ( strcmp ( II,"32" ) == 0 ) || ( strcmp ( II,"38" ) == 0 ) ||
            ( strcmp ( II,"35" ) == 0 ) || ( strcmp ( II,"36" ) == 0 ) || ( strcmp ( II,"39" ) == 0 ) ||
            ( strcmp ( aux, "20200" ) >= 0 && strcmp ( aux, "20999" ) <= 0 ) ||
            ( strcmp ( aux, "40000" ) >= 0 && strcmp ( aux, "48599" ) <= 0 ) ||
            ( strcmp ( aux, "48800" ) >= 0 && strcmp ( aux, "49999" ) <= 0 ) )
    {
      // Reg 2. Asia
      A1[0] = '2';
      strcpy ( Reg,"II" );
    }
  else if ( strcmp ( aux, "80000" ) >= 0 && strcmp ( aux, "88999" ) <= 0 )
    {
      // Reg 3. South america
      A1[0] = '3';
      strcpy ( Reg,"III" );
    }
  else if ( II[0] == '7' || strstr ( aux,"042" ) == aux ||
            strstr ( aux,"043" ) == aux  || strstr ( aux,"044" ) == aux )
    {
      // Reg 4. North and central america
      A1[0] = '4';
      strcpy ( Reg,"IV" );
    }
  else if ( ( strcmp ( aux, "48600" ) >= 0 && strcmp ( aux, "48799" ) <= 0 ) ||
            ( strcmp ( aux, "90000" ) >= 0 && strcmp ( aux, "98999" ) <= 0 ) )
    {
      // Reg 5. Pacific South
      A1[0] = '5';
      strcpy ( Reg,"V" );
    }
  else if ( strcmp ( II,"89" ) == 0 )
    {
      // Reg 0. Antarctica
      A1[0] = '0';
      strcpy ( Reg,"0" );
    }
  return A1;
}

Referenced by guess_WMO_region_synop(), guess_WMO_region_temp(), and syn_parse_x01().

Here is the caller graph for this function:

guess_WMO_region_synop()

char * guess_WMO_region_synop

(

struct synop_chunks *

syn

)

Try to find WMO region if it is not already set and WMO Block and number index are known.

Parameters

syn	pointer to the struct synop_chunks with all known data for a synop

It returns a pointer to the string with WMO region

Definition at line 93 of file bufr2tac_synop.c.

{
  if ( syn->s0.A1[0] )
    {
      return syn->s0.A1;
    }
 
  if ( syn->s0.II[0] == 0  || syn->s0.iii[0] == 0 )
    {
      return syn->s0.A1;
    }
 
  return guess_WMO_region ( syn->s0.A1, syn->s0.Reg, syn->s0.II, syn->s0.iii );
}

References synop_sec0::A1, guess_WMO_region(), synop_sec0::II, synop_sec0::iii, synop_sec0::Reg, and synop_chunks::s0.

Here is the call graph for this function:

guess_WMO_region_temp()

char * guess_WMO_region_temp

(

struct temp_chunks *

temp

)

Definition at line 34 of file bufr2tac_temp.c.

{
  if ( t->a.s1.A1[0] )
    {
      return t->a.s1.A1;
    }
 
  if ( t->a.s1.II[0] == 0  || t->a.s1.iii[0] == 0 )
    {
      return t->a.s1.A1;
    }
 
  if ( guess_WMO_region ( t->a.s1.A1, t->a.s1.Reg, t->a.s1.II, t->a.s1.iii ) != NULL )
    {
      // copy the results in part A to parts A,B and C
      strcpy ( t->b.s1.A1, t->a.s1.A1 );
      strcpy ( t->c.s1.A1, t->a.s1.A1 );
      strcpy ( t->d.s1.A1, t->a.s1.A1 );
      strcpy ( t->b.s1.Reg, t->a.s1.Reg );
      strcpy ( t->c.s1.Reg, t->a.s1.Reg );
      strcpy ( t->d.s1.Reg, t->a.s1.Reg );
      return t->a.s1.A1;
    }
  else
    {
      return NULL;
    }
}

References temp_chunks::a, temp_acd_sec1::A1, temp_b_sec1::A1, temp_chunks::b, temp_chunks::c, temp_chunks::d, guess_WMO_region(), temp_acd_sec1::II, temp_acd_sec1::iii, temp_acd_sec1::Reg, temp_b_sec1::Reg, temp_a::s1, temp_b::s1, temp_c::s1, and temp_d::s1.

Here is the call graph for this function:

hour_rounded()

int hour_rounded

(

struct synop_chunks *

syn

)

Get the rounded hour of a given date.

Parameters

syn	pointer to the synop_chunks struct

It returns the rounded hour if >= 0. If < 0 problems

Definition at line 78 of file bufr2tac_x04.c.

{
  time_t t;
  struct tm tim;
  char aux[32];
 
  sprintf ( aux, "%s%s%s%s%s", syn->e.YYYY,syn->e.MM,syn->e.DD,syn->e.HH, syn->e.mm );
  memset ( &tim, 0, sizeof ( struct tm ) );
  if ( strlen ( aux ) == 12 )
    {
      strptime ( aux, "%Y%m%d%H%M", &tim );
      t = mktime ( &tim );
      t += 1800;
      gmtime_r ( &t, &tim );
      return tim.tm_hour;
    }
  else if ( syn->e.mm[0] == 0 && syn->e.HH[0] )
    {
      return atoi ( syn->e.HH );
    }
  else
    return -1;
}

References report_date_ext::DD, synop_chunks::e, report_date_ext::HH, report_date_ext::MM, report_date_ext::mm, and report_date_ext::YYYY.

Referenced by syn_parse_x13().

Here is the caller graph for this function:

integer_to_descriptor()

int integer_to_descriptor	(	struct bufr_descriptor *	d,
		int	id
	)

parse an integer with a descriptor fom bufr ECWMF libary

Parameters

d	pointer to a struct bufr_descriptor where to set the result on output
id	integer with the descriptor from ewcwf

Definition at line 41 of file bufr2tac_utils.c.

{
  if ( d == NULL )
    return 1;
  d->f = id / 100000;
  d->x = ( id % 100000 ) / 1000;
  d->y = id % 1000;
  sprintf ( d->c, "%06d", id );
  return 0;
}

References bufr_descriptor::c, bufr_descriptor::f, bufr_descriptor::x, and bufr_descriptor::y.

kelvin_to_snTT()

char * kelvin_to_snTT	(	char *	target,
		double	T
	)

converts a kelvin temperature value into a snTT string

Parameters

T	the temperature ( Kelvin )
target	string with the result

Definition at line 69 of file bufr2tac_x12.c.

{
  int ic;
  if ( T < 173.65 || T > 340.0 )
    {
      return NULL;
    }
 
  // Whole degrees (Celsius)
  ic = ( int ) ( floor ( ( T - 273.15 ) + 0.5 ) );
  if ( ic < 0 )
    {
      sprintf ( target, "1%02d", -ic );
    }
  else
    {
      sprintf ( target, "%03d", ic );
    }
  return target;
}

Referenced by syn_parse_x12().

Here is the caller graph for this function:

kelvin_to_snTTT()

char * kelvin_to_snTTT	(	char *	target,
		double	T
	)

converts a kelvin temperature value into a snTTT string

Parameters

T	the temperature ( Kelvin )
target	string with the result

Definition at line 32 of file bufr2tac_x12.c.

{
  int ic;
  double Tx = T;
 
  if ( Tx > 15 && Tx < 34.0 ) // guess there is an scale error on coding , we better manage T * 10
    {
      Tx *= 10.0;
    }
  if ( Tx < 173.205 || Tx > 340.0 )
    {
      return NULL;
    }
 
  // tenths of degree (Celsius)
  // Patch introduced on 22-Dec-2019 due to some roundings errors from India and Australia
  // not converting properly from Kelvin to Celsius for Tmax and Tmin
  // Changed '0.5' to '0.45'
  //ic = ( int ) ( floor ( 10.0 * ( Tx - 273.15 ) + 0.5 ) );
  ic = ( int ) ( floor ( 10.0 * ( Tx - 273.15 ) + 0.45 ) );
  if ( ic < 0 )
    {
      sprintf ( target, "1%03d",  -ic );
    }
  else
    {
      sprintf ( target, "0%03d",  ic );
    }
  return target;
}

Referenced by buoy_parse_x12(), buoy_parse_x22(), climat_parse_x12(), syn_parse_x12(), syn_parse_x22(), and temp_parse_x22().

Here is the caller graph for this function:

kelvin_to_TT()

char * kelvin_to_TT	(	char *	target,
		double	T
	)

converts a kelvin temperature value into a TT string

Parameters

T	the temperature ( Kelvin )
target	string with the result

Definition at line 96 of file bufr2tac_x12.c.

{
  int ic;
  if ( T < 150.0 || T > 340.0 )
    {
      return NULL;
    }
 
  // Whole degrees (Celsius)
  ic = ( int ) ( floor ( ( T - 273.15 ) + 0.5 ) );
  if ( ic < 0 )
    {
      sprintf ( target, "%02d", 50 - ic );
    }
  else
    {
      sprintf ( target, "%02d", ic );
    }
  return target;
}

Referenced by syn_parse_x12().

Here is the caller graph for this function:

kelvin_to_TTTa()

char * kelvin_to_TTTa	(	char *	target,
		double	T
	)

Set temperature TTTa.

Parameters

target	result as string
T	temperature (kelvin)

Definition at line 147 of file bufr2tac_x12.c.

{
  int ix;
 
  if ( T == MISSING_REAL )
    {
      sprintf ( target, "///" );
      return target;
    }
 
  ix = ( int ) ( 10.0 * ( T - 273.15 ) );
 
  if ( ix >= 0 )
    {
      ix &= ~1;
    }
  else
    {
      ix = ( -ix );
      ix |= 1;
    }
  sprintf ( target, "%03d", ix );
  return target;
}

References MISSING_REAL.

Referenced by parse_temp_raw_data().

Here is the caller graph for this function:

kelvin_to_TTTT()

char * kelvin_to_TTTT	(	char *	target,
		double	T
	)

converts a kelvin temperature value into a TTTT string

Parameters

T	the temperature ( Kelvin )
target	string with the result

Definition at line 123 of file bufr2tac_x12.c.

{
  int ic;
  if ( T < 150.0 || T > 340.0 )
    {
      return NULL;
    }
  // hundreth of degrees (Celsius)
  ic = ( int ) ( floor ( 100.0 * ( T - 273.15 ) + 0.5 ) );
  if ( ic < 0 )
    {
      ic = 5000 - ic;
    }
  sprintf ( target, "%04d", ic );
  return target;
}

Referenced by buoy_parse_x22().

Here is the caller graph for this function:

latlon_to_MMM()

char * latlon_to_MMM	(	char *	target,
		double	lat,
		double	lon
	)

convert latitude and longitude to a MMM string

Parameters

lat	latitude (degree, N positive)
lon	longitude (degree, E positive)
target	resulting MMM string

Definition at line 34 of file bufr2tac_x06.c.

{
  int col, row, ori = 0;
 
  if ( lon < 0.0 )
    col = ( int ) ( -lat * 0.1 ) + 1;
  else
    col = 36 - ( int ) ( lat * 0.1 );
 
 
  if ( lat >= 80.0 )
    row = 25;
  else if ( lat >=  0.0 )
    row = ( int ) ( lat * 0.1 );
  else
    {
      ori = 299;
      row = ( int ) ( -lat * 0.1 );
    }
 
  sprintf ( target,"%03d", col + ori + row * 36 );
 
  return target;
}

Referenced by syn_parse_x05(), syn_parse_x06(), temp_parse_x05(), and temp_parse_x06().

Here is the caller graph for this function:

m_to_9h()

char * m_to_9h	(	char *	target,
		double	h
	)

converts the altitude of cloud layer into 9h string code

Parameters

h	the altitude in meters
target	the resulting 9x coded string

Definition at line 135 of file bufr2tac_x20.c.

{
  if ( h < 50.0 )
    {
      strcpy ( target,"90" );
    }
  else if ( h < 100.0 )
    {
      strcpy ( target,"91" );
    }
  else if ( h < 200.0 )
    {
      strcpy ( target,"92" );
    }
  else if ( h < 300.0 )
    {
      strcpy ( target,"93" );
    }
  else if ( h < 600.0 )
    {
      strcpy ( target,"94" );
    }
  else if ( h < 1000.0 )
    {
      strcpy ( target,"95" );
    }
  else if ( h < 1500.0 )
    {
      strcpy ( target,"96" );
    }
  else if ( h < 2000.0 )
    {
      strcpy ( target,"97" );
    }
  else if ( h < 2500.0 )
    {
      strcpy ( target,"98" );
    }
  else
    {
      strcpy ( target,"99" );
    }
  return target;
 
}

Referenced by syn_parse_x20().

Here is the caller graph for this function:

m_to_h()

char * m_to_h	(	char *	target,
		double	h
	)

converts the altitude of cloud layer into h string code

Parameters

h	the altitude in meters
target	the resulting h coded string

Definition at line 83 of file bufr2tac_x20.c.

{
  if ( h < 50.0 )
    {
      strcpy ( target,"0" );
    }
  else if ( h < 100.0 )
    {
      strcpy ( target,"1" );
    }
  else if ( h < 200.0 )
    {
      strcpy ( target,"2" );
    }
  else if ( h < 300.0 )
    {
      strcpy ( target,"3" );
    }
  else if ( h < 600.0 )
    {
      strcpy ( target,"4" );
    }
  else if ( h < 1000.0 )
    {
      strcpy ( target,"5" );
    }
  else if ( h < 1500.0 )
    {
      strcpy ( target,"6" );
    }
  else if ( h < 2000.0 )
    {
      strcpy ( target,"7" );
    }
  else if ( h < 2500.0 )
    {
      strcpy ( target,"8" );
    }
  else
    {
      strcpy ( target,"9" );
    }
  return target;
 
}

Referenced by syn_parse_x20(), and temp_parse_x20().

Here is the caller graph for this function:

m_to_hh()

char * m_to_hh	(	char *	target,
		double	h
	)

converts the altitude of cloud layer into hh string code

Parameters

h	the altitude in meters
target	the resulting h coded string

Definition at line 188 of file bufr2tac_x20.c.

{
  int ih = ( int ) h;
 
  if ( ih <= 1500 )
    {
      sprintf ( target, "%02d", ih / 30 );
    }
  else if ( ih <= 9000 )
    {
      if ( ih < 1800 )
        {
          strcpy ( target, "50" );
        }
      else
        {
          sprintf ( target, "%2d", ( ih / 300 ) + 50 );
        }
    }
  else if ( ih <= 21000 )
    {
      sprintf ( target, "%2d", ( ih / 500 ) + 50 );
    }
  else
    {
      strcpy ( target,"89" );
    }
  return target;
 
}

Referenced by syn_parse_x20().

Here is the caller graph for this function:

m_to_RR()

char * m_to_RR	(	char *	target,
		double	m
	)

Convert distance (m) in RR code (3570)

Parameters

m	the distance/diameter (m)
target	the resulting RR string

Definition at line 261 of file bufr2tac_x20.c.

{
  int ix;
  ix = ( int ) ( m * 1000.0 + 0.5 );
 
  if ( m > 0.4 )
    {
      strcpy ( target, "98" );
    }
  if ( m > 0.0 && m < 0.00065 )
    {
      sprintf ( target, "%02d", ( int ) ( m * 10000.0 + 0.5 ) );
    }
  else if ( ix <= 55 )
    {
      sprintf ( target, "%02d", ix );
    }
  else if ( ix <= 400 )
    {
      sprintf ( target, "%02d", ( ix / 10 ) + 50 );
    }
  else
    {
      strcpy ( target, "99" );
    }
  return target;
}

Referenced by syn_parse_x20().

Here is the caller graph for this function:

met_datetime_to_YYGG()

char * met_datetime_to_YYGG	(	char *	target,
		struct met_datetime *	t
	)

Get YYGG from a struct met_datetime.

Parameters

target	string with result as output
t	pointer to source struct met_datetime

Definition at line 180 of file bufr2tac_utils.c.

{
  time_t tx;
  struct tm tim;
 
  tx = ( ( t->t + 1800 ) / 3600 ) * 3600 ; // rounding to next whole hour
  memset ( &tim, 0, sizeof ( struct tm ) );
  gmtime_r ( &tx, &tim );
 
  strftime ( target, 8, "%d%H", &tim );
 
  return target;
}

References met_datetime::t.

Referenced by parse_subset_as_temp().

Here is the caller graph for this function:

parse_subset_as_buoy()

int parse_subset_as_buoy	(	struct metreport *	m,
		struct bufr2tac_subset_state *	s,
		struct bufr_subset_sequence_data *	sq,
		char *	err
	)

Definition at line 74 of file bufr2tac_buoy.c.

{
  size_t is;
  char aux[32];
  struct buoy_chunks *b;
 
  //
  b = &m->buoy;
 
  // clean data
  bufr2tac_clean_buoy_chunks ( b );
 
  // reject if still not coded type
  if ( strcmp ( s->type_report,"ZZYY" ) )
    {
      sprintf ( err,"bufr2tac: '%s' report still not decoded in this software", s->type_report );
      return 1;
    }
 
  strcpy ( b->s0.MiMi, "ZZ" );
  strcpy ( b->s0.MjMj, "YY" );
 
  b->mask = BUOY_SEC0;
 
  /**** First pass, sequential analysis *****/
  for ( is = 0; is < sq->nd; is++ )
    {
      // check if is a significance qualifier
      if ( sq->sequence[is].desc.x == 8 )
        {
          s->i = is;
          s->a = &sq->sequence[is];
          buoy_parse_x08 ( b, s );
        }
 
      if ( sq->sequence[is].mask & DESCRIPTOR_VALUE_MISSING ||
           s->isq   // case of an significance qualifier
         )
        {
          continue;
        }
 
      s->i = is;
      s->ival = ( int ) sq->sequence[is].val;
      s->val = sq->sequence[is].val;
      s->a = &sq->sequence[is];
      if ( is > 0 )
        {
          s->a1 = &sq->sequence[is - 1];
        }
 
      switch ( sq->sequence[is].desc.x )
        {
 
        case 1: //localization descriptors
          buoy_parse_x01 ( b, s );
          break;
 
        case 2: //Date time descriptors
          buoy_parse_x02 ( b, s );
          break;
 
        case 4: //Date time descriptors
          buoy_parse_x04 ( b, s );
          break;
 
        case 5: //Position
          buoy_parse_x05 ( b, s );
          break;
 
        case 6: // Horizontal Position -2
          buoy_parse_x06 ( b, s );
          break;
 
        case 7: // Vertical Position
          buoy_parse_x07 ( b, s );
          break;
 
        case 10: // Air Pressure descriptors
          buoy_parse_x10 ( b, s );
          break;
 
        case 11: // wind  data
          buoy_parse_x11 ( b, s );
          break;
 
        case 12: //Temperature descriptors
          buoy_parse_x12 ( b, s );
          break;
 
        case 13: // Humidity and precipitation data
          buoy_parse_x13 ( b, s );
          break;
 
        case 14: // Radiation
          buoy_parse_x14 ( b, s );
          break;
 
        case 20: // Cloud data
          buoy_parse_x20 ( b, s );
          break;
 
        case 22: // Oceanographic data
          buoy_parse_x22 ( b, s );
          break;
 
        case 31: // Replicators
          buoy_parse_x31 ( b, s );
          break;
 
 
        case 33: // Quality data
          buoy_parse_x33 ( b, s );
          break;
 
 
        default:
          break;
        }
 
    }
 
  if ( ( ( s->mask & SUBSET_MASK_HAVE_LATITUDE ) == 0 ) ||
       ( ( s->mask & SUBSET_MASK_HAVE_LONGITUDE ) == 0 ) ||
       ( ( s->mask & SUBSET_MASK_HAVE_YEAR ) == 0 ) ||
       ( ( s->mask & SUBSET_MASK_HAVE_MONTH ) == 0 ) ||
       ( ( s->mask & SUBSET_MASK_HAVE_DAY ) == 0 ) ||
       ( ( s->mask & SUBSET_MASK_HAVE_HOUR ) == 0 ) )
    {
      sprintf ( err,"bufr2tac: parse_subset_as_buoy(): lack of mandatory descriptor in sequence" );
      return 1;
    }
 
  // copy WIGOS ID, if any 
  memcpy(&m->g.wid, &m->buoy.wid, sizeof (struct wigos_id) );
  
  /****** Second pass. Global results and consistence analysis ************/
 
  // adjust iw
  if ( b->s0.iw[0] == '/' && b->s1.ff[0] != '/' )
    {
      b->s0.iw[0] = '1';
    }
 
  // fill date fields YYYYMMDDHHmm
  buoy_YYYYMMDDHHmm_to_JMMYYGGgg ( b );
  b->mask |= BUOY_EXT;
 
  // Fill some metreport fields
  if ( s->mask & SUBSET_MASK_HAVE_LATITUDE )
    {
      if ( fabs ( s->lat ) <= 90.0 )
        {
          m->g.lat = s->lat;
        }
      else
        {
          return 1;  // Bad latitude. Fatal error
        }
    }
  if ( s->mask & SUBSET_MASK_HAVE_LONGITUDE )
    {
      if ( fabs ( s->lon ) <= 180.0 )
        {
          m->g.lon = s->lon;
        }
      else
        {
          return 1;  // bad longitude. Fatal error
        }
    }
  if ( s->mask & SUBSET_MASK_HAVE_ALTITUDE )
    {
      m->g.alt = s->alt;
    }
  if ( s->mask & SUBSET_MASK_HAVE_NAME )
    {
      strcpy ( m->g.name, s->name );
    }
  sprintf ( aux,"%s%s%s%s%s", b->e.YYYY, b->e.MM, b->e.DD, b->e.HH, b->e.mm );
  YYYYMMDDHHmm_to_met_datetime ( &m->t, aux );
 
  // Fill some metreport fields
  if ( b->s0.A1[0] && b->s0.bw[0] && b->s0.nbnbnb[0] )
    {
      sprintf ( m->g.index, "%s%s%s", b->s0.A1, b->s0.bw, b->s0.nbnbnb );
    }
 
  // check if set both LaLaLa and LoLoLoLo to set Qc
  if ( ( b->s0.Qc[0] == 0 ) && b->s0.LaLaLaLaLa[0] && b->s0.LoLoLoLoLoLo[0] )
    {
      if ( s->mask & SUBSET_MASK_LATITUDE_SOUTH )
        {
          if ( s->mask & SUBSET_MASK_LONGITUDE_WEST )
            {
              strcpy ( b->s0.Qc, "5" );
            }
          else
            {
              strcpy ( b->s0.Qc, "3" );
            }
        }
      else
        {
          if ( s->mask & SUBSET_MASK_LONGITUDE_WEST )
            {
              strcpy ( b->s0.Qc, "7" );
            }
          else
            {
              strcpy ( b->s0.Qc, "1" );
            }
        }
    }
 
  // check Qx
  if ( b->s2.Qd[0] ==  0 )
    {
      b->s2.Qd[0] = '0';
    }
  if ( b->s3.k2[0] == 0 )
    {
      b->s3.k2[0] = '0';
    }
  if ( b->s1.Qx[0] == 0 && b->s1.Qd[0] )
    {
      b->s1.Qx[0] = '9';
    }
  if ( b->s2.Qx[0] == 0 && b->s2.Qd[0] )
    {
      b->s2.Qx[0] = '9';
    }
 
  if ( b->s3.Qd1[0] ==  0 )
    {
      b->s3.Qd1[0] = '0';
    }
  if ( b->s3.Qd2[0] ==  0 )
    {
      b->s3.Qd2[0] = '0';
    }
 
  if ( b->s3.k3[0] == 0 )
    {
      b->s3.k3[0] = '/';
    }
  if ( b->s3.k6[0] == 0 )
    {
      b->s3.k6[0] = '/';
    }
 
  return 0;
}

References bufr2tac_subset_state::a, bufr2tac_subset_state::a1, buoy_sec0::A1, bufr2tac_subset_state::alt, met_geo::alt, bufr2tac_clean_buoy_chunks(), metreport::buoy, BUOY_EXT, buoy_parse_x01(), buoy_parse_x02(), buoy_parse_x04(), buoy_parse_x05(), buoy_parse_x06(), buoy_parse_x07(), buoy_parse_x08(), buoy_parse_x10(), buoy_parse_x11(), buoy_parse_x12(), buoy_parse_x13(), buoy_parse_x14(), buoy_parse_x20(), buoy_parse_x22(), buoy_parse_x31(), buoy_parse_x33(), BUOY_SEC0, buoy_YYYYMMDDHHmm_to_JMMYYGGgg(), buoy_sec0::bw, report_date_ext::DD, DESCRIPTOR_VALUE_MISSING, buoy_chunks::e, buoy_sec1::ff, metreport::g, report_date_ext::HH, bufr2tac_subset_state::i, met_geo::index, bufr2tac_subset_state::isq, bufr2tac_subset_state::ival, buoy_sec0::iw, buoy_sec3::k2, buoy_sec3::k3, buoy_sec3::k6, buoy_sec0::LaLaLaLaLa, bufr2tac_subset_state::lat, met_geo::lat, buoy_sec0::LoLoLoLoLoLo, bufr2tac_subset_state::lon, met_geo::lon, bufr2tac_subset_state::mask, buoy_chunks::mask, buoy_sec0::MiMi, buoy_sec0::MjMj, report_date_ext::MM, report_date_ext::mm, bufr2tac_subset_state::name, met_geo::name, buoy_sec0::nbnbnb, buoy_sec0::Qc, buoy_sec1::Qd, buoy_sec2::Qd, buoy_sec3::Qd1, buoy_sec3::Qd2, buoy_sec1::Qx, buoy_sec2::Qx, buoy_chunks::s0, buoy_chunks::s1, buoy_chunks::s2, buoy_chunks::s3, SUBSET_MASK_HAVE_ALTITUDE, SUBSET_MASK_HAVE_DAY, SUBSET_MASK_HAVE_HOUR, SUBSET_MASK_HAVE_LATITUDE, SUBSET_MASK_HAVE_LONGITUDE, SUBSET_MASK_HAVE_MONTH, SUBSET_MASK_HAVE_NAME, SUBSET_MASK_HAVE_YEAR, SUBSET_MASK_LATITUDE_SOUTH, SUBSET_MASK_LONGITUDE_WEST, metreport::t, bufr2tac_subset_state::type_report, bufr2tac_subset_state::val, met_geo::wid, buoy_chunks::wid, report_date_ext::YYYY, and YYYYMMDDHHmm_to_met_datetime().

Referenced by parse_subset_sequence().

Here is the call graph for this function:

Here is the caller graph for this function:

parse_subset_as_climat()

int parse_subset_as_climat	(	struct metreport *	m,
		struct bufr2tac_subset_state *	s,
		struct bufr_subset_sequence_data *	sq,
		char *	err
	)

Definition at line 38 of file bufr2tac_climat.c.

{
  size_t is;
  char aux[32];
  struct climat_chunks *c;
 
  c = &m->climat;
 
  // clean data
  bufr2tac_clean_climat_chunks ( c );
 
  // reject if still not coded type
  if ( strcmp ( s->type_report,"CLIMAT" ) )
    {
      sprintf ( err,"bufr2tac: parse_subset_as_climat(): '%s' reports still not decoded in this software", s->type_report );
      return 1;
    }
 
  strcpy ( m->type, s->type_report );
 
  /**** First pass, sequential analysis *****/
  for ( is = 0; is < sq->nd; is++ )
    {
      s->i = is;
      s->ival = ( int ) sq->sequence[is].val;
      s->val = sq->sequence[is].val;
      s->a = &sq->sequence[is];
      if ( is > 0 )
        {
          s->a1 = &sq->sequence[is - 1];
        }
 
      switch ( sq->sequence[is].desc.x )
        {
        case 1: //localization descriptors
          climat_parse_x01 ( c, s );
          break;
 
        case 2: //Type of station descriptors
          climat_parse_x02 ( c, s );
          break;
 
        case 4: //Date and time descriptors
          climat_parse_x04 ( c, s );
          break;
 
        case 5: // Horizontal position. Latitude
          climat_parse_x05 ( c, s );
          break;
 
        case 6: // Horizontal position. Longitude
          climat_parse_x06 ( c, s );
          break;
 
        case 7: // Vertical position
          climat_parse_x07 ( c, s );
          break;
 
        case 8: // significance qualifier
          climat_parse_x08 ( c, s );
          break;
 
        case 10: // Air pressure
          climat_parse_x10 ( c, s );
          break;
 
        case 11: // Wind
          climat_parse_x11 ( c, s );
          break;
 
        case 12: // Temperature
          climat_parse_x12 ( c, s );
          break;
 
        case 13: // Humidity and precipitation data
          climat_parse_x13 ( c, s );
          break;
 
        case 14: // Radiation
          climat_parse_x14 ( c, s );
          break;
 
        default:
          break;
        }
 
    }
 
  // Fill some metreport fields
  if ( strlen ( c->s0.II ) )
    {
      strcpy ( m->g.index, c->s0.II );
      strcat ( m->g.index, c->s0.iii );
    }
 
  if ( s->mask & SUBSET_MASK_HAVE_LATITUDE )
    {
      m->g.lat = s->lat;
    }
  if ( s->mask & SUBSET_MASK_HAVE_LONGITUDE )
    {
      m->g.lon = s->lon;
    }
  if ( s->mask & SUBSET_MASK_HAVE_ALTITUDE )
    {
      m->g.alt = s->alt;
    }
  if ( s->mask & SUBSET_MASK_HAVE_NAME )
    {
      strcpy ( m->g.name, s->name );
    }
  if ( s->mask & SUBSET_MASK_HAVE_COUNTRY )
    {
      strcpy ( m->g.country, s->country );
    }
 
  sprintf ( aux,"%s%s%s%s%s", c->e.YYYY, c->e.MM, c->e.DD, c->e.HH, c->e.mm );
  YYYYMMDDHHmm_to_met_datetime ( &m->t, aux );
 
   // copy WIGOS ID 
  memcpy(&m->g.wid, &m->climat.wid, sizeof (struct wigos_id) );
   
  if ( check_date_from_future ( m ) )
    {
      return 1;  // Bad date/time . Is a report from future!
    }
 
 
  return 0;
}

References bufr2tac_subset_state::a, bufr2tac_subset_state::a1, bufr2tac_subset_state::alt, met_geo::alt, bufr2tac_clean_climat_chunks(), check_date_from_future(), metreport::climat, climat_parse_x01(), climat_parse_x02(), climat_parse_x04(), climat_parse_x05(), climat_parse_x06(), climat_parse_x07(), climat_parse_x08(), climat_parse_x10(), climat_parse_x11(), climat_parse_x12(), climat_parse_x13(), climat_parse_x14(), bufr2tac_subset_state::country, met_geo::country, report_date_ext::DD, climat_chunks::e, metreport::g, report_date_ext::HH, bufr2tac_subset_state::i, climat_sec0::II, climat_sec0::iii, met_geo::index, bufr2tac_subset_state::ival, bufr2tac_subset_state::lat, met_geo::lat, bufr2tac_subset_state::lon, met_geo::lon, bufr2tac_subset_state::mask, report_date_ext::MM, report_date_ext::mm, bufr2tac_subset_state::name, met_geo::name, climat_chunks::s0, SUBSET_MASK_HAVE_ALTITUDE, SUBSET_MASK_HAVE_COUNTRY, SUBSET_MASK_HAVE_LATITUDE, SUBSET_MASK_HAVE_LONGITUDE, SUBSET_MASK_HAVE_NAME, metreport::t, metreport::type, bufr2tac_subset_state::type_report, bufr2tac_subset_state::val, met_geo::wid, climat_chunks::wid, report_date_ext::YYYY, and YYYYMMDDHHmm_to_met_datetime().

Referenced by parse_subset_sequence().

Here is the call graph for this function:

Here is the caller graph for this function:

parse_subset_as_synop()

int parse_subset_as_synop	(	struct metreport *	m,
		struct bufr2tac_subset_state *	s,
		struct bufr_subset_sequence_data *	sq,
		char *	err
	)

parses a subset sequence as an Land fixed SYNOP FM-12, SHIP FM-13 or SYNOP-mobil FM-14 report

Parameters

m	pointer to a struct metreport where set some results
s	pointer to a struct bufr2tac_subset_state
sq	pointer to a struct bufr_subset_sequence_data with the parsed sequence on input
err	string with detected errors, if any

It return 0 if all is OK. Otherwise returns 1 and it also fills the err string

Definition at line 119 of file bufr2tac_synop.c.

{
  size_t is;
  char aux[32];
  struct synop_chunks *syn;
 
  // An auxiliar pointer
  syn = &m->synop;
 
  // clean data
  bufr2tac_clean_synop_chunks ( syn );
 
  // reject if still not coded type
  if ( strcmp ( s->type_report,"AAXX" ) && strcmp ( s->type_report,"BBXX" ) && strcmp ( s->type_report,"OOXX" ) )
    {
      sprintf ( err,"bufr2tac: parse_subset_as_synop(): '%s' reports still not decoded in this software", s->type_report );
      return 1;
    }
 
  syn->s0.MiMi[0] = s->type_report[0];
  syn->s0.MiMi[1] = s->type_report[1];
  syn->s0.MjMj[0] = s->type_report[2];
  syn->s0.MjMj[1] = s->type_report[3];
 
  strcpy ( m->type, s->type_report );
 
  /**** First pass, sequential analysis *****/
  for ( is = 0; is < sq->nd; is++ )
    {
      // check if is a significance qualifier
      if ( sq->sequence[is].desc.x == 8 )
        {
          s->i = is;
          s->a = &sq->sequence[is];
          s->ival = ( int ) sq->sequence[is].val;
          s->val = sq->sequence[is].val;
          syn_parse_x08 ( syn, s );
        }
      if ( s->isq )  // case of a significance qualifier
        {
          continue;
        }
 
      s->i = is;
      s->ival = ( int ) ( sq->sequence[is].val );
      s->val = sq->sequence[is].val;
      s->a = &sq->sequence[is];
      if ( is > 0 )
        {
          s->a1 = &sq->sequence[is - 1];
        }
 
      switch ( sq->sequence[is].desc.x )
        {
        case 1: //localization descriptors
          syn_parse_x01 ( syn, s );
          break;
 
        case 2: //Type of station descriptors
          syn_parse_x02 ( syn, s );
          break;
 
        case 4: //Date and time descriptors
          syn_parse_x04 ( syn, s );
          break;
 
        case 5: // Horizontal position. Latitude
          syn_parse_x05 ( syn, s );
          break;
 
        case 6: // Horizontal position. Longitude
          syn_parse_x06 ( syn, s );
          break;
 
        case 7: // Vertical position
          syn_parse_x07 ( syn, s );
          break;
 
        case 10: // Air Pressure descriptors
          syn_parse_x10 ( syn, s );
          break;
 
        case 11: // wind  data
          syn_parse_x11 ( syn, s );
          break;
 
        case 12: //Temperature descriptors
          syn_parse_x12 ( syn, s );
          break;
 
        case 13: // Humidity and precipitation data
          syn_parse_x13 ( syn, s );
          break;
 
        case 14: // Radiation
          syn_parse_x14 ( syn, s );
          break;
 
        case 20: // Cloud data
          syn_parse_x20 ( syn, s );
          break;
 
        case 22: // Oceanographic data
          syn_parse_x22 ( syn, s );
          break;
 
        case 31: // Replicators
          syn_parse_x31 ( syn, s );
          break;
 
 
        default:
          break;
        }
    }
 
  /* Check about needed descriptors */
  if ( ( ( s->mask & SUBSET_MASK_HAVE_LATITUDE ) == 0 ) ||
       ( ( s->mask & SUBSET_MASK_HAVE_LONGITUDE ) == 0 ) ||
       ( ( s->mask & SUBSET_MASK_HAVE_YEAR ) == 0 ) ||
       ( ( s->mask & SUBSET_MASK_HAVE_MONTH ) == 0 ) ||
       ( ( s->mask & SUBSET_MASK_HAVE_DAY ) == 0 ) ||
       ( ( s->mask & SUBSET_MASK_HAVE_HOUR ) == 0 ) ||
       ( ( s->mask & SUBSET_MASK_HAVE_MINUTE ) == 0 )
     )
    {
      sprintf ( err,"bufr2tac: %s(): lack of mandatory descriptor in sequence", __func__ );
      return 1;
    }
 
  // copy WIGOS ID 
  memcpy(&m->g.wid, &m->synop.wid, sizeof (struct wigos_id) );
  
  if ( strcmp ( s->type_report, "AAXX" ) == 0 && ( syn->s0.II[0] == 0 || syn->s0.iii[0] == 0 ) )
    {
      if ( s->mask & SUBSET_MASK_HAVE_WIGOS_ID &&
           ( syn->wid.issuer != 0 || syn->wid.issue != 0 ) &&
           syn->wid.local_id[0] )
        {
          strcpy ( syn->s0.II, "00" );
          strcpy ( syn->s0.iii, "000" );
        }
      else
        {
          sprintf ( err,"bufr2tac: %s(): lack of mandatory index station for AAXX report", __func__ );
          return 1;
        }
    }
 
 
  /****** Second pass. Global results and consistence analysis ************/
  // set ir
  if ( syn->s1.RRR[0] == 0 && syn->s3.RRR[0] == 0 && syn->s3.RRRR24[0] == 0 )
    {
      // no prec data case
      syn->s1.ir[0] = '4';
    }
  else if ( syn->s1.RRR[0] == 0 && syn->s3.RRR[0] != 0 )
    {
      syn->s1.ir[0] = '2';
    }
  else if ( syn->s1.RRR[0] != 0 && syn->s3.RRR[0] == 0 )
    {
      syn->s1.ir[0] = '1';
    }
  else
    {
      syn->s1.ir[0] = '0';
    }
 
  // Supress 7wwW1W2 if no significant weather
  if ( ( syn->s1.ww[0] || syn->s1.W1[0] || syn->s1.W2[0] ) &&
       ( syn->s1.ww[0] == 0 || syn->s1.ww[0] == '/' || ( strcmp ( syn->s1.ww,"04" ) < 0 ) ) &&
       ( syn->s1.W1[0] == 0 || syn->s1.W1[0] == '/' || ( strcmp ( syn->s1.W1,"3" ) < 0 ) ) &&
       ( syn->s1.W2[0] == 0 || syn->s1.W2[0] == '/' || ( strcmp ( syn->s1.W2,"3" ) < 0 ) ) )
    {
      syn->s1.ww[0] = 0;
      syn->s1.W1[0] = 0;
      syn->s1.W2[0] = 0;
      s->mask |= ( SUBSET_MASK_HAVE_NO_SIGNIFICANT_WW | SUBSET_MASK_HAVE_NO_SIGNIFICANT_W1 | SUBSET_MASK_HAVE_NO_SIGNIFICANT_W2 );
      if ( syn->s1.ix[0] == '1' )
        {
          syn->s1.ix[0] = '2';
        }
    }
 
  // adjust iw
  if ( syn->s0.iw[0] == '/' && syn->s1.ff[0] != '/' )
    {
      syn->s0.iw[0] = '1';
    }
 
  // adjust ix
  if ( syn->s1.ix[0] == '/' /*&& syn->s1.ww[0] == 0*/ )
    {
      if ( ( s->mask & SUBSET_MASK_HAVE_NO_SIGNIFICANT_WW ) &&
           ( s->mask & SUBSET_MASK_HAVE_NO_SIGNIFICANT_W1 ) &&
           ( s->mask & SUBSET_MASK_HAVE_NO_SIGNIFICANT_W2 )
         )
        {
          if ( s->mask & SUBSET_MASK_HAVE_TYPE_STATION )
            {
              if ( s->type == 1 || s->type == 2 )
                {
                  strcpy ( syn->s1.ix,"2" );
                }
              else if ( s->type == 0 )
                {
                  strcpy ( syn->s1.ix,"5" );
                }
            }
          else
            {
              strcpy ( syn->s1.ix,"6" );  //NOTE: here we assume an automatic station without W data
            }
        }
      else if ( s->mask & SUBSET_MASK_HAVE_TYPE_STATION )
        {
          if ( s->type == 1 )
            {
              strcpy ( syn->s1.ix,"3" );
            }
          else if ( s->type == 0 )
            {
              strcpy ( syn->s1.ix,"6" );
            }
        }
      else
        {
          strcpy ( syn->s1.ix,"6" );  //NOTE: here we assume an automatic station without W data
        }
    }
 
  // adjust radiation
  if ( ( syn->mask & SYNOP_SEC3 ) && ( syn->s3.SS[0] == '\0' ) &&
       ( syn->s3.j5[0][0] || syn->s3.j5[1][0] ||
         syn->s3.j5[2][0] || syn->s3.j5[3][0] ||
         syn->s3.j5[4][0] || syn->s3.j5[5][0] ||
         syn->s3.j5[6][0] ) )
    {
      sprintf ( syn->s3.SS, "//" );
    }
 
  if ( ( syn->mask & SYNOP_SEC3 ) && ( syn->s3.SSS[0] == '\0' ) &&
       ( syn->s3.j524[0][0] || syn->s3.j524[1][0] ||
         syn->s3.j524[2][0] || syn->s3.j524[3][0] ||
         syn->s3.j524[4][0] || syn->s3.j524[5][0] ||
         syn->s3.j524[6][0] ) )
    {
      sprintf ( syn->s3.SSS, "///" );
    }
 
  /****** Final Adjust ***********/
 
  // fix YYGG according with YYYYMMDDHHmm
  if ( syn->e.mm[0] == 0 )
    sprintf ( syn->e.mm, "00" );
  synop_YYYYMMDDHHmm_to_YYGG ( syn );
  if ( strcmp ( syn->e.mm,"00" ) )
    {
      strcpy ( syn->s1.GG, syn->e.HH );
      strcpy ( syn->s1.gg, syn->e.mm );
    }
  syn->mask |= SYNOP_EXT;
 
  // Marc as a synop from bufr
  syn->mask |= SYNOP_BUFR;
 
  // Fill some metreport fields
  if ( strlen ( syn->s0.II ) )
    {
      strcpy ( m->g.index, syn->s0.II );
      strcat ( m->g.index, syn->s0.iii );
    }
  else if ( strlen ( syn->s0.D_D ) )
    {
      strcpy ( m->g.index, syn->s0.D_D );
    }
  else if ( strlen ( syn->s0.IIIII ) )
    {
      strcpy ( m->g.index, syn->s0.IIIII );
    }
 
  if ( s->mask & SUBSET_MASK_HAVE_LATITUDE )
    {
      m->g.lat = s->lat;
    }
  if ( s->mask & SUBSET_MASK_HAVE_LONGITUDE )
    {
      m->g.lon = s->lon;
    }
  if ( s->mask & SUBSET_MASK_HAVE_ALTITUDE )
    {
      m->g.alt = s->alt;
    }
  if ( s->mask & SUBSET_MASK_HAVE_NAME )
    {
      strcpy ( m->g.name, s->name );
    }
  if ( s->mask & SUBSET_MASK_HAVE_COUNTRY )
    {
      strcpy ( m->g.country, s->country );
    }
 
  sprintf ( aux,"%s%s%s%s%s", syn->e.YYYY, syn->e.MM, syn->e.DD, syn->e.HH, syn->e.mm );
  YYYYMMDDHHmm_to_met_datetime ( &m->t, aux );
 
  if ( check_date_from_future ( m ) )
    {
      return 1;  // Bad date/time . Is a report from future!
    }
 
  // If finally we arrive here, It succeded
  return 0;
}

References bufr2tac_subset_state::a, bufr2tac_subset_state::a1, bufr2tac_subset_state::alt, met_geo::alt, bufr2tac_clean_synop_chunks(), check_date_from_future(), bufr2tac_subset_state::country, met_geo::country, synop_sec0::D_D, report_date_ext::DD, synop_chunks::e, synop_sec1::ff, metreport::g, synop_sec1::GG, synop_sec1::gg, report_date_ext::HH, bufr2tac_subset_state::i, synop_sec0::II, synop_sec0::iii, synop_sec0::IIIII, met_geo::index, synop_sec1::ir, bufr2tac_subset_state::isq, wigos_id::issue, wigos_id::issuer, bufr2tac_subset_state::ival, synop_sec0::iw, synop_sec1::ix, synop_sec3::j5, synop_sec3::j524, bufr2tac_subset_state::lat, met_geo::lat, wigos_id::local_id, bufr2tac_subset_state::lon, met_geo::lon, bufr2tac_subset_state::mask, synop_chunks::mask, synop_sec0::MiMi, synop_sec0::MjMj, report_date_ext::MM, report_date_ext::mm, bufr2tac_subset_state::name, met_geo::name, synop_sec1::RRR, synop_sec3::RRR, synop_sec3::RRRR24, synop_chunks::s0, synop_chunks::s1, synop_chunks::s3, synop_sec3::SS, synop_sec3::SSS, SUBSET_MASK_HAVE_ALTITUDE, SUBSET_MASK_HAVE_COUNTRY, SUBSET_MASK_HAVE_DAY, SUBSET_MASK_HAVE_HOUR, SUBSET_MASK_HAVE_LATITUDE, SUBSET_MASK_HAVE_LONGITUDE, SUBSET_MASK_HAVE_MINUTE, SUBSET_MASK_HAVE_MONTH, SUBSET_MASK_HAVE_NAME, SUBSET_MASK_HAVE_NO_SIGNIFICANT_W1, SUBSET_MASK_HAVE_NO_SIGNIFICANT_W2, SUBSET_MASK_HAVE_NO_SIGNIFICANT_WW, SUBSET_MASK_HAVE_TYPE_STATION, SUBSET_MASK_HAVE_WIGOS_ID, SUBSET_MASK_HAVE_YEAR, syn_parse_x01(), syn_parse_x02(), syn_parse_x04(), syn_parse_x05(), syn_parse_x06(), syn_parse_x07(), syn_parse_x08(), syn_parse_x10(), syn_parse_x11(), syn_parse_x12(), syn_parse_x13(), syn_parse_x14(), syn_parse_x20(), syn_parse_x22(), syn_parse_x31(), metreport::synop, SYNOP_BUFR, SYNOP_EXT, SYNOP_SEC3, synop_YYYYMMDDHHmm_to_YYGG(), metreport::t, bufr2tac_subset_state::type, metreport::type, bufr2tac_subset_state::type_report, bufr2tac_subset_state::val, synop_sec1::W1, synop_sec1::W2, met_geo::wid, synop_chunks::wid, synop_sec1::ww, report_date_ext::YYYY, and YYYYMMDDHHmm_to_met_datetime().

Referenced by parse_subset_sequence().

Here is the call graph for this function:

Here is the caller graph for this function:

parse_subset_as_temp()

int parse_subset_as_temp	(	struct metreport *	m,
		struct bufr2tac_subset_state *	s,
		struct bufr_subset_sequence_data *	sq,
		char *	err
	)

Definition at line 75 of file bufr2tac_temp.c.

{
  size_t is;
  char aux[32];
  struct temp_chunks *t;
  struct met_datetime dtm;
  struct temp_raw_data *r;
  struct temp_raw_wind_shear_data *w;
 
  if ( sq == NULL )
    {
      return 1;
    }
 
  t = &m->temp;
 
  // clean data
  bufr2tac_clean_temp_chunks ( t );
 
  // allocate memory for array of points in raw form
  if ( ( r = calloc ( 1, sizeof ( struct temp_raw_data ) ) ) == NULL )
    {
      sprintf ( err,"bufr2tac: parse_subset_as_temp(): Cannot allocate memory for raw data" );
      return 1;
    }
 
  if ( ( w = calloc ( 1, sizeof ( struct temp_raw_wind_shear_data ) ) ) == NULL )
    {
      sprintf ( err,"bufr2tac: parse_subset_as_temp(): Cannot allocate memory for raw data" );
      free ( ( void * ) ( r ) );
      return 1;
    }
 
  // set pointers
  s->r = r;
  s->w = w;
 
  // reject if still not coded type
  if ( strcmp ( s->type_report,"TTXX" ) == 0  && 0 )
    {
      // FIXME
      sprintf ( err,"bufr2tac: parse_subset_as_temp(): '%s' reports still not decoded in this software", s->type_report );
      free ( ( void * ) ( r ) );
      free ( ( void * ) ( w ) );
      return 1;
    }
 
  // Set the part. We are sure of this
  strcpy ( t->a.s1.MjMj, "AA" );
  strcpy ( t->b.s1.MjMj, "BB" );
  strcpy ( t->c.s1.MjMj, "CC" );
  strcpy ( t->d.s1.MjMj, "DD" );
 
  /**** First pass, sequential analysis *****/
  for ( is = 0; is < sq->nd; is++ )
    {
      s->i = is;
      s->ival = ( int ) sq->sequence[is].val;
      s->val = sq->sequence[is].val;
      s->a = &sq->sequence[is];
      if ( is > 0 )
        {
          s->a1 = &sq->sequence[is - 1];
        }
 
      // check if is a significance qualifier
      if ( sq->sequence[is].desc.x == 8 )
        {
          temp_parse_x08 ( t, s );
        }
 
      switch ( sq->sequence[is].desc.x )
        {
        case 1: //localization descriptors
          if ( temp_parse_x01 ( t, s ) )
            {
              free ( ( void * ) ( r ) );
              free ( ( void * ) ( w ) );
              return 1;
            }
          break;
 
        case 2: //Type of station descriptors
          if ( temp_parse_x02 ( t, s ) )
            {
              free ( ( void * ) ( r ) );
              free ( ( void * ) ( w ) );
              return 1;
            }
          break;
 
        case 4: //Date and time descriptors
          if ( temp_parse_x04 ( t, s ) )
            {
              free ( ( void * ) ( r ) );
              free ( ( void * ) ( w ) );
              return 1;
            }
          break;
 
        case 5: // Horizontal position. Latitude
          if ( temp_parse_x05 ( t, s ) )
            {
              free ( ( void * ) ( r ) );
              free ( ( void * ) ( w ) );
              return 1;
            }
          break;
 
        case 6: // Horizontal position. Longitude
          if ( temp_parse_x06 ( t, s ) )
            {
              free ( ( void * ) ( r ) );
              free ( ( void * ) ( w ) );
              return 1;
            }
          break;
 
        case 7: // Vertical position
          if ( temp_parse_x07 ( t, s ) )
            {
              free ( ( void * ) ( r ) );
              free ( ( void * ) ( w ) );
              return 1;
            }
          break;
 
        case 10: // Air Pressure descriptors
          if ( temp_parse_x10 ( t, s ) )
            {
              free ( ( void * ) ( r ) );
              free ( ( void * ) ( w ) );
              return 1;
            }
          break;
 
        case 11: // wind  data
          if ( temp_parse_x11 ( t, s ) )
            {
              free ( ( void * ) ( r ) );
              free ( ( void * ) ( w ) );
              return 1;
            }
          break;
 
        case 12: //Temperature descriptors
          if ( temp_parse_x12 ( t, s ) )
            {
              free ( ( void * ) ( r ) );
              free ( ( void * ) ( w ) );
              return 1;
            }
          break;
 
        case 20: // Cloud data
          if ( temp_parse_x20 ( t, s ) )
            {
              free ( ( void * ) ( r ) );
              free ( ( void * ) ( w ) );
              return 1;
            }
          break;
 
        case 22: // Oceanographic data
          if ( temp_parse_x22 ( t, s ) )
            {
              free ( ( void * ) ( r ) );
              free ( ( void * ) ( w ) );
              return 1;
            }
          break;
 
        case 31: // Replicators
          if ( temp_parse_x31 ( t, s ) )
            {
              free ( ( void * ) ( r ) );
              free ( ( void * ) ( w ) );
              return 1;
            }
          break;
 
        case 33: // Quality data
          if ( temp_parse_x33 ( t, s ) )
            {
              free ( ( void * ) ( r ) );
              free ( ( void * ) ( w ) );
              return 1;
            }
          break;
 
        default:
          break;
        }
    }
 
  /* Check about needed descriptors */
  if ( ( ( s->mask & SUBSET_MASK_HAVE_LATITUDE ) == 0 ) ||
       ( ( s->mask & SUBSET_MASK_HAVE_LONGITUDE ) == 0 ) ||
       ( ( s->mask & SUBSET_MASK_HAVE_YEAR ) == 0 ) ||
       ( ( s->mask & SUBSET_MASK_HAVE_MONTH ) == 0 ) ||
       ( ( s->mask & SUBSET_MASK_HAVE_DAY ) == 0 ) ||
       ( ( s->mask & SUBSET_MASK_HAVE_HOUR ) == 0 ) ||
       ( ( s->mask & SUBSET_MASK_HAVE_MINUTE ) == 0 )
     )
    {
      sprintf ( err,"bufr2tac: parse_subset_as_temp(): lack of mandatory descriptor in sequence" );
      free ( ( void * ) ( r ) );
      free ( ( void * ) ( w ) );
      return 1;
    }
 
  // copy WIGOS ID 
  memcpy(&m->g.wid, &m->temp.wid, sizeof (struct wigos_id) );
  
  /* Guess the type of TEMP report according with data parsed */
  if ( t->a.s1.II[0] )
    {
      // it seems this is a TEMP report
      strcpy ( t->a.s1.MiMi, "TT" );
      strcpy ( t->b.s1.MiMi, "TT" );
      strcpy ( t->c.s1.MiMi, "TT" );
      strcpy ( t->d.s1.MiMi, "TT" );
    }
  else if ( t->a.s1.h0h0h0h0[0] )
    {
      // it seems this is a TEMP MOBIL report
      strcpy ( t->a.s1.MiMi, "II" );
      strcpy ( t->b.s1.MiMi, "II" );
      strcpy ( t->c.s1.MiMi, "II" );
      strcpy ( t->d.s1.MiMi, "II" );
    }
  else if ( t->a.s1.D_D[0] )
    {
      // it seems this is a TEMP SHIP report
      strcpy ( t->a.s1.MiMi, "UU" );
      strcpy ( t->b.s1.MiMi, "UU" );
      strcpy ( t->c.s1.MiMi, "UU" );
      strcpy ( t->d.s1.MiMi, "UU" );
    }
  else if ( t->a.s1.Ula[0] )
    {
      // it seems this is a TEMP DROP report
      strcpy ( t->a.s1.MiMi, "XX" );
      strcpy ( t->b.s1.MiMi, "XX" );
      strcpy ( t->c.s1.MiMi, "XX" );
      strcpy ( t->d.s1.MiMi, "XX" );
    }
  else
    {
      sprintf ( err,"bufr2tac: parse_subset_as_temp(): Unknown type TEMP report" );
      free ( ( void * ) ( r ) );
      free ( ( void * ) ( w ) );
      return 1;
    }
  sprintf ( m->type, "%s%s" , t->a.s1.MiMi, t->a.s1.MjMj );
  sprintf ( m->type2, "%s%s" , t->b.s1.MiMi, t->b.s1.MjMj );
  sprintf ( m->type3, "%s%s" , t->c.s1.MiMi, t->c.s1.MjMj );
  sprintf ( m->type4, "%s%s" , t->d.s1.MiMi, t->d.s1.MjMj );
 
  /****** Second pass. Global results and consistence analysis ************/
  sprintf ( aux,"%s%s%s%s%s%s", t->a.e.YYYY, t->a.e.MM, t->a.e.DD, t->a.e.HH, t->a.e.mm, t->a.e.ss );
  YYYYMMDDHHmm_to_met_datetime ( &dtm, aux );
  round_met_datetime_to_hour ( &m->t, &dtm );
  memcpy ( &m->temp.t, &m->t, sizeof ( struct met_datetime ) );
 
  met_datetime_to_YYGG ( t->a.s1.YYGG, &dtm );
  strcpy ( t->b.s1.YYGG, t->a.s1.YYGG );
  strcpy ( t->c.s1.YYGG, t->a.s1.YYGG );
  strcpy ( t->d.s1.YYGG, t->a.s1.YYGG );
 
  if ( strlen ( t->a.s1.II ) )
    {
      strcpy ( m->g.index, t->a.s1.II );
      strcat ( m->g.index, t->a.s1.iii );
    }
  else if ( strlen ( t->a.s1.D_D ) )
    {
      strcpy ( m->g.index, t->a.s1.D_D );
    }
  else if ( strlen ( t->a.s1.IIIII ) )
    {
      strcpy ( m->g.index, t->a.s1.IIIII );
    }
 
  if ( s->mask & SUBSET_MASK_HAVE_LATITUDE )
    {
      m->g.lat = s->lat;
    }
  if ( s->mask & SUBSET_MASK_HAVE_LONGITUDE )
    {
      m->g.lon = s->lon;
    }
  if ( s->mask & SUBSET_MASK_HAVE_ALTITUDE )
    {
      m->g.alt = s->alt;
    }
  if ( s->mask & SUBSET_MASK_HAVE_NAME )
    {
      strcpy ( m->g.name, s->name );
    }
  if ( s->mask & SUBSET_MASK_HAVE_COUNTRY )
    {
      strcpy ( m->g.country, s->country );
    }
 
  //print_temp_raw_data ( r );
  //print_temp_raw_wind_shear_data ( w );
 
  // Finally parse raw data to fill all needed points for a TEMP
  if ( parse_temp_raw_data ( t, r ) )
    {
      sprintf ( err,"bufr2tac: parse_temp_raw_data(): Too much significant points" );
      free ( ( void * ) ( r ) );
      free ( ( void * ) ( w ) );
      return 1;
    }
  parse_temp_raw_wind_shear_data ( t, w );
 
  // Free memory
  free ( ( void * ) ( r ) );
  free ( ( void * ) ( w ) );
  return 0;
}

References bufr2tac_subset_state::a, temp_chunks::a, bufr2tac_subset_state::a1, bufr2tac_subset_state::alt, met_geo::alt, temp_chunks::b, bufr2tac_clean_temp_chunks(), temp_chunks::c, bufr2tac_subset_state::country, met_geo::country, temp_chunks::d, temp_acd_sec1::D_D, report_date_ext::DD, temp_a::e, metreport::g, temp_acd_sec1::h0h0h0h0, report_date_ext::HH, bufr2tac_subset_state::i, temp_acd_sec1::II, temp_acd_sec1::iii, temp_acd_sec1::IIIII, met_geo::index, bufr2tac_subset_state::ival, bufr2tac_subset_state::lat, met_geo::lat, bufr2tac_subset_state::lon, met_geo::lon, bufr2tac_subset_state::mask, met_datetime_to_YYGG(), temp_acd_sec1::MiMi, temp_b_sec1::MiMi, temp_acd_sec1::MjMj, temp_b_sec1::MjMj, report_date_ext::MM, report_date_ext::mm, bufr2tac_subset_state::name, met_geo::name, parse_temp_raw_data(), parse_temp_raw_wind_shear_data(), bufr2tac_subset_state::r, round_met_datetime_to_hour(), temp_a::s1, temp_b::s1, temp_c::s1, temp_d::s1, report_date_ext::ss, SUBSET_MASK_HAVE_ALTITUDE, SUBSET_MASK_HAVE_COUNTRY, SUBSET_MASK_HAVE_DAY, SUBSET_MASK_HAVE_HOUR, SUBSET_MASK_HAVE_LATITUDE, SUBSET_MASK_HAVE_LONGITUDE, SUBSET_MASK_HAVE_MINUTE, SUBSET_MASK_HAVE_MONTH, SUBSET_MASK_HAVE_NAME, SUBSET_MASK_HAVE_YEAR, metreport::t, temp_chunks::t, metreport::temp, temp_parse_x01(), temp_parse_x02(), temp_parse_x04(), temp_parse_x05(), temp_parse_x06(), temp_parse_x07(), temp_parse_x08(), temp_parse_x10(), temp_parse_x11(), temp_parse_x12(), temp_parse_x20(), temp_parse_x22(), temp_parse_x31(), temp_parse_x33(), metreport::type, metreport::type2, metreport::type3, metreport::type4, bufr2tac_subset_state::type_report, temp_acd_sec1::Ula, bufr2tac_subset_state::val, bufr2tac_subset_state::w, met_geo::wid, temp_chunks::wid, temp_acd_sec1::YYGG, temp_b_sec1::YYGG, report_date_ext::YYYY, and YYYYMMDDHHmm_to_met_datetime().

Referenced by parse_subset_sequence().

Here is the call graph for this function:

Here is the caller graph for this function:

parse_subset_sequence()

int parse_subset_sequence	(	struct metreport *	m,
		struct bufr_subset_sequence_data *	sq,
		struct bufr2tac_subset_state *	st,
		int *	kdtlst,
		size_t	nlst,
		int *	ksec1,
		char *	err
	)

Parse a sequence of expanded descriptors for a subset.

Parameters

m	pointer to a struct metreport where to set the data
sq	pointer to a struct bufr_subset_sequence_data where the values for sequence of descriptors for a subset has been decoded
st	pointer to a struct bufr2tac_subset_state
kdtlst	array of integers with descriptors
nlst	number of descriptors in kdtlst
ksec1	array of auxiliar integers decoded by bufrdc ECMWF library
err	string where to write errors if any

Definition at line 81 of file bufr2tac_sqparse.c.

{
  /* Clean the state */
  memset ( st, 0, sizeof ( struct bufr2tac_subset_state ) );
 
  /* First task to do is figure out the type of report */
  switch ( ksec1[5] )
    {
    case 0:
      if ( find_descriptor_interval ( kdtlst, nlst, 307071, 307073 ) )
        {
          strcpy ( st->type_report, "CLIMAT" );  // FM-71 CLIMAT
        }
      else if ( find_descriptor_interval ( kdtlst, nlst, 307079, 307086 ) ||
                find_descriptor ( kdtlst, nlst,307091 ) ||
                find_descriptor ( kdtlst, nlst,307092 ) ||
                find_descriptor ( kdtlst, nlst,307096 ) ||
                find_descriptor ( kdtlst, nlst,307182 ) ||
                ksec1[6] == 0 || ksec1[6] == 1 || ksec1[6] == 2 )
        {
          strcpy ( st->type_report,"AAXX" );  // FM-12 synop
        }
      else if ( find_descriptor ( kdtlst, nlst,307090 ) ||
                find_descriptor ( kdtlst, nlst,301092 ) ||
                ksec1[6] == 3 || ksec1[6] == 4 || ksec1[6] == 5 )
        {
          strcpy ( st->type_report,"OOXX" );  // FM-14 synop-mobil
        }
      break;
    case 1:
      if ( find_descriptor_interval ( kdtlst, nlst, 308004, 308005 ) ||
           find_descriptor ( kdtlst, nlst,301093 ) ||
           find_descriptor ( kdtlst, nlst,308009 ) || 
           find_descriptor ( kdtlst, nlst,1011 ) )
        {
          strcpy ( st->type_report,"BBXX" );  // FM-13 ship
        }
      else if ( find_descriptor_interval ( kdtlst, nlst, 308001, 308003 ) ||
                find_descriptor ( kdtlst, nlst,315008 ) ||
                find_descriptor ( kdtlst, nlst,315009 ) ||
                find_descriptor ( kdtlst, nlst,1005 ) ||
                find_descriptor ( kdtlst, nlst,2036 ) ||
                find_descriptor ( kdtlst, nlst,2149 ) ||
                ksec1[6] == 25 )
        {
          strcpy ( st->type_report,"ZZYY" );  // FM-18 buoy
        }
      else if ( find_descriptor_interval ( kdtlst, nlst, 308011, 308013 ) )
        {
          strcpy ( st->type_report, "CLIMAT SHIP" );  // FM-71 CLIMAT SHIP
        }
      else if ( find_descriptor ( kdtlst, nlst,307090 ) )
        {
          // FIXME Some FM-14 are coded as category 1
          strcpy ( st->type_report,"OOXX" );  // FM-14 synop-mobil
        }
      break;
    case 2:
      if ( find_descriptor_interval ( kdtlst, nlst, 309050, 309051 ) )
        {
          strcpy ( st->type_report,"PPXX" );  // PILOT, PILOT SHIP, PILOT DROP or PILOT MOBIL
        }
      else if ( find_descriptor ( kdtlst, nlst, 309052 ) ||
                find_descriptor ( kdtlst, nlst, 309057 ) 
              )
        {
          strcpy ( st->type_report,"TTXX" );  // TEMP, TEMP SHIP, TEMP MOBIL
        }
      break;
    default:
      sprintf ( err, "The data category %d is not parsed at the moment", ksec1[5] );
      return 1;
    }
  
  
  if ( st->type_report[0] == '\0' )
    {
      sprintf ( err, "Cannot find the report type\n" );
      return 1;
    }
 
  //if(DEBUG)
  //  printf("Going to parse a %s report\n", st->type_report);
 
 
  if ( strcmp ( st->type_report,"AAXX" ) == 0 || strcmp ( st->type_report,"BBXX" ) == 0 || strcmp ( st->type_report,"OOXX" ) == 0 )
    {
      // Parse FM-12, FM-13 and FM-14
      if ( parse_subset_as_synop ( m, st, sq, err ) == 0 )
        {
          if (BUFR2TAC_DEBUG_LEVEL)
            bufr2tac_print_error(&st->e);
          return print_synop_report ( m );
        }
        
    }
  else if ( strcmp ( st->type_report,"ZZYY" ) == 0 )
    {
      // parse BUOY
      if ( parse_subset_as_buoy ( m, st, sq, err ) == 0 )
        {
          if (BUFR2TAC_DEBUG_LEVEL)
            bufr2tac_print_error(&st->e);
          return print_buoy_report ( m );
        }
    }
  else if ( strcmp ( st->type_report,"TTXX" ) == 0 )
    {
      // psrse TEMP
      if ( parse_subset_as_temp ( m, st, sq, err ) == 0 )
        {
          if (BUFR2TAC_DEBUG_LEVEL)
            bufr2tac_print_error(&st->e);
          return print_temp_report ( m );
        }
    }
  else if ( strcmp ( st->type_report,"CLIMAT" ) == 0 )
    {
      // psrse CLIMAT
      if ( parse_subset_as_climat ( m, st, sq, err ) == 0 )
        {
          if (BUFR2TAC_DEBUG_LEVEL)
            bufr2tac_print_error(&st->e);
          return print_climat_report ( m );
        }
    }
 
  // when reached this point we have han error
  if (BUFR2TAC_DEBUG_LEVEL)
    bufr2tac_print_error(&st->e);
  return 1;
}

References BUFR2TAC_DEBUG_LEVEL, bufr2tac_print_error(), bufr2tac_subset_state::e, find_descriptor(), find_descriptor_interval(), parse_subset_as_buoy(), parse_subset_as_climat(), parse_subset_as_synop(), parse_subset_as_temp(), print_buoy_report(), print_climat_report(), print_synop_report(), print_temp_report(), and bufr2tac_subset_state::type_report.

Referenced by bufrtotac_parse_subset_sequence().

Here is the call graph for this function:

Here is the caller graph for this function:

parse_temp_raw_data()

int parse_temp_raw_data	(	struct temp_chunks *	t,
		struct temp_raw_data *	r
	)

parse a struct temp_raw_data to fill chunks in a struct temp_chunks

Definition at line 403 of file bufr2tac_temp.c.

{
  int ix, is_over_100;
  size_t i, j, isa = 0, isc = 0, ita = 0, itc = 0; // level counters
  size_t iwxa = 0, iwxc = 0, itb = 0, itd = 0;
  size_t iwd = 0, iwb = 0;
  size_t isav = 0, iscv = 0; // valid data counters for standard levels
  struct temp_raw_point_data *d;
 
  if ( t == NULL || r == NULL )
    {
      return 1;
    }
 
  if ( r->n == 0 )
    {
      return 1;
    }
 
  // Some default
  t->a.s1.id[0] = '/';
  t->c.s1.id[0] = '/';
  for ( i = 0; i < r->n; i++ )
    {
      d = & ( r->raw[i] ); // to make code easy
 
      if ( d->p < 10000.0 ) // to select which part
        {
          is_over_100 = 1;
        }
      else
        {
          is_over_100 = 0;
        }
 
      // Surface data
      if ( d->flags & TEMP_POINT_MASK_SURFACE )
        {
          pascal_to_pnpnpn ( t->a.s2.lev0.PnPnPn, d->p ); //PoPoPo
          kelvin_to_TTTa ( t->a.s2.lev0.TnTnTan, d->T ); // TnTnTan
          dewpoint_depression_to_DnDn ( t->a.s2.lev0.DnDn, d->T , d->Td ); // DnDn
          wind_to_dndnfnfnfn ( t->a.s2.lev0.dndnfnfnfn, d->dd, d->ff ); // dndnfnfnfn
        }
 
      // standard level
      if ( d->flags & TEMP_POINT_MASK_STANDARD_LEVEL )
        {
          ix = ( int ) ( d->p * 0.01 + 0.5 ); // hPa
          ix = ( ix / 10 ) % 100; // coded
          if ( is_over_100 )
            {
              sprintf ( t->c.s2.std[isc].PnPn, "%02d", ix );  // PnPn
            }
          else
            {
              sprintf ( t->a.s2.std[isa].PnPn, "%02d", ix );  // PnPn
            }
 
          ix = ( int ) ( d->h + 0.5 );
          if ( d->p <= 50000.0 )
            {
              if ( is_over_100 )
                {
                  sprintf ( t->c.s2.std[isc].hnhnhn, "%03d", ( ( ix + 5 ) / 10 ) % 1000 );
                }
              else
                {
                  sprintf ( t->a.s2.std[isa].hnhnhn, "%03d", ( ( ix + 5 ) / 10 ) % 1000 );
                }
            }
          else
            {
              if ( is_over_100 )
                {
                  sprintf ( t->c.s2.std[isc].hnhnhn, "%03d", ix % 1000 );
                }
              else if ( ix >= 0 )
                {
                  sprintf ( t->a.s2.std[isa].hnhnhn, "%03d", ix % 1000 );
                }
              else
                {
                  sprintf ( t->a.s2.std[isa].hnhnhn, "%03d", ( -ix + 500 ) % 1000 );
                }
            }
          if ( is_over_100 )
            {
              kelvin_to_TTTa ( t->c.s2.std[isc].TnTnTan, d->T ); // TnTnTan
              dewpoint_depression_to_DnDn ( t->c.s2.std[isc].DnDn, d->T, d->Td ); // DnDn
              wind_to_dndnfnfnfn ( t->c.s2.std[isc].dndnfnfnfn, d->dd, d->ff ); // dndnfnfnfn
              // Now update Id
              if ( d->ff != MISSING_REAL && d->dd != MISSING_REAL )
                {
                  t->c.s1.id[0] = t->c.s2.std[isc].PnPn[0];
                }
              if ( isc < TEMP_NSTAND_MAX )
                {
                  isc += 1;
                  t->c.s2.n = isc;
                }
              else
                return 1;
 
              if ( d->T != MISSING_REAL  || d->Td != MISSING_REAL ||
                   d->ff != MISSING_REAL || d->dd != MISSING_REAL )
                {
                  // data present
                  iscv += 1;
                }
            }
          else
            {
              kelvin_to_TTTa ( t->a.s2.std[isa].TnTnTan, d->T ); // TnTnTan
              dewpoint_depression_to_DnDn ( t->a.s2.std[isa].DnDn, d->T , d->Td ); // DnDn
              wind_to_dndnfnfnfn ( t->a.s2.std[isa].dndnfnfnfn, d->dd, d->ff ); // dndnfnfnfn
              // Now update Id
              if ( d->ff != MISSING_REAL && d->dd != MISSING_REAL )
                {
                  t->a.s1.id[0] = t->a.s2.std[isa].PnPn[0];
                }
              if ( isa < TEMP_NSTAND_MAX )
                {
                  isa += 1;
                  t->a.s2.n = isa;
                }
              else
                return 1;
 
              if ( d->T != MISSING_REAL  || d->Td != MISSING_REAL ||
                   d->ff != MISSING_REAL || d->dd != MISSING_REAL )
                {
                  // data present
                  isav += 1;
                }
            }
        }
 
      // Tropopause level
      if ( d->flags & TEMP_POINT_MASK_TROPOPAUSE_LEVEL )
        {
          if ( is_over_100 )
            {
              ix = ( int ) ( d->p * 0.1 + 0.5 );
              sprintf ( t->c.s3.trop[itc].PnPnPn, "%03d", ix % 1000 ); // PnPnPn
              kelvin_to_TTTa ( t->c.s3.trop[itc].TnTnTan, d->T ); // TnTnTan
              dewpoint_depression_to_DnDn ( t->c.s3.trop[itc].DnDn, d->T , d->Td ); // DnDn
              wind_to_dndnfnfnfn ( t->c.s3.trop[itc].dndnfnfnfn, d->dd, d->ff ); // dndnfnfnfn
              if ( ix && itc < TEMP_NTROP_MAX )
                {
                  itc += 1;
                  t->c.s3.n = itc;
                }
              else
                return 1;
            }
          else
            {
              ix = ( int ) ( d->p * 0.01 + 0.5 );
              sprintf ( t->a.s3.trop[ita].PnPnPn, "%03d", ix % 1000 ); // PnPnPn.
              kelvin_to_TTTa ( t->a.s3.trop[ita].TnTnTan, d->T ); // TnTnTan
              dewpoint_depression_to_DnDn ( t->a.s3.trop[ita].DnDn, d->T , d->Td ); // DnDn
              wind_to_dndnfnfnfn ( t->a.s3.trop[ita].dndnfnfnfn, d->dd, d->ff ); // dndnfnfnfn
              if ( ix && ita < TEMP_NTROP_MAX )
                {
                  ita += 1;
                  t->a.s3.n = ita;
                }
              else
                return 1;
            }
        }
 
      // Max wind level
      if ( d->flags & TEMP_POINT_MASK_MAXIMUM_WIND_LEVEL )
        {
          if ( is_over_100 )
            {
              ix = ( int ) ( d->p * 0.1 + 0.5 );
              sprintf ( t->c.s4.windx[iwxc].PmPmPm, "%03d", ix % 1000 ); // PnPnPn
              wind_to_dndnfnfnfn ( t->c.s4.windx[iwxc].dmdmfmfmfm, d->dd, d->ff ); // dndnfnfnfn
              // check if more wind data
              for ( j = i + 1; j < r->n ; j++ )
                {
                  if ( r->raw[j].ff != MISSING_REAL )
                    {
                      t->c.s4.windx[iwxc].no_last_wind = 1;
                      break;
                    }
                }
              if ( ix && iwxc < TEMP_NMAXWIND_MAX )
                {
                  iwxc += 1;
                  t->c.s4.n = iwxc;
                }
              else
                return 1;
            }
          else
            {
              ix = ( int ) ( d->p * 0.01 + 0.5 );
              sprintf ( t->a.s4.windx[iwxa].PmPmPm, "%03d", ix % 1000 ); // PnPnPn.
              wind_to_dndnfnfnfn ( t->a.s4.windx[iwxa].dmdmfmfmfm, d->dd, d->ff ); // dndnfnfnfn
              for ( j = i + 1; j < r->n ; j++ )
                {
                  if ( r->raw[j].ff != MISSING_REAL )
                    {
                      t->a.s4.windx[iwxa].no_last_wind = 1;
                      break;
                    }
                }
              if ( ix && iwxa < TEMP_NMAXWIND_MAX )
                {
                  iwxa += 1;
                  t->a.s4.n = iwxa;
                }
              else
                return 1;
            }
        }
 
      // Significant TH points
      if ( d->flags & ( TEMP_POINT_MASK_SIGNIFICANT_TEMPERATURE_LEVEL | TEMP_POINT_MASK_SIGNIFICANT_HUMIDITY_LEVEL ) )
        {
          if ( is_over_100 )
            {
              sprintf ( t->d.s5.th[itd].nini, "%d%d", ( ( int ) itd ) %9 + 1, ( ( int ) itd ) %9 + 1 );
              ix = ( int ) ( d->p * 0.1 + 0.5 );
              sprintf ( t->d.s5.th[itd].PnPnPn, "%03d", ix ); // PnPnPn
              kelvin_to_TTTa ( t->d.s5.th[itd].TnTnTan, d->T ); // TnTnTan
              dewpoint_depression_to_DnDn ( t->d.s5.th[itd].DnDn, d->T , d->Td ); // DnDn
              if ( ix && itd < TEMP_NMAX_POINTS )
                {
                  itd += 1;
                  t->d.s5.n = itd;
                }
              else
                return 1;
            }
          else
            {
              if ( d->flags & TEMP_POINT_MASK_SURFACE )
                {
                  strcpy ( t->b.s5.th[itb].nini, "00" ); // case of surface level
                }
              else
                {
                  sprintf ( t->b.s5.th[itb].nini, "%d%d", ( ( int ) itb - 1 ) %9 + 1, ( ( int ) itb - 1 ) %9 + 1 );
                }
              ix = ( int ) ( d->p * 0.01 + 0.5 );
              sprintf ( t->b.s5.th[itb].PnPnPn, "%03d", ix % 1000 ); // PnPnPn.
              kelvin_to_TTTa ( t->b.s5.th[itb].TnTnTan, d->T ); // TnTnTan
              dewpoint_depression_to_DnDn ( t->b.s5.th[itb].DnDn, d->T , d->Td ); // DnDn
              if ( ix && itb < TEMP_NMAX_POINTS )
                {
                  itb += 1;
                  t->b.s5.n = itb;
                }
              else
                return 1;
            }
        }
 
      // Significant wind points
      if ( d->flags & TEMP_POINT_MASK_SIGNIFICANT_WIND_LEVEL )
        {
          if ( is_over_100 )
            {
              sprintf ( t->d.s6.wd[iwd].nini, "%d%d", ( ( int ) iwd ) %9 + 1, ( ( int ) iwd ) %9 + 1 );
              ix = ( int ) ( d->p * 0.1 + 0.5 );
              sprintf ( t->d.s6.wd[iwd].PnPnPn, "%03d", ix ); // PnPnPn
              wind_to_dndnfnfnfn ( t->d.s6.wd[iwd].dndnfnfnfn, d->dd, d->ff ); // dndnfnfnfn
              if ( ix && iwd < TEMP_NMAX_POINTS )
                {
                  iwd += 1;
                  t->d.s6.n = iwd;
                }
              else
                return 1;
 
            }
          else
            {
              if ( d->flags & TEMP_POINT_MASK_SURFACE )
                {
                  strcpy ( t->b.s6.wd[iwb].nini, "00" ); // case of surface level
                }
              else
                {
                  sprintf ( t->b.s6.wd[iwb].nini, "%d%d", ( ( int ) iwb - 1 ) %9 + 1, ( ( int ) iwb - 1 ) %9 + 1 );
                }
              ix = ( int ) ( d->p * 0.01 + 0.5 );
              sprintf ( t->b.s6.wd[iwb].PnPnPn, "%03d", ix % 1000 ); // PnPnPn.
              wind_to_dndnfnfnfn ( t->b.s6.wd[iwb].dndnfnfnfn, d->dd, d->ff ); // dndnfnfnfn
              if ( ix && iwb < TEMP_NMAX_POINTS )
                {
                  iwb += 1;
                  t->b.s6.n = iwb;
                  //printf("%lu\n", t->b.s6.n);
                }
              else
                return 1;
            }
        }
    }
 
  // Now we set some bit masks
  if ( isav )
    {
      t->a.mask |= TEMP_SEC_2;
    }
  if ( iscv )
    {
      t->c.mask |= TEMP_SEC_2;
    }
  if ( ita )
    {
      t->a.mask |= TEMP_SEC_3;
    }
  if ( itc )
    {
      t->c.mask |= TEMP_SEC_3;
    }
  if ( iwxa )
    {
      t->a.mask |= TEMP_SEC_4;
    }
  if ( iwxc )
    {
      t->c.mask |= TEMP_SEC_4;
    }
  if ( itb )
    {
      t->b.mask |= TEMP_SEC_5;
    }
  if ( itd )
    {
      t->d.mask |= TEMP_SEC_5;
    }
  if ( iwb )
    {
      t->b.mask |= TEMP_SEC_6;
    }
  if ( iwd )
    {
      t->d.mask |= TEMP_SEC_6;
    }
 
  return 0;
}

References temp_chunks::a, temp_chunks::b, temp_chunks::c, temp_chunks::d, temp_raw_point_data::dd, dewpoint_depression_to_DnDn(), temp_max_wind_data::dmdmfmfmfm, temp_main_level_data::DnDn, temp_std_level_data::DnDn, temp_th_point::DnDn, temp_main_level_data::dndnfnfnfn, temp_std_level_data::dndnfnfnfn, temp_wind_point::dndnfnfnfn, temp_raw_point_data::ff, temp_raw_point_data::flags, temp_raw_point_data::h, temp_std_level_data::hnhnhn, temp_acd_sec1::id, kelvin_to_TTTa(), temp_a_sec2::lev0, temp_a::mask, temp_b::mask, temp_c::mask, temp_d::mask, MISSING_REAL, temp_raw_data::n, temp_a_sec2::n, temp_c_sec2::n, temp_ac_sec3::n, temp_ac_sec4::n, temp_bd_sec5::n, temp_bd_sec6::n, temp_th_point::nini, temp_wind_point::nini, temp_max_wind_data::no_last_wind, temp_raw_point_data::p, pascal_to_pnpnpn(), temp_max_wind_data::PmPmPm, temp_std_level_data::PnPn, temp_main_level_data::PnPnPn, temp_th_point::PnPnPn, temp_wind_point::PnPnPn, temp_raw_data::raw, temp_a::s1, temp_c::s1, temp_a::s2, temp_c::s2, temp_a::s3, temp_c::s3, temp_a::s4, temp_c::s4, temp_b::s5, temp_d::s5, temp_b::s6, temp_d::s6, temp_a_sec2::std, temp_c_sec2::std, temp_raw_point_data::T, temp_raw_point_data::Td, TEMP_NMAX_POINTS, TEMP_NMAXWIND_MAX, TEMP_NSTAND_MAX, TEMP_NTROP_MAX, TEMP_POINT_MASK_MAXIMUM_WIND_LEVEL, TEMP_POINT_MASK_SIGNIFICANT_HUMIDITY_LEVEL, TEMP_POINT_MASK_SIGNIFICANT_TEMPERATURE_LEVEL, TEMP_POINT_MASK_SIGNIFICANT_WIND_LEVEL, TEMP_POINT_MASK_STANDARD_LEVEL, TEMP_POINT_MASK_SURFACE, TEMP_POINT_MASK_TROPOPAUSE_LEVEL, TEMP_SEC_2, TEMP_SEC_3, TEMP_SEC_4, TEMP_SEC_5, TEMP_SEC_6, temp_bd_sec5::th, temp_main_level_data::TnTnTan, temp_std_level_data::TnTnTan, temp_th_point::TnTnTan, temp_ac_sec3::trop, temp_bd_sec6::wd, wind_to_dndnfnfnfn(), and temp_ac_sec4::windx.

Referenced by parse_subset_as_temp().

Here is the call graph for this function:

Here is the caller graph for this function:

parse_temp_raw_wind_shear_data()

int parse_temp_raw_wind_shear_data	(	struct temp_chunks *	t,
		struct temp_raw_wind_shear_data *	w
	)

Definition at line 757 of file bufr2tac_temp.c.

{
  size_t i, j;
  int ix, is_over_100;
  char aux[16];
 
  struct temp_raw_wind_shear_point *d;
 
  if ( t == NULL || w == NULL )
    {
      return 1;
    }
 
  if ( w->n == 0 )
    {
      return 1;
    }
 
  for ( i = 0; i < w->n; i++ )
    {
      d = & ( w->raw[i] ); // to make code easy
 
      if ( d->p < 10000.0 ) // to select which part
        {
          is_over_100 = 1;
        }
      else
        {
          is_over_100 = 0;
        }
 
      // set pnpnpn on aux
      if ( is_over_100 )
        {
          if ( t ->c.s4.n == 0 )
            {
              continue;
            }
 
          ix = ( int ) ( d->p * 0.1 + 0.5 );
          sprintf ( aux, "%03d", ix % 1000 ); // PnPnPn
 
          // checks for a significant wind level in section 4 with same pnpnpn
          for ( j = 0 ; j < t->c.s4.n ; j++ )
            {
              if ( strcmp ( t->c.s4.windx[j].PmPmPm , aux ) == 0 )
                {
                  if ( d->ws_blw != MISSING_REAL )
                    {
                      sprintf ( t->c.s4.windx[j].vbvb, "%02.0lf", d->ws_blw );
                    }
                  if ( d->ws_abv != MISSING_REAL )
                    {
                      sprintf ( t->c.s4.windx[j].vava, "%02.0lf", d->ws_abv );
                    }
                  break;
                }
            }
        }
      else
        {
          if ( t ->a.s4.n == 0 )
            {
              continue;
            }
          ix = ( int ) ( d->p * 0.01 + 0.5 );
          sprintf ( aux, "%03d", ix % 1000 ); // PnPnPn.
          // checks for a significant wind level in section 4 with same pnpnpn
          for ( j = 0 ; j < t->a.s4.n ; j++ )
            {
              if ( strcmp ( t->a.s4.windx[j].PmPmPm , aux ) == 0 )
                {
                  //printf("%s %s\n", aux, t->a.s4.windx[j].PmPmPm);
                  //printf("%.1lf %.1lf\n", d->ws_blw, d->ws_abv);
                  if ( d->ws_blw != MISSING_REAL )
                    {
                      sprintf ( t->a.s4.windx[j].vbvb, "%02.0lf", d->ws_blw );
                    }
                  if ( d->ws_abv != MISSING_REAL )
                    {
                      sprintf ( t->a.s4.windx[j].vava, "%02.0lf", d->ws_abv );
                    }
                  break;
                }
            }
        }
    }
 
  return 0;
}

References temp_chunks::a, temp_chunks::c, MISSING_REAL, temp_raw_wind_shear_data::n, temp_ac_sec4::n, temp_raw_wind_shear_point::p, temp_max_wind_data::PmPmPm, temp_raw_wind_shear_data::raw, temp_a::s4, temp_c::s4, temp_max_wind_data::vava, temp_max_wind_data::vbvb, temp_ac_sec4::windx, temp_raw_wind_shear_point::ws_abv, and temp_raw_wind_shear_point::ws_blw.

Referenced by parse_subset_as_temp().

Here is the caller graph for this function:

pascal_to_pnpnpn()

char * pascal_to_pnpnpn	(	char *	target,
		double	P
	)

Definition at line 47 of file bufr2tac_x10.c.

{
  int ic;
  if ( P > 10000.0 )
    {
      ic = ( int ) ( P * 0.01 + 0.5 );
    }
  else
    {
      ic = ( int ) ( P * 0.1 + 0.5 );
    }
  sprintf ( target, "%03d", ic % 1000 );
  return target;
}

Referenced by parse_temp_raw_data().

Here is the caller graph for this function:

pascal_to_ppp()

char * pascal_to_ppp	(	char *	target,
		double	P
	)

Converts pascal values (variation) into a ppp string.

Parameters

P	the pressure variation in Pascal units
target	string with the result

Definition at line 32 of file bufr2tac_x10.c.

{
  int ic;
  if ( P > 0 )
    {
      ic = ( int ) ( P * 0.1 );
    }
  else
    {
      ic = ( int ) ( -P * 0.1 );
    }
  sprintf ( target, "%03d", ic % 1000 );
  return target;
}

Referenced by buoy_parse_x10(), and syn_parse_x10().

Here is the caller graph for this function:

pascal_to_PPPP()

char * pascal_to_PPPP	(	char *	target,
		double	P
	)

Converts pascal values into a PPPP string.

Parameters

P	the pressure variation in Pascal units
target	string with the result

Definition at line 69 of file bufr2tac_x10.c.

{
  int ic;
  ic = ( int ) ( P * 0.1 );
  sprintf ( target, "%04d", ic % 10000 );
  return target;
}

Referenced by buoy_parse_x10(), climat_parse_x10(), and syn_parse_x10().

Here is the caller graph for this function:

percent_to_okta()

char * percent_to_okta	(	char *	target,
		double	perc
	)

Converts percent cloud cover into okta.

Parameters

perc	the precent cloud cover
target	the resulting okta string

Definition at line 32 of file bufr2tac_x20.c.

{
  if ( perc == 0.0 )
    {
      strcpy ( target,"0" );
    }
  else if ( perc < ( 25.0 - 6.25 ) )
    {
      strcpy ( target,"1" );
    }
  else if ( perc < ( 37.5 - 6.25 ) )
    {
      strcpy ( target,"2" );
    }
  else if ( perc < ( 50.0 - 6.25 ) )
    {
      strcpy ( target,"3" );
    }
  else if ( perc < ( 62.5 -6.25 ) )
    {
      strcpy ( target,"4" );
    }
  else if ( perc < ( 75.0 - 6.25 ) )
    {
      strcpy ( target,"5" );
    }
  else if ( perc < ( 87.5 - 6.25 ) )
    {
      strcpy ( target,"6" );
    }
  else if ( perc < 100.0 )
    {
      strcpy ( target,"7" );
    }
  else if ( perc <= 112.5 )
    {
      strcpy ( target,"8" );
    }
  else if ( perc == 113.0 )
    {
      strcpy ( target,"9" );
    }
  return target;
}

Referenced by syn_parse_x20().

Here is the caller graph for this function:

prec_to_RRR()

char * prec_to_RRR	(	char *	target,
		double	r
	)

converts a precipitation in Kg/m2 into a RRR string

Parameters

r	the precipitation
target	the resulting string

Definition at line 32 of file bufr2tac_x13.c.

{
  if ( r == 0.0 )
    {
      strcpy ( target,"000" );
    }
  else if ( r > -0.11 && r < -0.09 ) // this is an approach to -0.1
    {
      strcpy ( target,"990" );
    }
  else if ( r < 0.95 )
    {
      sprintf ( target, "99%d", ( int ) ( r * 10.0 + 0.5 ) );
    }
  else if ( r >= 989.0 )
    {
      strcpy ( target,"989" );
    }
  else
    {
      sprintf ( target, "%03d", ( int ) ( r + 0.5 ) );
    }
  return target;
 
}

Referenced by syn_parse_x13().

Here is the caller graph for this function:

prec_to_RRRR24()

char * prec_to_RRRR24	(	char *	target,
		double	r
	)

converts a precipitation in Kg/m2 into a RRRR24 string

Parameters

r	the precipitation
target	the resulting string

Definition at line 87 of file bufr2tac_x13.c.

{
  if ( r < 0.0 || ( r > 0.0 && r < 0.1 ) )
    {
      strcpy ( target,"9999" );
    }
  else if ( r <= 999.8 )
    {
      sprintf ( target,"%04d", ( int ) ( r * 10.0 + 0.5 ) );
    }
  else
    {
      strcpy ( target,"9998" );
    }
  return target;
}

Referenced by syn_parse_x13().

Here is the caller graph for this function:

print_buoy_report()

int print_buoy_report

(

struct metreport *

m

)

prints a buoy into a string

Parameters

m	pointer to struct metreport where are both target and source

If OK returns 0, otherwise 1

Definition at line 392 of file bufr2tac_print_buoy.c.

{
  char *c = & ( m->alphanum[0] );
  size_t used = 0;
  size_t lmax = sizeof ( m->alphanum );
  struct buoy_chunks *b = &m->buoy;
 
  // Needs time extension
  if ( b->e.YYYY[0] == 0  || b->e.YYYY[0] == '0' )
    {
      return 1;
    }
 
  if ( m->print_mask & PRINT_BITMASK_WIGOS )
    {
      used += print_wigos_id ( &c, lmax, m );
    }
 
  if ( m->print_mask & PRINT_BITMASK_GEO )
    {
      used += print_geo ( &c, lmax, m );
    }
 
  print_buoy_sec0 ( &c, lmax, b );
 
  if ( b->mask & ( BUOY_SEC1 | BUOY_SEC2 | BUOY_SEC3 ) )
    {
      used += print_buoy_sec1 ( &c, lmax - used, b );
 
      used += print_buoy_sec2 ( &c, lmax - used, b );
 
      used += print_buoy_sec3 ( &c, lmax - used, b );
    }
  else
    {
      c += snprintf ( c, lmax - used, " NIL" );
    }
  snprintf ( c, lmax - used - 1, "=" );
 
  return 0;
}

References metreport::alphanum, metreport::buoy, BUOY_SEC1, BUOY_SEC2, BUOY_SEC3, buoy_chunks::e, buoy_chunks::mask, PRINT_BITMASK_GEO, PRINT_BITMASK_WIGOS, print_buoy_sec0(), print_buoy_sec1(), print_buoy_sec2(), print_buoy_sec3(), print_geo(), metreport::print_mask, print_wigos_id(), and report_date_ext::YYYY.

Referenced by parse_subset_sequence().

Here is the call graph for this function:

Here is the caller graph for this function:

print_buoy_sec0()

size_t print_buoy_sec0	(	char **	sec0,
		size_t	lmax,
		struct buoy_chunks *	b
	)

Prints the buoy section 1.

Parameters

sec0	the pointer where to print section
lmax	max length permited
b	pointer to s atruct buoy_chunks where the parse results are set

Definition at line 33 of file bufr2tac_print_buoy.c.

{
  size_t used = 0;
  char *c = *sec0;
 
  used += snprintf ( c + used, lmax - used, "%s%s%s%s%s", b->e.YYYY, b->e.MM, b->e.DD, b->e.HH, b->e.mm );
 
  // Print type
  used += snprintf ( c + used, lmax - used, " %s%s", b->s0.MiMi, b->s0.MjMj );
 
  if ( b->s0.A1[0] && b->s0.bw[0] && b->s0.nbnbnb[0] )
    {
      used += snprintf ( c + used, lmax - used, " %s%s%s", b->s0.A1, b->s0.bw, b->s0.nbnbnb );
    }
  else if ( b->s0.D_D[0] )
    {
      used += snprintf ( c + used, lmax - used, " %s", b->s0.D_D );
    }
 
 
  used += snprintf ( c + used, lmax - used, " %s%s%s", b->s0.YY, b->s0.MM, b->s0.J );
 
  if ( b->s0.iw[0] )
    {
      used += snprintf ( c + used, lmax - used, " %s%s%s", b->s0.GG, b->s0.gg, b->s0.iw );
    }
  else
    {
      used += snprintf ( c + used, lmax - used, " %s%s/", b->s0.GG, b->s0.gg );
    }
 
  used += snprintf ( c + used, lmax - used, " %s%s", b->s0.Qc, b->s0.LaLaLaLaLa );
 
 
  used += snprintf ( c + used, lmax - used, " %s", b->s0.LoLoLoLoLoLo );
 
  if ( b->s0.QA[0] || b->s0.Ql[0] || b->s0.Qt[0] )
    {
      if ( b->s0.Ql[0] )
        {
          used += snprintf ( c + used, lmax - used,  " 6%s", b->s0.Ql );
        }
      else
        {
          used += snprintf ( c + used, lmax - used, " 6/" );
        }
 
      if ( b->s0.Qt[0] )
        {
          used +=snprintf ( c + used, lmax - used, "%s", b->s0.Qt );
        }
      else
        {
          used += snprintf ( c + used, lmax - used,  "/" );
        }
 
      if ( b->s0.QA[0] )
        {
          used += snprintf ( c + used, lmax - used,  "%s/", b->s0.QA );
        }
      else
        {
          used += snprintf ( c + used, lmax - used, "//" );
        }
    }
 
  *sec0 = c + used;
  return used;
}

References buoy_sec0::A1, buoy_sec0::bw, buoy_sec0::D_D, report_date_ext::DD, buoy_chunks::e, buoy_sec0::GG, buoy_sec0::gg, report_date_ext::HH, buoy_sec0::iw, buoy_sec0::J, buoy_sec0::LaLaLaLaLa, buoy_sec0::LoLoLoLoLoLo, buoy_sec0::MiMi, buoy_sec0::MjMj, buoy_sec0::MM, report_date_ext::MM, report_date_ext::mm, buoy_sec0::nbnbnb, buoy_sec0::QA, buoy_sec0::Qc, buoy_sec0::Ql, buoy_sec0::Qt, buoy_chunks::s0, buoy_sec0::YY, and report_date_ext::YYYY.

Referenced by print_buoy_report().

Here is the caller graph for this function:

print_buoy_sec1()

size_t print_buoy_sec1	(	char **	sec1,
		size_t	lmax,
		struct buoy_chunks *	b
	)

Prints the buoy section 1.

Parameters

sec1	the pointer where to print section
lmax	max length permited
b	pointer to s atruct buoy_chunks where the parse results are set

Definition at line 111 of file bufr2tac_print_buoy.c.

{
  size_t used = 0;
  char *c = *sec1;
 
  if ( b->mask & BUOY_SEC1 )
    {
      // 111QdQx
      used += snprintf ( c + used, lmax - used," 111" );
 
      if ( b->s1.Qd[0] )
        {
          used += snprintf ( c + used, lmax - used,"%s", b->s1.Qd );
        }
      else
        {
          used += snprintf ( c + used, lmax - used,"/" );
        }
 
      if ( b->s1.Qx[0] )
        {
          used += snprintf ( c + used, lmax - used,"%s", b->s1.Qx );
        }
      else
        {
          used += snprintf ( c + used, lmax - used,"/" );
        }
 
      // 0ddff
      if ( b->s1.dd[0] || b->s1.ff[0] )
        {
          used += snprintf ( c + used, lmax - used, " 0" );
          if ( b->s1.dd[0] )
            {
              used += snprintf ( c + used, lmax - used, "%s", b->s1.dd );
            }
          else
            {
              used += snprintf ( c + used, lmax - used, "//" );
            }
 
          if ( b->s1.ff[0] )
            {
              used += snprintf ( c + used, lmax - used, "%s", b->s1.ff );
            }
          else
            {
              used += snprintf ( c + used, lmax - used, "//" );
            }
        }
 
      // 1snTTT
      if ( b->s1.TTT[0] )
        {
          used += snprintf ( c + used, lmax - used, " 1%s%s", b->s1.sn1, b->s1.TTT );
        }
 
      // 2snTdTdTd
      if ( b->s1.TdTdTd[0] )
        {
          used += snprintf ( c + used, lmax - used, " 2%s%s", b->s1.sn2, b->s1.TdTdTd );
        }
 
      // 3PoPoPoPo
      if ( b->s1.PoPoPoPo[0] )
        {
          used += snprintf ( c + used, lmax - used, " 3%s", b->s1.PoPoPoPo );
        }
 
      // printf 4PPPP
      if ( b->s1.PPPP[0] )
        {
          used += snprintf ( c + used, lmax - used, " 4%s", b->s1.PPPP );
        }
 
      // printf 5appp
      if ( b->s1.a[0] || b->s1.ppp[0] )
        {
          if ( b->s1.a[0] == 0 )
            {
              b->s1.a[0] = '/';
            }
          if ( b->s1.ppp[0] == 0 )
            {
              strcpy ( b->s1.ppp, "///" );
            }
          used += snprintf ( c + used, lmax - used, " 5%s%s", b->s1.a, b->s1.ppp );
        }
    }
 
  *sec1 = c + used;
  return used;
}

References buoy_sec1::a, BUOY_SEC1, buoy_sec1::dd, buoy_sec1::ff, buoy_chunks::mask, buoy_sec1::PoPoPoPo, buoy_sec1::ppp, buoy_sec1::PPPP, buoy_sec1::Qd, buoy_sec1::Qx, buoy_chunks::s1, buoy_sec1::sn1, buoy_sec1::sn2, buoy_sec1::TdTdTd, and buoy_sec1::TTT.

Referenced by print_buoy_report().

Here is the caller graph for this function:

print_buoy_sec2()

size_t print_buoy_sec2	(	char **	sec2,
		size_t	lmax,
		struct buoy_chunks *	b
	)

Prints the buoy section 1.

Parameters

sec2	the pointer where to print section
lmax	max length permited
b	pointer to s atruct buoy_chunks where the parse results are set

Definition at line 212 of file bufr2tac_print_buoy.c.

{
  size_t used = 0;
  char *c = *sec2;
 
  if ( b->mask & BUOY_SEC2 )
    {
      // 222QdQx
      used += snprintf ( c + used, lmax - used," 222" );
 
      if ( b->s2.Qd[0] )
        {
          used += snprintf ( c + used, lmax - used,"%s", b->s2.Qd );
        }
      else
        {
          used += snprintf ( c + used, lmax - used,"/" );
        }
 
      if ( b->s2.Qx[0] )
        {
          used += snprintf ( c + used, lmax - used,"%s", b->s2.Qx );
        }
      else
        {
          used += snprintf ( c + used, lmax - used,"/" );
        }
 
      // 0snTwTwTw
      if ( b->s2.TwTwTw[0] )
        {
          used += snprintf ( c + used, lmax - used, " 0%s%s", b->s2.sn, b->s2.TwTwTw );
        }
 
      // 1PwaPwaHwaHwa
      if ( b->s2.PwaPwa[0] || b->s2.HwaHwa[0] )
        {
          used += snprintf ( c + used, lmax - used, " 1" );
          if ( b->s2.PwaPwa[0] )
            {
              used += snprintf ( c + used, lmax - used,"%s", b->s2.PwaPwa );
            }
          else
            {
              used += snprintf ( c + used, lmax - used,"//" );
            }
 
          if ( b->s2.HwaHwa[0] )
            {
              used += snprintf ( c + used, lmax - used,"%s", b->s2.HwaHwa );
            }
          else
            {
              used += snprintf ( c + used, lmax - used,"//" );
            }
        }
 
      // 20PwaPwaPwa
      if ( b->s2.PwaPwaPwa[0] )
        {
          used += snprintf ( c + used, lmax - used, " 20%s", b->s2.PwaPwaPwa );
        }
 
      // 21HwaHwaHwa
      if ( b->s2.HwaHwaHwa[0] )
        {
          used += snprintf ( c + used, lmax - used, " 21%s", b->s2.HwaHwaHwa );
        }
 
 
    }
 
  *sec2 = c + used;
  return used;
}

References BUOY_SEC2, buoy_sec2::HwaHwa, buoy_sec2::HwaHwaHwa, buoy_chunks::mask, buoy_sec2::PwaPwa, buoy_sec2::PwaPwaPwa, buoy_sec2::Qd, buoy_sec2::Qx, buoy_chunks::s2, buoy_sec2::sn, and buoy_sec2::TwTwTw.

Referenced by print_buoy_report().

Here is the caller graph for this function:

print_buoy_sec3()

size_t print_buoy_sec3	(	char **	sec3,
		size_t	lmax,
		struct buoy_chunks *	b
	)

Prints the buoy section 3.

Parameters

sec3	the pointer where to print section
lmax	max length permited
b	pointer to s atruct buoy_chunks where the parse results are set

Definition at line 295 of file bufr2tac_print_buoy.c.

{
  size_t used = 0;
  char *c = *sec3;
  size_t l;
 
  if ( b->mask & BUOY_SEC3 )
    {
      used += snprintf ( c + used, lmax - used, " 333%s%s", b->s3.Qd1, b->s3.Qd2 );
 
      // check if has 8887k2
      l = 0;
      while ( b->s3.l1[l].zzzz[0] && l < 32 )
        {
          if ( l == 0 )
            {
              used += snprintf ( c + used, lmax - used, " 8887%s", b->s3.k2 );
            }
          used += snprintf ( c + used, lmax - used,  " 2%s", b->s3.l1[l].zzzz );
 
          if ( b->s3.l1[l].TTTT[0] )
            {
              used += snprintf ( c + used, lmax - used,  " 3%s", b->s3.l1[l].TTTT );
            }
 
          if ( b->s3.l1[l].SSSS[0] )
            {
              used += snprintf ( c + used, lmax - used,  " 4%s", b->s3.l1[l].SSSS );
            }
          l++;
        }
 
      l = 0;
      while ( b->s3.l2[l].zzzz[0] && l < 32 )
        {
          if ( l == 0 )
            {
              used += snprintf ( c + used, lmax - used, " 66%s9%s", b->s3.k6, b->s3.k3 );
            }
          used += snprintf ( c + used, lmax - used,  " 2%s", b->s3.l2[l].zzzz );
 
          if ( b->s3.l2[l].dd[0] || b->s3.l2[l].ccc[0] )
            {
              if ( b->s3.l2[l].dd[0] )
                {
                  used += snprintf ( c + used, lmax - used,  " %s", b->s3.l2[l].dd );
                }
              else
                {
                  used += snprintf ( c + used, lmax - used,  " //" );
                }
              if ( b->s3.l2[l].ccc[0] )
                {
                  used += snprintf ( c + used, lmax - used,  "%s", b->s3.l2[l].ccc );
                }
              else
                {
                  used += snprintf ( c + used, lmax - used,  "///" );
                }
            }
          l++;
        }
    }
 
  *sec3 = c + used;
  return used;
}

References BUOY_SEC3, b_sec3_layer2::ccc, b_sec3_layer2::dd, buoy_sec3::k2, buoy_sec3::k3, buoy_sec3::k6, buoy_sec3::l1, buoy_sec3::l2, buoy_chunks::mask, buoy_sec3::Qd1, buoy_sec3::Qd2, buoy_chunks::s3, b_sec3_layer1::SSSS, b_sec3_layer1::TTTT, b_sec3_layer1::zzzz, and b_sec3_layer2::zzzz.

Referenced by print_buoy_report().

Here is the caller graph for this function:

print_buoy_wigos_id()

size_t print_buoy_wigos_id	(	char **	wid,
		size_t	lmax,
		struct buoy_chunks *	b
	)

Definition at line 367 of file bufr2tac_print_buoy.c.

{
  char aux[40];
  size_t used = 0;
  char sep = '|';
 
  if ( b->wid.series == 0 && b->wid.issuer == 0 && b->wid.issue == 0 && b->wid.local_id[0] == '\0' )
    sprintf ( aux,"0-0-0-MISSING" );
  else
    sprintf ( aux,"%d-%d-%d-%s", b->wid.series, b->wid.issuer, b->wid.issue, b->wid.local_id );
 
  used = snprintf ( *wid, lmax, "%-32s%c", aux, sep );
  *wid += used;
  return used;
}

References wigos_id::issue, wigos_id::issuer, wigos_id::local_id, wigos_id::series, and buoy_chunks::wid.

print_climat_report()

int print_climat_report

(

struct metreport *

m

)

prints a climat into a string

Parameters

m	pointer to struct metreport where are both target and source

If OK returns 0, otherwise 1

Definition at line 718 of file bufr2tac_print_climat.c.

{
  char *c = &(m->alphanum[0]);
  size_t used = 0;
  size_t lmax = sizeof(m->alphanum);
  struct climat_chunks *cl = &m->climat;
 
  // Needs time extension
  if ( cl->e.YYYY[0] == 0  || cl->e.YYYY[0] == '0' || cl->e.MM[0] == 0 )
    {
      return 1;
    }
 
  if ( m->print_mask & PRINT_BITMASK_WIGOS )
    {
      used += print_wigos_id ( &c, lmax, m );
    }
 
  if ( m->print_mask & PRINT_BITMASK_GEO )
    {
      used += print_geo ( &c, lmax, m );
    }
 
  used += print_climat_sec0 ( &c, lmax - used, cl );
 
  if ( cl->mask & ( CLIMAT_SEC1 | CLIMAT_SEC2 | CLIMAT_SEC3 | CLIMAT_SEC4 ) )
    {
      used += print_climat_sec1 ( &c, lmax - used, cl );
 
      used += print_climat_sec2 ( &c, lmax - used, cl );
 
      used += print_climat_sec3 ( &c, lmax - used, cl );
 
      used += print_climat_sec4 ( &c, lmax - used, cl );
    }
  else
    {
      c += snprintf ( c, lmax - used, " NIL" );
    }
  snprintf ( c, lmax - used - 1, "=" );
 
  return 0;
 
}

References metreport::alphanum, metreport::climat, CLIMAT_SEC1, CLIMAT_SEC2, CLIMAT_SEC3, CLIMAT_SEC4, climat_chunks::e, climat_chunks::mask, report_date_ext::MM, PRINT_BITMASK_GEO, PRINT_BITMASK_WIGOS, print_climat_sec0(), print_climat_sec1(), print_climat_sec2(), print_climat_sec3(), print_climat_sec4(), print_geo(), metreport::print_mask, print_wigos_id(), and report_date_ext::YYYY.

Referenced by parse_subset_sequence().

Here is the call graph for this function:

Here is the caller graph for this function:

print_climat_sec0()

size_t print_climat_sec0	(	char **	sec0,
		size_t	lmax,
		struct climat_chunks *	cl
	)

Prints the climat section 0 (header)

Parameters

sec0	the pointer where to print section
lmax	max length permited
cl	pointer to s atruct climat_chunks where the parse results are set

Definition at line 33 of file bufr2tac_print_climat.c.

{
  char *c = *sec0;
  size_t used = 0;
 
  used += snprintf ( c + used, lmax - used, "%s%s%s%s%s", cl->e.YYYY, cl->e.MM, cl->e.DD, cl->e.HH, cl->e.mm );
 
  // Print type
  used += snprintf ( c + used, lmax - used, " CLIMAT" );
 
  // print MMJJJ
  used += snprintf ( c + used, lmax - used, " %s%s", cl->s0.MM, cl->s0.JJJ );
 
 
  // print IIiii
  if ( cl->s0.II[0] )
    {
      used += snprintf ( c + used, lmax - used, " %s%s", cl->s0.II, cl->s0.iii );
    }
 
  *sec0 = c + used;
  return used;
}

References report_date_ext::DD, climat_chunks::e, report_date_ext::HH, climat_sec0::II, climat_sec0::iii, climat_sec0::JJJ, climat_sec0::MM, report_date_ext::MM, report_date_ext::mm, climat_chunks::s0, and report_date_ext::YYYY.

Referenced by print_climat_report().

Here is the caller graph for this function:

print_climat_sec1()

size_t print_climat_sec1	(	char **	sec1,
		size_t	lmax,
		struct climat_chunks *	cl
	)

Prints the climat section 1.

Parameters

sec1	the pointer where to print section
lmax	max length permited
cl	pointer to s atruct climat_chunks where the parse results are set

Definition at line 64 of file bufr2tac_print_climat.c.

{
  char *c = *sec1;
  size_t used = 0;
 
  if ( cl->mask & SYNOP_SEC1 )
    {
      used += snprintf ( c + used, lmax - used, " 111" );
 
      if ( cl->s1.PoPoPoPo[0] )
        {
          used += snprintf ( c + used, lmax - used, " 1%s", cl->s1.PoPoPoPo );
        }
 
      if ( cl->s1.PPPP[0] )
        {
          used += snprintf ( c + used, lmax - used, " 2%s", cl->s1.PPPP );
        }
 
      if ( cl->s1.TTT[0] || cl->s1.ststst[0] )
        {
          if ( cl->s1.TTT[0] == 0 )
            {
              strcpy ( cl->s1.s, "/" );
              strcpy ( cl->s1.TTT, "///" );
            }
          if ( cl->s1.ststst[0] == 0 )
            {
              strcpy ( cl->s1.ststst, "///" );
            }
          used += snprintf ( c + used, lmax - used, " 3%s%s%s", cl->s1.s, cl->s1.TTT, cl->s1.ststst );
        }
 
      if ( cl->s1.TxTxTx[0] || cl->s1.TnTnTn[0] )
        {
          if ( cl->s1.TxTxTx[0] == 0 )
            {
              strcpy ( cl->s1.sx, "/" );
              strcpy ( cl->s1.TxTxTx, "///" );
            }
          if ( cl->s1.TnTnTn[0] == 0 )
            {
              strcpy ( cl->s1.sn, "/" );
              strcpy ( cl->s1.TnTnTn, "///" );
            }
          used += snprintf ( c + used, lmax - used, " 4%s%s%s%s", cl->s1.sx, cl->s1.TxTxTx, cl->s1.sn, cl->s1.TnTnTn );
        }
 
      if ( cl->s1.eee[0] )
        {
          used += snprintf ( c + used, lmax - used, " 5%s", cl->s1.eee );
        }
 
      if ( cl->s1.R1R1R1R1[0] ||  cl->s1.Rd[0] ||  cl->s1.nrnr[0] )
        {
          if ( cl->s1.R1R1R1R1[0] == 0 )
            {
              strcpy ( cl->s1.R1R1R1R1, "////" );
            }
          if ( cl->s1.Rd[0] == 0 )
            {
              strcpy ( cl->s1.Rd, "/" );
            }
          if ( cl->s1.nrnr[0] == 0 )
            {
              strcpy ( cl->s1.nrnr, "//" );
            }
          used += snprintf ( c + used, lmax - used, " 6%s%s%s", cl->s1.R1R1R1R1, cl->s1.Rd, cl->s1.nrnr );
        }
 
      if ( cl->s1.S1S1S1[0] ||  cl->s1.pspsps[0] )
        {
          if ( cl->s1.S1S1S1[0] == 0 )
            {
              strcpy ( cl->s1.S1S1S1, "///" );
            }
          if ( cl->s1.pspsps[0] == 0 )
            {
              strcpy ( cl->s1.pspsps, "///" );
            }
          used += snprintf ( c + used, lmax - used, " 7%s%s", cl->s1.S1S1S1, cl->s1.pspsps );
        }
 
      if ( cl->s1.mpmp[0] || cl->s1.mtmt[0] ||  cl->s1.mtx[0] ||  cl->s1.mtn[0] )
        {
          if ( cl->s1.mpmp[0] == 0 )
            {
              strcpy ( cl->s1.mpmp, "//" );
            }
          if ( cl->s1.mtmt[0] == 0 )
            {
              strcpy ( cl->s1.mtmt, "//" );
            }
          if ( cl->s1.mtx[0] == 0 )
            {
              strcpy ( cl->s1.mtx, "/" );
            }
          if ( cl->s1.mtn[0] == 0 )
            {
              strcpy ( cl->s1.mtn, "/" );
            }
          used += snprintf ( c + used, lmax - used, " 8%s%s%s%s", cl->s1.mpmp, cl->s1.mtmt, cl->s1.mtx, cl->s1.mtn );
        }
 
 
      if ( cl->s1.meme[0] || cl->s1.mrmr[0] || cl->s1.msms[0] )
        {
          if ( cl->s1.meme[0] == 0 )
            {
              strcpy ( cl->s1.meme, "//" );
            }
          if ( cl->s1.mrmr[0] == 0 )
            {
              strcpy ( cl->s1.mrmr, "//" );
            }
          if ( cl->s1.msms[0] == 0 )
            {
              strcpy ( cl->s1.msms, "//" );
            }
          used += snprintf ( c + used, lmax - used, " 9%s%s%s", cl->s1.meme, cl->s1.mrmr, cl->s1.msms );
        }
    }
 
  *sec1 = c + used;
  return used;
}

References climat_sec1::eee, climat_chunks::mask, climat_sec1::meme, climat_sec1::mpmp, climat_sec1::mrmr, climat_sec1::msms, climat_sec1::mtmt, climat_sec1::mtn, climat_sec1::mtx, climat_sec1::nrnr, climat_sec1::PoPoPoPo, climat_sec1::PPPP, climat_sec1::pspsps, climat_sec1::R1R1R1R1, climat_sec1::Rd, climat_sec1::s, climat_chunks::s1, climat_sec1::S1S1S1, climat_sec1::sn, climat_sec1::ststst, climat_sec1::sx, SYNOP_SEC1, climat_sec1::TnTnTn, climat_sec1::TTT, and climat_sec1::TxTxTx.

Referenced by print_climat_report().

Here is the caller graph for this function:

print_climat_sec2()

size_t print_climat_sec2	(	char **	sec2,
		size_t	lmax,
		struct climat_chunks *	cl
	)

Prints the climat section 2.

Parameters

sec2	the pointer where to print section
lmax	max length permited
cl	pointer to s atruct climat_chunks where the parse results are set

Definition at line 198 of file bufr2tac_print_climat.c.

{
  char *c = *sec2;
  size_t used = 0, used0 = 0;
 
  if ( cl->mask & SYNOP_SEC2 )
    {
      //used += snprintf ( c + used, lmax - used, "\r\n      222" );
      used += snprintf ( c + used, lmax - used, " 222" );
 
      // init point to write info.
      // in case we finally write nothing in this section
      used0 = used;
 
      if (  cl->s2.YbYb[0] || cl->s2.YcYc[0] )
        {
          if ( cl->s2.YbYb[0] == 0 )
            {
              strcpy ( cl->s2.YbYb, "//" );
            }
          if ( cl->s2.YcYc[0] == 0 )
            {
              strcpy ( cl->s2.YcYc, "//" );
            }
          used += snprintf ( c + used, lmax - used, " 0%s%s", cl->s2.YbYb, cl->s2.YcYc );
        }
 
      if ( cl->s2.PoPoPoPo[0] )
        {
          used += snprintf ( c + used, lmax - used, " 1%s", cl->s2.PoPoPoPo );
        }
 
      if ( cl->s2.PPPP[0] )
        {
          used += snprintf ( c + used, lmax - used, " 2%s", cl->s2.PPPP );
        }
 
      if (  cl->s2.s[0] || cl->s2.TTT[0] || cl->s2.ststst[0] )
        {
          if ( cl->s2.s[0] == 0 )
            {
              strcpy ( cl->s2.s, "/" );
            }
          if ( cl->s2.TTT[0] == 0 )
            {
              strcpy ( cl->s2.TTT, "///" );
            }
          if ( cl->s2.ststst[0] == 0 )
            {
              strcpy ( cl->s2.ststst, "///" );
            }
 
          used += snprintf ( c + used, lmax - used, " 3%s%s%s", cl->s2.s, cl->s2.TTT, cl->s2.ststst );
        }
 
      if (  cl->s2.sx[0] || cl->s2.TxTxTx[0] || cl->s2.sn[0] || cl->s2.TnTnTn[0] )
        {
          if ( cl->s2.sx[0] == 0 )
            {
              strcpy ( cl->s2.sx, "/" );
            }
          if ( cl->s2.TxTxTx[0] == 0 )
            {
              strcpy ( cl->s2.TxTxTx, "///" );
            }
          if ( cl->s2.sn[0] == 0 )
            {
              strcpy ( cl->s2.sn, "/" );
            }
          if ( cl->s2.TnTnTn[0] == 0 )
            {
              strcpy ( cl->s2.TnTnTn, "///" );
            }
 
          used += snprintf ( c + used, lmax - used, " 4%s%s%s%s", cl->s2.sx, cl->s2.TxTxTx, cl->s2.sn, cl->s2.TnTnTn );
        }
 
      if (  cl->s2.eee[0] )
        {
          used += snprintf ( c + used, lmax - used, " 5%s", cl->s2.eee );
        }
 
      if ( cl->s2.R1R1R1R1[0] || cl->s2.nrnr[0]  )
        {
          if ( cl->s2.R1R1R1R1[0] == 0 )
            {
              strcpy ( cl->s2.R1R1R1R1, "////" );
            }
          if ( cl->s2.nrnr[0] == 0 )
            {
              strcpy ( cl->s2.nrnr, "//" );
            }
          used += snprintf ( c + used, lmax - used, " 6%s%s", cl->s2.R1R1R1R1, cl->s2.nrnr );
        }
 
      if ( cl->s2.S1S1S1[0] )
        {
          used += snprintf ( c + used, lmax - used, " 7%s", cl->s2.S1S1S1 );
        }
 
      if ( cl->s2.ypyp[0] || cl->s2.ytyt[0] || cl->s2.ytxytx[0] )
        {
          if ( cl->s2.ypyp[0] == 0 )
            {
              strcpy ( cl->s2.ypyp, "//" );
            }
          if ( cl->s2.ytyt[0] == 0 )
            {
              strcpy ( cl->s2.ytyt, "//" );
            }
          if ( cl->s2.ytxytx[0] == 0 )
            {
              strcpy ( cl->s2.ytxytx, "//" );
            }
 
          used += snprintf ( c + used, lmax - used, " 8%s%s%s", cl->s2.ypyp, cl->s2.ytyt, cl->s2.ytxytx );
        }
 
      if (  cl->s2.yeye[0] || cl->s2.yryr[0] || cl->s2.ysys[0] )
        {
          if ( cl->s2.yeye[0] == 0 )
            {
              strcpy ( cl->s2.yeye, "//" );
            }
          if ( cl->s2.yryr[0] == 0 )
            {
              strcpy ( cl->s2.yryr, "//" );
            }
          if ( cl->s2.ysys[0] == 0 )
            {
              strcpy ( cl->s2.ysys, "//" );
            }
 
          used += snprintf ( c + used, lmax - used, " 9%s%s%s", cl->s2.yeye, cl->s2.yryr, cl->s2.ysys );
        }
 
    }
 
  if ( used != used0 )
    {
      *sec2 = c + used;
    }
  else
    used = 0;
 
  return used;
}

References climat_sec2::eee, climat_chunks::mask, climat_sec2::nrnr, climat_sec2::PoPoPoPo, climat_sec2::PPPP, climat_sec2::R1R1R1R1, climat_sec2::s, climat_sec2::S1S1S1, climat_chunks::s2, climat_sec2::sn, climat_sec2::ststst, climat_sec2::sx, SYNOP_SEC2, climat_sec2::TnTnTn, climat_sec2::TTT, climat_sec2::TxTxTx, climat_sec2::YbYb, climat_sec2::YcYc, climat_sec2::yeye, climat_sec2::ypyp, climat_sec2::yryr, climat_sec2::ysys, climat_sec2::ytxytx, and climat_sec2::ytyt.

Referenced by print_climat_report().

Here is the caller graph for this function:

print_climat_sec3()

size_t print_climat_sec3	(	char **	sec3,
		size_t	lmax,
		struct climat_chunks *	cl
	)

Prints the climat section 3.

Parameters

sec3	the pointer where to print section
lmax	max length permited
cl	pointer to s atruct climat_chunks where the parse results are set

Definition at line 354 of file bufr2tac_print_climat.c.

{
  char *c = *sec3;
  size_t used0 = 0, used = 0;
 
  if ( cl->mask & SYNOP_SEC3 )
    {
      //used += snprintf ( c + used, lmax - used, "\r\n      333" );
      used += snprintf ( c + used, lmax - used, " 333" );
 
      // init point to write info.
      // in case we finally write nothing in this section
      used0 = used;
 
      if (   ( cl->s3.T25[0] && strcmp ( cl->s3.T25, "00" ) ) ||
             ( cl->s3.T30[0] && strcmp ( cl->s3.T30, "00" ) )
                    )
        {
          if ( cl->s3.T25[0] == 0 )
            {
              strcpy ( cl->s3.T25,"//" );
            }
          if ( cl->s3.T30[0] == 0 )
            {
              strcpy ( cl->s3.T30,"//" );
            }
          used += snprintf ( c + used, lmax - used, " 0%s%s", cl->s3.T25, cl->s3.T30 );
        }
 
      if ( 
             ( cl->s3.T35[0] && strcmp ( cl->s3.T35, "00" ) ) ||
             ( cl->s3.T40[0] && strcmp ( cl->s3.T40, "00" ) )
                   )
        {
          if ( cl->s3.T35[0] == 0 )
            {
              strcpy ( cl->s3.T35,"//" );
            }
          if ( cl->s3.T40[0] == 0 )
            {
              strcpy ( cl->s3.T40,"//" );
            }
          used += snprintf ( c + used, lmax - used, " 1%s%s", cl->s3.T35, cl->s3.T40 );
        }
 
      if ( 
             ( cl->s3.Tn0[0] && strcmp ( cl->s3.Tn0, "00" ) ) ||
             ( cl->s3.Tx0[0] && strcmp ( cl->s3.Tx0, "00" ) )
                    )
        {
          if ( cl->s3.Tn0[0] == 0 )
            {
              strcpy ( cl->s3.Tn0,"//" );
            }
          if ( cl->s3.Tx0[0] == 0 )
            {
              strcpy ( cl->s3.Tx0,"//" );
            }
          used += snprintf ( c + used, lmax - used, " 2%s%s", cl->s3.Tn0, cl->s3.Tx0 );
        }
 
      if (   ( cl->s3.R01[0] && strcmp ( cl->s3.R01, "00" ) ) ||
             ( cl->s3.R05[0] && strcmp ( cl->s3.R05, "00" ) )
           
         )
        {
          if ( cl->s3.R01[0] == 0 )
            {
              strcpy ( cl->s3.R01,"//" );
            }
          if ( cl->s3.R05[0] == 0 )
            {
              strcpy ( cl->s3.R05,"//" );
            }
          used += snprintf ( c + used, lmax - used, " 3%s%s", cl->s3.R01, cl->s3.R05 );
        }
 
      if (   ( cl->s3.R10[0] && strcmp ( cl->s3.R10, "00" ) ) ||
             ( cl->s3.R50[0] && strcmp ( cl->s3.R50, "00" ) )
           
         )
        {
          if ( cl->s3.R10[0] == 0 )
            {
              strcpy ( cl->s3.R10,"//" );
            }
          if ( cl->s3.R50[0] == 0 )
            {
              strcpy ( cl->s3.R50,"//" );
            }
          used += snprintf ( c + used, lmax - used, " 4%s%s", cl->s3.R10, cl->s3.R50 );
        }
 
      if (   ( cl->s3.R100[0] && strcmp ( cl->s3.R100, "00" ) ) ||
             ( cl->s3.R150[0] && strcmp ( cl->s3.R150, "00" ) )
           
         )
        {
          if ( cl->s3.R100[0] == 0 )
            {
              strcpy ( cl->s3.R100,"//" );
            }
          if ( cl->s3.R150[0] == 0 )
            {
              strcpy ( cl->s3.R150,"//" );
            }
          used += snprintf ( c + used, lmax - used, " 5%s%s", cl->s3.R100, cl->s3.R150 );
        }
 
      if (   ( cl->s3.s00[0] && strcmp ( cl->s3.s00, "00" ) ) ||
             ( cl->s3.s01[0] && strcmp ( cl->s3.s01, "00" ) )
                    )
        {
          if ( cl->s3.s00[0] == 0 )
            {
              strcpy ( cl->s3.s00,"//" );
            }
          if ( cl->s3.s01[0] == 0 )
            {
              strcpy ( cl->s3.s01,"//" );
            }
          used += snprintf ( c + used, lmax - used, " 6%s%s", cl->s3.s00, cl->s3.s01 );
        }
 
      if (   ( cl->s3.s10[0] && strcmp ( cl->s3.s10, "00" ) ) ||
             ( cl->s3.s50[0] && strcmp ( cl->s3.s50, "00" ) )
           
         )
        {
          if ( cl->s3.s10[0] == 0 )
            {
              strcpy ( cl->s3.s10,"//" );
            }
          if ( cl->s3.s50[0] == 0 )
            {
              strcpy ( cl->s3.s50,"//" );
            }
          used += snprintf ( c + used, lmax - used, " 7%s%s", cl->s3.s10, cl->s3.s50 );
        }
 
      if ( 
             ( cl->s3.f10[0] && strcmp ( cl->s3.f10, "00" ) ) ||
             ( cl->s3.f20[0] && strcmp ( cl->s3.f20, "00" ) ) ||
             ( cl->s3.f30[0] && strcmp ( cl->s3.f30, "00" ) )
                    )
        {
          if ( cl->s3.f10[0] == 0 )
            {
              strcpy ( cl->s3.f10,"//" );
            }
          if ( cl->s3.f20[0] == 0 )
            {
              strcpy ( cl->s3.f20,"//" );
            }
          if ( cl->s3.f30[0] == 0 )
            {
              strcpy ( cl->s3.f30,"//" );
            }
          used += snprintf ( c + used, lmax - used, " 8%s%s%s", cl->s3.f10, cl->s3.f20, cl->s3.f30 );
        }
 
      if ( 
             ( cl->s3.V1[0] && strcmp ( cl->s3.V1, "00" ) ) ||
             ( cl->s3.V2[0] && strcmp ( cl->s3.V2, "00" ) ) ||
             ( cl->s3.V3[0] && strcmp ( cl->s3.V3, "00" ) )
                    )
        {
          if ( cl->s3.V1[0] == 0 )
            {
              strcpy ( cl->s3.V1,"//" );
            }
          if ( cl->s3.V2[0] == 0 )
            {
              strcpy ( cl->s3.V2,"//" );
            }
          if ( cl->s3.V3[0] == 0 )
            {
              strcpy ( cl->s3.V3,"//" );
            }
          used += snprintf ( c + used, lmax - used, " 9%s%s%s", cl->s3.V1, cl->s3.V2, cl->s3.V3 );
        }
 
    }
 
  if ( used != used0 )
    {
      *sec3 = c + used;
    }
  used = 0;
 
  return used;
 
}

References climat_sec3::f10, climat_sec3::f20, climat_sec3::f30, climat_chunks::mask, climat_sec3::R01, climat_sec3::R05, climat_sec3::R10, climat_sec3::R100, climat_sec3::R150, climat_sec3::R50, climat_sec3::s00, climat_sec3::s01, climat_sec3::s10, climat_chunks::s3, climat_sec3::s50, SYNOP_SEC3, climat_sec3::T25, climat_sec3::T30, climat_sec3::T35, climat_sec3::T40, climat_sec3::Tn0, climat_sec3::Tx0, climat_sec3::V1, climat_sec3::V2, and climat_sec3::V3.

Referenced by print_climat_report().

Here is the caller graph for this function:

print_climat_sec4()

size_t print_climat_sec4	(	char **	sec4,
		size_t	lmax,
		struct climat_chunks *	cl
	)

Prints the climat section 4.

Parameters

sec4	the pointer where to print section
lmax	max length permited
cl	pointer to s atruct climat_chunks where the parse results are set

Definition at line 555 of file bufr2tac_print_climat.c.

{
  char *c = *sec4;
  size_t used0 = 0, used = 0;
 
  if ( cl->mask & CLIMAT_SEC4 )
    {
      //used += snprintf ( c + used, lmax - used, "\r\n      444" );
      used += snprintf ( c + used, lmax - used, " 444" );
 
      // init point to write info.
      // in case we finally write nothing in this section
      used0 = used;
 
      if (  cl->s4.sx[0] || cl->s4.Txd[0] || cl->s4.yx[0] )
        {
          if ( cl->s4.sx[0] == 0 )
            {
              strcpy ( cl->s4.sx, "/" );
            }
          if ( cl->s4.Txd[0] == 0 )
            {
              strcpy ( cl->s4.Txd, "///" );
            }
          if ( cl->s4.yx[0] == 0 )
            {
              strcpy ( cl->s4.yx, "//" );
            }
          used += snprintf ( c + used, lmax - used, " 0%s%s%s", cl->s4.sx, cl->s4.Txd, cl->s4.yx );
        }
 
      if ( cl->s4.sn[0] || cl->s4.Tnd[0] || cl->s4.yn[0] )
        {
          if ( cl->s4.sn[0] == 0 )
            {
              strcpy ( cl->s4.sn, "/" );
            }
          if ( cl->s4.Tnd[0] == 0 )
            {
              strcpy ( cl->s4.Tnd, "///" );
            }
          if ( cl->s4.yn[0] == 0 )
            {
              strcpy ( cl->s4.yn, "//" );
            }
          used += snprintf ( c + used, lmax - used, " 1%s%s%s", cl->s4.sn, cl->s4.Tnd, cl->s4.yn );
        }
 
      if (  cl->s4.sax[0] || cl->s4.Tax[0] || cl->s4.yax[0] )
        {
          if ( cl->s4.sax[0] == 0 )
            {
              strcpy ( cl->s4.sax, "/" );
            }
          if ( cl->s4.Tax[0] == 0 )
            {
              strcpy ( cl->s4.Tax, "///" );
            }
          if ( cl->s4.yax[0] == 0 )
            {
              strcpy ( cl->s4.yax, "//" );
            }
          used += snprintf ( c + used, lmax - used, " 2%s%s%s", cl->s4.sax, cl->s4.Tax, cl->s4.yax );
        }
 
      if (  cl->s4.san[0] || cl->s4.Tan[0] || cl->s4.yan[0] )
        {
          if ( cl->s4.san[0] == 0 )
            {
              strcpy ( cl->s4.san, "/" );
            }
          if ( cl->s4.Tan[0] == 0 )
            {
              strcpy ( cl->s4.Tan, "///" );
            }
          if ( cl->s4.yan[0] == 0 )
            {
              strcpy ( cl->s4.yan, "//" );
            }
          used += snprintf ( c + used, lmax - used, " 3%s%s%s", cl->s4.san, cl->s4.Tan, cl->s4.yan );
        }
 
      if (  cl->s4.RxRxRxRx[0] || cl->s4.yr[0] )
        {
          if ( cl->s4.RxRxRxRx[0] == 0 )
            {
              strcpy ( cl->s4.RxRxRxRx, "////" );
            }
          if ( cl->s4.yx[0] == 0 )
            {
              strcpy ( cl->s4.Tan, "//" );
            }
          used += snprintf ( c + used, lmax - used, " 4%s%s", cl->s4.RxRxRxRx, cl->s4.yr );
        }
 
      if (  cl->s4.fxfxfx[0] || cl->s4.yfx[0] )
        {
          if ( cl->s4.iw[0] == 0 )
            {
              strcpy ( cl->s4.iw, "/" );
            }
          if ( cl->s4.fxfxfx[0] == 0 )
            {
              strcpy ( cl->s4.fxfxfx, "///" );
            }
          if ( cl->s4.yfx[0] == 0 )
            {
              strcpy ( cl->s4.yfx, "//" );
            }
          used += snprintf ( c + used, lmax - used, " 5%s%s%s", cl->s4.iw, cl->s4.fxfxfx, cl->s4.yfx );
        }
 
      if ( cl->s4.Dts[0] || cl->s4.Dgr[0] )
        {
          if ( cl->s4.Dts[0] == 0 )
            {
              strcpy ( cl->s4.Dts,"//" );
            }
          if ( cl->s4.Dgr[0] == 0 )
            {
              strcpy ( cl->s4.Dgr,"//" );
            }
          used += snprintf ( c + used, lmax - used, " 6%s%s", cl->s4.Dts, cl->s4.Dgr );
        }
 
      if (  cl->s4.iy[0] || cl->s4.GxGx[0] || cl->s4.GnGn[0] )
        {
          if ( cl->s4.iw[0] == 0 )
            {
              strcpy ( cl->s4.iy, "/" );
            }
          if ( cl->s4.GxGx[0] == 0 )
            {
              strcpy ( cl->s4.GxGx, "///" );
            }
          if ( cl->s4.GnGn[0] == 0 )
            {
              strcpy ( cl->s4.GnGn, "//" );
            }
          used += snprintf ( c + used, lmax - used, " 7%s%s%s", cl->s4.iy, cl->s4.GxGx, cl->s4.GnGn );
        }
 
 
    }
 
  if ( used != used0 )
    {
      *sec4 = c + used;
    }
  else
    used = 0;
 
  return used;
}

References CLIMAT_SEC4, climat_sec4::Dgr, climat_sec4::Dts, climat_sec4::fxfxfx, climat_sec4::GnGn, climat_sec4::GxGx, climat_sec4::iw, climat_sec4::iy, climat_chunks::mask, climat_sec4::RxRxRxRx, climat_chunks::s4, climat_sec4::san, climat_sec4::sax, climat_sec4::sn, climat_sec4::sx, climat_sec4::Tan, climat_sec4::Tax, climat_sec4::Tnd, climat_sec4::Txd, climat_sec4::yan, climat_sec4::yax, climat_sec4::yfx, climat_sec4::yn, climat_sec4::yr, and climat_sec4::yx.

Referenced by print_climat_report().

Here is the caller graph for this function:

print_climat_wigos_id()

size_t print_climat_wigos_id	(	char **	wid,
		size_t	lmax,
		struct climat_chunks *	cl
	)

print_csv()

int print_csv	(	FILE *	f,
		struct metreport *	m
	)

prints a struct metreport in labeled csv format

Parameters

f	pointer to a file already open by caller routine
m	pointer to a struct metreport containing the data to print

Definition at line 85 of file bufr2tac_csv.c.

{
  // Single report
  if ( m->alphanum[0] )
    {
      print_csv_alphanum ( f, m->type, m->alphanum, m );
    }
 
  if ( m->alphanum2[0] ) //TTBB
    {
      print_csv_alphanum ( f, m->type2, m->alphanum2, m );
    }
 
  if ( m->alphanum3[0] ) //TTCC
    {
      print_csv_alphanum ( f, m->type3, m->alphanum3, m );
    }
 
  if ( m->alphanum4[0] ) //TTDD
    {
      print_csv_alphanum ( f, m->type4, m->alphanum4, m );
    }
 
  return 0;
}

References metreport::alphanum, metreport::alphanum2, metreport::alphanum3, metreport::alphanum4, print_csv_alphanum(), metreport::type, metreport::type2, metreport::type3, and metreport::type4.

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

print_geo()

size_t print_geo	(	char **	geo,
		size_t	lmax,
		struct metreport *	m
	)

Definition at line 71 of file bufr2tac_print.c.

{
  size_t used;
  char sep = '|';
  
  used = snprintf(*geo, lmax, "%8.4lf %9.4lf %6.1lf%c", m->g.lat, m->g.lon, m->g.alt, sep);
  *geo += used;
  return used;
}

References met_geo::alt, metreport::g, met_geo::lat, and met_geo::lon.

Referenced by print_buoy_report(), print_climat_report(), print_synop_report(), print_temp_a(), print_temp_b(), print_temp_c(), and print_temp_d().

Here is the caller graph for this function:

print_html()

int print_html	(	FILE *	f,
		struct metreport *	m
	)

Print in a file the report decoded to Traditional Alphanumeric Code in plain html format. A line per report.

Parameters

f	pointer to file where to write to
m	pointer to struct metreport where the decoded report is stored

Definition at line 51 of file bufr2tac_print.c.

{
  fprintf(f, "<pre>");
  if ( m->alphanum[0] )
    fprintf ( f, "%s\n", m->alphanum );
  if ( m->alphanum2[0] )
    fprintf ( f, "%s\n", m->alphanum2 );
  if ( m->alphanum3[0] )
    fprintf ( f, "%s\n", m->alphanum3 );
  if ( m->alphanum4[0] )
    fprintf ( f, "%s\n", m->alphanum4 );
  fprintf(f, "</pre>");
  return 0;
}

References metreport::alphanum, metreport::alphanum2, metreport::alphanum3, and metreport::alphanum4.

Referenced by main().

Here is the caller graph for this function:

print_json()

int print_json	(	FILE *	f,
		struct metreport *	m
	)

prints a struct metreport in json format

Parameters

f	pointer to a file already open by caller routine
m	pointer to a struct metreport containing the data to print

Definition at line 62 of file bufr2tac_json.c.

{
  fprintf ( f, "{\"metreport\" :" );
  if ( m->alphanum[0] )
    {
      print_json_alphanum ( f, m->type, m->alphanum, m );
    }
 
  if ( m->alphanum2[0] ) //TTBB
    {
      fprintf ( f, "," );
      print_json_alphanum ( f, m->type2, m->alphanum2, m );
    }
 
  if ( m->alphanum3[0] ) //TTCC
    {
      fprintf ( f, "," );
      print_json_alphanum ( f, m->type3, m->alphanum3, m );
    }
  if ( m->alphanum4[0] ) //TTDD
    {
      fprintf ( f, "," );
      print_json_alphanum ( f, m->type4, m->alphanum4, m );
    }
 
  fprintf ( f, "\n}\n" );
  return 0;
}

References metreport::alphanum, metreport::alphanum2, metreport::alphanum3, metreport::alphanum4, print_json_alphanum(), metreport::type, metreport::type2, metreport::type3, and metreport::type4.

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

print_plain()

int print_plain	(	FILE *	f,
		struct metreport *	m
	)

Print in a file the report decoded to Traditional Alphanumeric Code in plain text format. A line per report.

Parameters

f	pointer to file where to write to
m	pointer to struct metreport where the decoded report is stored

Definition at line 32 of file bufr2tac_print.c.

{
  if ( m->alphanum[0] )
    fprintf ( f, "%s\n", m->alphanum );
  if ( m->alphanum2[0] )
    fprintf ( f, "%s\n", m->alphanum2 );
  if ( m->alphanum3[0] )
    fprintf ( f, "%s\n", m->alphanum3 );
  if ( m->alphanum4[0] )
    fprintf ( f, "%s\n", m->alphanum4 );
  return 0;
}

References metreport::alphanum, metreport::alphanum2, metreport::alphanum3, and metreport::alphanum4.

Referenced by main().

Here is the caller graph for this function:

print_synop_report()

int print_synop_report

(

struct metreport *

m

)

prints a synop into a string

Parameters

m	pointer to struct metreport where are both target and source

If OK returns 0, otherwise 1

Definition at line 825 of file bufr2tac_print_synop.c.

{
  char *c = &(m->alphanum[0]);
  size_t used = 0;
  size_t lmax = sizeof(m->alphanum);
  struct synop_chunks *syn = &m->synop;
  
  // Needs time extension
  if ( syn->e.YYYY[0] == 0 || syn->e.YYYY[0] == '0' )
    {
      return 1;
    }
 
  if ( m->print_mask & PRINT_BITMASK_WIGOS )
    {
      used += print_wigos_id ( &c, lmax, m );
    }
  else
    {
      // Do not print a synop if no IIiii identifier when mode = 0
      if ( ( strcmp(syn->s0.MiMi, "AA") == 0 && strcmp(syn->s0.MjMj, "XX") == 0) && 
        ( syn->s0.II[0] == '\0' || syn->s0.iii[0] == '\0' || strcmp ( syn->s0.II, "00" ) == 0 ))
        return 1;
    }
 
  if ( m->print_mask & PRINT_BITMASK_GEO )
    {
      used += print_geo ( &c, lmax, m );
    }
    
  used += print_synop_sec0 ( &c, lmax - used, syn );
 
  if ( syn->mask & ( SYNOP_SEC1 | SYNOP_SEC2 | SYNOP_SEC3 | SYNOP_SEC4 | SYNOP_SEC5 ) )
    {
      used += print_synop_sec1 ( &c, lmax - used, syn );
 
      used += print_synop_sec2 ( &c, lmax - used, syn );
 
      used += print_synop_sec3 ( &c, lmax - used, syn );
 
      used += print_synop_sec4 ( &c, lmax - used, syn );
 
      used += print_synop_sec5 ( &c, lmax - used, syn );
    }
  else
    {
      c += snprintf ( c, lmax - used, " NIL" );
    }
  snprintf ( c, lmax - used - 1, "=" );
 
  return 0;
}

References metreport::alphanum, synop_chunks::e, synop_sec0::II, synop_sec0::iii, synop_chunks::mask, synop_sec0::MiMi, synop_sec0::MjMj, PRINT_BITMASK_GEO, PRINT_BITMASK_WIGOS, print_geo(), metreport::print_mask, print_synop_sec0(), print_synop_sec1(), print_synop_sec2(), print_synop_sec3(), print_synop_sec4(), print_synop_sec5(), print_wigos_id(), synop_chunks::s0, metreport::synop, SYNOP_SEC1, SYNOP_SEC2, SYNOP_SEC3, SYNOP_SEC4, SYNOP_SEC5, and report_date_ext::YYYY.

Referenced by parse_subset_sequence().

Here is the call graph for this function:

Here is the caller graph for this function:

print_synop_sec0()

size_t print_synop_sec0	(	char **	sec0,
		size_t	lmax,
		struct synop_chunks *	syn
	)

Prints the synop section 0 (header)

Parameters

sec0	the pointer where to print section
lmax	max length permited
syn	pointer to s atruct synop_chunks where the parse results are set

Returns

Used bytes

Definition at line 34 of file bufr2tac_print_synop.c.

{
  char *c = *sec0;
  size_t used = 0;
 
  used += snprintf ( c + used, lmax - used,  "%s%s%s%s%s", syn->e.YYYY, syn->e.MM, syn->e.DD, syn->e.HH, syn->e.mm );
 
  // Print type
  used += snprintf ( c + used, lmax - used,    " %s%s", syn->s0.MiMi, syn->s0.MjMj );
 
  if ( syn->s0.D_D[0] )
    {
      used += snprintf ( c + used, lmax - used,  " %s", syn->s0.D_D );
    }
  else if ( syn->s0.A1[0] && syn->s0.bw[0] && syn->s0.nbnbnb[0] )
    {
      used += snprintf ( c + used, lmax - used,  " %s%s%s", syn->s0.A1, syn->s0.bw, syn->s0.nbnbnb );
    }
 
 
  // print YYGGiw
  used += snprintf ( c + used, lmax - used, " %s%s%s", syn->s0.YY, syn->s0.GG, syn->s0.iw );
 
  // print IIiii
  if ( syn->s0.II[0] )
    {
      used += snprintf ( c + used, lmax - used, " %s%s", syn->s0.II, syn->s0.iii );
    }
  else
    {
      if ( syn->s0.LaLaLa[0] )
        {
          used += snprintf ( c + used, lmax - used, " 99%s", syn->s0.LaLaLa );
        }
      else
        {
          used += snprintf ( c + used, lmax - used, " 99///" );
        }
 
      if ( syn->s0.Qc[0] && syn->s0.LoLoLoLo[0] )
        {
          used += snprintf ( c + used, lmax - used, " %s%s", syn->s0.Qc, syn->s0.LoLoLoLo );
        }
      else
        {
          used += snprintf ( c + used, lmax - used, " /////" );
        }
    }
 
  if ( strcmp ( syn->s0.MiMi, "OO" ) == 0 )
    {
      if ( syn->s0.MMM[0] && syn->s0.Ula[0] && syn->s0.Ulo[0] )
        {
          used += snprintf ( c + used, lmax - used, " %s%s%s", syn->s0.MMM, syn->s0.Ula, syn->s0.Ulo );
        }
      if ( syn->s0.h0h0h0h0[0] )
        {
          used += snprintf ( c + used, lmax - used, " %s%s", syn->s0.h0h0h0h0, syn->s0.im );
        }
 
    }
 
  *sec0 = c + used;
  return used;
}

References synop_sec0::A1, synop_sec0::bw, synop_sec0::D_D, report_date_ext::DD, synop_chunks::e, synop_sec0::GG, synop_sec0::h0h0h0h0, report_date_ext::HH, synop_sec0::II, synop_sec0::iii, synop_sec0::im, synop_sec0::iw, synop_sec0::LaLaLa, synop_sec0::LoLoLoLo, synop_sec0::MiMi, synop_sec0::MjMj, report_date_ext::MM, report_date_ext::mm, synop_sec0::MMM, synop_sec0::nbnbnb, synop_sec0::Qc, synop_chunks::s0, synop_sec0::Ula, synop_sec0::Ulo, synop_sec0::YY, and report_date_ext::YYYY.

Referenced by print_synop_report().

Here is the caller graph for this function:

print_synop_sec1()

size_t print_synop_sec1	(	char **	sec1,
		size_t	lmax,
		struct synop_chunks *	syn
	)

Prints the synop section 1.

Parameters

sec1	the pointer where to print section
lmax	max length permited
syn	pointer to s atruct synop_chunks where the parse results are set

Returns

Used bytes

Definition at line 108 of file bufr2tac_print_synop.c.

{
  char *c = *sec1;
  size_t used = 0;
 
  if ( syn->mask & SYNOP_SEC1 )
    {
      // printf irixhVV
      used += snprintf ( c + used, lmax - used, " %s%s%s%s", syn->s1.ir, syn->s1.ix, syn->s1.h, syn->s1.VV );
 
 
      // printf Nddff
      used += snprintf ( c + used, lmax - used, " %s%s%s", syn->s1.N, syn->s1.dd, syn->s1.ff );
      if ( strlen ( syn->s1.fff ) )
        {
          used += snprintf ( c + used, lmax - used, " 00%s", syn->s1.fff );
        }
 
      // printf 1snTTT
 
      if ( syn->s1.TTT[0] )
        {
          used += snprintf ( c + used, lmax - used, " 1%s%s", syn->s1.sn1, syn->s1.TTT );
        }
 
      // printf 2snTdTdTd or 29UUU
      if ( syn->s1.TdTdTd[0] )
        {
          used += snprintf ( c + used, lmax - used, " 2%s%s", syn->s1.sn2, syn->s1.TdTdTd );
        }
      else if ( syn->s1.UUU[0] )
        {
          used += snprintf ( c + used, lmax - used, " 29%s", syn->s1.UUU );
        }
 
      // printf 3PoPoPoPo
      if ( syn->s1.PoPoPoPo[0] )
        {
          used += snprintf ( c + used, lmax - used, " 3%s", syn->s1.PoPoPoPo );
        }
 
      // printf 4PPPP or 4a3hhh
      if ( syn->s1.PPPP[0] )
        {
          used += snprintf ( c + used, lmax - used, " 4%s", syn->s1.PPPP );
        }
      else if ( syn->s1.hhh[0] )
        {
          if ( syn->s1.a3[0] == 0 )
            {
              syn->s1.a3[0] = '/';
            }
          used += snprintf ( c + used, lmax - used, " 4%s%s", syn->s1.a3, syn->s1.hhh );
        }
 
      // printf 5appp
      if ( syn->s1.a[0] || syn->s1.ppp[0] )
        {
          if ( syn->s1.a[0] == 0 )
            {
              syn->s1.a[0] = '/';
            }
          if ( syn->s1.ppp[0] == 0 )
            {
              strcpy ( syn->s1.ppp, "///" );
            }
          used += snprintf ( c + used, lmax - used, " 5%s%s", syn->s1.a, syn->s1.ppp );
        }
 
      // printf 6RRRtr
      if ( syn->s1.tr[0] || syn->s1.RRR[0] )
        {
          if ( syn->s1.tr[0] == 0 )
            {
              syn->s1.tr[0] = '/';
            }
          if ( syn->s1.RRR[0] == 0 )
            {
              strcpy ( syn->s1.RRR, "///" );
            }
          used += snprintf ( c + used, lmax - used, " 6%s%s", syn->s1.RRR, syn->s1.tr );
        }
 
      if ( syn->s1.ww[0] || syn->s1.W1[0] || syn->s1.W2[0] )
        {
          if ( syn->s1.ww[0] == 0 )
            {
              strcpy ( syn->s1.ww, "//" );
            }
          if ( syn->s1.W1[0] == 0 )
            {
              strcpy ( syn->s1.W1, "/" );
            }
          if ( syn->s1.W2[0] == 0 )
            {
              strcpy ( syn->s1.W2, "/" );
            }
          used += snprintf ( c + used, lmax - used, " 7%s%s%s", syn->s1.ww, syn->s1.W1, syn->s1.W2 );
        }
 
      if ( ( syn->s1.Nh[0] && syn->s1.Nh[0] != '0' && syn->s1.Nh[0] != '/' ) ||
           ( syn->s1.Cl[0] && syn->s1.Cl[0] != '0' && syn->s1.Cl[0] != '/' ) ||
           ( syn->s1.Cm[0] && syn->s1.Cm[0] != '0' && syn->s1.Cm[0] != '/' ) ||
           ( syn->s1.Ch[0] && syn->s1.Ch[0] != '0' && syn->s1.Ch[0] != '/' ) )
        {
          if ( syn->s1.Nh[0] == 0 )
            {
              strcpy ( syn->s1.Nh, "/" );
            }
          if ( syn->s1.Cl[0] == 0 )
            {
              strcpy ( syn->s1.Cl, "/" );
            }
          if ( syn->s1.Cm[0] == 0 )
            {
              strcpy ( syn->s1.Cm, "/" );
            }
          if ( syn->s1.Ch[0] == 0 )
            {
              strcpy ( syn->s1.Ch, "/" );
            }
          used += snprintf ( c + used, lmax - used, " 8%s%s%s%s", syn->s1.Nh, syn->s1.Cl, syn->s1.Cm, syn->s1.Ch );
        }
 
      if ( syn->s1.GG[0] )
        {
          used += snprintf ( c + used, lmax - used, " 9%s%s", syn->s1.GG, syn->s1.gg );
        }
    }
  *sec1 = c + used;
  return used;
}

References synop_sec1::a, synop_sec1::a3, synop_sec1::Ch, synop_sec1::Cl, synop_sec1::Cm, synop_sec1::dd, synop_sec1::ff, synop_sec1::fff, synop_sec1::GG, synop_sec1::gg, synop_sec1::h, synop_sec1::hhh, synop_sec1::ir, synop_sec1::ix, synop_chunks::mask, synop_sec1::N, synop_sec1::Nh, synop_sec1::PoPoPoPo, synop_sec1::ppp, synop_sec1::PPPP, synop_sec1::RRR, synop_chunks::s1, synop_sec1::sn1, synop_sec1::sn2, SYNOP_SEC1, synop_sec1::TdTdTd, synop_sec1::tr, synop_sec1::TTT, synop_sec1::UUU, synop_sec1::VV, synop_sec1::W1, synop_sec1::W2, and synop_sec1::ww.

Referenced by print_synop_report().

Here is the caller graph for this function:

print_synop_sec2()

size_t print_synop_sec2	(	char **	sec2,
		size_t	lmax,
		struct synop_chunks *	syn
	)

Prints the synop section 2.

Parameters

sec2	the pointer where to print section
lmax	max length permited
syn	pointer to s atruct synop_chunks where the parse results are set

Returns

Used bytes

Definition at line 250 of file bufr2tac_print_synop.c.

{
  char *c = *sec2;
  size_t used = 0;
 
  if ( syn->mask & SYNOP_SEC2 )
    {
      // 222Dsvs
      used += snprintf ( c + used, lmax - used, " 222" );
      if ( syn->s2.Ds[0] )
        {
          used += snprintf ( c + used, lmax - used, "%s", syn->s2.Ds );
        }
      else
        {
          used += snprintf ( c + used, lmax - used, "/" );
        }
 
      if ( syn->s2.vs[0] )
        {
          used += snprintf ( c + used, lmax - used, "%s", syn->s2.vs );
        }
      else
        {
          used += snprintf ( c + used, lmax - used, "/" );
        }
 
      // printf 0ssTwTwTw
      if ( syn->s2.TwTwTw[0] )
        {
          used += snprintf ( c + used, lmax - used, " 0%s%s", syn->s2.ss, syn->s2.TwTwTw );
        }
 
      if ( syn->s2.PwaPwa[0] || syn->s2.HwaHwa[0] )
        {
          if ( syn->s2.PwaPwa[0] )
            {
              used += snprintf ( c + used, lmax - used, " 1%s", syn->s2.PwaPwa );
            }
          else
            {
              used += snprintf ( c + used, lmax - used, " 1//" );
            }
 
          if ( syn->s2.HwaHwa[0] )
            {
              used += snprintf ( c + used, lmax - used, "%s", syn->s2.HwaHwa );
            }
          else
            {
              used += snprintf ( c + used, lmax - used, "//" );
            }
        }
 
      if ( syn->s2.PwPw[0] || syn->s2.HwHw[0] )
        {
          if ( syn->s2.PwPw[0] )
            {
              used += snprintf ( c + used, lmax - used, " 2%s", syn->s2.PwPw );
            }
          else
            {
              used += snprintf ( c + used, lmax - used, " 2//" );
            }
 
          if ( syn->s2.HwHw[0] )
            {
              used += snprintf ( c + used, lmax - used, "%s", syn->s2.HwHw );
            }
          else
            {
              used += snprintf ( c + used, lmax - used, "//" );
            }
        }
 
      if ( syn->s2.dw1dw1[0] || syn->s2.dw2dw2[0] )
        {
          if ( syn->s2.dw1dw1[0] )
            {
              used += snprintf ( c + used, lmax - used, " 3%s", syn->s2.dw1dw1 );
            }
          else
            {
              used += snprintf ( c + used, lmax - used, " 3//" );
            }
 
          if ( syn->s2.dw2dw2[0] )
            {
              used += snprintf ( c + used, lmax - used, "%s", syn->s2.dw2dw2 );
            }
          else
            {
              used += snprintf ( c + used, lmax - used, "//" );
            }
        }
 
      if ( syn->s2.Pw1Pw1[0] || syn->s2.Hw1Hw1[0] )
        {
          if ( syn->s2.Pw1Pw1[0] )
            {
              used += snprintf ( c + used, lmax - used, " 4%s", syn->s2.Pw1Pw1 );
            }
          else
            {
              used += snprintf ( c + used, lmax - used, " 4//" );
            }
 
          if ( syn->s2.Hw1Hw1[0] )
            {
              used += snprintf ( c + used, lmax - used, "%s", syn->s2.Hw1Hw1 );
            }
          else
            {
              used += snprintf ( c + used, lmax - used, "//" );
            }
        }
 
 
      if ( syn->s2.Pw2Pw2[0] || syn->s2.Hw2Hw2[0] )
        {
          if ( syn->s2.Pw2Pw2[0] )
            {
              used += snprintf ( c + used, lmax - used, " 5%s", syn->s2.Pw2Pw2 );
            }
          else
            {
              used += snprintf ( c + used, lmax - used, " 5//" );
            }
 
          if ( syn->s2.Hw2Hw2[0] )
            {
              used += snprintf ( c + used, lmax - used, "%s", syn->s2.Hw2Hw2 );
            }
          else
            {
              used += snprintf ( c + used, lmax - used, "//" );
            }
        }
 
      if ( syn->s2.HwaHwaHwa[0] )
        {
          used += snprintf ( c + used, lmax - used, " 70%s", syn->s2.HwaHwaHwa );
        }
 
 
      if ( syn->s2.TbTbTb[0] )
        {
          used += snprintf ( c + used, lmax - used, " 8%s%s", syn->s2.sw, syn->s2.TbTbTb );
        }
 
    }
  *sec2 = c + used;
  return used;
}

References synop_sec2::Ds, synop_sec2::dw1dw1, synop_sec2::dw2dw2, synop_sec2::Hw1Hw1, synop_sec2::Hw2Hw2, synop_sec2::HwaHwa, synop_sec2::HwaHwaHwa, synop_sec2::HwHw, synop_chunks::mask, synop_sec2::Pw1Pw1, synop_sec2::Pw2Pw2, synop_sec2::PwaPwa, synop_sec2::PwPw, synop_chunks::s2, synop_sec2::ss, synop_sec2::sw, SYNOP_SEC2, synop_sec2::TbTbTb, synop_sec2::TwTwTw, and synop_sec2::vs.

Referenced by print_synop_report().

Here is the caller graph for this function:

print_synop_sec3()

size_t print_synop_sec3	(	char **	sec3,
		size_t	lmax,
		struct synop_chunks *	syn
	)

Prints the synop section 3.

Parameters

sec3	the pointer where to print section
lmax	max length permited
syn	pointer to s atruct synop_chunks where the parse results are set

Returns

Used bytes

Definition at line 413 of file bufr2tac_print_synop.c.

{
  size_t i;
  char *c = *sec3;
  size_t used = 0, used0;
 
  if ( syn->mask & SYNOP_SEC3 )
    {
      used += snprintf ( c + used, lmax - used, " 333" );
 
      // init point to write info.
      // in case we finally write nothing in this section
      used0 = used;
 
      // printf 0XoXoXoXo
      if ( syn->s3.XoXoXoXo[0] && ( strstr ( syn->s3.XoXoXoXo,"///" ) == NULL ) )
        {
          if ( syn->s3.XoXoXoXo[0] == 0 )
            {
              syn->s3.XoXoXoXo[0] = '/';
            }
          if ( syn->s3.XoXoXoXo[1] == 0 )
            {
              syn->s3.XoXoXoXo[1] = '/';
            }
          if ( syn->s3.XoXoXoXo[2] == 0 )
            {
              syn->s3.XoXoXoXo[2] = '/';
            }
          if ( syn->s3.XoXoXoXo[3] == 0 )
            {
              syn->s3.XoXoXoXo[3] = '/';
            }
          used += snprintf ( c + used, lmax - used, " 0%s", syn->s3.XoXoXoXo );
        }
 
      // printf 1snxTxTxTx
      if ( syn->s3.snx[0] )
        {
          used += snprintf ( c + used, lmax - used, " 1%s%s", syn->s3.snx, syn->s3.TxTxTx );
        }
 
      // printf 1snnTnTnTn
      if ( syn->s3.snn[0] )
        {
          used += snprintf ( c + used, lmax - used, " 2%s%s", syn->s3.snn, syn->s3.TnTnTn );
        }
 
      // printf 3Ejjj
      if ( syn->s3.E[0] || syn->s3.jjj[0] )
        {
          if ( syn->s3.E[0] == 0 )
            {
              syn->s3.E[0] = '/';
            }
          if ( syn->s3.jjj[0] == 0 )
            {
              strcpy ( syn->s3.jjj, "///" );
            }
          used += snprintf ( c + used, lmax - used, " 3%s%s", syn->s3.E, syn->s3.jjj );
        }
 
      // printf 4E1sss
      if ( syn->s3.E1[0] || syn->s3.sss[0] )
        {
          if ( syn->s3.E1[0] == 0 )
            {
              syn->s3.E1[0] = '/';
            }
          if ( syn->s3.sss[0] == 0 )
            {
              strcpy ( syn->s3.sss, "///" );
            }
          if ( syn->s3.E1[0] != '/' || strcmp ( syn->s3.sss, "999" ) )
            {
              used += snprintf ( c + used, lmax - used, " 4%s%s", syn->s3.E1, syn->s3.sss );
            }
        }
 
      /**** Radiation Sunshine gropus ***/
 
      // print 55SSS
      if ( syn->s3.SSS[0] )
        {
          if ( strcmp ( syn->s3.SSS, "///" ) )
            {
              used += snprintf ( c + used, lmax - used, " 55%s", syn->s3.SSS );
            }
          else if ( syn->s3.j524[0][0] || syn->s3.j524[1][0] ||
                    syn->s3.j524[2][0] || syn->s3.j524[3][0] ||
                    syn->s3.j524[4][0] || syn->s3.j524[5][0] ||
                    syn->s3.j524[6][0] )
            {
              used += snprintf ( c + used, lmax - used, " 55%s", syn->s3.SSS );
            }
 
          for ( i = 0; i < 7; i++ )
            {
              if ( syn->s3.j524[i][0] )
                {
                  used += snprintf ( c + used, lmax - used, " %s%s", syn->s3.j524[i], syn->s3.FFFF24[i] );
                }
            }
        }
 
      // print 553SS
      if ( syn->s3.SS[0] )
        {
          if ( strcmp ( syn->s3.SS, "//" ) )
            {
              used += snprintf ( c + used, lmax - used, " 553%s", syn->s3.SS );
            }
          else if ( syn->s3.j5[0][0] || syn->s3.j5[1][0] ||
                    syn->s3.j5[2][0] || syn->s3.j5[3][0] ||
                    syn->s3.j5[4][0] || syn->s3.j5[5][0] ||
                    syn->s3.j5[6][0] )
            {
              used += snprintf ( c + used, lmax - used, " 553%s", syn->s3.SS );
            }
 
          for ( i = 0; i < 7; i++ )
            {
              if ( syn->s3.j5[i][0] )
                {
                  used += snprintf ( c + used, lmax - used, " %s%s", syn->s3.j5[i], syn->s3.FFFF[i] );
                }
            }
        }
 
      // print 55407
      if ( syn->s3.FFFF407[0] )
        {
          used += snprintf ( c + used, lmax - used, " 55407 4%s", syn->s3.FFFF407 );
        }
 
      // print 55408
      if ( syn->s3.FFFF408[0] )
        {
          used += snprintf ( c + used, lmax - used, " 55408 4%s", syn->s3.FFFF408 );
        }
 
      // print 55507
      if ( syn->s3.FFFF507[0] )
        {
          used += snprintf ( c + used, lmax - used, " 55507 4%s", syn->s3.FFFF507 );
        }
 
      // print 55507
      if ( syn->s3.FFFF508[0] )
        {
          used += snprintf ( c + used, lmax - used, " 55508 4%s", syn->s3.FFFF508 );
        }
 
      // print 56DlDmDh
      if ( syn->s3.Dl[0] || syn->s3.Dm[0] || syn->s3.Dh[0] )
        {
          if ( syn->s3.Dl[0] == 0 )
            {
              syn->s3.Dl[0] = '/';
            }
          if ( syn->s3.Dm[0] == 0 )
            {
              syn->s3.Dm[0] = '/';
            }
          if ( syn->s3.Dh[0] == 0 )
            {
              syn->s3.Dh[0] = '/';
            }
 
          used += snprintf ( c + used, lmax - used, " 56%s%s%s", syn->s3.Dl, syn->s3.Dm, syn->s3.Dh );
        }
 
      // print 57CDeec
      if ( syn->s3.Da[0] || syn->s3.ec[0] )
        {
          if ( syn->s3.Da[0] == 0 )
            {
              syn->s3.Da[0] = '/';
            }
          if ( syn->s3.ec[0] == 0 )
            {
              syn->s3.ec[0] = '/';
            }
 
          used += snprintf ( c + used, lmax - used, " 57%s%s%s", syn->s3.C, syn->s3.Da, syn->s3.ec );
        }
 
      // print 58ppp24 or 59ppo24
      if ( syn->s3.ppp24[0] )
        {
          used += snprintf ( c + used, lmax - used, " 5%s%s", syn->s3.snp24, syn->s3.ppp24 );
        }
 
      // printf 6RRRtr
      if ( syn->s3.tr[0] || syn->s3.RRR[0] )
        {
          if ( syn->s3.tr[0] == 0 )
            {
              syn->s3.tr[0] = '/';
            }
          if ( syn->s3.RRR[0] == 0 )
            {
              strcpy ( syn->s3.RRR, "///" );
            }
          used += snprintf ( c + used, lmax - used, " 6%s%s", syn->s3.RRR,syn->s3.tr );
        }
 
      if ( syn->s3.RRRR24[0] )
        {
          used += snprintf ( c + used, lmax - used, " 7%s", syn->s3.RRRR24 );
        }
 
      // additional cloud layers
      for ( i = 0; i < 4 ; i++ )
        {
          if ( syn->s3.nub[i].hshs[0] )
            {
              if ( syn->s3.nub[i].Ns[0] == 0 && syn->s3.nub[i].C[0] == 0 )
                {
                  used += snprintf ( c + used, lmax - used, " 8//%s", syn->s3.nub[i].hshs ); // Detected cloud but no anymore info
                }
              else
                {
                  used += snprintf ( c + used, lmax - used, " 8" );
                  if ( syn->s3.nub[i].Ns[0] )
                    {
                      used += snprintf ( c + used, lmax - used, "%s", syn->s3.nub[i].Ns );
                    }
                  else
                    {
                      used += snprintf ( c + used, lmax - used, "/" );
                    }
 
                  if ( syn->s3.nub[i].C[0] )
                    {
                      used += snprintf ( c + used, lmax - used, "%s", syn->s3.nub[i].C );
                    }
                  else
                    {
                      used += snprintf ( c + used, lmax - used, "/" );
                    }
 
                  used += snprintf ( c + used, lmax - used, "%s", syn->s3.nub[i].hshs );
 
                }
            }
        }
 
      // additional info
      for ( i = 0; i < syn->s3.d9.n && i < SYNOP_NMISC ; i++ )
        {
          if ( syn->s3.d9.misc[i].SpSp[0] && syn->s3.d9.misc[i].spsp[0] )
            {
              used += snprintf ( c + used, lmax - used, " %s%s", syn->s3.d9.misc[i].SpSp, syn->s3.d9.misc[i].spsp );
            }
        }
 
 
      // aditional regional info
      if ( syn->mask & SYNOP_SEC3_8 )
        {
          used += snprintf ( c + used, lmax - used, " 80000" );
          for ( i = 0; i < SYNOP_NMISC; i++ )
            {
              if ( syn->s3.R8[i][0] || syn->s3.R8[i][0] || syn->s3.R8[i][0] || syn->s3.R8[i][0] )
                {
                  if ( syn->s3.R8[i][0] == 0 )
                    {
                      syn->s3.R8[i][0] = '/';
                    }
                  if ( syn->s3.R8[i][1] == 0 )
                    {
                      syn->s3.R8[i][1] = '/';
                    }
                  if ( syn->s3.R8[i][2] == 0 )
                    {
                      syn->s3.R8[i][2] = '/';
                    }
                  if ( syn->s3.R8[i][3] == 0 )
                    {
                      syn->s3.R8[i][3] = '/';
                    }
                  used += snprintf ( c + used, lmax - used, " %ld%s", i, syn->s3.R8[i] );
                }
            }
        }
 
      if ( used != used0 )
        {
          *sec3 = c + used;
        }
      else
        used = 0;
 
    }
  return used;
}

References nub3::C, synop_sec3::C, synop_sec3::d9, synop_sec3::Da, synop_sec3::Dh, synop_sec3::Dl, synop_sec3::Dm, synop_sec3::E, synop_sec3::E1, synop_sec3::ec, synop_sec3::FFFF, synop_sec3::FFFF24, synop_sec3::FFFF407, synop_sec3::FFFF408, synop_sec3::FFFF507, synop_sec3::FFFF508, nub3::hshs, synop_sec3::j5, synop_sec3::j524, synop_sec3::jjj, synop_chunks::mask, data9::misc, data9::n, nub3::Ns, synop_sec3::nub, synop_sec3::ppp24, synop_sec3::R8, synop_sec3::RRR, synop_sec3::RRRR24, synop_chunks::s3, synop_sec3::snn, synop_sec3::snp24, synop_sec3::snx, misc3::SpSp, misc3::spsp, synop_sec3::SS, synop_sec3::sss, synop_sec3::SSS, SYNOP_NMISC, SYNOP_SEC3, SYNOP_SEC3_8, synop_sec3::TnTnTn, synop_sec3::tr, synop_sec3::TxTxTx, and synop_sec3::XoXoXoXo.

Referenced by print_synop_report().

Here is the caller graph for this function:

print_synop_wigos_id()

size_t print_synop_wigos_id	(	char **	wid,
		size_t	lmax,
		struct synop_chunks *	syn
	)

print_temp_a()

size_t print_temp_a

(

struct metreport *

m

)

Prints the part A of a TEMP report into a string.

Parameters

m	pointer to struct metreport where are both target and source

If OK returns 0, otherwise 1

Definition at line 346 of file bufr2tac_print_temp.c.

{
  char *c = &(m->alphanum[0]);
  size_t used = 0;
  size_t lmax = sizeof(m->alphanum);
  struct temp_chunks *t = &m->temp;
 
 
  // Needs time extension
  if ( t->a.e.YYYY[0] == 0  || t->a.e.YYYY[0] == '0')
    {
      return 1;
    }
 
  if ( m->print_mask & PRINT_BITMASK_WIGOS )
    {
      used += print_wigos_id ( &c, lmax, m );
    }
 
  if ( m->print_mask & PRINT_BITMASK_GEO )
    {
      used += print_geo ( &c, lmax, m );
    }
 
  used += print_temp_a_sec1 ( &c, lmax - used, t );
  used += print_temp_a_sec2 ( &c, lmax - used, t );
  used += print_temp_a_sec3 ( &c, lmax - used, t );
  used += print_temp_a_sec4 ( &c, lmax - used, t );
  used += print_temp_a_sec7 ( &c, lmax - used, t );
  used += snprintf ( c, lmax - used, "=" );
  return 0;
}

References metreport::alphanum, temp_chunks::c, PRINT_BITMASK_GEO, PRINT_BITMASK_WIGOS, print_geo(), metreport::print_mask, print_temp_a_sec1(), print_temp_a_sec2(), print_temp_a_sec3(), print_temp_a_sec4(), print_temp_a_sec7(), print_wigos_id(), temp_chunks::t, and metreport::temp.

Referenced by print_temp_report().

Here is the call graph for this function:

Here is the caller graph for this function:

print_temp_a_sec1()

size_t print_temp_a_sec1	(	char **	sec1,
		size_t	lmax,
		struct temp_chunks *	t
	)

Prints the section 1 of part A of a TEMP report.

Parameters

sec1	the pointer where to print section
lmax	max length permited
t	pointer to s atruct temp_chunks where the parse results are set

returns the string sec1

Definition at line 145 of file bufr2tac_print_temp.c.

{
  size_t used = 0;
  char *c = *sec1;
 
  used += snprintf ( c + used, lmax - used, "%s", t->t.datime );
 
  used += snprintf ( c + used, lmax - used, " %s%s", t->a.s1.MiMi, t->a.s1.MjMj );
 
  if ( t->a.s1.D_D[0] && t->a.s1.II[0] == 0 )
    {
      used += snprintf ( c + used, lmax - used, " %s", t->a.s1.D_D );
    }
 
  used += snprintf ( c + used, lmax - used, " %s%s", t->a.s1.YYGG, t->a.s1.id );
 
  // print IIiii
  if ( t->a.s1.II[0] )
    {
      used += snprintf ( c + used, lmax - used, " %s%s", t->a.s1.II, t->a.s1.iii );
    }
  else
    {
      if ( t->a.s1.LaLaLa[0] )
        {
          used += snprintf ( c + used, lmax - used, " 99%s", t->a.s1.LaLaLa );
        }
      else
        {
          used += snprintf ( c + used, lmax - used, " 99///" );
        }
 
      if ( t->a.s1.Qc[0] && t->a.s1.LoLoLoLo[0] )
        {
          used += snprintf ( c + used, lmax - used, " %s%s", t->a.s1.Qc, t->a.s1.LoLoLoLo );
        }
      else
        {
          used += snprintf ( c + used, lmax - used, " /////" );
        }
 
      if ( t->a.s1.MMM[0] && t->a.s1.Ula[0] && t->a.s1.Ulo[0] )
        {
          used += snprintf ( c + used, lmax - used, " %s%s%s", t->a.s1.MMM, t->a.s1.Ula, t->a.s1.Ulo );
        }
 
      if ( t->a.s1.h0h0h0h0[0] )
        {
          used += snprintf ( c + used, lmax - used, " %s%s", t->a.s1.h0h0h0h0, t->a.s1.im );
        }
    }
 
  *sec1 = c + used;
  return used;
}

References temp_chunks::a, temp_acd_sec1::D_D, met_datetime::datime, temp_acd_sec1::h0h0h0h0, temp_acd_sec1::id, temp_acd_sec1::II, temp_acd_sec1::iii, temp_acd_sec1::im, temp_acd_sec1::LaLaLa, temp_acd_sec1::LoLoLoLo, temp_acd_sec1::MiMi, temp_acd_sec1::MjMj, temp_acd_sec1::MMM, temp_acd_sec1::Qc, temp_a::s1, temp_chunks::t, temp_acd_sec1::Ula, temp_acd_sec1::Ulo, and temp_acd_sec1::YYGG.

Referenced by print_temp_a().

Here is the caller graph for this function:

print_temp_a_sec2()

size_t print_temp_a_sec2	(	char **	sec2,
		size_t	lmax,
		struct temp_chunks *	t
	)

Prints the section 2 of part A of a TEMP report.

Parameters

sec2	the pointer where to print section
lmax	max length permited
t	pointer to s atruct temp_chunks where the parse results are set

returns the string sec2

Definition at line 211 of file bufr2tac_print_temp.c.

{
  size_t i;
  size_t used = 0;
  char *c = *sec2;
 
  //Surface level
  used += snprintf ( c + used, lmax - used, " 99%s", t->a.s2.lev0.PnPnPn );
  used += snprintf ( c + used, lmax - used, " %s%s", t->a.s2.lev0.TnTnTan, t->a.s2.lev0.DnDn );
  used += snprintf ( c + used, lmax - used, " %s", t->a.s2.lev0.dndnfnfnfn );
 
  for ( i = 0; i < t->a.s2.n ; i++ )
    {
      used += snprintf ( c + used, lmax - used, " %s%s", t->a.s2.std[i].PnPn, t->a.s2.std[i].hnhnhn );
      used += snprintf ( c + used, lmax - used, " %s%s", t->a.s2.std[i].TnTnTan, t->a.s2.std[i].DnDn );
      used += snprintf ( c + used, lmax - used, " %s", t->a.s2.std[i].dndnfnfnfn );
    }
 
  *sec2 = c + used;
  return used;
}

References temp_chunks::a, temp_main_level_data::DnDn, temp_std_level_data::DnDn, temp_main_level_data::dndnfnfnfn, temp_std_level_data::dndnfnfnfn, temp_std_level_data::hnhnhn, temp_a_sec2::lev0, temp_a_sec2::n, temp_std_level_data::PnPn, temp_main_level_data::PnPnPn, temp_a::s2, temp_a_sec2::std, temp_main_level_data::TnTnTan, and temp_std_level_data::TnTnTan.

Referenced by print_temp_a().

Here is the caller graph for this function:

print_temp_a_sec3()

size_t print_temp_a_sec3	(	char **	sec3,
		size_t	lmax,
		struct temp_chunks *	t
	)

Prints the section 3 of part A of a TEMP report.

Parameters

sec3	the pointer where to print section
lmax	max length permited
t	pointer to s atruct temp_chunks where the parse results are set

returns the string sec3

Definition at line 242 of file bufr2tac_print_temp.c.

{
  size_t i;
  size_t used = 0;
  char *c = *sec3;
 
  if ( t->a.s3.n == 0 )
    {
      used += snprintf ( c + used, lmax - used, " 88999" );
    }
  else
    {
      for ( i = 0; i < t->a.s3.n ; i++ )
        {
          used += snprintf ( c + used, lmax - used, " 88%s", t->a.s3.trop[i].PnPnPn );
          used += snprintf ( c + used, lmax - used, " %s%s", t->a.s3.trop[i].TnTnTan, t->a.s3.trop[i].DnDn );
          used += snprintf ( c + used, lmax - used, " %s", t->a.s3.trop[i].dndnfnfnfn );
        }
    }
 
  *sec3 = c + used;
  return used;
 
}

References temp_chunks::a, temp_main_level_data::DnDn, temp_main_level_data::dndnfnfnfn, temp_ac_sec3::n, temp_main_level_data::PnPnPn, temp_a::s3, temp_main_level_data::TnTnTan, and temp_ac_sec3::trop.

Referenced by print_temp_a().

Here is the caller graph for this function:

print_temp_a_sec4()

size_t print_temp_a_sec4	(	char **	sec4,
		size_t	lmax,
		struct temp_chunks *	t
	)

Prints the section 4 of part A of a TEMP report.

Parameters

sec4	the pointer where to print section
lmax	max length permited
t	pointer to s atruct temp_chunks where the parse results are set

returns the string sec1

Definition at line 276 of file bufr2tac_print_temp.c.

{
  size_t i;
  size_t used = 0;
  char *c = *sec4;
 
  if ( t->a.s4.n == 0 )
    {
      used += snprintf ( c + used, lmax - used, " 77999" );
    }
  else
    {
      for ( i = 0; i < t->a.s4.n ; i++ )
        {
          if ( t->a.s4.windx[i].no_last_wind )
            {
              used += snprintf ( c + used, lmax - used, " 77%s", t->a.s4.windx[i].PmPmPm );
            }
          else
            {
              used += snprintf ( c + used, lmax - used, " 66%s", t->a.s4.windx[i].PmPmPm );
            }
          used += snprintf ( c + used, lmax - used, " %s", t->a.s4.windx[i].dmdmfmfmfm );
 
          if ( t->a.s4.windx[i].vbvb[0] && t->a.s4.windx[i].vava[0] )
            {
              used += snprintf ( c + used, lmax - used, " 4%s%s", t->a.s4.windx[i].vbvb, t->a.s4.windx[i].vava );
            }
        }
    }
 
  *sec4 = c + used;
  return used;
 
}

References temp_chunks::a, temp_max_wind_data::dmdmfmfmfm, temp_ac_sec4::n, temp_max_wind_data::no_last_wind, temp_max_wind_data::PmPmPm, temp_a::s4, temp_max_wind_data::vava, temp_max_wind_data::vbvb, and temp_ac_sec4::windx.

Referenced by print_temp_a().

Here is the caller graph for this function:

print_temp_a_sec7()

size_t print_temp_a_sec7	(	char **	sec7,
		size_t	lmax,
		struct temp_chunks *	t
	)

Prints the section 7 of part A of a TEMP report.

Parameters

sec7	the pointer where to print section
lmax	max length permited
t	pointer to s atruct temp_chunks where the parse results are set

returns the string sec7

Definition at line 321 of file bufr2tac_print_temp.c.

{
  size_t used = 0;
  char *c = *sec7;
 
  used += snprintf ( c + used, lmax - used, " 31313" );
  used += snprintf ( c + used, lmax - used, " %s%s%s", t->a.s7.sr, t->a.s7.rara, t->a.s7.sasa );
  used += snprintf ( c + used, lmax - used, " 8%s%s", t->a.s7.GG, t->a.s7.gg );
 
  if ( t->a.s7.TwTwTw[0] )
    {
      used += snprintf ( c + used, lmax - used, " 9%s%s", t->a.s7.sn, t->a.s7.TwTwTw );
    }
 
  *sec7 = c + used;
  return used;
}

References temp_chunks::a, temp_sec7::GG, temp_sec7::gg, temp_sec7::rara, temp_a::s7, temp_sec7::sasa, temp_sec7::sn, temp_sec7::sr, and temp_sec7::TwTwTw.

Referenced by print_temp_a().

Here is the caller graph for this function:

print_temp_b()

int print_temp_b

(

struct metreport *

m

)

Prints the part B of a TEMP report into a string.

Parameters

m	pointer to struct metreport where are both target and source

If OK returns 0, otherwise 1

Definition at line 600 of file bufr2tac_print_temp.c.

{
  char *c = &(m->alphanum2[0]);
  size_t used = 0;
  size_t lmax = sizeof(m->alphanum);
  struct temp_chunks *t = &m->temp;
 
 
  // Needs time extension
  if ( t->b.e.YYYY[0] == 0  || t->b.e.YYYY[0] == '0')
    {
      return 1;
    }
 
  if ( m->print_mask & PRINT_BITMASK_WIGOS )
    {
      used += print_wigos_id ( &c, lmax, m );
    }
 
  if ( m->print_mask & PRINT_BITMASK_GEO )
    {
      used += print_geo ( &c, lmax, m );
    }
 
  used += print_temp_b_sec1 ( &c, lmax - used, t );
  used += print_temp_b_sec5 ( &c, lmax - used, t );
  used += print_temp_b_sec6 ( &c, lmax - used, t );
  used += print_temp_b_sec7 ( &c, lmax - used, t );
  used += print_temp_b_sec8 ( &c, lmax - used, t );
  used += snprintf ( c, lmax - used, "=" );
  return 0;
}

References metreport::alphanum, metreport::alphanum2, temp_chunks::c, PRINT_BITMASK_GEO, PRINT_BITMASK_WIGOS, print_geo(), metreport::print_mask, print_temp_b_sec1(), print_temp_b_sec5(), print_temp_b_sec6(), print_temp_b_sec7(), print_temp_b_sec8(), print_wigos_id(), temp_chunks::t, and metreport::temp.

Referenced by print_temp_report().

Here is the call graph for this function:

Here is the caller graph for this function:

print_temp_b_sec1()

size_t print_temp_b_sec1	(	char **	sec1,
		size_t	lmax,
		struct temp_chunks *	t
	)

Prints the section 1 of part B of a TEMP report.

Parameters

sec1	the pointer where to print section
lmax	max length permited
t	pointer to s atruct temp_chunks where the parse results are set

returns the string sec1

Definition at line 388 of file bufr2tac_print_temp.c.

{
  size_t used = 0;
  char *c = *sec1;
 
  used += snprintf ( c + used, lmax - used, "%s", t->t.datime );
 
  used += snprintf ( c + used, lmax - used, " %s%s", t->b.s1.MiMi, t->b.s1.MjMj );
 
  if ( t->b.s1.D_D[0] && t->a.s1.II[0] == 0 )
    {
      used += snprintf ( c + used, lmax - used, " %s", t->b.s1.D_D );
    }
 
  used += snprintf ( c + used, lmax - used, " %s%s", t->b.s1.YYGG, t->b.s1.a4 );
 
  // print IIiii
  if ( t->b.s1.II[0] )
    {
      used += snprintf ( c + used, lmax - used, " %s%s", t->b.s1.II, t->b.s1.iii );
    }
  else
    {
      if ( t->b.s1.LaLaLa[0] )
        {
          used += snprintf ( c + used, lmax - used, " 99%s", t->b.s1.LaLaLa );
        }
      else
        {
          used += snprintf ( c + used, lmax - used, " 99///" );
        }
 
      if ( t->b.s1.Qc[0] && t->b.s1.LoLoLoLo[0] )
        {
          used += snprintf ( c + used, lmax - used, " %s%s", t->b.s1.Qc, t->b.s1.LoLoLoLo );
        }
      else
        {
          used += snprintf ( c + used, lmax - used, " /////" );
        }
 
      if ( t->b.s1.MMM[0] && t->b.s1.Ula[0] && t->b.s1.Ulo[0] )
        {
          used += snprintf ( c + used, lmax - used, " %s%s%s", t->b.s1.MMM, t->b.s1.Ula, t->b.s1.Ulo );
        }
 
      if ( t->b.s1.h0h0h0h0[0] )
        {
          used += snprintf ( c + used, lmax - used, " %s%s", t->b.s1.h0h0h0h0, t->b.s1.im );
        }
    }
 
  *sec1= c + used;
  return used;
}

References temp_chunks::c, met_datetime::t, and temp_chunks::t.

Referenced by print_temp_b().

Here is the caller graph for this function:

print_temp_b_sec5()

size_t print_temp_b_sec5	(	char **	sec5,
		size_t	lmax,
		struct temp_chunks *	t
	)

Prints the section 5 of part B of a TEMP report.

Parameters

sec5	the pointer where to print section
lmax	max length permited
t	pointer to s atruct temp_chunks where the parse results are set

returns the string sec5

Definition at line 453 of file bufr2tac_print_temp.c.

{
  size_t used = 0;
  size_t i;
  char *c = *sec5;
 
  for ( i = 0; i < t->b.s5.n && i < TEMP_NMAX_POINTS ; i++ )
    {
      used += snprintf ( c + used, lmax - used, " %s%s", t->b.s5.th[i].nini, t->b.s5.th[i].PnPnPn );
      used += snprintf ( c + used, lmax - used, " %s%s", t->b.s5.th[i].TnTnTan, t->b.s5.th[i].DnDn );
    }
 
  *sec5 = c + used;
  return used;
}

References temp_chunks::c, temp_chunks::t, and TEMP_NMAX_POINTS.

Referenced by print_temp_b().

Here is the caller graph for this function:

print_temp_b_sec6()

size_t print_temp_b_sec6	(	char **	sec6,
		size_t	lmax,
		struct temp_chunks *	t
	)

Prints the section 6 of part B of a TEMP report.

Parameters

sec6	the pointer where to print section
lmax	max length permited
t	pointer to s atruct temp_chunks where the parse results are set

returns the string sec6

Definition at line 478 of file bufr2tac_print_temp.c.

{
  size_t i;
  size_t used = 0;
  char *c = *sec6;
 
  used += snprintf ( c + used, lmax - used, " 21212" );
 
  for ( i = 0; i < t->b.s6.n && i < TEMP_NMAX_POINTS ; i++ )
    {
      used += snprintf ( c + used, lmax - used, " %s%s", t->b.s6.wd[i].nini, t->b.s6.wd[i].PnPnPn );
      used += snprintf ( c + used, lmax - used, " %s", t->b.s6.wd[i].dndnfnfnfn );
    }
 
  *sec6 = c + used;
  return used;
}

References temp_chunks::c, temp_chunks::t, and TEMP_NMAX_POINTS.

Referenced by print_temp_b().

Here is the caller graph for this function:

print_temp_b_sec7()

size_t print_temp_b_sec7	(	char **	sec7,
		size_t	lmax,
		struct temp_chunks *	t
	)

Prints the section 7 of part B of a TEMP report.

Parameters

sec7	the pointer where to print section
lmax	max length permited
t	pointer to s atruct temp_chunks where the parse results are set

returns the string sec7

Definition at line 505 of file bufr2tac_print_temp.c.

{
  size_t used = 0;
  char *c = *sec7;
 
  used += snprintf ( c + used, lmax - used, " 31313" );
  used += snprintf ( c + used, lmax - used, " %s%s%s", t->b.s7.sr, t->b.s7.rara, t->b.s7.sasa );
  used += snprintf ( c + used, lmax - used, " 8%s%s", t->b.s7.GG, t->b.s7.gg );
 
  if ( t->b.s7.TwTwTw[0] )
    {
      used += snprintf ( c + used, lmax - used, " 9%s%s", t->b.s7.sn, t->b.s7.TwTwTw );
    }
 
  *sec7 = c + used;
  return used;
}

References temp_chunks::c, and temp_chunks::t.

Referenced by print_temp_b().

Here is the caller graph for this function:

print_temp_b_sec8()

size_t print_temp_b_sec8	(	char **	sec8,
		size_t	lmax,
		struct temp_chunks *	t
	)

Prints the section 8 of part B of a TEMP report.

Parameters

sec8	the pointer where to print section
lmax	max length permited
t	pointer to s atruct temp_chunks where the parse results are set

returns the string sec8

Definition at line 532 of file bufr2tac_print_temp.c.

{
  size_t used = 0;
  char *c = *sec8;
 
  if ( t->b.s8.h[0] )
    {
      used += snprintf ( c + used, lmax - used, " 41414 " );
      if ( t->b.s8.Nh[0] )
        {
          used += snprintf ( c + used, lmax - used, "%s", t->b.s8.Nh );
        }
      else
        {
          used += snprintf ( c + used, lmax - used, "/" );
        }
 
      if ( t->b.s8.Cl[0] )
        {
          used += snprintf ( c + used, lmax - used, "%s", t->b.s8.Cl );
        }
      else
        {
          used += snprintf ( c + used, lmax - used, "/" );
        }
 
      if ( t->b.s8.h[0] )
        {
          used += snprintf ( c + used, lmax - used, "%s", t->b.s8.h );
        }
      else
        {
          used += snprintf ( c + used, lmax - used, "/" );
        }
 
      if ( t->b.s8.Cm[0] )
        {
          used += snprintf ( c + used, lmax - used, "%s", t->b.s8.Cm );
        }
      else
        {
          used += snprintf ( c + used, lmax - used, "/" );
        }
 
      if ( t->b.s8.Ch[0] )
        {
          used += snprintf ( c + used, lmax - used, "%s", t->b.s8.Ch );
        }
      else
        {
          used += snprintf ( c + used, lmax - used, "/" );
        }
 
      //used += snprintf ( c + used, lmax - used, " %s%s%s%s%s", t->b.s8.Nh, t->b.s8.Cl, t->b.s8.h, t->b.s8.Cm, t->b.s8.Ch );
    }
 
  *sec8 = c + used;
  return used;
}

References temp_chunks::c, and temp_chunks::t.

Referenced by print_temp_b().

Here is the caller graph for this function:

print_temp_c()

int print_temp_c

(

struct metreport *

m

)

Prints the part C of a TEMP report into a string.

Parameters

m	pointer to struct metreport where are both target and source

If OK returns 0, otherwise 1

Definition at line 838 of file bufr2tac_print_temp.c.

{
  char *c = &(m->alphanum3[0]);
  size_t used = 0;
  size_t lmax = sizeof(m->alphanum);
  struct temp_chunks *t = &m->temp;
 
 
  // Needs time extension
  if ( t->c.e.YYYY[0] == 0  || t->c.e.YYYY[0] == '0')
    {
      return 1;
    }
 
  if ( m->print_mask & PRINT_BITMASK_WIGOS )
    {
      used += print_wigos_id ( &c, lmax, m );
    }
 
  if ( m->print_mask & PRINT_BITMASK_GEO )
    {
      used += print_geo ( &c, lmax, m );
    }
 
  used += print_temp_c_sec1 ( &c, lmax - used, t );
  used += print_temp_c_sec2 ( &c, lmax - used, t );
  used += print_temp_c_sec3 ( &c, lmax - used, t );
  used += print_temp_c_sec4 ( &c, lmax - used, t );
  used += print_temp_c_sec7 ( &c, lmax - used, t );
  used += snprintf ( c, lmax - used, "=" );
  return 0;
}

References metreport::alphanum, metreport::alphanum3, temp_chunks::c, PRINT_BITMASK_GEO, PRINT_BITMASK_WIGOS, print_geo(), metreport::print_mask, print_temp_c_sec1(), print_temp_c_sec2(), print_temp_c_sec3(), print_temp_c_sec4(), print_temp_c_sec7(), print_wigos_id(), temp_chunks::t, and metreport::temp.

Referenced by print_temp_report().

Here is the call graph for this function:

Here is the caller graph for this function:

print_temp_c_sec1()

size_t print_temp_c_sec1	(	char **	sec1,
		size_t	lmax,
		struct temp_chunks *	t
	)

Prints the section 1 of part C of a TEMP report.

Parameters

sec1	the pointer where to print section
lmax	max length permited
t	pointer to s atruct temp_chunks where the parse results are set

returns the string sec1

Definition at line 643 of file bufr2tac_print_temp.c.

{
  size_t used = 0;
  char *c = *sec1;
 
  used += snprintf ( c + used, lmax - used, "%s", t->t.datime );
 
  used += snprintf ( c + used, lmax - used, " %s%s", t->c.s1.MiMi, t->c.s1.MjMj );
 
  if ( t->c.s1.D_D[0] && t->a.s1.II[0] == 0 )
    {
      used += snprintf ( c + used, lmax - used, " %s", t->c.s1.D_D );
    }
 
  used += snprintf ( c + used, lmax - used, " %s%s", t->c.s1.YYGG, t->c.s1.id );
 
  // print IIiii
  if ( t->c.s1.II[0] )
    {
      used += snprintf ( c + used, lmax - used, " %s%s", t->c.s1.II, t->c.s1.iii );
    }
  else
    {
      if ( t->c.s1.LaLaLa[0] )
        {
          used += snprintf ( c + used, lmax - used, " 99%s", t->c.s1.LaLaLa );
        }
      else
        {
          used += snprintf ( c + used, lmax - used, " 99///" );
        }
 
      if ( t->c.s1.Qc[0] && t->c.s1.LoLoLoLo[0] )
        {
          used += snprintf ( c + used, lmax - used, " %s%s", t->c.s1.Qc, t->c.s1.LoLoLoLo );
        }
      else
        {
          used += snprintf ( c + used, lmax - used, " /////" );
        }
 
      if ( t->c.s1.MMM[0] && t->c.s1.Ula[0] && t->c.s1.Ulo[0] )
        {
          used += snprintf ( c + used, lmax - used, " %s%s%s", t->c.s1.MMM, t->c.s1.Ula, t->c.s1.Ulo );
        }
 
      if ( t->c.s1.h0h0h0h0[0] )
        {
          used += snprintf ( c + used, lmax - used, " %s%s", t->c.s1.h0h0h0h0, t->c.s1.im );
        }
    }
 
  *sec1 = c + used;
  return used;
}

References temp_chunks::c, met_datetime::t, and temp_chunks::t.

Referenced by print_temp_c().

Here is the caller graph for this function:

print_temp_c_sec2()

size_t print_temp_c_sec2	(	char **	sec2,
		size_t	lmax,
		struct temp_chunks *	t
	)

Prints the section 2 of part C of a TEMP report.

Parameters

sec2	the pointer where to print section
lmax	max length permited
t	pointer to s atruct temp_chunks where the parse results are set

returns the string sec2

Definition at line 708 of file bufr2tac_print_temp.c.

{
  size_t i;
  size_t used = 0;
  char *c = *sec2;
 
  for ( i = 0; i < t->c.s2.n ; i++ )
    {
      used += snprintf ( c + used, lmax - used, " %s%s", t->c.s2.std[i].PnPn, t->c.s2.std[i].hnhnhn );
      used += snprintf ( c + used, lmax - used, " %s%s", t->c.s2.std[i].TnTnTan, t->c.s2.std[i].DnDn );
      used += snprintf ( c + used, lmax - used, " %s", t->c.s2.std[i].dndnfnfnfn );
    }
 
  *sec2 = c + used;
  return used;
 
}

References temp_chunks::c, and temp_chunks::t.

Referenced by print_temp_c().

Here is the caller graph for this function:

print_temp_c_sec3()

size_t print_temp_c_sec3	(	char **	sec3,
		size_t	lmax,
		struct temp_chunks *	t
	)

Prints the section 3 of part C of a TEMP report.

Parameters

sec3	the pointer where to print section
lmax	max length permited
t	pointer to s atruct temp_chunks where the parse results are set

returns the string sec3

Definition at line 735 of file bufr2tac_print_temp.c.

{
  size_t i;
  size_t used = 0;
  char *c = *sec3;
 
  if ( t->c.s3.n == 0 )
    {
      used += snprintf ( c + used, lmax - used, " 88999" );
    }
  else
    {
      for ( i = 0; i < t->c.s3.n ; i++ )
        {
          used += snprintf ( c + used, lmax - used, " 88%s", t->c.s3.trop[i].PnPnPn );
          used += snprintf ( c + used, lmax - used, " %s%s", t->c.s3.trop[i].TnTnTan, t->c.s3.trop[i].DnDn );
          used += snprintf ( c + used, lmax - used, " %s", t->c.s3.trop[i].dndnfnfnfn );
        }
    }
 
  *sec3 = c + used;
  return used;
 
}

References temp_chunks::c, and temp_chunks::t.

Referenced by print_temp_c().

Here is the caller graph for this function:

print_temp_c_sec4()

size_t print_temp_c_sec4	(	char **	sec4,
		size_t	lmax,
		struct temp_chunks *	t
	)

Prints the section 4 of part C of a TEMP report.

Parameters

sec4	the pointer where to print section
lmax	max length permited
t	pointer to s atruct temp_chunks where the parse results are set

returns the string sec4

Definition at line 769 of file bufr2tac_print_temp.c.

{
  size_t i;
  size_t used = 0;
  char *c = *sec4;
 
  if ( t->c.s4.n == 0 )
    {
      used += snprintf ( c + used, lmax - used, " 77999" );
    }
  else
    {
      for ( i = 0; i < t->c.s4.n ; i++ )
        {
          if ( t->c.s4.windx[i].no_last_wind )
            {
              used += snprintf ( c + used, lmax - used, " 77%s", t->c.s4.windx[i].PmPmPm );
            }
          else
            {
              used += snprintf ( c + used, lmax - used, " 66%s", t->c.s4.windx[i].PmPmPm );
            }
          used += snprintf ( c + used, lmax - used, " %s", t->c.s4.windx[i].dmdmfmfmfm );
          if ( t->c.s4.windx[i].vbvb[0] && t->c.s4.windx[i].vava[0] )
            {
              used += snprintf ( c + used, lmax - used, " 4%s%s", t->c.s4.windx[i].vbvb, t->c.s4.windx[i].vava );
            }
        }
    }
 
  *sec4 = c + used;
  return used;
 
}

References temp_chunks::c, and temp_chunks::t.

Referenced by print_temp_c().

Here is the caller graph for this function:

print_temp_c_sec7()

size_t print_temp_c_sec7	(	char **	sec7,
		size_t	lmax,
		struct temp_chunks *	t
	)

Prints the section 7 of part C of a TEMP report.

Parameters

sec7	the pointer where to print section
lmax	max length permited
t	pointer to s atruct temp_chunks where the parse results are set

returns the string sec7

Definition at line 813 of file bufr2tac_print_temp.c.

{
  size_t used = 0;
  char *c = *sec7;
 
  used += snprintf ( c + used, lmax - used, " 31313" );
  used += snprintf ( c + used, lmax - used, " %s%s%s", t->c.s7.sr, t->c.s7.rara, t->c.s7.sasa );
  used += snprintf ( c + used, lmax - used, " 8%s%s", t->c.s7.GG, t->c.s7.gg );
 
  if ( t->c.s7.TwTwTw[0] )
    {
      used += snprintf ( c + used, lmax - used, " 9%s%s", t->c.s7.sn, t->c.s7.TwTwTw );
    }
 
  *sec7 = c + used;
  return used;
}

References temp_chunks::c, and temp_chunks::t.

Referenced by print_temp_c().

Here is the caller graph for this function:

print_temp_d()

int print_temp_d

(

struct metreport *

m

)

Prints the part D of a TEMP report into a string.

Parameters

m	pointer to struct metreport where are both target and source

If OK returns 0, otherwise 1

Definition at line 1022 of file bufr2tac_print_temp.c.

{
  char *c = &(m->alphanum4[0]);
  size_t used = 0;
  size_t lmax = sizeof(m->alphanum);
  struct temp_chunks *t = &m->temp;
 
  // Needs time extension
  if ( t->d.e.YYYY[0] == 0  || t->d.e.YYYY[0] == '0')
    {
      return 1;
    }
 
  if ( m->print_mask & PRINT_BITMASK_WIGOS )
    {
      used += print_wigos_id ( &c, lmax, m );
    }
 
  if ( m->print_mask & PRINT_BITMASK_GEO )
    {
      used += print_geo ( &c, lmax, m );
    }
 
  used += print_temp_d_sec1 ( &c, lmax - used, t );
  used += print_temp_d_sec5 ( &c, lmax - used, t );
  used += print_temp_d_sec6 ( &c, lmax - used, t );
  used += print_temp_d_sec7 ( &c, lmax - used, t );
  used += snprintf ( c, lmax - used, "=" );
  return 0;
}

References metreport::alphanum, metreport::alphanum4, temp_chunks::c, PRINT_BITMASK_GEO, PRINT_BITMASK_WIGOS, print_geo(), metreport::print_mask, print_temp_d_sec1(), print_temp_d_sec5(), print_temp_d_sec6(), print_temp_d_sec7(), print_wigos_id(), temp_chunks::t, and metreport::temp.

Referenced by print_temp_report().

Here is the call graph for this function:

Here is the caller graph for this function:

print_temp_d_sec1()

size_t print_temp_d_sec1	(	char **	sec1,
		size_t	lmax,
		struct temp_chunks *	t
	)

Prints the section 1 of part D of a TEMP report.

Parameters

sec1	the pointer where to print section
lmax	max length permited
t	pointer to s atruct temp_chunks where the parse results are set

returns the string sec1

Definition at line 880 of file bufr2tac_print_temp.c.

{
  size_t used = 0;
  char *c = *sec1;
 
  used += snprintf ( c + used, lmax - used, "%s", t->t.datime );
 
  used += snprintf ( c + used, lmax - used, " %s%s", t->d.s1.MiMi, t->d.s1.MjMj );
 
  if ( t->d.s1.D_D[0] && t->a.s1.II[0] == 0 )
    {
      used += snprintf ( c + used, lmax - used, " %s", t->d.s1.D_D );
    }
 
  used += snprintf ( c + used, lmax - used, " %s/", t->d.s1.YYGG );
 
  // print IIiii
  if ( t->d.s1.II[0] )
    {
      used += snprintf ( c + used, lmax - used, " %s%s", t->d.s1.II, t->d.s1.iii );
    }
  else
    {
      if ( t->d.s1.LaLaLa[0] )
        {
          used += snprintf ( c + used, lmax - used, " 99%s", t->d.s1.LaLaLa );
        }
      else
        {
          used += snprintf ( c + used, lmax - used, " 99///" );
        }
 
      if ( t->d.s1.Qc[0] && t->d.s1.LoLoLoLo[0] )
        {
          used += snprintf ( c + used, lmax - used, " %s%s", t->d.s1.Qc, t->d.s1.LoLoLoLo );
        }
      else
        {
          used += snprintf ( c + used, lmax - used, " /////" );
        }
 
      if ( t->d.s1.MMM[0] && t->d.s1.Ula[0] && t->d.s1.Ulo[0] )
        {
          used += snprintf ( c + used, lmax - used, " %s%s%s", t->d.s1.MMM, t->d.s1.Ula, t->d.s1.Ulo );
        }
 
      if ( t->d.s1.h0h0h0h0[0] )
        {
          used += snprintf ( c + used, lmax - used, " %s%s", t->d.s1.h0h0h0h0, t->d.s1.im );
        }
    }
 
  *sec1 = c + used;
  return used;
}

References temp_chunks::c, met_datetime::t, and temp_chunks::t.

Referenced by print_temp_d().

Here is the caller graph for this function:

print_temp_d_sec5()

size_t print_temp_d_sec5	(	char **	sec5,
		size_t	lmax,
		struct temp_chunks *	t
	)

Prints the section 5 of part D of a TEMP report.

Parameters

sec5	the pointer where to print section
lmax	max length permited
t	pointer to s atruct temp_chunks where the parse results are set

returns the string sec5

Definition at line 945 of file bufr2tac_print_temp.c.

{
  size_t i;
  size_t used = 0;
  char *c = *sec5;
 
  for ( i = 0; i < t->d.s5.n && i < TEMP_NMAX_POINTS ; i++ )
    {
      used += snprintf ( c + used, lmax - used, " %s%s", t->d.s5.th[i].nini, t->d.s5.th[i].PnPnPn );
      used += snprintf ( c + used, lmax - used, " %s%s", t->d.s5.th[i].TnTnTan, t->d.s5.th[i].DnDn );
    }
 
  *sec5 = c + used;
  return used;
}

References temp_chunks::c, temp_chunks::t, and TEMP_NMAX_POINTS.

Referenced by print_temp_d().

Here is the caller graph for this function:

print_temp_d_sec6()

size_t print_temp_d_sec6	(	char **	sec6,
		size_t	lmax,
		struct temp_chunks *	t
	)

Prints the section 6 of part D of a TEMP report.

Parameters

sec6	the pointer where to print section
lmax	max length permited
t	pointer to s atruct temp_chunks where the parse results are set

returns the string sec6

Definition at line 970 of file bufr2tac_print_temp.c.

{
  size_t i;
  size_t used = 0;
  char *c = *sec6;
 
  used += snprintf ( c + used, lmax - used, " 21212" );
 
  for ( i = 0; i < t->d.s6.n && i < TEMP_NMAX_POINTS ; i++ )
    {
      used += snprintf ( c + used, lmax - used, " %s%s", t->d.s6.wd[i].nini, t->d.s6.wd[i].PnPnPn );
      used += snprintf ( c + used, lmax - used, " %s", t->d.s6.wd[i].dndnfnfnfn );
    }
 
  *sec6 = c + used;
  return used;
}

References temp_chunks::c, temp_chunks::t, and TEMP_NMAX_POINTS.

Referenced by print_temp_d().

Here is the caller graph for this function:

print_temp_d_sec7()

size_t print_temp_d_sec7	(	char **	sec7,
		size_t	lmax,
		struct temp_chunks *	t
	)

Prints the section 7 of part D of a TEMP report.

Parameters

sec7	the pointer where to print section
lmax	max length permited
t	pointer to s atruct temp_chunks where the parse results are set

returns the string sec7

Definition at line 997 of file bufr2tac_print_temp.c.

{
  size_t used = 0;
  char *c = *sec7;
 
  used += snprintf ( c + used, lmax - used, " 31313" );
  used += snprintf ( c + used, lmax - used, " %s%s%s", t->d.s7.sr, t->d.s7.rara, t->d.s7.sasa );
  used += snprintf ( c + used, lmax - used, " 8%s%s", t->d.s7.GG, t->d.s7.gg );
 
  if ( t->d.s7.TwTwTw[0] )
    {
      used += snprintf ( c + used, lmax - used, " 9%s%s", t->d.s7.sn, t->d.s7.TwTwTw );
    }
 
  *sec7 = c + used;
  return used;
}

References temp_chunks::c, and temp_chunks::t.

Referenced by print_temp_d().

Here is the caller graph for this function:

print_temp_d_sec8()

size_t print_temp_d_sec8	(	char **	sec8,
		size_t	lmax,
		struct temp_chunks *	t
	)

print_temp_raw_data()

int print_temp_raw_data

(

struct temp_raw_data *

r

)

Prints for debug a struct temp_raw_data.

Parameters

r	the pointer of struct to print

This is used mainly for debug

Definition at line 33 of file bufr2tac_print_temp.c.

{
  size_t i;
 
  printf ( "raw points %lu\n", r->n );
  for ( i = 0; i < r->n ; i++ )
    {
      if ( r->raw[i].T != MISSING_REAL &&
           r->raw[i].Td != MISSING_REAL &&
           r->raw[i].dd != MISSING_REAL &&
           r->raw[i].ff != MISSING_REAL )
        printf ( "i=%3ld, dt=%4d, flags=%08X, P=%6.1lf, h=%6.0lf, dlat=%7.4lf, dlon=%7.4lf, T=%6.1lf, Td=%6.1lf, dd=%03.0lf, ff=%5.1lf\n",
                 i, r->raw[i].dt, r->raw[i].flags, r->raw[i].p * 0.01, r->raw[i].h, r->raw[i].dlat, r->raw[i].dlon,
                 r->raw[i].T - 273.15, r->raw[i].Td - 273.15, r->raw[i].dd, r->raw[i].ff );
      else
        {
          printf ( "i=%3ld, dt=%4d, flags=%08X, P=%6.1lf, h=%6.0lf, dlat=%7.4lf, dlon=%7.4lf, ",
                   i, r->raw[i].dt, r->raw[i].flags, r->raw[i].p * 0.01, r->raw[i].h, r->raw[i].dlat, r->raw[i].dlon );
          if ( r->raw[i].T != MISSING_REAL )
            {
              printf ( "T=%6.1lf, ", r->raw[i].T - 273.15 );
            }
          else
            {
              printf ( "T= ///./, " );
            }
 
          if ( r->raw[i].Td != MISSING_REAL )
            {
              printf ( "T=%6.1lf, ", r->raw[i].Td - 273.15 );
            }
          else
            {
              printf ( "Td= ///./, " );
            }
 
          if ( r->raw[i].dd != MISSING_REAL )
            {
              printf ( "dd=%03.0lf, ", r->raw[i].dd );
            }
          else
            {
              printf ( "dd=///, " );
            }
 
          if ( r->raw[i].dd != MISSING_REAL )
            {
              printf ( "ff=%5.1lf\n", r->raw[i].ff );
            }
          else
            {
              printf ( "ff= //./\n" );
            }
        }
    }
  return 0;
}

References temp_raw_point_data::dd, temp_raw_point_data::dlat, temp_raw_point_data::dlon, temp_raw_point_data::dt, temp_raw_point_data::ff, temp_raw_point_data::flags, temp_raw_point_data::h, MISSING_REAL, temp_raw_data::n, temp_raw_point_data::p, temp_raw_data::raw, temp_raw_point_data::T, and temp_raw_point_data::Td.

print_temp_raw_wind_shear_data()

int print_temp_raw_wind_shear_data

(

struct temp_raw_wind_shear_data *

w

)

Prints for debug a struct temp_raw_data.

Parameters

w	the pointer of struct to print

Used in debug stage

Definition at line 98 of file bufr2tac_print_temp.c.

{
  size_t i;
 
  printf ( "raw share wind points %lu\n", w->n );
  for ( i = 0; i < w->n ; i++ )
    {
      if ( w->raw[i].ws_blw != MISSING_REAL && w->raw[i].ws_abv != MISSING_REAL )
        printf ( "i=%3ld, dt=%4d, flags=%08X, P=%6.1lf, dlat=%7.4lf, dlon=%7.4lf, ws_blw=%5.1lf, ws_abv=%5.1lf\n",
                 i, w->raw[i].dt, w->raw[i].flags, w->raw[i].p * 0.01, w->raw[i].dlat, w->raw[i].dlon,
                 w->raw[i].ws_blw, w->raw[i].ws_abv );
      else
        {
          printf ( "i=%3ld, dt=%4d, flags=%08X, P=%6.1lf, dlat=%7.4lf, dlon=%7.4lf, ",
                   i, w->raw[i].dt, w->raw[i].flags, w->raw[i].p * 0.01, w->raw[i].dlat, w->raw[i].dlon );
 
          if ( w->raw[i].ws_blw != MISSING_REAL )
            {
              printf ( "ws_blw=%5.1lf, ", w->raw[i].ws_blw );
            }
          else
            {
              printf ( "ws_blw= ///./, " );
            }
 
          if ( w->raw[i].ws_abv != MISSING_REAL )
            {
              printf ( "ws_abv=%5.1lf\n", w->raw[i].ws_abv );
            }
          else
            {
              printf ( "ws_abv= ///./\n" );
            }
        }
    }
  return 0;
}

References temp_raw_wind_shear_point::dlat, temp_raw_wind_shear_point::dlon, temp_raw_wind_shear_point::dt, temp_raw_wind_shear_point::flags, MISSING_REAL, temp_raw_wind_shear_data::n, temp_raw_wind_shear_point::p, temp_raw_wind_shear_data::raw, temp_raw_wind_shear_point::ws_abv, and temp_raw_wind_shear_point::ws_blw.

print_temp_report()

int print_temp_report

(

struct metreport *

m

)

print the four parts of a decoded TEMP report from a BUFR file into strings

Parameters

m	pointer to a struct metreport in which alphanumeric string members stores the reults

Definition at line 1058 of file bufr2tac_print_temp.c.

{
  // It is required that al lesat a standard level where decoded in SEC A
  if ( m->temp.a.mask & TEMP_SEC_2 )
    {
      print_temp_a ( m );
    }
 
  // It is required a significant TH or wind poind for sec B
  if ( m->temp.b.mask & ( TEMP_SEC_5 | TEMP_SEC_6 ) )
    {
      print_temp_b ( m );
    }
 
  // It is required a standard level for SEC C
  if ( m->temp.c.mask & TEMP_SEC_2 )
    {
      print_temp_c ( m );
    }
 
  // It is required a significant TH or wind poind for sec B
  if ( m->temp.d.mask & ( TEMP_SEC_5 | TEMP_SEC_6 ) )
    {
      print_temp_d ( m );
    }
 
  return 0;
}

References temp_chunks::a, temp_chunks::b, temp_chunks::c, temp_chunks::d, temp_a::mask, temp_b::mask, temp_c::mask, temp_d::mask, print_temp_a(), print_temp_b(), print_temp_c(), print_temp_d(), metreport::temp, TEMP_SEC_2, TEMP_SEC_5, and TEMP_SEC_6.

Referenced by parse_subset_sequence().

Here is the call graph for this function:

Here is the caller graph for this function:

print_temp_wigos_id()

size_t print_temp_wigos_id	(	char **	wid,
		size_t	lmax,
		struct temp_chunks *	t
	)

print_wigos_id()

size_t print_wigos_id	(	char **	wid,
		size_t	lmax,
		struct metreport *	m
	)

Definition at line 86 of file bufr2tac_print.c.

{
  char aux[40];
  size_t used;
  char sep = '|';
  
  if (m->g.wid.series == 0 && m->g.wid.issuer == 0 && m->g.wid.issue == 0 && m->g.wid.local_id[0] == '\0')
    sprintf (aux,"0-0-0-MISSING");
  else
    sprintf (aux,"%d-%d-%d-%s", m->g.wid.series, m->g.wid.issuer, m->g.wid.issue, m->g.wid.local_id );
 
  used = snprintf (*wid, lmax, "%-32s%c", aux, sep);
  *wid += used;
  return used;
}

References metreport::g, wigos_id::issue, wigos_id::issuer, wigos_id::local_id, wigos_id::series, and met_geo::wid.

Referenced by print_buoy_report(), print_climat_report(), print_synop_report(), print_temp_a(), print_temp_b(), print_temp_c(), and print_temp_d().

Here is the caller graph for this function:

print_xml()

int print_xml	(	FILE *	f,
		struct metreport *	m
	)

prints a struct metreport in xml format

Parameters

f	pointer to a file already open by caller routine
m	pointer to a struct metreport containing the data to print

Definition at line 71 of file bufr2tac_xml.c.

{
  // Single report
  if ( m->alphanum[0] )
    {
      print_xml_alphanum ( f, m->type, m->alphanum, m );
    }
 
  if ( m->alphanum2[0] ) //TTBB
    {
      print_xml_alphanum ( f, m->type2, m->alphanum2, m );
    }
 
  if ( m->alphanum3[0] ) //TTCC
    {
      print_xml_alphanum ( f, m->type3, m->alphanum3, m );
    }
 
  if ( m->alphanum4[0] ) //TTDD
    {
      print_xml_alphanum ( f, m->type4, m->alphanum4, m );
    }
 
  return 0;
}

References metreport::alphanum, metreport::alphanum2, metreport::alphanum3, metreport::alphanum4, print_xml_alphanum(), metreport::type, metreport::type2, metreport::type3, and metreport::type4.

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

read_bufr()

int read_bufr	(	unsigned char *	bufr,
		char *	filename,
		int *	length
	)

read a bufr file as an array of unsigned chars

Parameters

bufr	pointer to an array of unsigned chars. On output it will contain the bufr
filename	string with complete pathname of bufr file to read
length	On input max length allocated by caller. On output real length of bufr

Definition at line 34 of file bufr2tac_io.c.

{
  int aux;
  size_t n = 0;
  FILE *fp;
 
  /* Open input file */
  if ( ( fp = fopen ( filename, "r" ) ) == NULL )
    {
      fprintf ( stderr, "cannot open file '%s'\n", filename );
      exit ( EXIT_FAILURE );
    }
 
  while ( ( aux = fgetc ( fp ) ) != EOF && ( int ) n < *length )
    bufr[n++] = aux;
  *length = n;
 
  // close the file
  fclose ( fp );
 
  if ( n < 8 ) // we need at least 8 bytes
    return -4;
 
  // check if begins with BUFR
  if ( bufr[0] != 'B' || bufr[1] != 'U' || bufr[2] != 'F' || bufr[3] != 'R' )
    return -1;
 
  // check if end with '7777'
  if ( bufr[n - 4] != '7' || bufr[n - 3] != '7' || bufr[n - 2] != '7'
       || bufr[n - 1] != '7' )
    return -2;
 
  //printf("%d %d\n", n, three_bytes_to_uint(bufr + 4));
  // check about the expected size
  if ( n != three_bytes_to_uint ( bufr + 4 ) )
    return -3;
 
  return 0;
}

References three_bytes_to_uint().

Here is the call graph for this function:

read_table_c()

int read_table_c	(	char	tablec[MAXLINES_TABLEC][92],
		size_t *	nlines_tablec,
		char *	bufrtables_dir,
		int	ksec1[40]
	)

Definition at line 64 of file bufr2tac_tablec.c.

{
  char *c, file[256];
  FILE *t;
  size_t i = 0;
 
  *nlines_tablec = 0;
 
  get_ecmwf_tablename ( &file[0], 'C', bufrtables_dir, ksec1 );
 
  if ( ( t = fopen ( file, "r" ) ) == NULL )
    {
      fprintf ( stderr,"Unable to open table C file '%s'\n", file );
      return 0;
    }
 
  while ( fgets ( tablec[i], 90, t ) != NULL && i < MAXLINES_TABLEC )
    {
      // supress the newline
      if ( ( c = strrchr ( tablec[i],'\n' ) ) != NULL )
        *c = '\0';
      i++;
    }
  fclose ( t );
  *nlines_tablec = i;
  //printf("file='%s', NLINES_TABLEC=%d\n", file,NLINES_TABLEC);
  return i;
}

References get_ecmwf_tablename(), and MAXLINES_TABLEC.

Here is the call graph for this function:

recent_snow_to_ss()

char * recent_snow_to_ss	(	char *	target,
		double	r
	)

converts recent snow in m to ss (code table 3870)

Parameters

r	recent snow depth in meters
target	the resulting string

Definition at line 157 of file bufr2tac_x13.c.

{
  int i;
  i = ( int ) ( r * 1000.0 + 0.5 ); // convert to mm
 
  if ( i == 0 )
    {
      sprintf ( target,"00" );
    }
  else if ( i < 0 )
    {
      sprintf ( target,"97" );
    }
  else if ( i < 7 )
    {
      sprintf ( target,"%02d", i + 90 );
    }
  else if ( i < 600 )
    {
      sprintf ( target,"%02d", i / 10 );
    }
  else if ( i <= 4000 )
    {
      sprintf ( target,"%02d", 50 + i/100 );
    }
  else if ( i > 4000 )
    {
      sprintf ( target,"98" );
    }
  else
    {
      sprintf ( target,"99" );
    }
  return target;
}

Referenced by syn_parse_x13().

Here is the caller graph for this function:

round_met_datetime_to_hour()

int round_met_datetime_to_hour	(	struct met_datetime *	target,
		struct met_datetime *	source
	)

Definition at line 194 of file bufr2tac_utils.c.

{
  target->t = ( ( source->t + 1800 ) / 3600 ) * 3600 ; // rounding to next whole hour
  memset ( &target->tim, 0, sizeof ( struct tm ) );
  gmtime_r ( &target->t, &target->tim );
  strftime ( target->datime, 16, "%Y%m%d%H%M", &target->tim );
  return 0;
}

References met_datetime::datime, met_datetime::t, and met_datetime::tim.

Referenced by parse_subset_as_temp().

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

tt	string with the resulting table code
secs	second

returns the pointer to tt

Definition at line 34 of file bufr2tac_x11.c.

{
  int i;
 
  if ( secs < 0 )
    {
      i = ( -secs ) / 360;
    }
  else
    {
      i = ( secs ) / 360;
    }
 
  if ( i <= 60 )
    {
      sprintf ( tt, "%02d", i );
    }
  else if ( i < 700 )
    {
      sprintf ( tt, "61" );
    }
  else if ( i < 800 )
    {
      sprintf ( tt, "62" );
    }
  else if ( i < 900 )
    {
      sprintf ( tt, "63" );
    }
  else if ( i < 1000 )
    {
      sprintf ( tt, "64" );
    }
  else if ( i < 1100 )
    {
      sprintf ( tt, "65" );
    }
  else if ( i < 1200 )
    {
      sprintf ( tt, "66" );
    }
  else if ( i < 1800 )
    {
      sprintf ( tt, "67" );
    }
  else
    {
      sprintf ( tt, "68" );
    }
  return tt;
}

Referenced by syn_parse_x11(), and syn_parse_x20().

Here is the caller graph for this function:

set_environment()

int set_environment	(	char *	default_bufrtables,
		char *	bufrtables_dir
	)

syn_parse_x01()

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

Parse a expanded descriptor with X = 01.

Parameters

syn	pointer to a struct synop_chunks where to set the results
s	pointer 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 54 of file bufr2tac_x01.c.

{
  char aux[80];
 
  if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
    return 0;
 
  switch ( s->a->desc.y )
    {
    case 1: // 0 01 001 . WMO block number
      sprintf ( syn->s0.II, "%02d", s->ival );
      break;
 
    case 2: // 0 01 002 . WMO station number
      sprintf ( syn->s0.iii, "%03d", s->ival );
      break;
 
    case 3: // 0 01 003 . WMO Region
      sprintf ( syn->s0.A1, "%d", s->ival );
      if ( strcmp ( syn->s0.A1, "1" ) == 0 )
        strcpy ( syn->s0.Reg, "I" );
      else if ( strcmp ( syn->s0.A1, "2" ) == 0 )
        strcpy ( syn->s0.Reg, "II" );
      else if ( strcmp ( syn->s0.A1, "3" ) == 0 )
        strcpy ( syn->s0.Reg, "III" );
      else if ( strcmp ( syn->s0.A1, "4" ) == 0 )
        strcpy ( syn->s0.Reg, "IV" );
      else if ( strcmp ( syn->s0.A1, "5" ) == 0 )
        strcpy ( syn->s0.Reg, "V" );
      else if ( strcmp ( syn->s0.A1, "6" ) == 0 )
        strcpy ( syn->s0.Reg, "VI" );
      break;
 
    case 4: // 0 01 004 . WMO Subarea
    case 20: // 0 01 020 . WMO region subarea
      sprintf ( syn->s0.bw, "%d", s->ival );
      break;
 
    case 10: // 0 01 010. Stationary buoy platform identifier
      if ( strlen ( s->a->cval ) < 16 )
        {
          strcpy ( aux, s->a->cval );
          adjust_string ( aux );
          if ( aux[0] == '\xff' )
            break;
          if ( strlen ( aux ) < 10 )
            strcpy ( syn->s0.D_D, aux );
          else
            bufr2tac_set_error ( s, 1, "syn_parse_x01()", "Ship or mobile land station index length >= 10. Cannot set s0.D_D" );
        }
      else if ( BUFR2TAC_DEBUG_LEVEL > 0 )
        {
          bufr2tac_set_error ( s, 1, "syn_parse_x01()", "Ship or mobile land station index length >= 16" );
        }
      break;
 
    case 11: // 0 01 011. Ship or mobile land station index
      if ( strlen ( s->a->cval ) < 16 )
        {
          strcpy ( aux, s->a->cval );
          adjust_string ( aux );
          if ( aux[0] == '\xff' )
            break;
          if ( strlen ( aux ) < 10 )
            strcpy ( syn->s0.D_D, aux );
          else
            bufr2tac_set_error ( s, 1, "syn_parse_x01()", "Ship or mobile land station index length >= 10. Cannot set s0.D_D" );
        }
      else if ( BUFR2TAC_DEBUG_LEVEL > 0 )
        {
          bufr2tac_set_error ( s, 1, "syn_parse_x01()", "Ship or mobile land station index length >= 16" );
        }
      break;
 
    case 15: // 0 01 015 . Station or site name
    case 18: // 0 01 018 . Short station or site name
    case 19: // 0 01 019 . Long station or site name
      if ( strlen ( s->a->cval ) <= 80 )
        {
          strcpy ( aux, s->a->cval );
          adjust_string ( aux );
          strcpy ( s->name, aux );
          s->mask |= SUBSET_MASK_HAVE_NAME;
        }
      else if ( BUFR2TAC_DEBUG_LEVEL > 0 )
        {
          bufr2tac_set_error ( s, 1, "syn_parse_x01()", "Station or site name length > 80. Cannot set s->name" );
        }
      break;
 
    case 101: // 0 01 101 . State identifier
      if ( strlen ( s->a->ctable ) <= 256 )
        {
          strcpy ( aux, s->a->ctable );
          adjust_string ( aux );
          strcpy ( s->country, aux );
          s->mask |= SUBSET_MASK_HAVE_COUNTRY;
        }
      else if ( BUFR2TAC_DEBUG_LEVEL > 0 )
        {
          bufr2tac_set_error ( s, 1, "syn_parse_x01()", "State identifier length > 256. Cannot set s->country" );
        }
      break;
 
    case 125: // 0 01 125 . WIGOS identifier series
      syn->wid.series = ( uint8_t ) s->ival;
      break;
 
    case 126: // 0 01 126 . WIGOS issuer of identifier
      syn->wid.issuer = ( uint16_t ) s->ival;
      break;
 
    case 127: // 0 01 127 , WIGOS issue number
      syn->wid.issue = ( uint16_t ) s->ival;
      break;
 
    case 128: // 0 01 128 . WIGOS local identifier (character)
      if ( strlen ( s->a->cval ) <= 16 )
        {
          adjust_string ( s->a->cval );
          if ( check_wigos_local_id ( s->a->cval ) )
            {
              bufr2tac_set_error ( s, 1, "synop_parse_x01()","Bad WIGOS Local identifier" );
            }
          strcpy ( syn->wid.local_id, s->a->cval );
          s->mask |= SUBSET_MASK_HAVE_WIGOS_ID ;
        }
      break;
 
    default:
      if ( BUFR2TAC_DEBUG_LEVEL > 1 && ( s->a->mask & DESCRIPTOR_VALUE_MISSING ) == 0 )
        bufr2tac_set_error ( s, 0, "syn_parse_x01()", "Descriptor not parsed" );
      break;
    }
 
  //set WMO region if we know II and iii and still no set A1
  if ( ( syn->s0.A1[0] == 0 ) && syn->s0.II[0] && syn->s0.iii[0] )
    {
      guess_WMO_region ( syn->s0.A1, syn->s0.Reg, syn->s0.II, syn->s0.iii );
    }
  return 0;
}

References bufr2tac_subset_state::a, synop_sec0::A1, adjust_string(), BUFR2TAC_DEBUG_LEVEL, bufr2tac_set_error(), synop_sec0::bw, check_wigos_local_id(), bufr2tac_subset_state::country, bufr_atom_data::ctable, bufr_atom_data::cval, synop_sec0::D_D, bufr_atom_data::desc, DESCRIPTOR_VALUE_MISSING, guess_WMO_region(), synop_sec0::II, synop_sec0::iii, wigos_id::issue, wigos_id::issuer, bufr2tac_subset_state::ival, wigos_id::local_id, bufr_atom_data::mask, bufr2tac_subset_state::mask, bufr2tac_subset_state::name, synop_sec0::Reg, synop_chunks::s0, wigos_id::series, SUBSET_MASK_HAVE_COUNTRY, SUBSET_MASK_HAVE_NAME, SUBSET_MASK_HAVE_WIGOS_ID, synop_chunks::wid, 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:

syn_parse_x02()

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

Parse a expanded descriptor with X = 02.

Parameters

syn	pointer to a struct synop_chunks where to set the results
s	pointer 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 34 of file bufr2tac_x02.c.

{
 
 
  switch ( s->a->desc.y )
    {
    case 1: // 0 02 001 Type of station
      if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
        {
          strcpy ( syn->s1.ix,"/" );
          return 0;
        }
      s->type = s->ival;
      s->mask |= SUBSET_MASK_HAVE_TYPE_STATION;
      break;
    case 2: // 0 02 002 . Type of instrumentation for wind measurement
      if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
        return 0;
      if ( s->ival == 0 )
        strcpy ( syn->s0.iw, "0" );
      else if ( s->ival == 8 )
        strcpy ( syn->s0.iw, "1" );
      else if ( s->ival == 4 )
        strcpy ( syn->s0.iw, "3" );
      else if ( s->ival == 12 )
        strcpy ( syn->s0.iw, "4" );
 
      /*
      if ( s->ival & 4 )
        strcpy ( syn->s0.iw, "4" );
      else
        strcpy ( syn->s0.iw, "1" );*/
      break;
    default:
      if ( BUFR2TAC_DEBUG_LEVEL > 1 && (s->a->mask & DESCRIPTOR_VALUE_MISSING) == 0 ) 
        bufr2tac_set_error ( s, 0, "syn_parse_x02()", "Descriptor not parsed" );
      break;
    }
  return 0;
}

References bufr2tac_subset_state::a, BUFR2TAC_DEBUG_LEVEL, bufr2tac_set_error(), bufr_atom_data::desc, DESCRIPTOR_VALUE_MISSING, bufr2tac_subset_state::ival, synop_sec0::iw, synop_sec1::ix, bufr_atom_data::mask, bufr2tac_subset_state::mask, synop_chunks::s0, synop_chunks::s1, SUBSET_MASK_HAVE_TYPE_STATION, bufr2tac_subset_state::type, 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:

syn_parse_x04()

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

Parse a expanded descriptor with X = 04.

Parameters

syn	pointer to a struct synop_chunks where to set the results
s	pointer 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 110 of file bufr2tac_x04.c.

{
  switch ( s->a->desc.y )
    {
    case 1: // 0 04 001 .Year
      if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
        {
          return 0;
        }
      else if ( s->ival < 2000 || s->ival > 2050 )
        {
          if ( BUFR2TAC_DEBUG_LEVEL > 0 )
            bufr2tac_set_error ( s, 2, "syn_parse_x04()", "Bad year" );
          return 1;
        }
      sprintf ( syn->e.YYYY, "%04d", s->ival );
      s->mask |= SUBSET_MASK_HAVE_YEAR;
      break;
 
    case 2: // 0 04 002 . Month
      if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
        {
          return 0;
        }
      sprintf ( syn->e.MM, "%02d", s->ival );
      s->mask |= SUBSET_MASK_HAVE_MONTH;
      break;
 
    case 3: // 0 04 003 . Day of month
      if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
        {
          return 0;
        }
      sprintf ( syn->e.DD, "%02d", s->ival );
      s->mask |= SUBSET_MASK_HAVE_DAY;
      break;
 
    case 4: // 0 04 004 . Hour
      if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
        {
          return 0;
        }
      sprintf ( syn->e.HH, "%02d", s->ival );
      s->mask |= SUBSET_MASK_HAVE_HOUR;
      break;
 
    case 5: // 0 04 005 . Minute
      if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
        {
          return 0;
        }
      sprintf ( syn->e.mm, "%02d", s->ival );
      s->mask |= SUBSET_MASK_HAVE_MINUTE;
      break;
 
    // store latest displacement in seconds
    case 23: // 0 04 023 . Time period of displacement (days)
      if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
        {
          s->k_jtval = s->k_itval;
          s->jtval = s->itval;
          s->jtmask = s->itmask;
          s->k_itval = s->i;
          s->itval = 0;
          return 0;
        }
      s->k_jtval = s->k_itval;
      s->jtval = s->itval;
      s->jtmask = s->itmask;
      s->k_itval = s->i;
      s->itmask = s->a->mask;
      s->itval = s->ival * 86400;
      break;
 
    case 24: // 0 04 024 .  Time period of displacement (hours)
      if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
        {
          s->k_jtval = s->k_itval;
          s->jtval = s->itval;
          s->jtmask = s->itmask;
          s->k_itval = s->i;
          s->itval = 0;
          return 0;
        }
      s->k_jtval = s->k_itval;
      s->jtval = s->itval;
      s->jtmask = s->itmask;
      s->k_itval = s->i;
      s->itmask = s->a->mask;
      s->itval = s->ival * 3600;
      break;
 
    case 25: // 0 04 025  Time period of displacement (minutes)
      if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
        {
          s->k_jtval = s->k_itval;
          s->jtval = s->itval;
          s->jtmask = s->itmask;
          s->k_itval = s->i;
          s->itval = 0;
          return 0;
        }
      s->k_jtval = s->k_itval;
      s->jtval = s->itval;
      s->jtmask = s->itmask;
      s->k_itval = s->i;
      s->itmask = s->a->mask;
      s->itval = s->ival * 60;
      break;
 
    case 26: // 0 04 026 .  Time period of displacement (seconds)
      if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
        {
          s->k_jtval = s->k_itval;
          s->jtval = s->itval;
          s->jtmask = s->itmask;
          s->k_itval = s->i;
          s->itval = 0;
          return 0;
        }
      s->k_jtval = s->k_itval;
      s->jtval = s->itval;
      s->jtmask = s->itmask;
      s->k_itval = s->i;
      s->itmask = s->a->mask;
      s->itval = s->ival;
      break;
 
    default:
      if ( BUFR2TAC_DEBUG_LEVEL > 1 && ( s->a->mask & DESCRIPTOR_VALUE_MISSING ) == 0 )
        bufr2tac_set_error ( s, 0, "syn_parse_x04()", "Descriptor not parsed" );
      break;
    }
  return 0;
}

References bufr2tac_subset_state::a, BUFR2TAC_DEBUG_LEVEL, bufr2tac_set_error(), report_date_ext::DD, bufr_atom_data::desc, DESCRIPTOR_VALUE_MISSING, synop_chunks::e, report_date_ext::HH, bufr2tac_subset_state::i, bufr2tac_subset_state::itmask, bufr2tac_subset_state::itval, bufr2tac_subset_state::ival, bufr2tac_subset_state::jtmask, bufr2tac_subset_state::jtval, bufr2tac_subset_state::k_itval, bufr2tac_subset_state::k_jtval, bufr_atom_data::mask, bufr2tac_subset_state::mask, report_date_ext::MM, report_date_ext::mm, SUBSET_MASK_HAVE_DAY, SUBSET_MASK_HAVE_HOUR, SUBSET_MASK_HAVE_MINUTE, SUBSET_MASK_HAVE_MONTH, SUBSET_MASK_HAVE_YEAR, bufr_descriptor::y, and report_date_ext::YYYY.

Referenced by parse_subset_as_synop().

Here is the call graph for this function:

Here is the caller graph for this function:

syn_parse_x05()

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

Parse a expanded descriptor with X = 05.

Parameters

syn	pointer to a struct synop_chunks where to set the results
s	pointer 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 66 of file bufr2tac_x05.c.

{
  int ia;
 
  if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
    return 0;
 
  switch ( s->a->desc.y )
    {
    case 1: // 0 05 001 . Latitude (High accuracy)
    case 2: // 0 05 002 . Latitude (Coarse accuracy)
      if ( s->val < 0.0 )
        s->mask |= SUBSET_MASK_LATITUDE_SOUTH; // Sign for latitude
      s->mask |= SUBSET_MASK_HAVE_LATITUDE;
      ia = ( int ) ( fabs ( s->val ) * 10.0 + 0.5 );
      if (ia > 999 || ia < 0)
        return 1;
      sprintf ( syn->s0.LaLaLa, "%03d", ia );
      syn->s0.Ula[0] = syn->s0.LaLaLa[1];
      s->lat = s->val;
      break;
 
    case 21: // 0 05 021 . Bearing or azimut
      grad_to_D ( syn->s3.Da, s->val );
      syn->mask |= SYNOP_SEC3;
      break;
    default:
      if ( BUFR2TAC_DEBUG_LEVEL > 1 && (s->a->mask & DESCRIPTOR_VALUE_MISSING) == 0 ) 
        bufr2tac_set_error ( s, 0, "syn_parse_x05()", "Descriptor not parsed" );
      break;
    }
 
  // check if set both LaLaLa and LoLoLoLo to set Qc
  if ( ( syn->s0.Qc[0] == 0 ) && syn->s0.LaLaLa[0] && syn->s0.LoLoLoLo[0] )
    {
      if ( s->mask & SUBSET_MASK_LATITUDE_SOUTH )
        {
          if ( s->mask & SUBSET_MASK_LONGITUDE_WEST )
            strcpy ( syn->s0.Qc, "5" );
          else
            strcpy ( syn->s0.Qc, "3" );
        }
      else
        {
          if ( s->mask & SUBSET_MASK_LONGITUDE_WEST )
            strcpy ( syn->s0.Qc, "7" );
          else
            strcpy ( syn->s0.Qc, "1" );
        }
    }
 
  // check about Mardsen square
  if ( ( syn->s0.MMM[0] == 0 ) && syn->s0.LaLaLa[0] && syn->s0.LoLoLoLo[0] )
    {
      latlon_to_MMM ( syn->s0.MMM, s->lat, s->lon ); // compute it
    }
    
  return 0;
}

References bufr2tac_subset_state::a, BUFR2TAC_DEBUG_LEVEL, bufr2tac_set_error(), synop_sec3::Da, bufr_atom_data::desc, DESCRIPTOR_VALUE_MISSING, grad_to_D(), synop_sec0::LaLaLa, bufr2tac_subset_state::lat, latlon_to_MMM(), synop_sec0::LoLoLoLo, bufr2tac_subset_state::lon, bufr_atom_data::mask, bufr2tac_subset_state::mask, synop_chunks::mask, synop_sec0::MMM, synop_sec0::Qc, synop_chunks::s0, synop_chunks::s3, SUBSET_MASK_HAVE_LATITUDE, SUBSET_MASK_LATITUDE_SOUTH, SUBSET_MASK_LONGITUDE_WEST, SYNOP_SEC3, synop_sec0::Ula, 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:

syn_parse_x06()

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

Parse a expanded descriptor with X = 06.

Parameters

syn	pointer to a struct synop_chunks where to set the results
s	pointer 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 67 of file bufr2tac_x06.c.

{
  int ia;
 
  if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
    return 0;
 
  switch ( s->a->desc.y )
    {
    case 1: // 0 06 001 . Longitude (High accuracy)
    case 2: // 0 06 002 . Longitude (Coarse)
      if ( s->val < 0.0 )
        s->mask |= SUBSET_MASK_LONGITUDE_WEST; // Sign for longitude
      s->mask |= SUBSET_MASK_HAVE_LONGITUDE;
      ia = ( int ) ( fabs ( s->val ) * 10.0 + 0.5 );
      sprintf ( syn->s0.LoLoLoLo, "%04d",ia );
      syn->s0.Ulo[0] = syn->s0.LoLoLoLo[2];
      s->lon = s->val;
      break;
 
    default:
      if ( BUFR2TAC_DEBUG_LEVEL > 1 && (s->a->mask & DESCRIPTOR_VALUE_MISSING) == 0 ) 
        bufr2tac_set_error ( s, 0, "syn_parse_x06()", "Descriptor not parsed" );
      break;
    }
 
  // check if set both LaLaLa and LoLoLoLo to set Qc
  if ( ( syn->s0.Qc[0] == 0 ) && syn->s0.LaLaLa[0] && syn->s0.LoLoLoLo[0] )
    {
      if ( s->mask & SUBSET_MASK_LATITUDE_SOUTH )
        {
          if ( s->mask & SUBSET_MASK_LONGITUDE_WEST )
            strcpy ( syn->s0.Qc, "5" );
          else
            strcpy ( syn->s0.Qc, "3" );
        }
      else
        {
          if ( s->mask & SUBSET_MASK_LONGITUDE_WEST )
            strcpy ( syn->s0.Qc, "7" );
          else
            strcpy ( syn->s0.Qc, "1" );
        }
    }
 
  // check if about MMM
  if ( ( syn->s0.MMM[0] == 0 ) && syn->s0.LaLaLa[0] && syn->s0.LoLoLoLo[0] )
    {
      latlon_to_MMM ( syn->s0.MMM, s->lat, s->lon );
    }
 
  return 0;
}

References bufr2tac_subset_state::a, BUFR2TAC_DEBUG_LEVEL, bufr2tac_set_error(), bufr_atom_data::desc, DESCRIPTOR_VALUE_MISSING, synop_sec0::LaLaLa, bufr2tac_subset_state::lat, latlon_to_MMM(), synop_sec0::LoLoLoLo, bufr2tac_subset_state::lon, bufr_atom_data::mask, bufr2tac_subset_state::mask, synop_sec0::MMM, synop_sec0::Qc, synop_chunks::s0, SUBSET_MASK_HAVE_LONGITUDE, SUBSET_MASK_LATITUDE_SOUTH, SUBSET_MASK_LONGITUDE_WEST, synop_sec0::Ulo, 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:

syn_parse_x07()

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

Parse a expanded descriptor with X = 07.

Parameters

syn	pointer to a struct synop_chunks where to set the results
s	pointer 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 65 of file bufr2tac_x07.c.

{
  // this is to avoid warning
  if ( syn == NULL )
    {
      return 1;
    }
 
  switch ( s->a->desc.y )
    {
    case 1: // 0 07 001 . Heigh of station
    case 30: // 0 07 030 . Height of station ground above msl
    case 31: // 0 07 031 . Height of barometer above msl
      if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
        {
          return 0;
        }
      if ( syn->s0.h0h0h0h0[0] == 0 )
        {
          if (s->ival > 9999 || s->ival < -9999)
            return 1;
          sprintf ( syn->s0.h0h0h0h0, "%04d", s->ival );
          syn->s0.im[0] = '1';// set unit as m
          s->mask |= SUBSET_MASK_HAVE_ALTITUDE;
        }
      s->alt = s->val;
      break;
 
    case 4: // 0 07 004 . Pressure at standard level
      if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
        {
          return 0;
        }
      if ( s->ival == 100000 )
        {
          strcpy ( syn->s1.a3, "1" );
        }
      else if ( s->ival == 92500 )
        {
          strcpy ( syn->s1.a3, "2" );
        }
      else if ( s->ival == 85000 )
        {
          strcpy ( syn->s1.a3, "8" );
        }
      else if ( s->ival == 70000 )
        {
          strcpy ( syn->s1.a3, "7" );
        }
      else if ( s->ival == 50000 )
        {
          strcpy ( syn->s1.a3, "5" );
        }
      break;
 
    case 21: // 0 07 021 . Elevation angle
      if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
        {
          return 0;
        }
      grad_to_ec ( syn->s3.ec, s->val );
      syn->mask |= SYNOP_SEC3;
      break;
 
    case 32: // 0 07 032 Height of sensor above local ground
      if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
        {
          s->hsensor = -999.9; // clean value
          return 0;
        }
      s->hsensor = s->val;
      break;
 
    case 33: // 0 07 033 Height of sensor above water surface
      if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
        {
          s->hwsensor = -999.9; // clean value
          return 0;
        }
      s->hwsensor = s->val;
      break;
 
    default:
      if ( BUFR2TAC_DEBUG_LEVEL > 1 && (s->a->mask & DESCRIPTOR_VALUE_MISSING) == 0 ) 
        bufr2tac_set_error ( s, 0, "syn_parse_x07()", "Descriptor not parsed" );
      break;
    }
 
  return 0;
}

References bufr2tac_subset_state::a, synop_sec1::a3, bufr2tac_subset_state::alt, BUFR2TAC_DEBUG_LEVEL, bufr2tac_set_error(), bufr_atom_data::desc, DESCRIPTOR_VALUE_MISSING, synop_sec3::ec, grad_to_ec(), synop_sec0::h0h0h0h0, bufr2tac_subset_state::hsensor, bufr2tac_subset_state::hwsensor, synop_sec0::im, bufr2tac_subset_state::ival, bufr_atom_data::mask, bufr2tac_subset_state::mask, synop_chunks::mask, synop_chunks::s0, synop_chunks::s1, synop_chunks::s3, SUBSET_MASK_HAVE_ALTITUDE, SYNOP_SEC3, 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:

syn_parse_x08()

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

Parse a expanded descriptor with X = 08.

Parameters

syn	pointer to a struct synop_chunks where to set the results
s	pointer 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 37 of file bufr2tac_x08.c.

{
  if ( syn == NULL )
    {
      return 1;
    }
 
  switch ( s->a->desc.y )
    {
    case 2: // 0 08 002 . Vertical significance (surface observations)
      if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
        {
          s->clayer = 0; // clean vertical significance;
          return 0;
        }
 
      if ( s->ival == 21 || s->ival == 1 )
        {
          s->clayer = 1;  // first cloud layer or first no CB layer
        }
      else if ( s->ival == 22 || s->ival == 2 )
        {
          s->clayer = 2;  // second cloud layer or second no CB layer
        }
      else if ( s->ival == 23 || s->ival == 3 )
        {
          s->clayer = 3;  // third cloud layer or third no CB layer
        }
      else if ( s->ival == 24 || s->ival == 4 )
        {
          s->clayer = 4;  // fourth cloud layer or CB layer
        }
      else if ( s->ival == 10 )
        {
          s->clayer = -1; // base of cloud layer below level station and top over level station
        }
      else if ( s->ival == 11 )
        {
          s->clayer = -2; // base and top of cloud layer below level station
        }
      else if ( s->ival <= 9 && s->ival >= 7 )
        {
          s->clayer = s->ival;
        }
      else if ( s->ival == 5 || s->ival == 62 )
        {
          // 5 should be used for N = 9 and 62 for N = 0
          s->clayer = s->ival;
        }
      break;
 
    case 22:  // 0 08 022 . Total number
    case 23:  // 0 08 023 . First-order statistics
    case 24:  // 0 08 024 . Difference statistics
      if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
        {
          return 0;
        }
      if ( s->isq )
        {
          s->isq = 0;
        }
      else
        {
          s->isq = 1;
        }
      break;
 
    default:
      if ( BUFR2TAC_DEBUG_LEVEL > 1 && (s->a->mask & DESCRIPTOR_VALUE_MISSING) == 0 ) 
        bufr2tac_set_error ( s, 0, "syn_parse_x08()", "Descriptor not parsed" );
      break;
    }
  return 0;
}

References bufr2tac_subset_state::a, BUFR2TAC_DEBUG_LEVEL, bufr2tac_set_error(), bufr2tac_subset_state::clayer, bufr_atom_data::desc, DESCRIPTOR_VALUE_MISSING, bufr2tac_subset_state::isq, bufr2tac_subset_state::ival, bufr_atom_data::mask, 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:

syn_parse_x10()

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

Parse a expanded descriptor with X = 10.

Parameters

syn	pointer to a s if ( BUFR2TAC_DEBUG_LEVEL > 0 ) bufr2tac_set_error ( s, 0, "syn_parse_x08()", "Descriptor not parsed" ); truct synop_chunks where to set the results
s	pointer 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 87 of file bufr2tac_x10.c.

{
  char aux[16];
 
  if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
    {
      return 0;
    }
 
  switch ( s->a->desc.y )
    {
    case 4: // 0 10 004 . Pressure
      pascal_to_PPPP ( aux, s->val );
      strcpy ( syn->s1.PoPoPoPo, aux );
      syn->mask |= SYNOP_SEC1;
      break;
 
    case 9: // 0 10 009. Geopotential at standard level
      sprintf ( syn->s1.hhh, "%03d", abs(s->ival) % 1000 );
      syn->mask |= SYNOP_SEC1;
      break;
 
    case 51: // 0 10 051 . Pressure reduced to mean sea level
      pascal_to_PPPP ( aux, s->val );
      memcpy ( syn->s1.PPPP, aux, 4 );
      syn->s1.PPPP[4] = 0;
      syn->mask |= SYNOP_SEC1;
      break;
 
    case 61: // 0 10 061 . 3-hour pressure change
      pascal_to_ppp ( aux, s->val );
      memcpy(syn->s1.ppp, aux, 3);
      syn->s1.ppp[3] = 0;
      syn->mask |= SYNOP_SEC1;
      break;
 
    case 62: // 0 10 062 . 24-hour pressure change
      pascal_to_ppp ( aux, s->val );
      memcpy ( syn->s3.ppp24, aux, 3 );
      syn->s3.ppp24[3] = 0;
      if ( s->val >= 0 )
        {
          strcpy ( syn->s3.snp24, "8" );
        }
      else
        {
          strcpy ( syn->s3.snp24, "9" );
        }
      syn->mask |= SYNOP_SEC3;
      break;
 
    case 63: // 0 10 063 . Characteristic of pressure tendency
      if ( s->ival > 9 || s->ival < 0)
        return 1;
      sprintf ( syn->s1.a, "%1d",s->ival );
      syn->mask |= SYNOP_SEC1;
      break;
 
    default:
      if ( BUFR2TAC_DEBUG_LEVEL > 1 && (s->a->mask & DESCRIPTOR_VALUE_MISSING) == 0 ) 
        bufr2tac_set_error ( s, 0, "syn_parse_x10()", "Descriptor not parsed" );
      break;
    }
  return 0;
}

References bufr2tac_subset_state::a, synop_sec1::a, BUFR2TAC_DEBUG_LEVEL, bufr2tac_set_error(), bufr_atom_data::desc, DESCRIPTOR_VALUE_MISSING, synop_sec1::hhh, bufr2tac_subset_state::ival, bufr_atom_data::mask, synop_chunks::mask, pascal_to_ppp(), pascal_to_PPPP(), synop_sec1::PoPoPoPo, synop_sec1::ppp, synop_sec3::ppp24, synop_sec1::PPPP, synop_chunks::s1, synop_chunks::s3, synop_sec3::snp24, SYNOP_SEC1, SYNOP_SEC3, 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:

syn_parse_x11()

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

Parse a expanded descriptor with X = 11.

Parameters

syn	pointer to a struct synop_chunks where to set the results
s	pointer 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.

{
 
  if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
    {
      return 0;
    }
 
  switch ( s->a->desc.y )
    {
    case 1: // 0 11 001 . Wind direction
    case 11: // 0 11 011 . Wind direction at 10 meters
      sprintf ( syn->s1.dd, "%02d", abs((s->ival + 5 ) / 10) % 100 );
      syn->mask |= SYNOP_SEC1;
      break;
 
    case 2: // 0 11 002 . Wind speed
    case 12: // 0 11 012 . Wind speed at 10 meters
      if ( syn->s0.iw[0] == '4' )
        {
          s->val *= 1.94384449;
        }
      if ( s->val < 100.0 )
        {
          sprintf ( syn->s1.ff, "%02d", ( int ) ( s->val + 0.5 ) );
        }
      else
        {
          sprintf ( syn->s1.ff,"99" );
          sprintf ( syn->s1.fff, "%03d", ( int ) ( s->val + 0.5 ) );
        }
      syn->mask |= SYNOP_SEC1;
      break;
 
    case 41: // 0 11 041 . Max wind gust speed
      if ( syn->s3.d9.n == SYNOP_NMISC )
        {
          return 0; // No more groups space
        }
        
      if ( s->itval == -600 )
        {
          if ( syn->mask & SUBSET_MASK_HAVE_GUST10 )
            {
              break; // Already have gust for 10 minutes
            }
          sprintf ( syn->s3.d9.misc[syn->s3.d9.n].SpSp, "910" );
          s->SnSn = 910;
          if ( syn->s0.iw[0] == '4' )
            {
              s->val *= 1.94384449; // original value was in m/s. So it change to knots
            }
          if ( s->val < 100.0 )
            {
              sprintf ( syn->s3.d9.misc[syn->s3.d9.n].spsp, "%02d", ( int ) ( s->val + 0.5 ) );
            }
          else
            {
              // Case more than 99 knots
              sprintf ( syn->s3.d9.misc[syn->s3.d9.n].spsp,"99" );
              syn->s3.d9.n++;
              sprintf ( syn->s3.d9.misc[syn->s3.d9.n].SpSp, "00" );
              sprintf ( syn->s3.d9.misc[syn->s3.d9.n].spsp, "%03d", ( int ) ( s->val + 0.5 ) );
            }
          syn->s3.d9.n++;
          syn->mask |= SUBSET_MASK_HAVE_GUST10;
          syn->mask |= SYNOP_SEC3;
        }
      else if ( s->itval )
        {
          if ( s->mask & SUBSET_MASK_HAVE_GUST )
            {
              sprintf ( syn->s5.d9.misc[syn->s5.d9.n].SpSp, "907" );
              secs_to_tt ( syn->s5.d9.misc[syn->s5.d9.n].spsp, s->itval );
              syn->s5.d9.n++;
              sprintf ( syn->s5.d9.misc[syn->s5.d9.n].SpSp, "911" );
              s->SnSn = 911;
              if ( syn->s0.iw[0] == '4' )
                {
                  s->val *= 1.94384449;
                }
              if ( s->val < 100.0 )
                {
                  sprintf ( syn->s5.d9.misc[syn->s5.d9.n].spsp, "%02d", ( int ) ( s->val + 0.5 ) );
                }
              else
                {
                  sprintf ( syn->s5.d9.misc[syn->s5.d9.n].spsp,"99" );
                  syn->s5.d9.n++;
                  sprintf ( syn->s5.d9.misc[syn->s5.d9.n].SpSp, "00" );
                  sprintf ( syn->s5.d9.misc[syn->s5.d9.n].spsp, "%03d", ( int ) ( s->val + 0.5 ) );
                }
              syn->s5.d9.n++;
              syn->mask |= SYNOP_SEC5;
            }
          else
            {
              sprintf ( syn->s3.d9.misc[syn->s3.d9.n].SpSp, "907" );
              secs_to_tt ( syn->s3.d9.misc[syn->s3.d9.n].spsp, s->itval );
              syn->s3.d9.n++;
              sprintf ( syn->s3.d9.misc[syn->s3.d9.n].SpSp, "911" );
              s->SnSn = 911;
              if ( syn->s0.iw[0] == '4' )
                {
                  s->val *= 1.94384449;
                }
              if ( s->val < 100.0 )
                {
                  sprintf ( syn->s3.d9.misc[syn->s3.d9.n].spsp, "%02d", ( int ) ( s->val + 0.5 ) );
                }
              else
                {
                  sprintf ( syn->s3.d9.misc[syn->s3.d9.n].spsp,"99" );
                  syn->s3.d9.n++;
                  sprintf ( syn->s3.d9.misc[syn->s3.d9.n].SpSp, "00" );
                  sprintf ( syn->s3.d9.misc[syn->s3.d9.n].spsp, "%03d", ( int ) ( s->val + 0.5 ) );
                }
              syn->s3.d9.n++;
              syn->mask |= SYNOP_SEC3;
              s->mask |= SUBSET_MASK_HAVE_GUST;
            }
        }
      break;
 
    case 42: // 0 11 042 . Max wind speed (10-minutes mean)
      if ( syn->s3.d9.n == SYNOP_NMISC )
        {
          return 0;
        }
      sprintf ( syn->s3.d9.misc[syn->s3.d9.n].SpSp, "907" );
      secs_to_tt ( syn->s3.d9.misc[syn->s3.d9.n].spsp, s->itval );
      syn->s3.d9.n++;
      sprintf ( syn->s3.d9.misc[syn->s3.d9.n].SpSp, "912" );
      s->SnSn = 912;
      if ( syn->s0.iw[0] == '4' )
        {
          s->val *= 1.94384449;
        }
      if ( s->val < 100.0 )
        {
          sprintf ( syn->s3.d9.misc[syn->s3.d9.n].spsp, "%02d", ( int ) ( s->val + 0.5 ) );
        }
      else
        {
          sprintf ( syn->s3.d9.misc[syn->s3.d9.n].spsp,"99" );
          syn->s3.d9.n++;
          sprintf ( syn->s3.d9.misc[syn->s3.d9.n].SpSp, "00" );
          sprintf ( syn->s3.d9.misc[syn->s3.d9.n].spsp, "%03d", ( int ) ( s->val + 0.5 ) );
        }
      syn->s3.d9.n++;
      syn->mask |= SYNOP_SEC3;
      break;
 
    case 43: // 0 11 043 . Max wind gust direction
      if ( BUFR2TAC_DEBUG_LEVEL > 1 && (s->a->mask & DESCRIPTOR_VALUE_MISSING) == 0 ) 
        bufr2tac_set_error ( s, 0, "syn_parse_x11()", "Descriptor not parsed" );
      break;
 
    case 84: // 0 11 084 . Wind speed in knots
      if ( syn->s0.iw[0] == '1' )
        {
          s->val /= 1.94384449;
        }
      if ( s->val < 100.0 )
        {
          sprintf ( syn->s1.ff, "%02d", ( int ) ( s->val + 0.5 ) );
        }
      else
        {
          sprintf ( syn->s1.ff,"99" );
          sprintf ( syn->s1.fff, "%03d", ( int ) ( s->val + 0.5 ) );
        }
      syn->mask |= SYNOP_SEC1;
      break;
 
    case 86: // 0 11 086 . Max wind speed in knots
      if ( syn->s3.d9.n == SYNOP_NMISC )
        {
          return 0;
        }
      if ( s->itval == -600 )
        {
          sprintf ( syn->s3.d9.misc[syn->s3.d9.n].SpSp, "910" );
          if ( syn->s0.iw[0] == '1' )
            {
              s->val /= 1.94384449; // original values in knots. passed to m/s
            }
          if ( s->val < 100.0 )
            {
              sprintf ( syn->s3.d9.misc[syn->s3.d9.n].spsp, "%02d", ( int ) ( s->val + 0.5 ) );
            }
          else
            {
              sprintf ( syn->s3.d9.misc[syn->s3.d9.n].spsp,"99" );
              syn->s3.d9.n++;
              sprintf ( syn->s3.d9.misc[syn->s3.d9.n].SpSp, "00" );
              sprintf ( syn->s3.d9.misc[syn->s3.d9.n].spsp, "%03d", ( int ) ( s->val + 0.5 ) );
            }
          syn->mask |= SYNOP_SEC3;
          syn->s3.d9.n++;
        }
      else if ( s->itval )
        {
          if ( s->mask & SUBSET_MASK_HAVE_GUST )
            {
              sprintf ( syn->s5.d9.misc[syn->s5.d9.n].SpSp, "907" );
              secs_to_tt ( syn->s5.d9.misc[syn->s5.d9.n].spsp, s->itval );
              syn->s5.d9.n++;
              sprintf ( syn->s5.d9.misc[syn->s5.d9.n].SpSp, "911" );
              if ( syn->s0.iw[0] == '1' )
                {
                  s->val /= 1.94384449;
                }
              if ( s->val < 100.0 )
                {
                  sprintf ( syn->s5.d9.misc[syn->s5.d9.n].spsp, "%02d", ( int ) ( s->val + 0.5 ) );
                }
              else
                {
                  sprintf ( syn->s5.d9.misc[syn->s5.d9.n].spsp,"99" );
                  syn->s5.d9.n++;
                  sprintf ( syn->s5.d9.misc[syn->s5.d9.n].SpSp, "00" );
                  sprintf ( syn->s5.d9.misc[syn->s5.d9.n].spsp, "%03d", ( int ) ( s->val + 0.5 ) );
                }
              syn->s5.d9.n++;
              syn->mask |= SYNOP_SEC5;
            }
          else
            {
              sprintf ( syn->s3.d9.misc[syn->s3.d9.n].SpSp, "907" );
              secs_to_tt ( syn->s3.d9.misc[syn->s3.d9.n].spsp, s->itval );
              syn->s3.d9.n++;
              sprintf ( syn->s3.d9.misc[syn->s3.d9.n].SpSp, "911" );
              if ( syn->s0.iw[0] == '1' )
                {
                  s->val /= 1.94384449;
                }
              if ( s->val < 100.0 )
                {
                  sprintf ( syn->s3.d9.misc[syn->s3.d9.n].spsp, "%02d", ( int ) ( s->val + 0.5 ) );
                }
              else
                {
                  sprintf ( syn->s3.d9.misc[syn->s3.d9.n].spsp,"99" );
                  syn->s3.d9.n++;
                  sprintf ( syn->s3.d9.misc[syn->s3.d9.n].SpSp, "00" );
                  sprintf ( syn->s3.d9.misc[syn->s3.d9.n].spsp, "%03d", ( int ) ( s->val + 0.5 ) );
                }
              syn->s3.d9.n++;
              syn->mask |= SYNOP_SEC3;
              s->mask |= SUBSET_MASK_HAVE_GUST;
            }
        }
      break;
 
    default:
      if ( BUFR2TAC_DEBUG_LEVEL > 1 && (s->a->mask & DESCRIPTOR_VALUE_MISSING) == 0 ) 
        bufr2tac_set_error ( s, 0, "syn_parse_x11()", "Descriptor not parsed" );
      break;
    }
  return 0;
}

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:

syn_parse_x12()

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

Parse a expanded descriptor with X = 12.

Parameters

syn	pointer to a struct synop_chunks where to set the results
s	pointer 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 220 of file bufr2tac_x12.c.

{
  char aux[16];
 
  if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
    {
      return 0;
    }
 
  switch ( s->a->desc.y )
    {
    case 1: // 0 12 001 . Air temperature
    case 4: // 0 12 004 . Air temperatura at 2 m
    case 101: // 0 12 101 . Air temperature
    case 104: // 0 12 104 . Air temperature at 2 m
      if ( syn->s1.TTT[0] == 0 )
        {
          if ( kelvin_to_snTTT ( aux, s->val ) )
            {
              syn->s1.sn1[0] = aux[0];
              strcpy ( syn->s1.TTT, aux + 1 );
              syn->mask |= SYNOP_SEC1;
            }
          else if ( BUFR2TAC_DEBUG_LEVEL > 0 )
            bufr2tac_set_error ( s, 1, "syn_parse_x12()->kelvin_to_snTTT()", "Unspected parse problem" );
        }
      break;
 
    case 3: // 0 12 003 . Dewpoint temperature
    case 6: // 0 12 006 . Dewpoint temperature at 2 m
    case 103: // 0 12 103 . Dewpoint temperature
    case 106: // 0 12 106 . Dewpoint temperature at 2 m
      if ( syn->s1.TdTdTd[0] == 0 )
        {
          if ( kelvin_to_snTTT ( aux, s->val ) )
            {
              syn->s1.sn2[0] = aux[0];
              strcpy ( syn->s1.TdTdTd, aux + 1 );
              syn->mask |= SYNOP_SEC1;
            }
          else if ( BUFR2TAC_DEBUG_LEVEL > 0 )
            bufr2tac_set_error ( s, 1, "syn_parse_x12()->kelvin_to_snTTT()", "Unspected parse problem" );
        }
      break;
 
    case 14: // 0 12 014 . Maximum temperature at 2 m , past 12 hours
    case 21: // 0 12 021 . Maximum temperature.
    case 114: // 0 12 114 . Maximum temperature at 2 m , past 12 hours
    case 116: // 0 12 116 . Maximum temperature at 2 m , past 24 hours
      if ( syn->s3.TxTxTx[0] == 0 && ( s->itval % ( 3 * 3600 ) ) == 0 ) // only for 3, 6 ... hours
        {
          if ( kelvin_to_snTTT ( aux, s->val ) )
            {
              syn->s3.snx[0] = aux[0];
              strcpy ( syn->s3.TxTxTx, aux + 1 );
              syn->mask |= SYNOP_SEC3;
            }
          else if ( BUFR2TAC_DEBUG_LEVEL > 0 )
            bufr2tac_set_error ( s, 1, "syn_parse_x12()->kelvin_to_snTTT()", "Unspected parse problem" );
        }
      break;
 
    case 11: // 0 12 011 . Maximum temperature at heigh and over the period specified
    case 111: // 0 12 111 . Maximum temperature at heigh and over the period specified
      if ( syn->s3.TxTxTx[0] == 0 &&
           ( s->hsensor >= 1.0 || s->hsensor <= 0 ) &&
           ( time_period_duration ( s ) % ( 12 * 3600 ) ) == 0 ) // only for 12 , 24 hours
        {
          if ( kelvin_to_snTTT ( aux, s->val ) )
            {
              syn->s3.snx[0] = aux[0];
              strcpy ( syn->s3.TxTxTx, aux + 1 );
              syn->mask |= SYNOP_SEC3;
            }
          else if ( BUFR2TAC_DEBUG_LEVEL > 0 )
            bufr2tac_set_error ( s, 1, "syn_parse_x12()->kelvin_to_snTTT()", "Unspected parse problem" );
        }
      break;
 
 
    case 15: // 0 12 015 . Minimum temperature at 2 m , past 12 hours
    case 22: // 0 12 022 . Minimum temperature.
    case 115: // 0 12 115 . Minimum temperature at 2 m , past 12 hours
    case 117: // 0 12 117 . Minimum temperature at 2 m , past 24 hours
      if ( syn->s3.TnTnTn[0] == 0 && ( s->itval % ( 3 * 3600 ) ) == 0 ) // only for 3, 6 ... hours
        {
          if ( kelvin_to_snTTT ( aux, s->val ) )
            {
              syn->s3.snn[0] = aux[0];
              strcpy ( syn->s3.TnTnTn, aux + 1 );
              syn->mask |= SYNOP_SEC3;
            }
          else if ( BUFR2TAC_DEBUG_LEVEL > 0 )
            bufr2tac_set_error ( s, 1, "syn_parse_x12()->kelvin_to_snTTT()", "Unspected parse problem" );
        }
      break;
 
    case 12: // 0 12 012 . Minimum temperature at heigh and over the period specified
    case 112: // 0 12 112 . Minimum temperature at heigh and over the period specified
      if ( syn->s3.TnTnTn[0] == 0 &&
           ( s->hsensor >= 1.0 || s->hsensor <= 0 ) &&
           ( time_period_duration ( s ) % ( 12 * 3600 ) ) == 0 ) // only for 12 , 24 hours
        {
          if ( kelvin_to_snTTT ( aux, s->val ) )
            {
              syn->s3.snn[0] = aux[0];
              strcpy ( syn->s3.TnTnTn, aux + 1 );
              syn->mask |= SYNOP_SEC3;
            }
          else if ( BUFR2TAC_DEBUG_LEVEL > 0 )
            bufr2tac_set_error ( s, 1, "syn_parse_x12()->kelvin_to_snTTT()", "Unspected parse problem" );
        }
      break;
 
    case 2: // 0 12 002 . Wet bulb temperature
    case 5: // 0 12 005 . Wet bulb temperature at 2 m
    case 102: // 0 12 102 . Wet bulb temperature
    case 105: // 0 12 105 . Wet bulb temperature at 2 m
      if ( syn->s2.TbTbTb[0] == 0 )
        {
          if ( kelvin_to_snTTT ( aux, s->val ) )
            {
              syn->s2.sw[0] = aux[0];
              strcpy ( syn->s2.TbTbTb, aux + 1 );
              syn->mask |= SYNOP_SEC2;
            }
          else if ( BUFR2TAC_DEBUG_LEVEL > 0 )
            bufr2tac_set_error ( s, 1, "syn_parse_x12()->kelvin_to_snTTT()", "Unspected parse problem" );
        }
      break;
 
    case 113: // 0 12 113 . Ground minimum temperature, past 12 hours
      if ( strcmp ( "6", syn->s0.A1 ) == 0 ||
           strcmp ( "3", syn->s0.A1 ) == 0 ||
           strcmp ( "2", syn->s0.A1 ) == 0
         ) // region III or VI
        {
          if ( kelvin_to_snTT ( aux, s->val ) )
            {
              strcpy ( syn->s3.jjj, aux );
              syn->mask |= SYNOP_SEC3;
            }
          else if ( BUFR2TAC_DEBUG_LEVEL > 0 )
            bufr2tac_set_error ( s, 1, "syn_parse_x12()->kelvin_to_snTT()", "Unspected parse problem" );
        }
      else if ( strcmp ( "1", syn->s0.A1 ) == 0 )
        {
          if ( kelvin_to_TT ( aux, s->val ) )
            {
              syn->s3.XoXoXoXo[0] = aux[0];
              syn->s3.XoXoXoXo[1] = aux[1];
              if ( syn->s3.XoXoXoXo[2] == 0 )
                {
                  syn->s3.XoXoXoXo[2] = '/';
                }
              if ( syn->s3.XoXoXoXo[3] == 0 )
                {
                  syn->s3.XoXoXoXo[3] = '/';
                }
              syn->mask |= SYNOP_SEC3;
            }
          else if ( BUFR2TAC_DEBUG_LEVEL > 0 )
            bufr2tac_set_error ( s, 1, "syn_parse_x12()->kelvin_to_snTT()", "Unspected parse problem" );
        }
      break;
 
    case 121: // 0 12 121 . Ground minimum temperature (at the time of observation)
      if ( strcmp ( "2", syn->s0.A1 ) == 0 ) // region II
        {
          if ( kelvin_to_snTT ( aux, s->val ) )
            {
              syn->s3.XoXoXoXo[1] = aux[0];
              syn->s3.XoXoXoXo[2] = aux[1];
              syn->s3.XoXoXoXo[3] = aux[2];
              syn->mask |= SYNOP_SEC3;
            }
          else if ( BUFR2TAC_DEBUG_LEVEL > 0 )
            bufr2tac_set_error ( s, 1, "syn_parse_x12()->kelvin_to_snTT()", "Unspected parse problem" );
        }
      break;
 
    case 120: // 0 12 120 . Ground temperature
      if ( strcmp ( "2", syn->s0.A1 ) == 0 ) // Only for Region II
        {
          if ( kelvin_to_snTT ( aux, s->val ) )
            {
              if ( syn->s3.E1[0] )
                syn->s3.XoXoXoXo[0] = '/';
              else if ( syn->s3.E[0] )
                syn->s3.XoXoXoXo[0] = syn->s3.E[0];
              syn->s3.XoXoXoXo[1] = aux[0];
              syn->s3.XoXoXoXo[2] = aux[1];
              syn->s3.XoXoXoXo[3] = aux[2];
            }
          else if ( BUFR2TAC_DEBUG_LEVEL > 0 )
            bufr2tac_set_error ( s, 1, "syn_parse_x12()->kelvin_to_snTT()", "Unspected parse problem" );
        }
      break;
 
    case 122: // 0 12 122 . Ground minimum temperature during preceding night
      if ( strcmp ( "1", syn->s0.A1 ) == 0 ) // Only for Region I
        {
          if ( kelvin_to_TT ( aux, s->val ) )
            {
              syn->s3.XoXoXoXo[0] = aux[0];
              syn->s3.XoXoXoXo[1] = aux[1];
              if ( syn->s3.XoXoXoXo[2] == 0 )
                {
                  syn->s3.XoXoXoXo[2] = '/';
                }
              if ( syn->s3.XoXoXoXo[3] == 0 )
                {
                  syn->s3.XoXoXoXo[3] = '/';
                }
              syn->mask |= SYNOP_SEC3;
            }
          else if ( BUFR2TAC_DEBUG_LEVEL > 0 )
            bufr2tac_set_error ( s, 1, "syn_parse_x12()->kelvin_to_TT()", "Unspected parse problem" );
        }
      else if ( strcmp ( "2", syn->s0.A1 ) == 0 ||
                strcmp ( "3", syn->s0.A1 ) == 0 ) // Region II and III
        {
          if ( kelvin_to_snTT ( aux, s->val ) )
            {
              strcpy ( syn->s3.jjj, aux );
              syn->mask |= SYNOP_SEC3;
            }
        }
      break;
 
    default:
      if ( BUFR2TAC_DEBUG_LEVEL > 1 && (s->a->mask & DESCRIPTOR_VALUE_MISSING) == 0 ) 
        bufr2tac_set_error ( s, 0, "syn_parse_x12()", "Descriptor not parsed" );
      break;
    }
  return 0;
}

References bufr2tac_subset_state::a, synop_sec0::A1, BUFR2TAC_DEBUG_LEVEL, bufr2tac_set_error(), bufr_atom_data::desc, DESCRIPTOR_VALUE_MISSING, synop_sec3::E, synop_sec3::E1, bufr2tac_subset_state::hsensor, bufr2tac_subset_state::itval, synop_sec3::jjj, kelvin_to_snTT(), kelvin_to_snTTT(), kelvin_to_TT(), bufr_atom_data::mask, synop_chunks::mask, synop_chunks::s0, synop_chunks::s1, synop_chunks::s2, synop_chunks::s3, synop_sec1::sn1, synop_sec1::sn2, synop_sec3::snn, synop_sec3::snx, synop_sec2::sw, SYNOP_SEC1, SYNOP_SEC2, SYNOP_SEC3, synop_sec2::TbTbTb, synop_sec1::TdTdTd, time_period_duration(), synop_sec3::TnTnTn, synop_sec1::TTT, synop_sec3::TxTxTx, bufr2tac_subset_state::val, synop_sec3::XoXoXoXo, 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:

syn_parse_x13()

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

Parse a expanded descriptor with X = 13.

Parameters

syn	pointer to a struct synop_chunks where to set the results
s	pointer 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 201 of file bufr2tac_x13.c.

{
  int tpd, hr;
  char aux[8];
 
  if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
    {
      return 0;
    }
 
  switch ( s->a->desc.y )
    {
    case 3: // 0 13 003 . Relative humidity %
      if ( s->ival < 0 || s->ival > 100 )
        {
          return 0;
        }
      sprintf ( syn->s1.UUU, "%03d", s->ival );
      syn->mask |= SYNOP_SEC1;
      break;
 
    case 11: // 0 13 011 . Total precipitation
        if ( s->val < 0.0 )
        {
           if (s->val < -0.11 || s->val > -0.09)  
             return 0; 
        }
      tpd = time_period_duration ( s );
      hr = hour_rounded ( syn );
      if ( tpd ==  3600 )
        {
          if ( syn->s3.RRR[0] == 0 )
            {
              if ( strcmp ( "1", syn->s0.A1 ) == 0 ||
                   strcmp ( "2", syn->s0.A1 ) == 0 ||
                   strcmp ( "3", syn->s0.A1 ) == 0 ||
                   strcmp ( "4", syn->s0.A1 ) == 0 ||
                   strcmp ( "5", syn->s0.A1 ) == 0 ||
                   strcmp ( "6", syn->s0.A1 ) == 0 )
                {
                  /*if ( hr % 3)
                    {*/
                  syn->s3.tr[0] = '5'; // 1 hour
                  prec_to_RRR ( syn->s3.RRR, s->val );
                  syn->mask |= SYNOP_SEC3;
                  /*}*/
                }
            }
          else if ( syn->s5.RRR[0] == 0 )
            {
              syn->s5.tr[0] = '5'; // 1 hour
              prec_to_RRR ( syn->s5.RRR, s->val );
              syn->mask |= SYNOP_SEC5;
            }
        }
      else if ( tpd == 7200 )
        {
          if ( syn->s1.RRR[0] == 0 )
            {
              if ( strcmp ( "6", syn->s0.A1 ) )
                {
                  //Not for REG IV
                  syn->s1.tr[0] = '6'; // 2 hour
                  prec_to_RRR ( syn->s1.RRR, s->val );
                  syn->mask |= SYNOP_SEC1;
                }
            }
        }
      else if ( tpd == 10800 )
        {
          if ( ( hr % 3 ) == 0 )
            {
              if ( syn->s3.tr[0] == '5' )
                {
                  syn->s5.tr[0] = '5';
                  strcpy ( syn->s5.RRR, syn->s3.RRR );
                  syn->mask |= SYNOP_SEC5;
                }
              syn->s3.tr[0] = '7'; // 3 hour
              prec_to_RRR ( syn->s3.RRR, s->val );
              syn->mask |= SYNOP_SEC3;
            }
        }
      else if ( tpd == ( 6 * 3600 ) )
        {
          if ( strcmp ( "1", syn->s0.A1 ) == 0 )
            {
              if ( ( hr % 12 ) == 0 )
                {
                  syn->s1.tr[0] = '1'; // 6 hour
                  prec_to_RRR ( syn->s1.RRR, s->val );
                  syn->mask |= SYNOP_SEC1;
                }
            }
          else if ( strcmp ( "2", syn->s0.A1 ) == 0 )
            {
              if ( ( hr % 3 )  == 0 )
                {
                  syn->s1.tr[0] = '1'; // 6 hour
                  prec_to_RRR ( syn->s1.RRR, s->val );
                  syn->mask |= SYNOP_SEC1;
                }
            }
          else if ( strcmp ( "3", syn->s0.A1 ) == 0 )
            {
              if ( hr == 0 ||
                   hr == 6 ||
                   hr == 18 )
                {
                  syn->s1.tr[0] = '1'; // 6 hour
                  prec_to_RRR ( syn->s1.RRR, s->val );
                  syn->mask |= SYNOP_SEC1;
                }
            }
          else if ( strcmp ( "4", syn->s0.A1 ) == 0 )
            {
              if ( ( hr % 6 ) == 0 )
                {
                  syn->s1.tr[0] = '1'; // 6 hour
                  prec_to_RRR ( syn->s1.RRR, s->val );
                  syn->mask |= SYNOP_SEC1;
                }
            }
          else if ( strcmp ( "5", syn->s0.A1 ) == 0 )
            {
              if ( hr == 6  ||
                   hr == 12 ||
                   hr == 18 )
                {
                  syn->s1.tr[0] = '1'; // 6 hour
                  prec_to_RRR ( syn->s1.RRR, s->val );
                  syn->mask |= SYNOP_SEC1;
                }
            }
          else if ( strcmp ( "6", syn->s0.A1 ) == 0 )
            {
              if ( hr == 0 ||
                   hr == 18 )
                {
                  syn->s1.tr[0] = '1'; // 6 hour
                  prec_to_RRR ( syn->s1.RRR, s->val );
                  syn->mask |= SYNOP_SEC1;
                }
            }
          else if ( strcmp ( "7", syn->s0.A1 ) == 0 )
            {
              if ( hr == 6 )
                {
                  syn->s1.tr[0] = '1'; // 6 hour
                  prec_to_RRR ( syn->s1.RRR, s->val );
                  syn->mask |= SYNOP_SEC1;
                }
            }
 
          // last chance
          if ( syn->s1.RRR[0] == 0 )
            {
              if ( ( hr % 6 ) == 0 )
                {
                  syn->s1.tr[0] = '1'; // 6 hour
                  prec_to_RRR ( syn->s1.RRR, s->val );
                  syn->mask |= SYNOP_SEC1;
                }
            }
        }
      else if ( tpd == ( 9 * 3600 ) )
        {
          if ( syn->s3.RRR[0] == 0 )
            {
              syn->s3.tr[0] = '8'; // 9 hour
              prec_to_RRR ( syn->s3.RRR, s->val );
              syn->mask |= SYNOP_SEC3;
            }
          else if ( syn->s5.RRR[0] == 0 )
            {
              syn->s5.tr[0] = '8'; // 9 hour
              prec_to_RRR ( syn->s5.RRR, s->val );
              syn->mask |= SYNOP_SEC5;
            }
        }
      else if ( tpd == ( 12 * 3600 ) )
        {
          if ( strcmp ( "1", syn->s0.A1 ) == 0 )
            {
              if ( hr == 18 )
                {
                  syn->s1.tr[0] = '2'; // 12 hour
                  prec_to_RRR ( syn->s1.RRR, s->val );
                  syn->mask |= SYNOP_SEC1;
                }
            }
          else if ( strcmp ( "2", syn->s0.A1 ) == 0 )
            {
              if ( ( hr % 3 ) == 0 )
                {
                  syn->s1.tr[0] = '2'; // 12 hour
                  prec_to_RRR ( syn->s1.RRR, s->val );
                  syn->mask |= SYNOP_SEC1;
                }
            }
          else if ( strcmp ( "6", syn->s0.A1 ) == 0 )
            {
              if ( ( hr % 12 ) == 6 )
                {
                  syn->s1.tr[0] = '2'; // 12 hour
                  prec_to_RRR ( syn->s1.RRR, s->val ) ;
                  syn->mask |= SYNOP_SEC1;
                }
              else if ( strcmp( syn->s0.II, "08") == 0  && syn->s0.iii[0] == '5' ) // Portugal exception
                {
                  syn->s1.tr[0] = '2'; // 12 hour
                  prec_to_RRR ( syn->s1.RRR, s->val );
                  syn->mask |= SYNOP_SEC1;
                }
            }
          else if ( strcmp ( "7", syn->s0.A1 ) == 0 )
            {
              if ( hr == 12 )
                {
                  syn->s1.tr[0] = '2'; // 12 hour
                  prec_to_RRR ( syn->s1.RRR, s->val );
                  syn->mask |= SYNOP_SEC1;
                }
            }
 
          // last chance
          if ( syn->s1.RRR[0] == 0 )
            {
              if ( ( hr % 6 ) == 0 )
                {
                  syn->s1.tr[0] = '2'; // 12 hour
                  prec_to_RRR ( syn->s1.RRR, s->val );
                  syn->mask |= SYNOP_SEC1;
                }
              else if ( ( hr % 3 ) == 0 )
                {
                  if ( syn->s3.RRR[0] == 0 )
                    {
                      syn->s3.tr[0] = '2'; // 12 hour
                      prec_to_RRR ( syn->s3.RRR, s->val );
                      syn->mask |= SYNOP_SEC3;
                    }
                  else if ( syn->s3.tr[0] == '1' ||
                            syn->s3.tr[0] == '5' )
                    {
                      strcpy ( syn->s5.tr, syn->s3.tr );
                      strcpy ( syn->s5.RRR, syn->s3.RRR );
                      syn->mask |= SYNOP_SEC5;
                      syn->s3.tr[0] = '2'; // 12 hour
                      prec_to_RRR ( syn->s3.RRR, s->val );
                      syn->mask |= SYNOP_SEC3;
                    }
                }
            }
        }
      else if ( tpd == ( 15 * 3600 ) )
        {
          if ( syn->s3.RRR[0] == 0 )
            {
              syn->s3.tr[0] = '9'; // 15 hour
              prec_to_RRR ( syn->s3.RRR, s->val );
              syn->mask |= SYNOP_SEC3;
            }
          else if ( syn->s5.RRR[0] == 0 )
            {
              syn->s5.tr[0] = '9'; // 15 hour
              prec_to_RRR ( syn->s5.RRR, s->val );
              syn->mask |= SYNOP_SEC5;
            }
        }
      else if ( tpd == ( 18 * 3600 ) )
        {
          if ( strcmp ( "7", syn->s0.A1 ) == 0 )
            {
              if ( hr == 18 )
                {
                  syn->s1.tr[0] = '3'; // 12 hour
                  prec_to_RRR ( syn->s1.RRR, s->val );
                  syn->mask |= SYNOP_SEC1;
                }
            }
        }
      else if ( tpd == ( 24 * 3600 ) )
        {
          if ( strcmp ( "1", syn->s0.A1 ) == 0 )
            {
              if ( hr == 6 )
                {
                  syn->s1.tr[0] = '4'; // 24 hour
                  prec_to_RRR ( syn->s1.RRR, s->val );
                  syn->mask |= SYNOP_SEC1;
                }
              prec_to_RRRR24 ( syn->s3.RRRR24, s->val );
              syn->mask |= SYNOP_SEC3;
            }
          else if ( strcmp ( "2", syn->s0.A1 ) == 0 )
            {
              prec_to_RRRR24 ( syn->s3.RRRR24, s->val );
              syn->mask |= SYNOP_SEC3;
            }
          else if ( strcmp ( "3", syn->s0.A1 ) == 0 )
            {
              if ( hr == 12 )
                {
                  syn->s1.tr[0] = '4'; // 24 hour
                  prec_to_RRR ( syn->s1.RRR, s->val );
                  syn->mask |= SYNOP_SEC1;
                }
              prec_to_RRRR24 ( syn->s3.RRRR24, s->val );
              syn->mask |= SYNOP_SEC3;
            }
          else if ( strcmp ( "4", syn->s0.A1 ) == 0 )
            {
              prec_to_RRRR24 ( syn->s3.RRRR24, s->val );
              syn->mask |= SYNOP_SEC3;
            }
          else if ( strcmp ( "5", syn->s0.A1 ) == 0 )
            {
              if ( hr == 0 )
                {
                  syn->s1.tr[0] = '4'; // 24 hour
                  prec_to_RRR ( syn->s1.RRR, s->val );
                  syn->mask |= SYNOP_SEC1;
                }
              prec_to_RRRR24 ( syn->s3.RRRR24, s->val );
              syn->mask |= SYNOP_SEC3;
            }
          else if ( strcmp ( "6", syn->s0.A1 ) == 0 )
            {
              if ( strcmp ( "07", syn->s0.II ) == 0 ) // France
                {
                  if ( strcmp ( "06", syn->e.HH ) == 0 )
                    {
                      prec_to_RRRR24 ( syn->s3.RRRR24, s->val );
                      syn->mask |= SYNOP_SEC3;
                    }
                }
              else
                {
                  prec_to_RRRR24 ( syn->s3.RRRR24, s->val );
                  syn->mask |= SYNOP_SEC3;
                }
            }
          else if ( strcmp ( "7", syn->s0.A1 ) == 0 )
            {
              if ( hr == 0 )
                {
                  syn->s1.tr[0] = '4'; // 24 hour
                  prec_to_RRR ( syn->s1.RRR, s->val );
                  syn->mask |= SYNOP_SEC1;
                }
            }
        }
      break;
 
    case 13: // 0 13 013 . Total snow depth
      if ( syn->s3.sss[0] == 0 )
        {
          total_snow_depth_to_sss ( syn->s3.sss, s->val );
          syn->mask |= SYNOP_SEC3;
        }
      break;
 
    case 19: // 0 13 019 . Total precipitaction past 1 hour
      hr = hour_rounded ( syn );
      if ( syn->s3.RRR[0] == 0 )
        {
          if ( strcmp ( "1", syn->s0.A1 ) == 0 ||
               strcmp ( "2", syn->s0.A1 ) == 0 ||
               strcmp ( "3", syn->s0.A1 ) == 0 ||
               strcmp ( "4", syn->s0.A1 ) == 0 ||
               strcmp ( "5", syn->s0.A1 ) == 0 ||
               strcmp ( "6", syn->s0.A1 ) == 0 )
            {
              /*if ( hr % 3)
                {*/
              syn->s3.tr[0] = '5'; // 1 hour
              prec_to_RRR ( syn->s3.RRR, s->val );
              syn->mask |= SYNOP_SEC3;
              /*}*/
            }
        }
      else if ( syn->s5.RRR[0] == 0 )
        {
          syn->s5.tr[0] = '5'; // 1 hour
          prec_to_RRR ( syn->s5.RRR, s->val );
          syn->mask |= SYNOP_SEC5;
        }
      break;
 
    case 20: // 0 13 020 . Total precipitation past 3 hours
      hr = hour_rounded ( syn );
      if ( ( hr % 3 ) == 0 )
        {
          if ( syn->s3.tr[0] == '5' )
            {
              syn->s5.tr[0] = '5';
              strcpy ( syn->s5.RRR, syn->s3.RRR );
              syn->mask |= SYNOP_SEC5;
            }
          syn->s3.tr[0] = '7'; // 3 hour
          prec_to_RRR ( syn->s3.RRR, s->val );
          syn->mask |= SYNOP_SEC3;
        }
      break;
 
    case 21: // 0 13 021 . Total precipitation past 6 hours
      hr = hour_rounded ( syn );
      if ( strcmp ( "1", syn->s0.A1 ) == 0 )
        {
          if ( ( hr % 12 ) == 0 )
            {
              syn->s1.tr[0] = '1'; // 6 hour
              prec_to_RRR ( syn->s1.RRR, s->val );
              syn->mask |= SYNOP_SEC1;
            }
        }
      else if ( strcmp ( "2", syn->s0.A1 ) == 0 )
        {
          if ( ( hr % 3 ) == 0 )
            {
              syn->s1.tr[0] = '1'; // 6 hour
              prec_to_RRR ( syn->s1.RRR, s->val );
              syn->mask |= SYNOP_SEC1;
            }
        }
      else if ( strcmp ( "3", syn->s0.A1 ) == 0 )
        {
          if ( hr == 0 ||
               hr == 6 ||
               hr == 18 )
            {
              syn->s1.tr[0] = '1'; // 6 hour
              prec_to_RRR ( syn->s1.RRR, s->val );
              syn->mask |= SYNOP_SEC1;
            }
        }
      else if ( strcmp ( "4", syn->s0.A1 ) == 0 )
        {
          if ( ( hr % 6 ) == 0 )
            {
              syn->s1.tr[0] = '1'; // 6 hour
              prec_to_RRR ( syn->s1.RRR, s->val );
              syn->mask |= SYNOP_SEC1;
            }
        }
      else if ( strcmp ( "5", syn->s0.A1 ) == 0 )
        {
          if ( hr == 6 ||
               hr == 12 ||
               hr == 18 )
            {
              syn->s1.tr[0] = '1'; // 6 hour
              prec_to_RRR ( syn->s1.RRR, s->val );
              syn->mask |= SYNOP_SEC1;
            }
        }
      else if ( strcmp ( "6", syn->s0.A1 ) == 0 )
        {
          if ( hr == 0 ||
               hr == 18 )
            {
              syn->s1.tr[0] = '1'; // 6 hour
              prec_to_RRR ( syn->s1.RRR, s->val );
              syn->mask |= SYNOP_SEC1;
            }
        }
      else if ( strcmp ( "7", syn->s0.A1 ) == 0 )
        {
          if ( hr == 6 )
            {
              syn->s1.tr[0] = '1'; // 6 hour
              prec_to_RRR ( syn->s1.RRR, s->val );
              syn->mask |= SYNOP_SEC1;
            }
        }
 
      if ( syn->s1.RRR[0] == 0 )
        {
          if ( ( hr % 6 ) == 0 )
            {
              syn->s1.tr[0] = '1'; // 6 hour
              prec_to_RRR ( syn->s1.RRR, s->val );
              syn->mask |= SYNOP_SEC1;
            }
        }
      break;
 
    case 22: // 0 13 022 . Total precipitation past 12 hours
      hr = hour_rounded ( syn );
      if ( strcmp ( "1", syn->s0.A1 ) == 0 )
        {
          if ( hr == 18 )
            {
              syn->s1.tr[0] = '2'; // 12 hour
              prec_to_RRR ( syn->s1.RRR, s->val );
              syn->mask |= SYNOP_SEC1;
            }
        }
      else if ( strcmp ( "2", syn->s0.A1 ) == 0 )
        {
          if ( ( hr % 3 ) == 0 )
            {
              syn->s1.tr[0] = '2'; // 12 hour
              prec_to_RRR ( syn->s1.RRR, s->val );
              syn->mask |= SYNOP_SEC1;
            }
        }
      else if ( strcmp ( "6", syn->s0.A1 ) == 0 )
        {
          if ( ( hr % 12 ) == 6 )
            {
              syn->s1.tr[0] = '2'; // 12 hour
              prec_to_RRR ( syn->s1.RRR, s->val );
              syn->mask |= SYNOP_SEC1;
            }
        }
      else if ( strcmp ( "7", syn->s0.A1 ) == 0 )
        {
          if ( hr == 12 )
            {
              syn->s1.tr[0] = '2'; // 12 hour
              prec_to_RRR ( syn->s1.RRR, s->val );
              syn->mask |= SYNOP_SEC1;
            }
        }
 
      // Last chance
      if ( syn->s1.RRR[0] == 0 )
        {
          if ( ( hr % 6 ) == 0 )
            {
              syn->s1.tr[0] = '2'; // 12 hour
              prec_to_RRR ( syn->s1.RRR, s->val );
              syn->mask |= SYNOP_SEC1;
            }
          else if ( ( hr % 3 ) == 0 )
            {
              if ( syn->s3.RRR[0] == 0 )
                {
                  syn->s3.tr[0] = '2'; // 12 hour
                  prec_to_RRR ( syn->s3.RRR, s->val );
                  syn->mask |= SYNOP_SEC3;
                }
              else if ( syn->s3.tr[0] == '1' ||
                        syn->s3.tr[0] == '5' )
                {
                  strcpy ( syn->s5.tr, syn->s3.tr );
                  strcpy ( syn->s5.RRR, syn->s3.RRR );
                  syn->mask |= SYNOP_SEC5;
                  syn->s3.tr[0] = '2'; // 12 hour
                  prec_to_RRR ( syn->s3.RRR, s->val );
                  syn->mask |= SYNOP_SEC3;
                }
            }
        }
 
      break;
 
    case 23: // 0 13 023 . Total precipitaction past 24 hours
      if ( s->val < 0.0 )
        {
          return 0;
        }
      hr = hour_rounded ( syn );
      if ( strcmp ( "1", syn->s0.A1 ) == 0 )
        {
          if ( hr == 6 )
            {
              syn->s1.tr[0] = '4'; // 24 hour
              prec_to_RRR ( syn->s1.RRR, s->val );
              syn->mask |= SYNOP_SEC1;
            }
          prec_to_RRRR24 ( syn->s3.RRRR24, s->val );
          syn->mask |= SYNOP_SEC3;
        }
      else if ( strcmp ( "2", syn->s0.A1 ) == 0 )
        {
          prec_to_RRRR24 ( syn->s3.RRRR24, s->val );
          syn->mask |= SYNOP_SEC3;
        }
      else if ( strcmp ( "3", syn->s0.A1 ) == 0 )
        {
          if ( hr == 12 )
            {
              syn->s1.tr[0] = '4'; // 24 hour
              prec_to_RRR ( syn->s1.RRR, s->val );
              syn->mask |= SYNOP_SEC1;
            }
          prec_to_RRRR24 ( syn->s3.RRRR24, s->val );
          syn->mask |= SYNOP_SEC3;
        }
      else if ( strcmp ( "4", syn->s0.A1 ) == 0 )
        {
          prec_to_RRRR24 ( syn->s3.RRRR24, s->val );
          syn->mask |= SYNOP_SEC3;
        }
      else if ( strcmp ( "5", syn->s0.A1 ) == 0 )
        {
          if ( hr == 0 )
            {
              syn->s1.tr[0] = '4'; // 24 hour
              prec_to_RRR ( syn->s1.RRR, s->val );
              syn->mask |= SYNOP_SEC1;
            }
          prec_to_RRRR24 ( syn->s3.RRRR24, s->val );
          syn->mask |= SYNOP_SEC3;
        }
      else if ( strcmp ( "6", syn->s0.A1 ) == 0 )
        {
          if ( strcmp ( "07", syn->s0.II ) == 0 ) // France
            {
              if ( strcmp ( "06", syn->e.HH ) == 0 )
                {
                  prec_to_RRRR24 ( syn->s3.RRRR24, s->val );
                  syn->mask |= SYNOP_SEC3;
                }
            }
          else
            {
              prec_to_RRRR24 ( syn->s3.RRRR24, s->val );
              syn->mask |= SYNOP_SEC3;
            }
        }
      else if ( strcmp ( "7", syn->s0.A1 ) == 0 )
        {
          if ( hr == 0 )
            {
              syn->s1.tr[0] = '4'; // 24 hour
              prec_to_RRR ( syn->s1.RRR, s->val );
              syn->mask |= SYNOP_SEC1;
            }
        }
      break;
 
    case 56: // 0 13 056 . Character and intensity of precipitation
      if ( strcmp ( syn->s0.A1, "1" ) == 0 ) // Only for Region I
        {
          sprintf ( aux, "%d", s->ival );
          syn->s3.XoXoXoXo[2] = aux[0];
          syn->mask |= SYNOP_SEC3;
        }
      break;
 
    case 57: // 0 13 057 . Time of beginning or end of precipitation
      if ( strcmp ( syn->s0.A1, "1" ) == 0 ) // Only for region I
        {
          sprintf ( aux, "%d" , s->ival );
          syn->s3.XoXoXoXo[3] = aux[0];
          syn->mask |= SYNOP_SEC3;
        }
      break;
 
    case 118: // 0 13 118 . Recent snow depth
      if ( syn->s3.d9.n < SYNOP_NMISC )
        {
          sprintf ( syn->s3.d9.misc[syn->s3.d9.n].SpSp, "931%s", recent_snow_to_ss ( aux, s->val ) );
          ( syn->s3.d9.n ) ++;
        }
      break;
    default:
      if ( BUFR2TAC_DEBUG_LEVEL > 1 && (s->a->mask & DESCRIPTOR_VALUE_MISSING) == 0 ) 
        bufr2tac_set_error ( s, 0, "syn_parse_x13()", "Descriptor not parsed" );
      break;
    }
  return 0;
}

References bufr2tac_subset_state::a, synop_sec0::A1, BUFR2TAC_DEBUG_LEVEL, bufr2tac_set_error(), synop_sec3::d9, bufr_atom_data::desc, DESCRIPTOR_VALUE_MISSING, synop_chunks::e, report_date_ext::HH, hour_rounded(), synop_sec0::II, synop_sec0::iii, bufr2tac_subset_state::ival, bufr_atom_data::mask, synop_chunks::mask, data9::misc, data9::n, prec_to_RRR(), prec_to_RRRR24(), recent_snow_to_ss(), synop_sec1::RRR, synop_sec3::RRR, synop_sec5::RRR, synop_sec3::RRRR24, synop_chunks::s0, synop_chunks::s1, synop_chunks::s3, synop_chunks::s5, misc3::SpSp, synop_sec3::sss, SYNOP_NMISC, SYNOP_SEC1, SYNOP_SEC3, SYNOP_SEC5, time_period_duration(), total_snow_depth_to_sss(), synop_sec1::tr, synop_sec3::tr, synop_sec5::tr, synop_sec1::UUU, bufr2tac_subset_state::val, synop_sec3::XoXoXoXo, 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:

syn_parse_x14()

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

Parse a expanded descriptor with X = 14.

Parameters

syn	pointer to a struct synop_chunks where to set the results
s	pointer 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 59 of file bufr2tac_x14.c.

{
  int tpd;
 
  switch ( s->a->desc.y )
    {
    case 1: // 0 14 001 long-wave radiation 24 hours
    case 11:
      if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
        {
          return 0;
        }
      strcpy ( syn->s3.j524[4], "4" );
      sprintf ( syn->s3.FFFF24[4], "%04d", ( int ) ( s->val / 10000.0 + 0.5 ) );
      syn->mask |= SYNOP_SEC3;
      break;
 
    case 2: // 0 14 002 Long-wave radiation
    case 12:
      if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
        {
          return 0;
        }
      tpd = time_period_duration ( s );
      if ( tpd == ( 24 * 3600 ) )
        {
          if ( check_j_cm2 ( s->val ) == 0 )
            return 0;
          if ( strcmp ( "07", syn->s0.II ) == 0 ) // France
            {
              if ( strcmp ( "06", syn->e.HH ) == 0 )
                {
                  if ( s->ival >= 0 )
                    {
                      strcpy ( syn->s3.j524[4], "4" );
                      sprintf ( syn->s3.FFFF24[4], "%04d", ( int ) ( s->val / 10000.0 + 0.5 ) );
                    }
                  else
                    {
                      strcpy ( syn->s3.j524[5], "5" );
                      sprintf ( syn->s3.FFFF24[5], "%04d", ( int ) ( - ( s->val ) / 10000.0 + 0.5 ) );
                    }
                  syn->mask |= SYNOP_SEC3;
                }
            }
          else
            {
              if ( s->ival >= 0 )
                {
                  strcpy ( syn->s3.j524[4], "4" );
                  sprintf ( syn->s3.FFFF24[4], "%04d", ( int ) ( s->val / 10000.0 + 0.5 ) );
                }
              else
                {
                  strcpy ( syn->s3.j524[5], "5" );
                  sprintf ( syn->s3.FFFF24[5], "%04d", ( int ) ( - ( s->val ) / 10000.0 + 0.5 ) );
                }
              syn->mask |= SYNOP_SEC3;
            }
        }
      else if ( tpd == 3600 )
        {
          if ( check_kj_m2 ( s->val ) == 0 )
            return 0;
          if ( s->ival >= 0 )
            {
              strcpy ( syn->s3.j5[4], "4" );
              sprintf ( syn->s3.FFFF[4], "%04d", ( int ) ( s->val / 1000.0 + 0.5 ) );
            }
          else
            {
              strcpy ( syn->s3.j5[4], "5" );
              sprintf ( syn->s3.FFFF[4], "%04d", ( int ) ( - ( s->val ) / 1000.0 + 0.5 ) );
            }
        }
      syn->mask |= SYNOP_SEC3;
      break;
 
    case 3: // 0 14 003 short-wave radiation 24 hours
    case 13:
      if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
        {
          return 0;
        }
      if ( check_j_cm2 ( s->val ) == 0 )
        return 0;
      strcpy ( syn->s3.j524[6], "6" );
      sprintf ( syn->s3.FFFF24[6], "%04d", ( int ) ( s->val / 10000.0 + 0.5 ) );
      syn->mask |= SYNOP_SEC3;
      break;
 
    case 4: // 0 14 002 short-wave radiation
      if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
        {
          return 0;
        }
      tpd = time_period_duration ( s );
      if ( tpd == ( 24 * 3600 ) )
        {
          if ( check_j_cm2 ( s->val ) == 0 )
            return 0;
          if ( strcmp ( "07", syn->s0.II ) == 0 ) // France
            {
              if ( strcmp ( "06", syn->e.HH ) == 0 )
                {
                  strcpy ( syn->s3.j524[6], "6" );
                  sprintf ( syn->s3.FFFF24[6], "%04d", ( int ) ( s->val / 10000.0 + 0.5 ) );
                }
            }
          else
            {
              strcpy ( syn->s3.j524[6], "6" );
              sprintf ( syn->s3.FFFF24[6], "%04d", ( int ) ( s->val / 10000.0 + 0.5 ) );
            }
        }
      else if ( tpd == 3600 )
        {
          if ( check_kj_m2 ( s->val ) == 0 )
            return 0;
          strcpy ( syn->s3.j5[6], "6" );
          sprintf ( syn->s3.FFFF[6], "%04d", ( int ) ( s->val / 1000.0 + 0.5 ) );
        }
      syn->mask |= SYNOP_SEC3;
      break;
 
    case 14: // 0 14 014 Net short wave radiation integrated over period specified
      if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
        {
          return 0;
        }
      tpd = time_period_duration ( s );
      if ( tpd == ( 24 * 3600 ) )
        {
          if ( check_j_cm2 ( s->val ) == 0 )
            return 0;
          if ( strcmp ( "07", syn->s0.II ) == 0 ) // France
            {
              if ( strcmp ( "06", syn->e.HH ) == 0 )
                {
                  sprintf ( syn->s3.FFFF507, "%04d", ( int ) ( s->val / 10000.0 + 0.5 ) );
                  syn->mask |= SYNOP_SEC3;
                }
            }
          else
            {
              sprintf ( syn->s3.FFFF507, "%04d", ( int ) ( s->val / 10000.0 + 0.5 ) );
              syn->mask |= SYNOP_SEC3;
            }
        }
      else if ( tpd == 3600 )
        {
          if ( check_kj_m2 ( s->val ) == 0 )
            return 0;
          sprintf ( syn->s3.FFFF407, "%04d", ( int ) ( s->val / 1000.0 + 0.5 ) );
        }
      syn->mask |= SYNOP_SEC3;
      break;
 
 
    case 16: // 0 14 016 Short wave radiation integrated over period specified
      if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
        {
          return 0;
        }
      tpd = time_period_duration ( s );
      if ( tpd == ( 24 * 3600 ) )
        {
          if ( check_j_cm2 ( s->val ) == 0 )
            return 0;
          if ( strcmp ( "07", syn->s0.II ) == 0 ) // France
            {
              if ( strcmp ( "06", syn->e.HH ) == 0 )
                {
                  if ( s->ival >= 0 )
                    {
                      strcpy ( syn->s3.j524[0], "0" );
                      sprintf ( syn->s3.FFFF24[0], "%04d", ( int ) ( s->val / 10000.0 + 0.5 ) );
                    }
                  else
                    {
                      strcpy ( syn->s3.j524[1], "1" );
                      sprintf ( syn->s3.FFFF24[1], "%04d", ( int ) ( - ( s->val ) / 10000.0 + 0.5 ) );
                    }
                  syn->mask |= SYNOP_SEC3;
                }
            }
          else
            {
              if ( s->ival >= 0 )
                {
                  strcpy ( syn->s3.j524[0], "0" );
                  sprintf ( syn->s3.FFFF24[0], "%04d", ( int ) ( s->val / 10000.0 + 0.5 ) );
                }
              else
                {
                  strcpy ( syn->s3.j524[1], "1" );
                  sprintf ( syn->s3.FFFF24[1], "%04d", ( int ) ( - ( s->val ) / 10000.0 + 0.5 ) );
                }
              syn->mask |= SYNOP_SEC3;
            }
        }
      else if ( tpd == 3600 )
        {
          if ( check_kj_m2 ( s->val ) == 0 )
            return 0;
          if ( s->ival >= 0 )
            {
              strcpy ( syn->s3.j5[0], "0" );
              sprintf ( syn->s3.FFFF[0], "%04d", ( int ) ( s->val / 1000.0 + 0.5 ) );
            }
          else
            {
              strcpy ( syn->s3.j5[1], "1" );
              sprintf ( syn->s3.FFFF[1], "%04d", ( int ) ( - ( s->val ) / 1000.0 + 0.5 ) );
            }
        }
      syn->mask |= SYNOP_SEC3;
      break;
 
    case 28: // 0 14 028 Global solar radiation integrated over period specified
      if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
        {
          return 0;
        }
      tpd = time_period_duration ( s );
      if ( tpd == ( 24 * 3600 ) )
        {
          if ( check_j_cm2 ( s->val ) == 0 )
            return 0;
          if ( strcmp ( "07", syn->s0.II ) == 0 ) // France
            {
              if ( strcmp ( "06", syn->e.HH ) == 0 )
                {
                  strcpy ( syn->s3.j524[2], "2" );
                  sprintf ( syn->s3.FFFF24[2], "%04d", ( int ) ( s->val / 10000.0 + 0.5 ) );
                  syn->mask |= SYNOP_SEC3;
                }
            }
          else
            {
              strcpy ( syn->s3.j524[2], "2" );
              sprintf ( syn->s3.FFFF24[2], "%04d", ( int ) ( s->val / 10000.0 + 0.5 ) );
              syn->mask |= SYNOP_SEC3;
            }
        }
      else if ( tpd == 3600 )
        {
          if ( check_kj_m2 ( s->val ) == 0 )
            return 0;
          strcpy ( syn->s3.j5[2], "2" );
          sprintf ( syn->s3.FFFF[2], "%04d", ( int ) ( s->val / 1000.0 + 0.5 ) );
        }
      syn->mask |= SYNOP_SEC3;
      break;
 
    case 29: // 0 14 029 Diffuse solar radiation integrated over period specified
      if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
        {
          return 0;
        }
      tpd = time_period_duration ( s );
      if ( tpd == ( 24 * 3600 ) )
        {
          if ( check_j_cm2 ( s->val ) == 0 )
            return 0;
          if ( strcmp ( "07", syn->s0.II ) == 0 ) // France
            {
              if ( strcmp ( "06", syn->e.HH ) == 0 )
                {
                  strcpy ( syn->s3.j524[3], "3" );
                  sprintf ( syn->s3.FFFF24[3], "%04d", ( int ) ( s->val / 10000.0 + 0.5 ) );
                  syn->mask |= SYNOP_SEC3;
                }
            }
          else
            {
              strcpy ( syn->s3.j524[3], "3" );
              sprintf ( syn->s3.FFFF24[3], "%04d", ( int ) ( s->val / 10000.0 + 0.5 ) );
              syn->mask |= SYNOP_SEC3;
            }
        }
      else if ( tpd == 3600 )
        {
          if ( check_kj_m2 ( s->val ) == 0 )
            return 0;
          strcpy ( syn->s3.j5[3], "3" );
          sprintf ( syn->s3.FFFF[3], "%04d", ( int ) ( s->val / 1000.0 + 0.5 ) );
        }
      syn->mask |= SYNOP_SEC3;
      break;
 
 
    case 30: // 0 14 030 Direct solar radiation integrated over period specified
      if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
        {
          return 0;
        }
      tpd = time_period_duration ( s );
      if ( tpd == ( 24 * 3600 ) )
        {
          if ( check_j_cm2 ( s->val ) == 0 )
            return 0;
          if ( strcmp ( "07", syn->s0.II ) == 0 ) // France
            {
              if ( strcmp ( "06", syn->e.HH ) == 0 )
                {
                  sprintf ( syn->s3.FFFF508, "%04d", ( int ) ( s->val / 10000.0 + 0.5 ) );
                  syn->mask |= SYNOP_SEC3;
                }
            }
          else
            {
              sprintf ( syn->s3.FFFF508, "%04d", ( int ) ( s->val / 10000.0 + 0.5 ) );
              syn->mask |= SYNOP_SEC3;
            }
        }
      else if ( tpd == 3600 )
        {
          if ( check_kj_m2 ( s->val ) == 0 )
            return 0;
          sprintf ( syn->s3.FFFF408, "%04d", ( int ) ( s->val / 1000.0 + 0.5 ) );
        }
      syn->mask |= SYNOP_SEC3;
      break;
 
    case 31: // 0 14 031 Total sunshine
      if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
        {
          return 0;
        }
      tpd = time_period_duration ( s );
      if ( tpd == ( 24 * 3600 ) )
        {
          if ( check_j_cm2 ( s->val ) == 0 )
            return 0;
          if ( strcmp ( "07", syn->s0.II ) == 0 ) // France
            {
              if ( strcmp ( "06", syn->e.HH ) == 0 )
                {
                  sprintf ( syn->s3.SSS, "%03d", (abs(s->ival) / 6) % 1000 );
                  syn->mask |= SYNOP_SEC3;
                }
            }
          else
            {
              sprintf ( syn->s3.SSS, "%03d", (abs(s->ival) / 6) % 1000 );
              syn->mask |= SYNOP_SEC3;
            }
        }
      else if ( tpd == 3600 )
        {
          if ( check_kj_m2 ( s->val ) == 0 )
            return 0;
          sprintf ( syn->s3.SS, "%02d", abs(s->ival / 6) % 100 );
          syn->mask |= SYNOP_SEC3;
        }
      break;
 
    case 32: // 0 14 032 Total sunshine (hours)
      if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
        {
          return 0;
        }
      tpd = time_period_duration ( s );
      if ( tpd == ( 24 * 3600 ) )
        {
          if ( check_j_cm2 ( s->val ) == 0 )
            return 0;
          if ( strcmp ( "07", syn->s0.II ) == 0 ) // France
            {
              if ( strcmp ( "06", syn->e.HH ) == 0 )
                {
                  sprintf ( syn->s3.SSS, "%03d", s->ival * 10 );
                  syn->mask |= SYNOP_SEC3;
                }
            }
          else
            {
              sprintf ( syn->s3.SSS, "%03d", s->ival * 10 );
              syn->mask |= SYNOP_SEC3;
            }
        }
      else if ( tpd == 3600 )
        {
          if ( check_kj_m2 ( s->val ) == 0 )
            return 0;
          sprintf ( syn->s3.SS, "%02d", s->ival * 10 );
          syn->mask |= SYNOP_SEC3;
        }
      break;
 
    default:
      if ( BUFR2TAC_DEBUG_LEVEL > 1 && (s->a->mask & DESCRIPTOR_VALUE_MISSING) == 0 ) 
        bufr2tac_set_error ( s, 0, "syn_parse_x14()", "Descriptor not parsed" );
      break;
    }
 
  return 0;
}

References bufr2tac_subset_state::a, BUFR2TAC_DEBUG_LEVEL, bufr2tac_set_error(), check_j_cm2(), check_kj_m2(), bufr_atom_data::desc, DESCRIPTOR_VALUE_MISSING, synop_chunks::e, synop_sec3::FFFF, synop_sec3::FFFF24, synop_sec3::FFFF407, synop_sec3::FFFF408, synop_sec3::FFFF507, synop_sec3::FFFF508, report_date_ext::HH, synop_sec0::II, bufr2tac_subset_state::ival, synop_sec3::j5, synop_sec3::j524, bufr_atom_data::mask, synop_chunks::mask, synop_chunks::s0, synop_chunks::s3, synop_sec3::SS, synop_sec3::SSS, SYNOP_SEC3, time_period_duration(), 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:

syn_parse_x20()

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

Parse a expanded descriptor with X = 20.

Parameters

syn	pointer to a struct synop_chunks where to set the results
s	pointer 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 298 of file bufr2tac_x20.c.

{
  char aux[16];
 
  switch ( s->a->desc.y )
    {
    case 1: // 0 20 001 . Horizontal visibility
      if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
        {
          return 0;
        }
      vism_to_VV ( syn->s1.VV, s->val );
      break;
 
    case 3: // 0 20 003 . Present weather
      // there are some cases
      // Case 1)
      // On current templates, sec1 WW is NOT preceeded by a time displacament descriptor
      // In some national cases, a further complementary info about weather conditions is
      // precedeed by two time displacament descriptors giving the time interval from where
      // significant weather is described. In such cases we will use 902tt and 903tt, or
      // 964.. if the period macthes with W1W2 period
      // If WW = 20-29 and period matches last hour we then use 962.. group
      // as the indication of period and 966WW as weather
      if ( ( s->i - 1 ) == s->k_itval  && ( s->i - 2 ) == s->k_jtval )
        {
          // check missing value
          if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
            {
              return 0;
            }
          // check no significan weather.
          if ( s->ival == 100 || s->ival == 508 )
            {
              return 0;
            }
 
          // parse period
          if ( s->itval == 0 && s->jtval == s->tw1w2 )
            {
              // Case of W1W2 interval
              if ( syn->s3.d9.n  == SYNOP_NMISC )
                {
                  return 0;
                }
              sprintf ( syn->s3.d9.misc[syn->s3.d9.n].SpSp, "964" );
              s->SnSn = 964;
            }
          else if ( s->itval == 0 && s->jtval == -3600 && syn->s1.ww[0] == '2' )
            {
              // case of ww 20-29 and period equal to last hour. We will use 962...
              if ( syn->s3.d9.n  == SYNOP_NMISC )
                {
                  return 0;
                }
              sprintf ( syn->s3.d9.misc[syn->s3.d9.n].SpSp, "962" );
              s->SnSn = 962;
            }
          else
            {
              if ( ( syn->s3.d9.n + 2 ) >= SYNOP_NMISC )
                {
                  return 0;
                }
              sprintf ( syn->s3.d9.misc[syn->s3.d9.n].SpSp, "902" );
              secs_to_tt ( syn->s3.d9.misc[syn->s3.d9.n].spsp, s->jtval );
              syn->s3.d9.n++;
              sprintf ( syn->s3.d9.misc[syn->s3.d9.n].SpSp, "903" );
              secs_to_tt ( syn->s3.d9.misc[syn->s3.d9.n].spsp, s->itval );
              syn->s3.d9.n++;
              sprintf ( syn->s3.d9.misc[syn->s3.d9.n].SpSp, "966" );
              s->SnSn = 966;
            }
 
          // now set the value
          if ( s->ival < 100 )
            {
              sprintf ( syn->s3.d9.misc[syn->s3.d9.n].spsp , "%02d", s->ival );
              syn->mask |= SYNOP_SEC3;
            }
          else if ( s->ival < 200 )
            {
              sprintf ( syn->s3.d9.misc[syn->s3.d9.n].spsp, "%02d", s->ival % 100 );
              syn->mask |= SYNOP_SEC3;
            }
          syn->s3.d9.n++;
        }
 
      //  Case 2)
      // Complementary present weather after 7wwW1W1 has been set.
      // If last itval == 0 the we assume that the info should be set on 960.. groups
      else if ( syn->s1.ww[0] && s->itval == 0 )
        {
          // check if overflowed 9 struct
          if ( syn->s3.d9.n == SYNOP_NMISC )
            {
              return 0;
            }
          sprintf ( syn->s3.d9.misc[syn->s3.d9.n].SpSp, "960" );
          s->SnSn = 960;
 
          if ( s->ival < 0 )
            {
              return 0;
            }
          if ( s->ival < 100 )
            {
              sprintf ( syn->s3.d9.misc[syn->s3.d9.n].spsp , "%02d", s->ival );
              syn->mask |= SYNOP_SEC3;
            }
          else if ( s->ival < 200 )
            {
              sprintf ( syn->s3.d9.misc[syn->s3.d9.n].spsp, "%02d", s->ival % 100 );
              syn->mask |= SYNOP_SEC3;
            }
          syn->s3.d9.n++;
        }
      else
        {
          // 7wwW1W2 group
          if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
            {
              s->mask |= ( SUBSET_MASK_HAVE_NO_SIGNIFICANT_WW | SUBSET_MASK_HAVE_NO_SIGNIFICANT_W1 | SUBSET_MASK_HAVE_NO_SIGNIFICANT_W2 );
              return 0;
            }
          if ( s->ival < 100 )
            {
              if ( syn->s1.ix[0] == '/' && ( ( s->mask & SUBSET_MASK_HAVE_TYPE_STATION ) == 0 ) )
                {
                  strcpy ( syn->s1.ix, "1" );
                }
              else if ( s->type == 1 || s->type == 2 )
                {
                  strcpy ( syn->s1.ix, "1" );
                }
              else if ( s->type == 0 )
                {
                  strcpy ( syn->s1.ix, "4" );
                }
              sprintf ( syn->s1.ww, "%02d", s->ival );
              syn->mask |= SYNOP_SEC1;
            }
          else if ( s->ival == 100 )
            {
              strcpy ( syn->s1.ix, "5" );
              syn->mask |= SYNOP_SEC1;
              s->mask |=  SUBSET_MASK_HAVE_NO_SIGNIFICANT_WW;
            }
          else if ( s->ival < 200 )
            {
              if ( syn->s1.ix[0] == '/' && ( ( s->mask & SUBSET_MASK_HAVE_TYPE_STATION ) == 0 ) )
                {
                  strcpy ( syn->s1.ix, "7" );
                }
              else if ( s->type == 0 || s->type == 2 )
                {
                  strcpy ( syn->s1.ix, "7" );
                }
              sprintf ( syn->s1.ww, "%02d", s->ival % 100 );
              syn->mask |= SYNOP_SEC1;
            }
          else if ( s->ival == 508 )
            {
              if ( syn->s1.ix[0] == '/' && ( ( s->mask & SUBSET_MASK_HAVE_TYPE_STATION ) == 0 ) )
                {
                  strcpy ( syn->s1.ix, "5" );
                }
              else if ( s->type == 0 || s->type == 2 )
                {
                  strcpy ( syn->s1.ix, "5" );
                }
              s->mask |= ( SUBSET_MASK_HAVE_NO_SIGNIFICANT_WW | SUBSET_MASK_HAVE_NO_SIGNIFICANT_W1 | SUBSET_MASK_HAVE_NO_SIGNIFICANT_W2 );
            }
          else if ( s->ival == 509 )
            {
              if ( syn->s1.ix[0] == '/' && ( ( s->mask & SUBSET_MASK_HAVE_TYPE_STATION ) == 0 ) )
                {
                  strcpy ( syn->s1.ix, "6" );
                }
              else if ( s->type == 0 || s->type == 2 )
                {
                  strcpy ( syn->s1.ix, "6" );
                }
              s->mask |= ( SUBSET_MASK_HAVE_NO_SIGNIFICANT_WW | SUBSET_MASK_HAVE_NO_SIGNIFICANT_W1 | SUBSET_MASK_HAVE_NO_SIGNIFICANT_W2 );
            }
 
          //printf("%s%s* %s\n", syn->s0.II, syn->s0.iii, syn->s1.ww);
        }
      break;
 
    case 4: // 0 20 004 . Past weather (1)
      if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
        {
          s->mask |=  SUBSET_MASK_HAVE_NO_SIGNIFICANT_W1;
          return 0;
        }
 
      // stores w1w2 period
      s->tw1w2 = s->itval;
      if ( s->ival < 10 )
        {
          if ( syn->s1.ix[0] == '/' && ( ( s->mask & SUBSET_MASK_HAVE_TYPE_STATION ) == 0 ) )
            {
              strcpy ( syn->s1.ix,"1" );
            }
          else if ( syn->s1.ix[0] == '/' )
            {
              if ( s->type == 1 || s->type == 2 )
                {
                  strcpy ( syn->s1.ix, "1" );
                }
              else if ( s->type == 0 )
                {
                  strcpy ( syn->s1.ix, "4" );
                }
            }
          sprintf ( syn->s1.W1, "%d", s->ival );
          syn->mask |= SYNOP_SEC1;
        }
      else if ( s->ival == 10 )
        {
          if ( syn->s1.ix[0] == '/' && ( ( s->mask & SUBSET_MASK_HAVE_TYPE_STATION ) == 0 ) )
            {
              if ( s->type == 1 || s->type == 2 )
                {
                  strcpy ( syn->s1.ix, "2" );
                }
              else if ( s->type == 0 )
                {
                  strcpy ( syn->s1.ix, "5" );
                }
            }
          s->mask |= SUBSET_MASK_HAVE_NO_SIGNIFICANT_W1;
        }
      else
        {
          if ( syn->s1.ix[0] == '/' && ( ( s->mask & SUBSET_MASK_HAVE_TYPE_STATION ) == 0 ) )
            {
              strcpy ( syn->s1.ix,"7" );
            }
          else if ( s->type == 0 || s->type == 2 )
            {
              strcpy ( syn->s1.ix, "7" );
            }
          sprintf ( syn->s1.W1, "%d", abs ( s->ival ) % 10 );
          syn->mask |= SYNOP_SEC1;
        }
      break;
 
    case 5: // 0 20 005 . Past weather (2)
      if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
        {
          s->mask |=  SUBSET_MASK_HAVE_NO_SIGNIFICANT_W2;
          return 0;
        }
      if ( s->ival < 10 )
        {
          if ( syn->s1.ix[0] == '/' && ( ( s->mask & SUBSET_MASK_HAVE_TYPE_STATION ) == 0 ) )
            {
              strcpy ( syn->s1.ix,"1" );
            }
          else if ( syn->s1.ix[0] == '/' )
            {
              if ( s->type == 1 || s->type == 2 )
                {
                  strcpy ( syn->s1.ix, "1" );
                }
              else if ( s->type == 0 )
                {
                  strcpy ( syn->s1.ix, "4" );
                }
            }
          sprintf ( syn->s1.W2, "%d", s->ival );
          syn->mask |= SYNOP_SEC1;
        }
      else if ( s->ival == 10 )
        {
          if ( syn->s1.ix[0] == '/' && ( ( s->mask & SUBSET_MASK_HAVE_TYPE_STATION ) == 0 ) )
            {
              if ( s->type == 1 || s->type == 2 )
                {
                  strcpy ( syn->s1.ix, "2" );
                }
              else if ( s->type == 0 )
                {
                  strcpy ( syn->s1.ix, "5" );
                }
            }
          s->mask |= SUBSET_MASK_HAVE_NO_SIGNIFICANT_W2;
        }
      else
        {
          if ( syn->s1.ix[0] == '/' && ( ( s->mask & SUBSET_MASK_HAVE_TYPE_STATION ) == 0 ) )
            {
              strcpy ( syn->s1.ix, "7" );
            }
          else if ( s->type == 0 || s->type == 2 )
            {
              strcpy ( syn->s1.ix, "7" );
            }
          sprintf ( syn->s1.W2, "%d", abs ( s->ival ) % 10 );
          syn->mask |= SYNOP_SEC1;
        }
      break;
 
    case 10: // 0 20 010 . Cloud cover (total)
      if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
        {
          return 0;
        }
      percent_to_okta ( syn->s1.N, s->val );
      break;
 
    case 11: // 0 20 011 . Cloud amount
      if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
        {
          return 0;
        }
      if ( s->clayer == 0 || s->clayer == 5 || s->clayer == 7 || s->clayer == 8 || s->clayer == 62 )
        {
          if ( s->ival <= 8 )
            {
              sprintf ( syn->s1.Nh, "%1d", abs(s->ival) % 10 );
            }
          else if ( s->ival <= 10 )
            {
              sprintf ( syn->s1.Nh, "9" );
            }
          else if ( s->ival == 15 )
            {
              sprintf ( syn->s1.Nh, "/" );
            }
          syn->mask |= SYNOP_SEC1;
        }
      else if ( s->clayer < 0 )
        {
          if ( s->ival <= 8 )
            {
              sprintf ( syn->s4.N1, "%1d", abs(s->ival) % 10 );
            }
          else if ( s->ival <= 10 )
            {
              sprintf ( syn->s4.N1, "9" );
            }
          else if ( s->ival == 15 )
            {
              sprintf ( syn->s4.N1, "/" );
            }
          syn->mask |= SYNOP_SEC4;
        }
      else if ( s->clayer > 0 && s->clayer < 5 )
        {
          if ( s->ival <= 8 )
            {
              sprintf ( syn->s3.nub[s->clayer - 1].Ns, "%1d", s->ival );
            }
          else if ( s->ival <= 10 )
            {
              sprintf ( syn->s3.nub[s->clayer - 1].Ns, "9" );
            }
          else if ( s->ival == 15 )
            {
              sprintf ( syn->s3.nub[s->clayer - 1].Ns, "/" );
            }
          syn->mask |= SYNOP_SEC3;
        }
      break;
 
    case 12: // 0 20 012 . Cloud type
      if ( s->clayer == 0 || s->clayer == 5 || s->clayer == 7 || s->clayer == 8 || s->clayer == 62 )
        {
          if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
            {
              return 0;
            }
          if ( s->ival < 10 )
            {
              sprintf ( syn->s3.C, "%d", abs(s->ival) % 10 );
              syn->mask |= SYNOP_SEC3;
            }
          else if ( s->ival >= 10 && s->ival < 20 )
            {
              sprintf ( syn->s1.Ch, "%1d", s->ival % 10 );
              syn->mask |= SYNOP_SEC1;
            }
          else if ( s->ival >= 20 && s->ival < 30 )
            {
              sprintf ( syn->s1.Cm, "%1d", s->ival % 10 );
              syn->mask |= SYNOP_SEC1;
            }
          else if ( s->ival >= 30 && s->ival < 40 )
            {
              sprintf ( syn->s1.Cl, "%1d", s->ival % 10 );
              syn->mask |= SYNOP_SEC1;
            }
          else if ( s->ival == 59 )
            {
              sprintf ( syn->s1.Nh, "/" );
              syn->mask |= SYNOP_SEC1;
            }
          else if ( s->ival == 60 )
            {
              sprintf ( syn->s1.Ch, "/" );
              syn->mask |= SYNOP_SEC1;
            }
          else if ( s->ival == 61 )
            {
              sprintf ( syn->s1.Cm, "/" );
              syn->mask |= SYNOP_SEC1;
            }
          else if ( s->ival == 62 )
            {
              sprintf ( syn->s1.Cl, "/" );
              syn->mask |= SYNOP_SEC1;
            }
        }
      else if ( s->clayer < 0 )
        {
          // case of base of clouds below station level
          if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
            {
              return 0;
            }
          if ( s->ival == 59 )
            {
              sprintf ( syn->s4.C1, "/" );
              syn->mask |= SYNOP_SEC4;
            }
          else if ( s->ival < 10 )
            {
              sprintf ( syn->s4.C1, "%1d", abs (s->ival) % 10 );
              syn->mask |= SYNOP_SEC4;
            }
        }
      else if ( s->clayer > 0 && s->clayer < 5 )
        {
          if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
            {
              sprintf ( syn->s3.nub[s->clayer - 1].C, "/" );
              return 0;
            }
          if ( s->ival == 59 || s->ival >= 10 )
            {
              sprintf ( syn->s3.nub[s->clayer - 1].C, "/" );
            }
          else
            {
              // C clouds for 8 groups SEC 3
              sprintf ( syn->s3.nub[s->clayer - 1].C, "%1d", s->ival % 10 );
            }
          syn->mask |= SYNOP_SEC3;
        }
      break;
 
    case 13: // 0 20 013 . Height of base of cloud
      if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
        {
          return 0;
        }
      if ( s->clayer == 0 || s->clayer == 7 || s->clayer == 5 || s->clayer == 62 ) // first layer or low layer is for sec1
        {
          m_to_h ( syn->s1.h, s->val );
        }
      else if ( s->clayer > 0 && s->clayer < 5 )
        {
          if ( syn->s3.nub[s->clayer - 1].Ns[0] )
            {
              m_to_hh ( syn->s3.nub[s->clayer - 1].hshs, s->val );
            }
          else
            {
              m_to_9h ( syn->s3.nub[s->clayer - 1].hshs, s->val );
            }
        }
      break;
 
    case 14: // 0 20 014 . Height of Top of cloud
      if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
        {
          return 0;
        }
      if ( s->clayer < 0 ) // base below station level
        {
          m_to_hh ( syn->s4.H1H1, s->val );
          syn->mask |= SYNOP_SEC4;
        }
      break;
 
    case 17:
      if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
        {
          return 0;
        }
      if ( s->clayer < 0 && s->ival < 10 ) // base below station level
        {
          sprintf ( syn->s4.Ct, "%d", abs(s->ival) % 10 );
          syn->mask |= SYNOP_SEC4;
        }
      break;
 
    case 21: // 0 20 021 . Type of precipitation
      if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
        {
          return 0;
        }
 
      if ( syn->s0.A1[0] == '6' ) // for Reg VI
        {
          // flag table width = 30 bits
          if ( s->ival & ( 1 << ( 30 - 15 ) ) &&
               ( s->ival & ( 1 << ( 30 - 16 ) ) ) == 0  &&
               ( s->ival & ( 1 << ( 30 - 20 ) ) ) == 0
             )
            {
              // Only Glaze
              strcpy ( syn->s3.d9.misc[syn->s3.d9.n].SpSp, "934" );
              s->SnSn = 934;
              // here we increase counter
              syn->s3.d9.n++;
            }
          else if ( s->ival & ( 1 << ( 30 - 16 ) ) &&
                    ( s->ival & ( 1 << ( 30 - 15 ) ) ) == 0  &&
                    ( s->ival & ( 1 << ( 30 - 20 ) ) ) == 0
                  )
            {
              // Only Rime
              strcpy ( syn->s3.d9.misc[syn->s3.d9.n].SpSp, "935" );
              s->SnSn = 935;
              // here we increase counter
              syn->s3.d9.n++;
            }
          else if ( s->ival & ( 1 << ( 30 - 20 ) ) &&
                    ( s->ival & ( 1 << ( 30 - 15 ) ) ) == 0  &&
                    ( s->ival & ( 1 << ( 30 - 16 ) ) ) == 0
                  )
            {
              // Only Wet snow
              strcpy ( syn->s3.d9.misc[syn->s3.d9.n].SpSp, "937" );
              s->SnSn = 937;
              // here we increase counter
              syn->s3.d9.n++;
            }
          else if ( s->ival & ( 1 << ( 30 - 15 ) ) ||
                    s->ival & ( 1 << ( 30 - 16 ) ) ||
                    s->ival & ( 1 << ( 30 - 20 ) ) )
            {
              // Compound deposit
              strcpy ( syn->s3.d9.misc[syn->s3.d9.n].SpSp, "936" );
              s->SnSn = 936;
              // here we increase counter
              syn->s3.d9.n++;
            }
        }
      break;
 
    case 23: // 0 20 023 . Other weather phenomena
      if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
        {
          return 0;
        }
 
      if ( syn->s0.A1[0] == '6' ) // for Reg VI
        {
          // flag table width = 18 bits
          if ( s->ival & ( 1 << ( 18 - 1 ) ) )
            {
              // Dust/sand whirl
              syn->s3.d9.misc[syn->s3.d9.n].spsp[0] = '5'; // moderate intensity
              syn->s3.d9.misc[syn->s3.d9.n].spsp[1] = '/'; // at the moment
              strcpy ( syn->s3.d9.misc[syn->s3.d9.n].SpSp, "919" );
              s->SnSn = 919;
              // here we increase counter
              syn->s3.d9.n++;
            }
          else if ( ( s->ival & ( 1 << ( 18 - 9 ) ) ) ||
                    ( s->ival & ( 1 << ( 18 - 10 ) ) )
                  )
            {
              // Funnel clouds
              syn->s3.d9.misc[syn->s3.d9.n].spsp[0] = '3'; // assumed less than 3 Km from station
              syn->s3.d9.misc[syn->s3.d9.n].spsp[1] = '/'; // at the moment
              strcpy ( syn->s3.d9.misc[syn->s3.d9.n].SpSp, "919" );
              s->SnSn = 919;
              // here we increase counter
              syn->s3.d9.n++;
            }
          else if ( s->ival & ( 1 << ( 18 - 12 ) ) )
            {
              syn->s3.d9.misc[syn->s3.d9.n].spsp[0] = '0'; // assumed less than 3 Km from station
              syn->s3.d9.misc[syn->s3.d9.n].spsp[1] = '/'; // at the moment
              strcpy ( syn->s3.d9.misc[syn->s3.d9.n].SpSp, "919" );
              s->SnSn = 919;
              // here we increase counter
              syn->s3.d9.n++;
            }
          else if ( s->ival & ( 1 << ( 18 - 2 ) ) )
            {
              syn->s3.d9.misc[syn->s3.d9.n].spsp[0] = '2'; // FIXME What kind of squall ?
              syn->s3.d9.misc[syn->s3.d9.n].spsp[1] = '/'; // at the moment
              strcpy ( syn->s3.d9.misc[syn->s3.d9.n].SpSp, "918" );
              s->SnSn = 918;
              // here we increase counter
              syn->s3.d9.n++;
            }
        }
      break;
 
    case 24: // 0 20 024 . Intensity of phenomena
      if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
        {
          return 0;
        }
      if ( syn->s0.A1[0] == '6' ) // for Reg VI
        {
          if ( s->SnSn == 919 )
            {
              if ( syn->s3.d9.misc[syn->s3.d9.n - 1].spsp[0] == '5' )
                {
                  if ( s->ival == 1 )
                    {
                      syn->s3.d9.misc[syn->s3.d9.n - 1].spsp[0] = '4';
                    }
                  else if ( s->ival == 3 || s->ival == 4 )
                    {
                      syn->s3.d9.misc[syn->s3.d9.n - 1].spsp[0] = '6';
                    }
                }
            }
        }
      break;
 
    case 25: // 0 20 025 . Obscuration
      if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
        {
          return 0;
        }
 
      if ( syn->s0.A1[0] == '6' ) // for Reg VI
        {
          // flag table width = 21 bits
          if ( s->ival & ( 1 << ( 21 - 1 ) ) )
            {
              // Dust/sand whirl
              syn->s3.d9.misc[syn->s3.d9.n].spsp[0] = '1'; // We next willl modify
              strcpy ( syn->s3.d9.misc[syn->s3.d9.n].SpSp, "929" );
              s->SnSn = 929;
              // here we increase counter
              syn->s3.d9.n++;
            }
 
        }
      break;
 
    case 26: // 9 29 026 . Character of obscuration
      if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
        {
          return 0;
        }
      if ( syn->s0.A1[0] == '6' ) // for Reg VI
        {
          if ( s->SnSn == 929 )
            {
              if ( s->ival == 6 )
                {
                  syn->s3.d9.misc[syn->s3.d9.n - 1].spsp[0] = '6';
                }
            }
        }
      break;
 
    case 27: // 0 20 027 . Phenomenon occurrence
      if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
        {
          if ( syn->s0.A1[0] == '6' ) // for Reg VI
            {
              // flag table width = 9 bits
              if ( s->SnSn == 919 || s->SnSn == 918 )
                {
                  syn->s3.d9.misc[syn->s3.d9.n - 1].SpSp[0] = 0;
                }
            }
          return 0;
        }
      if ( syn->s0.A1[0] == '6' ) // for Reg VI
        {
          // flag table width = 9 bits
          if ( s->SnSn == 919 || s->SnSn == 918 )
            {
              if ( ( s->ival & ( 1 << ( 9 - 3 ) ) ) == 0 )
                {
                  syn->s3.d9.misc[syn->s3.d9.n - 1].SpSp[0] = 0;  // No valid group
                }
            }
        }
      break;
 
    case 40: // 9 29 040 . Evolution of drift of snow
      if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
        {
          return 0;
        }
      if ( syn->s0.A1[0] == '6' ) // for Reg VI
        {
          if ( s->SnSn == 929 )
            {
              sprintf ( aux, "%d", s->ival % 10 );
              syn->s3.d9.misc[syn->s3.d9.n - 1].spsp[1] = aux[0]; // S8'
            }
        }
      break;
 
    case 54: // 0 20 054 . True direction from which clouds are moving
      if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
        {
          return 0;
        }
      if ( syn->s0.A1[0] == '6' ) // for Reg VI
        {
          grad_to_D ( aux, s->val );
          if ( s->SnSn == 919 || s->SnSn == 918 )
            {
              syn->s3.d9.misc[syn->s3.d9.n - 1].spsp[1] = aux[0];
            }
          else if ( s->clayer == 7 )
            {
              grad_to_D ( syn->s3.Dl, s->val );
            }
          else if ( s->clayer == 8 )
            {
              grad_to_D ( syn->s3.Dm, s->val );
            }
          else if ( s->clayer == 9 )
            {
              grad_to_D ( syn->s3.Dh, s->val );
            }
          syn->mask |= SYNOP_SEC3;
        }
      else if ( syn->s0.A1[0] == '4' ) // for Reg IV
        {
          grad_to_D ( aux, s->val );
          if ( s->clayer == 7 )
            {
              syn->s3.XoXoXoXo[1] = aux[0];
            }
          else if ( s->clayer == 8 )
            {
              syn->s3.XoXoXoXo[2] = aux[0];
            }
          else if ( s->clayer == 9 )
            {
              syn->s3.XoXoXoXo[3] = aux[0];
            }
          syn->mask |= SYNOP_SEC3;
        }
      else  // other Regions
        {
          if ( s->clayer == 7 )
            {
              grad_to_D ( syn->s3.Dl, s->val );
            }
          else if ( s->clayer == 8 )
            {
              grad_to_D ( syn->s3.Dm, s->val );
            }
          else if ( s->clayer == 9 )
            {
              grad_to_D ( syn->s3.Dh, s->val );
            }
          syn->mask |= SYNOP_SEC3;
        }
      break;
 
    case 55: // 0 20 055 . State of sky in tropics
      if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
        {
          return 0;
        }
      if ( strcmp ( syn->s0.A1, "4" ) == 0 )
        {
          // For REG IV
          if ( s->ival < 10 )
            {
              sprintf ( aux,"%d", s->ival );
              syn->s3.XoXoXoXo[0] = aux[0];
            }
          else
            {
              syn->s3.XoXoXoXo[0] = '/';
            }
          // then copy data direction of cloud drift from 3 02 047 if any
          if ( syn->s3.Dl[0] )
            {
              syn->s3.XoXoXoXo[1] = syn->s3.Dl[0];
            }
          if ( syn->s3.Dm[0] )
            {
              syn->s3.XoXoXoXo[1] = syn->s3.Dm[0];
            }
          if ( syn->s3.Dh[0] )
            {
              syn->s3.XoXoXoXo[1] = syn->s3.Dh[0];
            }
          syn->mask |= SYNOP_SEC3;
        }
      break;
 
    case 62: // 0 20 062 . State of the ground (with or without snow)
      if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
        {
          return 0;
        }
      if ( strcmp ( syn->s0.A1, "2" ) == 0 )
        {
          // For REG II
          if ( s->ival < 10 )
            {
              sprintf ( aux,"%d", s->ival );
              sprintf ( syn->s3.E, "%d", s->ival );
              syn->s3.XoXoXoXo[0] = aux[0];
            }
          else if ( s->ival < 20 )
            {
              syn->s3.XoXoXoXo[0] = '/';
              sprintf ( syn->s3.E1,"%d", s->ival % 10 );
            }
          if ( syn->s3.XoXoXoXo[1] == 0 )
            {
              // In case of still no snTgTg
              syn->s3.XoXoXoXo[1] = '/';
              syn->s3.XoXoXoXo[2] = '/';
              syn->s3.XoXoXoXo[3] = '/';
            }
        }
      else
        {
          // The Other regs
          if ( s->ival < 10 )
            {
              sprintf ( syn->s3.E,"%d", abs(s->ival) % 10 );
            }
          else if ( s->ival < 20 )
            {
              sprintf ( syn->s3.E1,"%d", s->ival % 10 );
            }
        }
      syn->mask |= SYNOP_SEC3;
      break;
 
    case 66: // 0 20 066 . Max diameter of hailstones
      if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
        {
          return 0;
        }
      if ( strcmp ( syn->s0.A1, "1" ) == 0 ) // Only for Region I
        {
          m_to_RR ( syn->s3.d9.misc[syn->s3.d9.n].spsp, s->val );
          strcpy ( syn->s3.d9.misc[syn->s3.d9.n].SpSp, "932" );
          s->SnSn = 932;
          // here we increase counter
          syn->s3.d9.n++;
        }
      break;
 
    case 67: // 0 20 067 . Diameter of deposit
      if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
        {
          return 0;
        }
      if ( strcmp ( syn->s0.A1, "1" ) == 0 ) // Only for Region I
        {
          m_to_RR ( syn->s3.d9.misc[syn->s3.d9.n - 1].spsp, s->val );
        }
      break;
 
    case 101: // 0 20 101. Locust (acridian) name
      if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
        {
          return 0;
        }
      if ( strcmp ( syn->s0.A1, "1" ) == 0 ) // Only for Region I
        {
          if ( s->ival < 10 )
            {
              sprintf ( aux, "%d", s->ival );
              syn->s3.R8[0][0] = aux[0]; // Ln
              syn->mask |= ( SYNOP_SEC3 | SYNOP_SEC3_8 );
            }
        }
      break;
 
    case 102: // 0 20 102. Locust (maturity) color
      if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
        {
          return 0;
        }
      if ( strcmp ( syn->s0.A1, "1" ) == 0 ) // Only for Region I
        {
          if ( s->ival < 10 )
            {
              sprintf ( aux, "%d", s->ival );
              syn->s3.R8[0][1] = aux[0]; // Lc
              syn->mask |= ( SYNOP_SEC3 | SYNOP_SEC3_8 );
            }
        }
      break;
 
    case 103: // 0 20 103. Stage of development of locusts
      if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
        {
          return 0;
        }
      if ( strcmp ( syn->s0.A1, "1" ) == 0 ) // Only for Region I
        {
          if ( s->ival < 10 )
            {
              sprintf ( aux, "%d", s->ival );
              syn->s3.R8[0][2] = aux[0]; // Ld
              syn->mask |= ( SYNOP_SEC3 | SYNOP_SEC3_8 );
            }
        }
      break;
 
    case 104: // 0 20 104. Organization state of swarm or band of locusts
      if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
        {
          return 0;
        }
      if ( strcmp ( syn->s0.A1, "1" ) == 0 ) // Only for Region I
        {
          if ( s->ival < 10 )
            {
              sprintf ( aux, "%d", s->ival );
              syn->s3.R8[0][3] = aux[0]; // Lg
              syn->mask |= ( SYNOP_SEC3 | SYNOP_SEC3_8 );
            }
        }
      break;
 
    case 105: // 0 20 105. Size of swarm or band of locusts and duration of
      // passage of swarm
      if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
        {
          return 0;
        }
      if ( strcmp ( syn->s0.A1, "1" ) == 0 ) // Only for Region I
        {
          if ( s->ival < 10 )
            {
              sprintf ( aux, "%d", s->ival );
              syn->s3.R8[1][0] = aux[0]; // Sl
              syn->mask |= ( SYNOP_SEC3 | SYNOP_SEC3_8 );
            }
        }
      break;
 
    case 106: // 0 20 106. Locust population density
      if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
        {
          return 0;
        }
      if ( strcmp ( syn->s0.A1, "1" ) == 0 ) // Only for Region I
        {
          if ( s->ival < 10 )
            {
              sprintf ( aux, "%d", s->ival );
              syn->s3.R8[1][1] = aux[0]; // dl
              syn->mask |= ( SYNOP_SEC3 | SYNOP_SEC3_8 );
            }
        }
      break;
 
    case 107: // 0 20 107. Direction of movements of locust swarm
      if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
        {
          return 0;
        }
      if ( strcmp ( syn->s0.A1, "1" ) == 0 ) // Only for Region I
        {
          if ( s->ival < 10 )
            {
              sprintf ( aux, "%d", s->ival );
              syn->s3.R8[1][1] = aux[0]; // Dl
              syn->mask |= ( SYNOP_SEC3 | SYNOP_SEC3_8 );
            }
        }
      break;
 
    case 108: // 0 20 108. Extent of vegetation
      if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
        {
          return 0;
        }
      if ( strcmp ( syn->s0.A1, "1" ) == 0 ) // Only for Region I
        {
          if ( s->ival < 8 )
            {
              sprintf ( aux, "%d", s->ival );
              syn->s3.R8[1][1] = aux[0]; // Dl
              syn->mask |= ( SYNOP_SEC3 | SYNOP_SEC3_8 );
            }
        }
      break;
 
    default:
      if ( BUFR2TAC_DEBUG_LEVEL > 1 && (s->a->mask & DESCRIPTOR_VALUE_MISSING) == 0 ) 
        bufr2tac_set_error ( s, 0, "syn_parse_x20()", "Descriptor not parsed" );
      break;
    }
 
  // check about h
  if ( syn->s1.h[0] == '/' && syn->s1.N[0] == '0' )
    {
      syn->s1.h[0] = '9';
    }
 
  return 0;
}

References bufr2tac_subset_state::a, synop_sec0::A1, BUFR2TAC_DEBUG_LEVEL, bufr2tac_set_error(), nub3::C, synop_sec3::C, synop_sec4::C1, synop_sec1::Ch, synop_sec1::Cl, bufr2tac_subset_state::clayer, synop_sec1::Cm, synop_sec4::Ct, synop_sec3::d9, bufr_atom_data::desc, DESCRIPTOR_VALUE_MISSING, synop_sec3::Dh, synop_sec3::Dl, synop_sec3::Dm, synop_sec3::E, synop_sec3::E1, grad_to_D(), synop_sec1::h, synop_sec4::H1H1, nub3::hshs, bufr2tac_subset_state::i, bufr2tac_subset_state::itval, bufr2tac_subset_state::ival, synop_sec1::ix, bufr2tac_subset_state::jtval, bufr2tac_subset_state::k_itval, bufr2tac_subset_state::k_jtval, m_to_9h(), m_to_h(), m_to_hh(), m_to_RR(), bufr_atom_data::mask, bufr2tac_subset_state::mask, synop_chunks::mask, data9::misc, synop_sec1::N, data9::n, synop_sec4::N1, synop_sec1::Nh, nub3::Ns, synop_sec3::nub, percent_to_okta(), synop_sec3::R8, synop_chunks::s0, synop_chunks::s1, synop_chunks::s3, synop_chunks::s4, secs_to_tt(), bufr2tac_subset_state::SnSn, misc3::SpSp, misc3::spsp, SUBSET_MASK_HAVE_NO_SIGNIFICANT_W1, SUBSET_MASK_HAVE_NO_SIGNIFICANT_W2, SUBSET_MASK_HAVE_NO_SIGNIFICANT_WW, SUBSET_MASK_HAVE_TYPE_STATION, SYNOP_NMISC, SYNOP_SEC1, SYNOP_SEC3, SYNOP_SEC3_8, SYNOP_SEC4, bufr2tac_subset_state::tw1w2, bufr2tac_subset_state::type, bufr2tac_subset_state::val, vism_to_VV(), synop_sec1::VV, synop_sec1::W1, synop_sec1::W2, synop_sec1::ww, synop_sec3::XoXoXoXo, 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:

syn_parse_x22()

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

Parse a expanded descriptor with X = 01.

Parameters

syn	pointer to a struct synop_chunks where to set the results
s	pointer 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 35 of file bufr2tac_x22.c.

{
  char aux[16];
 
  if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
    return 0;
 
  switch ( s->a->desc.y )
    {
    case 1: // 0 22 001 Direction of waves
    case 3: // 0 22 003 Direction of swell waves
      if ( syn->s2.dw1dw1[0] == 0 )
        {
          sprintf ( syn->s2.dw1dw1, "%02d", abs(( s->ival + 5 ) /10) % 100 );
        }
      else if ( syn->s2.dw2dw2[0] == 0 )
        {
          sprintf ( syn->s2.dw2dw2, "%02d", abs(( s->ival + 5 ) /10) % 100 );
        }
      syn->mask |= SYNOP_SEC2; // have sec2 data
      break;
 
    case 11: // 0 22 011 wind period in seconds
      if ( syn->s2.PwPw[0] == 0 )
        {
          sprintf ( syn->s2.PwPw, "%02d", ( int ) ( s->val ) );
          syn->mask |= SYNOP_SEC2; // have sec2 data
        }
      break;
 
    case 12: // 0 22 012 wind wave period in seconds
      if ( syn->s2.PwaPwa[0] == 0 )
        {
          sprintf ( syn->s2.PwaPwa, "%02d", ( int ) ( s->val ) );
          syn->mask |= SYNOP_SEC2; // have sec2 data
        }
      break;
 
    case 13: // 0 22 013 swell wave period in seconds
      if ( syn->s2.Pw1Pw1[0] == 0 )
        {
          sprintf ( syn->s2.Pw1Pw1, "%02d", ( int ) ( s->val ) );
        }
      else if ( syn->s2.Pw2Pw2[0] == 0 )
        {
          sprintf ( syn->s2.Pw2Pw2, "%02d", ( int ) ( s->val ) );
        }
      syn->mask |= SYNOP_SEC2; // have sec2 data
      break;
 
    case 21: // 0 22 021  wind wave heigh in m
      if ( syn->s2.HwHw[0] == 0 )
        {
          sprintf ( syn->s2.HwHw, "%02d", ( int ) ( s->val * 2.0 + 0.01 ) );
          syn->mask |= SYNOP_SEC2; // have sec2 data
        }
      break;
 
    case 22: // 0 22 022 wind wave heigh in meters
      if ( syn->s2.HwaHwa[0] == 0 )
        {
          sprintf ( syn->s2.HwaHwa, "%02d", ( int ) ( s->val * 2.0 + 0.01 ) ); // 0.5 m units
          syn->mask |= SYNOP_SEC2; // have sec2 data
        }
      if ( syn->s2.HwaHwaHwa[0] == 0 )
        {
          sprintf ( syn->s2.HwaHwaHwa, "%03d", ( int ) ( s->val * 10.0 + 0.5 ) ); // 0.1 m units
          syn->mask |= SYNOP_SEC2; // have sec2 data
        }
      break;
 
    case 23: // 0 22 023 swell wave heigh in meters
      if ( syn->s2.Hw1Hw1[0] == 0 )
        {
          sprintf ( syn->s2.Hw1Hw1, "%02d", ( int ) ( s->val * 2.0 + 0.01 ) );
        }
      else if ( syn->s2.Hw2Hw2[0] == 0 )
        {
          sprintf ( syn->s2.Hw2Hw2, "%02d", ( int ) ( s->val * 2.0 + 0.01 ) );
        }
      syn->mask |= SYNOP_SEC2; // have sec2 data
      break;
 
    case 42:
    case 43:
    case 45:
    case 49: // 0 22 049 Sea surface temperature
      if ( syn->s2.TwTwTw[0] == 0 )
        {
          if ( kelvin_to_snTTT ( aux, s->val ) )
            {
              syn->s2.ss[0] = aux[0];
              strcpy ( syn->s2.TwTwTw, aux + 1 );
              syn->mask |= SYNOP_SEC2; // have sec2 data
            }
        }
      break;
    default:
      if ( BUFR2TAC_DEBUG_LEVEL > 1 && (s->a->mask & DESCRIPTOR_VALUE_MISSING) == 0 ) 
        bufr2tac_set_error ( s, 0, "syn_parse_x22()", "Descriptor not parsed" );
      break;
    }
  return 0;
}

References bufr2tac_subset_state::a, BUFR2TAC_DEBUG_LEVEL, bufr2tac_set_error(), bufr_atom_data::desc, DESCRIPTOR_VALUE_MISSING, synop_sec2::dw1dw1, synop_sec2::dw2dw2, synop_sec2::Hw1Hw1, synop_sec2::Hw2Hw2, synop_sec2::HwaHwa, synop_sec2::HwaHwaHwa, synop_sec2::HwHw, bufr2tac_subset_state::ival, kelvin_to_snTTT(), bufr_atom_data::mask, synop_chunks::mask, synop_sec2::Pw1Pw1, synop_sec2::Pw2Pw2, synop_sec2::PwaPwa, synop_sec2::PwPw, synop_chunks::s2, synop_sec2::ss, SYNOP_SEC2, synop_sec2::TwTwTw, 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:

syn_parse_x31()

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

Parse a expanded descriptor with X = 31.

Parameters

syn	pointer to a struct synop_chunks where to set the results
s	pointer 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 35 of file bufr2tac_x31.c.

{
  
  if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
    {
      // 0 31 000 does not have DESCRIPTOR_VALUE_MISSING
      if (s->a->desc.y != 0)
        return 0;
      s->rep = 1;
      s->k_rep = s->i;
    }
 
  if ( syn == NULL )
    {
      return 1;
    }
 
  switch ( s->a->desc.y )
    {
    case 0: // 0 31 000 .  Short delayed descriptor replication factor
      s->rep = s->ival;
      s->k_rep = s->i;
      break;
 
    case 1:
      s->rep = s->ival;
      s->k_rep = s->i;
      break;
 
    default:
      if ( BUFR2TAC_DEBUG_LEVEL > 1 && (s->a->mask & DESCRIPTOR_VALUE_MISSING) == 0 ) 
        bufr2tac_set_error ( s, 0, "syn_parse_x31()", "Descriptor not parsed" );
      break;
    }
  return 0;
}

References bufr2tac_subset_state::a, BUFR2TAC_DEBUG_LEVEL, bufr2tac_set_error(), bufr_atom_data::desc, DESCRIPTOR_VALUE_MISSING, bufr2tac_subset_state::i, bufr2tac_subset_state::ival, bufr2tac_subset_state::k_rep, bufr_atom_data::mask, bufr2tac_subset_state::rep, 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:

synop_YYYYMMDDHHmm_to_YYGG()

int synop_YYYYMMDDHHmm_to_YYGG

(

struct synop_chunks *

syn

)

Sets YYGG from YYYYMMDDHHmm extended group.

Parameters

syn	pointer to the target struct synop_chunks

Definition at line 31 of file bufr2tac_synop.c.

{
  char aux[20];
  char tz[256], *c;
  time_t t;
  struct tm tim;
 
  if ( strlen ( syn->e.YYYY ) &&
       strlen ( syn->e.MM ) &&
       strlen ( syn->e.DD ) &&
       strlen ( syn->e.HH ) &&
       strlen ( syn->e.mm ) )
    {
      sprintf ( aux,"%s%s%s%s%s", syn->e.YYYY, syn->e.MM, syn->e.DD, syn->e.HH, syn->e.mm );
    }
 
  if ( strlen ( aux ) != 12 )
    {
      return 1;
    }
 
  // Get current TZ
  tz[0] = '\0';
  c = getenv ( "TZ" );
  if ( c != NULL && c[0] && strlen ( c ) < 256 )
    {
      strcpy ( tz, c );
    }
 
  // Set TZ to UTC
  setenv ( "TZ", "UTC", 1 );
  tzset();
 
  memset ( &tim, 0, sizeof ( struct tm ) );
  strptime ( aux, "%Y%m%d%H%M", &tim );
 
  t = mktime ( &tim ) + 1799 ; // rounding trick
  gmtime_r ( &t, &tim );
  sprintf ( syn->s0.YY, "%02d", tim.tm_mday );
  sprintf ( syn->s0.GG, "%02d", tim.tm_hour );
 
  // Revert TZ changes
  if ( tz[0] )
    {
      setenv ( "TZ", tz, 1 );
      tzset();
    }
  else
    {
      unsetenv ( "TZ" );
    }
 
  return 0;
}

References report_date_ext::DD, synop_chunks::e, synop_sec0::GG, report_date_ext::HH, report_date_ext::MM, report_date_ext::mm, synop_chunks::s0, synop_sec0::YY, and report_date_ext::YYYY.

Referenced by parse_subset_as_synop().

Here is the caller graph for this function:

temp_parse_x01()

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

Parse a expanded descriptor with X = 01.

Parameters

t	pointer to a struct temp_chunks where to set the results
s	pointer 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 415 of file bufr2tac_x01.c.

{
  char aux[80];
 
  if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
    return 0;
 
  switch ( s->a->desc.y )
    {
    case 1: // 0 01 001 . WMO block number
      sprintf ( t->a.s1.II, "%02d", s->ival );
      sprintf ( t->b.s1.II, "%02d", s->ival );
      sprintf ( t->c.s1.II, "%02d", s->ival );
      sprintf ( t->d.s1.II, "%02d", s->ival );
      break;
 
    case 2: // 0 01 002 . WMO station number
      sprintf ( t->a.s1.iii, "%03d", s->ival );
      sprintf ( t->b.s1.iii, "%03d", s->ival );
      sprintf ( t->c.s1.iii, "%03d", s->ival );
      sprintf ( t->d.s1.iii, "%03d", s->ival );
      break;
 
    case 3: // 0 01 003 . WMO Region
      sprintf ( t->a.s1.A1, "%d", s->ival );
      sprintf ( t->b.s1.A1, "%d", s->ival );
      sprintf ( t->c.s1.A1, "%d", s->ival );
      sprintf ( t->d.s1.A1, "%d", s->ival );
      if ( strcmp ( t->a.s1.A1, "1" ) == 0 )
        {
          strcpy ( t->a.s1.Reg, "I" );
          strcpy ( t->b.s1.Reg, "I" );
          strcpy ( t->c.s1.Reg, "I" );
          strcpy ( t->d.s1.Reg, "I" );
        }
      else if ( strcmp ( t->a.s1.A1, "2" ) == 0 )
        {
          strcpy ( t->a.s1.Reg, "II" );
          strcpy ( t->b.s1.Reg, "II" );
          strcpy ( t->c.s1.Reg, "II" );
          strcpy ( t->d.s1.Reg, "II" );
        }
      else if ( strcmp ( t->a.s1.A1, "3" ) == 0 )
        {
          strcpy ( t->a.s1.Reg, "III" );
          strcpy ( t->b.s1.Reg, "III" );
          strcpy ( t->c.s1.Reg, "III" );
          strcpy ( t->d.s1.Reg, "III" );
        }
      else if ( strcmp ( t->a.s1.A1, "4" ) == 0 )
        {
          strcpy ( t->a.s1.Reg, "IV" );
          strcpy ( t->b.s1.Reg, "IV" );
          strcpy ( t->c.s1.Reg, "IV" );
          strcpy ( t->d.s1.Reg, "IV" );
        }
      else if ( strcmp ( t->a.s1.A1, "5" ) == 0 )
        {
          strcpy ( t->a.s1.Reg, "V" );
          strcpy ( t->b.s1.Reg, "V" );
          strcpy ( t->c.s1.Reg, "V" );
          strcpy ( t->d.s1.Reg, "V" );
        }
      else if ( strcmp ( t->a.s1.A1, "6" ) == 0 )
        {
          strcpy ( t->a.s1.Reg, "VI" );
          strcpy ( t->b.s1.Reg, "VI" );
          strcpy ( t->c.s1.Reg, "VI" );
          strcpy ( t->d.s1.Reg, "VI" );
        }
      break;
 
    case 4: // 0 01 004 . WMO Subarea
    case 20: // 0 01 020 . WMO region subarea
      sprintf ( t->a.s1.bw, "%d", s->ival );
      sprintf ( t->b.s1.bw, "%d", s->ival );
      sprintf ( t->c.s1.bw, "%d", s->ival );
      sprintf ( t->d.s1.bw, "%d", s->ival );
      break;
 
    case 11: // 0 01 011. Ship or mobile land station index
      if ( strlen ( s->a->cval ) < 16 )
        {
          strcpy ( aux, s->a->cval );
          adjust_string ( aux );
          if ( aux[0] == '\xff' )
            break;
 
          if ( strlen ( aux ) < 10 )
            {
              strcpy ( t->a.s1.D_D, aux );
              strcpy ( t->b.s1.D_D, aux );
              strcpy ( t->c.s1.D_D, aux );
              strcpy ( t->d.s1.D_D, aux );
            }
        }
      break;
 
    case 15: // 0 01 015 . Station or site name
    case 18: // 0 01 018 . Short station or site name
    case 19: // 0 01 019 . Long station or site name
      if ( strlen ( s->a->cval ) <= 80 )
        {
          strcpy ( aux, s->a->cval );
          adjust_string ( aux );
          strcpy ( s->name, aux );
          s->mask |= SUBSET_MASK_HAVE_NAME;
        }
      else if ( BUFR2TAC_DEBUG_LEVEL > 0 )
        {
          bufr2tac_set_error ( s, 1, "temp_parse_x01()", "Station or site name length > 80. Cannot set s->name" );
        }
      break;
 
    case 101: // 0 01 101 . State identifier
      if ( strlen ( s->a->ctable ) <= 256 )
        {
          strcpy ( aux, s->a->ctable );
          adjust_string ( aux );
          strcpy ( s->country, aux );
          s->mask |= SUBSET_MASK_HAVE_COUNTRY;
        }
      else if ( BUFR2TAC_DEBUG_LEVEL > 0 )
        {
          bufr2tac_set_error ( s, 1, "temp_parse_x01()", "State identifier length > 256. Cannot set s->country" );
        }
      break;
 
    case 125: // 0 01 125 . WIGOS identifier series
      t->wid.series = ( uint8_t ) s->ival;
      break;
 
    case 126: // 0 01 126 . WIGOS issuer of identifier
      t->wid.issuer = ( uint16_t ) s->ival;
      break;
 
    case 127: // 0 01 127 , WIGOS issue number
      t->wid.issue = ( uint16_t ) s->ival;
      break;
 
    case 128: // 0 01 128 . WIGOS local identifier (character)
      if ( strlen ( s->a->cval ) <= 16 )
        {
          strcpy ( t->wid.local_id, s->a->cval );
          if ( check_wigos_local_id ( s->a->cval ) )
            {
              bufr2tac_set_error ( s, 1, "temp_parse_x01()","Bad WIGOS Local identifier" );
            }
          s->mask |= SUBSET_MASK_HAVE_WIGOS_ID ;
        }
      break;
 
    default:
      if ( BUFR2TAC_DEBUG_LEVEL > 1 && ( s->a->mask & DESCRIPTOR_VALUE_MISSING ) == 0 )
        bufr2tac_set_error ( s, 0, "temp_parse_x01()", "Descriptor not parsed" );
      break;
    }
  return 0;
}

References bufr2tac_subset_state::a, temp_chunks::a, temp_acd_sec1::A1, temp_b_sec1::A1, adjust_string(), temp_chunks::b, BUFR2TAC_DEBUG_LEVEL, bufr2tac_set_error(), temp_acd_sec1::bw, temp_b_sec1::bw, temp_chunks::c, check_wigos_local_id(), bufr2tac_subset_state::country, bufr_atom_data::ctable, bufr_atom_data::cval, temp_chunks::d, temp_acd_sec1::D_D, temp_b_sec1::D_D, bufr_atom_data::desc, DESCRIPTOR_VALUE_MISSING, temp_acd_sec1::II, temp_b_sec1::II, temp_acd_sec1::iii, temp_b_sec1::iii, wigos_id::issue, wigos_id::issuer, bufr2tac_subset_state::ival, wigos_id::local_id, bufr_atom_data::mask, bufr2tac_subset_state::mask, bufr2tac_subset_state::name, temp_acd_sec1::Reg, temp_b_sec1::Reg, temp_a::s1, temp_b::s1, temp_c::s1, temp_d::s1, wigos_id::series, SUBSET_MASK_HAVE_COUNTRY, SUBSET_MASK_HAVE_NAME, SUBSET_MASK_HAVE_WIGOS_ID, temp_chunks::wid, 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:

temp_parse_x02()

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

Parse a expanded descriptor with X = 02.

Parameters

t	pointer to a struct temp_chunks where to set the results
s	pointer 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 187 of file bufr2tac_x02.c.

{
  if ( t == NULL )
    return 1;
 
  switch ( s->a->desc.y )
    {
    case 3:  // 0 02 003 . Type of measuring equipment used
      if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
        {
          sprintf ( t->b.s1.a4,"/" );
          return 0;
        }
      switch ( s->ival )
        {
        case 0:
        case 1:
        case 2:
        case 3:
          sprintf ( t->b.s1.a4,"%d", s->ival );
          break;
        case 4:
        case 5:
        case 6:
        case 7:
          sprintf ( t->b.s1.a4,"%d", s->ival + 1 );
          break;
        default:
          strcpy ( t->b.s1.a4, "9" ); // reserved
          break;
        }
      break;
 
    case 11: // 0 02 011 . Radiosonde type
      if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
        {
          sprintf ( t->a.s7.rara, "//" );
          sprintf ( t->b.s7.rara, "//" );
          sprintf ( t->c.s7.rara, "//" );
          sprintf ( t->d.s7.rara, "//" );
          return 0;
        }
      if ( s->ival >= 0 )
        {
          sprintf ( t->a.s7.rara, "%02d", s->ival % 100 );
          sprintf ( t->b.s7.rara, "%02d", s->ival % 100 );
          sprintf ( t->c.s7.rara, "%02d", s->ival % 100 );
          sprintf ( t->d.s7.rara, "%02d", s->ival % 100 );
        }
      break;
 
    case 13: // 0 02 013 . Solar and infrared radiation correction
      if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
        {
          strcpy ( t->a.s7.sr, "/" );
          strcpy ( t->b.s7.sr, "/" );
          strcpy ( t->c.s7.sr, "/" );
          strcpy ( t->d.s7.sr, "/" );
          return 0;
 
        }
      if ( s->ival >= 0 && s->ival <= 7 )
        {
          sprintf ( t->a.s7.sr, "%d", s->ival );
          sprintf ( t->b.s7.sr, "%d", s->ival );
          sprintf ( t->c.s7.sr, "%d", s->ival );
          sprintf ( t->d.s7.sr, "%d", s->ival );
        }
      else
        {
          // case of missing data
          strcpy ( t->a.s7.sr, "/" );
          strcpy ( t->b.s7.sr, "/" );
          strcpy ( t->c.s7.sr, "/" );
          strcpy ( t->d.s7.sr, "/" );
        }
      break;
 
    case 14: // 0 02 014 . Tracking technique/status of system used
      if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
        {
          strcpy ( t->a.s7.sasa, "//" );
          strcpy ( t->b.s7.sasa, "//" );
          strcpy ( t->c.s7.sasa, "//" );
          strcpy ( t->d.s7.sasa, "//" );
          return 0;
        }
      if ( s->ival >= 0 && s->ival < 100 )
        {
          sprintf ( t->a.s7.sasa, "%02d", s->ival );
          sprintf ( t->b.s7.sasa, "%02d", s->ival );
          sprintf ( t->c.s7.sasa, "%02d", s->ival );
          sprintf ( t->d.s7.sasa, "%02d", s->ival );
        }
      else
        {
          strcpy ( t->a.s7.sasa, "//" );
          strcpy ( t->b.s7.sasa, "//" );
          strcpy ( t->c.s7.sasa, "//" );
          strcpy ( t->d.s7.sasa, "//" );
        }
      break;
 
    default:
      if ( BUFR2TAC_DEBUG_LEVEL > 0 )
        bufr2tac_set_error ( s, 0, "temp_parse_x02()", "Descriptor not parsed" );
      break;
    }
  return 0;
}

References bufr2tac_subset_state::a, temp_chunks::a, temp_b_sec1::a4, temp_chunks::b, BUFR2TAC_DEBUG_LEVEL, bufr2tac_set_error(), temp_chunks::c, temp_chunks::d, bufr_atom_data::desc, DESCRIPTOR_VALUE_MISSING, bufr2tac_subset_state::ival, bufr_atom_data::mask, temp_sec7::rara, temp_b::s1, temp_a::s7, temp_b::s7, temp_c::s7, temp_d::s7, temp_sec7::sasa, temp_sec7::sr, 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:

temp_parse_x04()

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

Parse a expanded descriptor with X = 04.

Parameters

t	pointer to a struct temp_chunks where to set the results
s	pointer 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 575 of file bufr2tac_x04.c.

{
  switch ( s->a->desc.y )
    {
    case 1: // 0 04 001 . Year
      if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
        {
          return 0;
        }
      else if ( s->ival < 2000 || s->ival > 2050 )
        {
          if ( BUFR2TAC_DEBUG_LEVEL > 0 )
            bufr2tac_set_error ( s, 2, "temp_parse_x04()", "Bad year" );
          return 1;
        }
      if ( t->a.e.YYYY[0] == 0 )
        {
          sprintf ( t->a.e.YYYY, "%04d", s->ival );
          sprintf ( t->b.e.YYYY, "%04d", s->ival );
          sprintf ( t->c.e.YYYY, "%04d", s->ival );
          sprintf ( t->d.e.YYYY, "%04d", s->ival );
        }
      s->mask |= SUBSET_MASK_HAVE_YEAR;
      break;
 
    case 2: // 0 04 002 . Month
      if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
        {
          return 0;
        }
      if ( t->a.e.MM[0] == 0 )
        {
          sprintf ( t->a.e.MM, "%02d", s->ival );
          sprintf ( t->b.e.MM, "%02d", s->ival );
          sprintf ( t->c.e.MM, "%02d", s->ival );
          sprintf ( t->d.e.MM, "%02d", s->ival );
        }
      s->mask |= SUBSET_MASK_HAVE_MONTH;
      break;
 
    case 3: // 0 04 003 . Day of month
      if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
        {
          return 0;
        }
      if ( t->a.e.DD[0] == 0 )
        {
          sprintf ( t->a.e.DD, "%02d", s->ival );
          sprintf ( t->b.e.DD, "%02d", s->ival );
          sprintf ( t->c.e.DD, "%02d", s->ival );
          sprintf ( t->d.e.DD, "%02d", s->ival );
        }
      s->mask |= SUBSET_MASK_HAVE_DAY;
      //sprintf(t->s0.YY, "%02d", (int) sq->sequence[is].val);
      break;
 
    case 4: // 0 04 004 . Hour
      if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
        {
          return 0;
        }
      if ( t->a.e.HH[0] == 0 )
        {
          sprintf ( t->a.e.HH, "%02d", s->ival );
          sprintf ( t->b.e.HH, "%02d", s->ival );
          sprintf ( t->c.e.HH, "%02d", s->ival );
          sprintf ( t->d.e.HH, "%02d", s->ival );
          sprintf ( t->a.s7.GG, "%02d", s->ival );
          sprintf ( t->b.s7.GG, "%02d", s->ival );
          sprintf ( t->c.s7.GG, "%02d", s->ival );
          sprintf ( t->d.s7.GG, "%02d", s->ival );
        }
      s->mask |= SUBSET_MASK_HAVE_HOUR;
      //sprintf(t->s0.GG, "%02d", (int) sq->sequence[is].val);
      break;
 
    case 5: // 0 04 005 . Minute
      if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
        {
          return 0;
        }
      if ( t->a.e.mm[0] == 0 )
        {
          sprintf ( t->a.e.mm, "%02d", s->ival );
          sprintf ( t->b.e.mm, "%02d", s->ival );
          sprintf ( t->c.e.mm, "%02d", s->ival );
          sprintf ( t->d.e.mm, "%02d", s->ival );
          sprintf ( t->a.s7.gg, "%02d", s->ival );
          sprintf ( t->b.s7.gg, "%02d", s->ival );
          sprintf ( t->c.s7.gg, "%02d", s->ival );
          sprintf ( t->d.s7.gg, "%02d", s->ival );
        }
      s->mask |= SUBSET_MASK_HAVE_MINUTE;
      break;
 
    case 6: // 0 04 006 . Second
      if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
        {
          return 0;
        }
      if ( t->a.e.ss[0] == 0 )
        {
          sprintf ( t->a.e.ss, "%02d", s->ival );
          sprintf ( t->b.e.ss, "%02d", s->ival );
          sprintf ( t->c.e.ss, "%02d", s->ival );
          sprintf ( t->d.e.ss, "%02d", s->ival );
        }
      s->mask |= SUBSET_MASK_HAVE_SECOND;
      break;
 
    case 86: // 0 04 086 . Long time period or displacement (since launch time)
 
      // s->rep is used to check what type of point we are dealing from
      // see repliator 0 31 001 and 0 31 002 to understand it better
      // Because this is the first descriptor in a sequence for a point, we use this
      // descriptor to set properly the current index
      if ( s->rep > 0 )
        {
          // case of Temperature, humidty ... point
          if ( ( int ) s->r->n < s->rep )
            {
              // Because of there are bufr reports with a lot of not significant points
              // we only collect the first one and significant points, i.e. those that flags are non zero
              // When flags are zero we just overwrite points
              if ( s->r->n < ( RAW_TEMP_NMAX_POINTS ) &&
                   ( s->r->n == 0 || s->r->raw[s->r->n - 1].flags ) )
                {
                  s->r->n += 1; // Here we update the index
                }
            }
          s->r->raw[s->r->n - 1].dt = s->ival;
        }
      else
        {
          // case of wind shear point
          if ( ( int ) s->w->n < s->itval )
            {
              s->w->n += 1;
            }
          s->w->raw[s->w->n - 1].dt = s->ival;
        }
      break;
 
    default:
      if ( BUFR2TAC_DEBUG_LEVEL > 1 && ( s->a->mask & DESCRIPTOR_VALUE_MISSING ) == 0 )
        bufr2tac_set_error ( s, 0, "temp_parse_x04()", "Descriptor not parsed" );
      break;
    }
  return 0;
}

References bufr2tac_subset_state::a, temp_chunks::a, temp_chunks::b, BUFR2TAC_DEBUG_LEVEL, bufr2tac_set_error(), temp_chunks::c, temp_chunks::d, report_date_ext::DD, bufr_atom_data::desc, DESCRIPTOR_VALUE_MISSING, temp_raw_point_data::dt, temp_raw_wind_shear_point::dt, temp_a::e, temp_b::e, temp_c::e, temp_d::e, temp_raw_point_data::flags, temp_sec7::GG, temp_sec7::gg, report_date_ext::HH, bufr2tac_subset_state::itval, bufr2tac_subset_state::ival, bufr_atom_data::mask, bufr2tac_subset_state::mask, report_date_ext::MM, report_date_ext::mm, temp_raw_data::n, temp_raw_wind_shear_data::n, bufr2tac_subset_state::r, temp_raw_data::raw, temp_raw_wind_shear_data::raw, RAW_TEMP_NMAX_POINTS, bufr2tac_subset_state::rep, temp_a::s7, temp_b::s7, temp_c::s7, temp_d::s7, report_date_ext::ss, SUBSET_MASK_HAVE_DAY, SUBSET_MASK_HAVE_HOUR, SUBSET_MASK_HAVE_MINUTE, SUBSET_MASK_HAVE_MONTH, SUBSET_MASK_HAVE_SECOND, SUBSET_MASK_HAVE_YEAR, bufr2tac_subset_state::w, bufr_descriptor::y, and report_date_ext::YYYY.

Referenced by parse_subset_as_temp().

Here is the call graph for this function:

Here is the caller graph for this function:

temp_parse_x05()

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

Definition at line 204 of file bufr2tac_x05.c.

{
  int ia;
 
  if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
    return 0;
 
  // this is to avoid warning
  if ( t == NULL )
    return 1;
 
  switch ( s->a->desc.y )
    {
    case 1: // 0 05 001 . Latitude (High accuracy)
    case 2: // 0 05 002 . Latitude (Coarse accuracy)
      if ( s->val < 0.0 )
        s->mask |= SUBSET_MASK_LATITUDE_SOUTH; // Sign for latitude
      s->mask |= SUBSET_MASK_HAVE_LATITUDE;
      s->lat = s->val;
      ia = ( int ) ( fabs ( s->val ) * 10.0 + 0.5 );
      sprintf ( t->a.s1.LaLaLa, "%03d",ia );
      sprintf ( t->b.s1.LaLaLa, "%03d",ia );
      sprintf ( t->c.s1.LaLaLa, "%03d",ia );
      sprintf ( t->d.s1.LaLaLa, "%03d",ia );
      t->a.s1.Ula[0] = t->a.s1.LaLaLa[1];
      t->b.s1.Ula[0] = t->b.s1.LaLaLa[1];
      t->c.s1.Ula[0] = t->c.s1.LaLaLa[1];
      t->d.s1.Ula[0] = t->d.s1.LaLaLa[1];
 
      // check if set both LaLaLa and LoLoLoLo to set Qc
      if ( ( t->a.s1.Qc[0] == 0 ) && t->a.s1.LaLaLa[0] && t->a.s1.LoLoLoLo[0] )
        {
          if ( s->mask & SUBSET_MASK_LATITUDE_SOUTH )
            {
              if ( s->mask & SUBSET_MASK_LONGITUDE_WEST )
                strcpy ( t->a.s1.Qc, "5" );
              else
                strcpy ( t->a.s1.Qc, "3" );
            }
          else
            {
              if ( s->mask & SUBSET_MASK_LONGITUDE_WEST )
                strcpy ( t->a.s1.Qc, "7" );
              else
                strcpy ( t->a.s1.Qc, "1" );
            }
          strcpy ( t->b.s1.Qc, t->a.s1.Qc );
          strcpy ( t->c.s1.Qc, t->a.s1.Qc );
          strcpy ( t->d.s1.Qc, t->a.s1.Qc );
        }
 
      // check if about MMM
      if ( ( t->a.s1.MMM[0] == 0 ) && t->a.s1.LaLaLa[0] && t->a.s1.LoLoLoLo[0] )
        {
          latlon_to_MMM ( t->a.s1.MMM, s->lat, s->lon );
          strcpy ( t->b.s1.MMM, t->a.s1.MMM );
          strcpy ( t->c.s1.MMM, t->a.s1.MMM );
          strcpy ( t->d.s1.MMM, t->a.s1.MMM );
        }
      break;
 
    case 15: // 0 05 015. Latitude displacement since launch site (high accuracy)
      if ( s->rep > 0 && s->r->n > 0 )
        {
          s->r->raw[s->r->n - 1].dlat = s->val;
        }
      else if ( s->w->n > 0 )
        {
          s->w->raw[s->w->n - 1].dlat = s->val;
        }
      break;
 
    default:
      if ( BUFR2TAC_DEBUG_LEVEL > 1 && (s->a->mask & DESCRIPTOR_VALUE_MISSING) == 0 ) 
        bufr2tac_set_error ( s, 0, "temp_parse_x05()", "Descriptor not parsed" );
      break;
    }
 
  return 0;
}

References bufr2tac_subset_state::a, temp_chunks::a, temp_chunks::b, BUFR2TAC_DEBUG_LEVEL, bufr2tac_set_error(), temp_chunks::c, temp_chunks::d, bufr_atom_data::desc, DESCRIPTOR_VALUE_MISSING, temp_raw_point_data::dlat, temp_raw_wind_shear_point::dlat, temp_acd_sec1::LaLaLa, temp_b_sec1::LaLaLa, bufr2tac_subset_state::lat, latlon_to_MMM(), temp_acd_sec1::LoLoLoLo, bufr2tac_subset_state::lon, bufr_atom_data::mask, bufr2tac_subset_state::mask, temp_acd_sec1::MMM, temp_b_sec1::MMM, temp_raw_data::n, temp_raw_wind_shear_data::n, temp_acd_sec1::Qc, temp_b_sec1::Qc, bufr2tac_subset_state::r, temp_raw_data::raw, temp_raw_wind_shear_data::raw, bufr2tac_subset_state::rep, temp_a::s1, temp_b::s1, temp_c::s1, temp_d::s1, SUBSET_MASK_HAVE_LATITUDE, SUBSET_MASK_LATITUDE_SOUTH, SUBSET_MASK_LONGITUDE_WEST, temp_acd_sec1::Ula, temp_b_sec1::Ula, bufr2tac_subset_state::val, bufr2tac_subset_state::w, 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:

temp_parse_x06()

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

Definition at line 200 of file bufr2tac_x06.c.

{
  int ia;
 
  if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
    return 0;
 
  switch ( s->a->desc.y )
    {
    case 1: // 0 06 001 . Longitude (High accuracy)
    case 2: // 0 06 002 . Longitude (Coarse)
      if ( s->val < 0.0 )
        s->mask |= SUBSET_MASK_LONGITUDE_WEST; // Sign for longitude
      s->mask |= SUBSET_MASK_HAVE_LONGITUDE;
      ia = ( int ) ( fabs ( s->val ) * 10.0 + 0.5 );
      sprintf ( t->a.s1.LoLoLoLo, "%04d",ia );
      sprintf ( t->b.s1.LoLoLoLo, "%04d",ia );
      sprintf ( t->c.s1.LoLoLoLo, "%04d",ia );
      sprintf ( t->d.s1.LoLoLoLo, "%04d",ia );
      t->a.s1.Ulo[0] = t->a.s1.LoLoLoLo[2];
      t->b.s1.Ulo[0] = t->b.s1.LoLoLoLo[2];
      t->c.s1.Ulo[0] = t->c.s1.LoLoLoLo[2];
      t->d.s1.Ulo[0] = t->d.s1.LoLoLoLo[2];
      s->lon = s->val;
 
      // check if set both LaLaLa and LoLoLoLo to set Qc
      if ( ( t->a.s1.Qc[0] == 0 ) && t->a.s1.LaLaLa[0] && t->a.s1.LoLoLoLo[0] )
        {
          if ( s->mask & SUBSET_MASK_LATITUDE_SOUTH )
            {
              if ( s->mask & SUBSET_MASK_LONGITUDE_WEST )
                strcpy ( t->a.s1.Qc, "5" );
              else
                strcpy ( t->a.s1.Qc, "3" );
            }
          else
            {
              if ( s->mask & SUBSET_MASK_LONGITUDE_WEST )
                strcpy ( t->a.s1.Qc, "7" );
              else
                strcpy ( t->a.s1.Qc, "1" );
            }
          strcpy ( t->b.s1.Qc, t->a.s1.Qc );
          strcpy ( t->c.s1.Qc, t->a.s1.Qc );
          strcpy ( t->d.s1.Qc, t->a.s1.Qc );
        }
 
      // check if about MMM
      if ( ( t->a.s1.MMM[0] == 0 ) && t->a.s1.LaLaLa[0] && t->a.s1.LoLoLoLo[0] )
        {
          latlon_to_MMM ( t->a.s1.MMM, s->lat, s->lon );
          strcpy ( t->b.s1.MMM, t->a.s1.MMM );
          strcpy ( t->c.s1.MMM, t->a.s1.MMM );
          strcpy ( t->d.s1.MMM, t->a.s1.MMM );
        }
      break;
 
    case 15: // 0 06 015. Longitude displacement since launch site (high accuracy)
      if ( s->rep > 0 && s->r->n > 0 )
        {
          s->r->raw[s->r->n - 1].dlon = s->val;
        }
      else if ( s->w->n > 0 )
        {
          s->w->raw[s->w->n - 1].dlon = s->val;
        }
      break;
 
    default:
      if ( BUFR2TAC_DEBUG_LEVEL > 1 && (s->a->mask & DESCRIPTOR_VALUE_MISSING) == 0 ) 
        bufr2tac_set_error ( s, 0, "temp_parse_x06()", "Descriptor not parsed" );
      break;
    }
 
  return 0;
}

References bufr2tac_subset_state::a, temp_chunks::a, temp_chunks::b, BUFR2TAC_DEBUG_LEVEL, bufr2tac_set_error(), temp_chunks::c, temp_chunks::d, bufr_atom_data::desc, DESCRIPTOR_VALUE_MISSING, temp_raw_point_data::dlon, temp_raw_wind_shear_point::dlon, temp_acd_sec1::LaLaLa, bufr2tac_subset_state::lat, latlon_to_MMM(), temp_acd_sec1::LoLoLoLo, temp_b_sec1::LoLoLoLo, bufr2tac_subset_state::lon, bufr_atom_data::mask, bufr2tac_subset_state::mask, temp_acd_sec1::MMM, temp_b_sec1::MMM, temp_raw_data::n, temp_raw_wind_shear_data::n, temp_acd_sec1::Qc, temp_b_sec1::Qc, bufr2tac_subset_state::r, temp_raw_data::raw, temp_raw_wind_shear_data::raw, bufr2tac_subset_state::rep, temp_a::s1, temp_b::s1, temp_c::s1, temp_d::s1, SUBSET_MASK_HAVE_LONGITUDE, SUBSET_MASK_LATITUDE_SOUTH, SUBSET_MASK_LONGITUDE_WEST, temp_acd_sec1::Ulo, temp_b_sec1::Ulo, bufr2tac_subset_state::val, bufr2tac_subset_state::w, 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:

temp_parse_x07()

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

Definition at line 258 of file bufr2tac_x07.c.

{
  if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
    {
      return 0;
    }
 
// this is to avoid warning
  if ( t == NULL )
    {
      return 1;
    }
 
  switch ( s->a->desc.y )
    {
    case 4:  // 0 07 004 . Pressure
      if ( s->rep > 0 && s->r->n > 0 )
        {
          s->r->raw[s->r->n - 1].p = s->val;
        }
      else if ( s->w->n > 0 )
        {
          s->w->raw[s->w->n - 1].p = s->val;
        }
      break;
 
    case 30: // 0 07 030 . Height of station ground above msl
      sprintf ( t->a.s1.h0h0h0h0, "%04.0lf" , s->val );
      sprintf ( t->b.s1.h0h0h0h0, "%04.0lf" , s->val );
      sprintf ( t->c.s1.h0h0h0h0, "%04.0lf" , s->val );
      sprintf ( t->d.s1.h0h0h0h0, "%04.0lf" , s->val );
      break;
 
    case 31: // 0 07 031 . Height of barometer above msl
      s->alt = s->val;
      break;
 
    default:
      if ( BUFR2TAC_DEBUG_LEVEL > 1 && (s->a->mask & DESCRIPTOR_VALUE_MISSING) == 0 ) 
        bufr2tac_set_error ( s, 0, "temp_parse_x07()", "Descriptor not parsed" );
      break;
    }
 
  return 0;
}

References bufr2tac_subset_state::a, temp_chunks::a, bufr2tac_subset_state::alt, temp_chunks::b, BUFR2TAC_DEBUG_LEVEL, bufr2tac_set_error(), temp_chunks::c, temp_chunks::d, bufr_atom_data::desc, DESCRIPTOR_VALUE_MISSING, temp_acd_sec1::h0h0h0h0, temp_b_sec1::h0h0h0h0, bufr_atom_data::mask, temp_raw_data::n, temp_raw_wind_shear_data::n, temp_raw_point_data::p, temp_raw_wind_shear_point::p, bufr2tac_subset_state::r, temp_raw_data::raw, temp_raw_wind_shear_data::raw, bufr2tac_subset_state::rep, temp_a::s1, temp_b::s1, temp_c::s1, temp_d::s1, bufr2tac_subset_state::val, bufr2tac_subset_state::w, 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:

temp_parse_x08()

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

Parse a expanded descriptor with X = 08.

Parameters

t	pointer to a struct temp_chunks where to set the results
s	pointer 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 421 of file bufr2tac_x08.c.

{
  if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
    {
      return 0;
    }
 
  if ( t == NULL )
    {
      return 1;
    }
 
  switch ( s->a->desc.y )
    {
    case 2: // 0 08 002.
      // this is to mark of the begining or end of cloud surface data
      if ( s->isq == 0 )
        {
          s->isq = 1;
        }
      else
        {
          s->isq = 0;
        }
      break;
 
    case 21: // 0 08 021. Time significance
      if ( s->ival != 18 )
        {
          return 1;  // it should be 18 (launch date/time)
        }
      break;
 
    case 42: // 0 08 042. Extended vertical sounding significance
      if ( s->rep > 0 && s->r->n > 0 )
        {
          s->r->raw[s->r->n - 1].flags = s->ival;
        }
      else if ( s->w->n > 0 )
        {
          // wind shear case
          s->w->raw[s->w->n - 1].flags = s->ival;
        }
      break;
 
    default:
      if ( BUFR2TAC_DEBUG_LEVEL > 1 && (s->a->mask & DESCRIPTOR_VALUE_MISSING) == 0 ) 
        bufr2tac_set_error ( s, 0, "temp_parse_x08()", "Descriptor not parsed" );
      break;
    }
  return 0;
}

References bufr2tac_subset_state::a, BUFR2TAC_DEBUG_LEVEL, bufr2tac_set_error(), bufr_atom_data::desc, DESCRIPTOR_VALUE_MISSING, temp_raw_point_data::flags, temp_raw_wind_shear_point::flags, bufr2tac_subset_state::isq, bufr2tac_subset_state::ival, bufr_atom_data::mask, 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::w, 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:

temp_parse_x10()

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

Parse a expanded descriptor with X = 10.

Parameters

t	pointer to a struct temp_chunks where to set the results
s	pointer 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 297 of file bufr2tac_x10.c.

{
  if ( t == NULL || s == NULL )
    {
      return 1;
    }
 
  if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
    {
      return 0;
    }
 
  switch ( s->a->desc.y )
    {
    case 9: // 0 10 009. geopotential
      if ( s->rep > 0 && s->r->n > 0 )
        {
          s->r->raw[s->r->n - 1].h = s->val;
        }
      break;
 
    default:
      if ( BUFR2TAC_DEBUG_LEVEL > 1 && (s->a->mask & DESCRIPTOR_VALUE_MISSING) == 0 ) 
        bufr2tac_set_error ( s, 0, "temp_parse_x10()", "Descriptor not parsed" );
      break;
    }
  return 0;
}

References bufr2tac_subset_state::a, BUFR2TAC_DEBUG_LEVEL, bufr2tac_set_error(), bufr_atom_data::desc, DESCRIPTOR_VALUE_MISSING, temp_raw_point_data::h, bufr_atom_data::mask, temp_raw_data::n, bufr2tac_subset_state::r, temp_raw_data::raw, bufr2tac_subset_state::rep, bufr2tac_subset_state::val, 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:

temp_parse_x11()

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

Parse a expanded descriptor with X = 11.

Parameters

t	pointer to a struct temp_chunks where to set the results
s	pointer 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.

{
 
  if ( t == NULL )
    {
      return 1;
    }
 
  switch ( s->a->desc.y )
    {
    case 1: // 0 11 001. Wind direction
      if ( s->rep > 0 && s->r->n > 0 )
        {
          if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
            {
              s->r->raw[s->r->n - 1].dd = MISSING_REAL;
            }
          else
            {
              s->r->raw[s->r->n - 1].dd = s->val;
            }
        }
      break;
 
    case 2: // 0 11 002. Wind speed
      if ( s->rep > 0 && s->r->n > 0 )
        {
          if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
            {
              s->r->raw[s->r->n - 1].ff = MISSING_REAL;
            }
          else
            {
              s->r->raw[s->r->n - 1].ff = s->val;
            }
        }
      break;
 
    case 61: // 0 11 061. Absolute wind shear in 1 km layer below
      if ( s->w->n > 0 )
        {
          if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
            {
              s->w->raw[s->w->n - 1].ws_blw = MISSING_REAL;
            }
          else
            {
              s->w->raw[s->w->n - 1].ws_blw = s->val;
            }
        }
      break;
 
    case 62: // 0 11 062. Absolute wind shear in 1 km layer above
      if ( s->w->n > 0 )
        {
          if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
            {
              s->w->raw[s->w->n - 1].ws_abv = MISSING_REAL;
            }
          else
            {
              s->w->raw[s->w->n - 1].ws_abv = s->val;
            }
        }
      break;
 
    default:
      if ( BUFR2TAC_DEBUG_LEVEL > 1 && (s->a->mask & DESCRIPTOR_VALUE_MISSING) == 0 ) 
        bufr2tac_set_error ( s, 0, "temp_parse_x11()", "Descriptor not parsed" );
      break;
    }
  return 0;
}

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:

temp_parse_x12()

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

Parse a expanded descriptor with X = 12.

Parameters

t	pointer to a struct temp_chunks where to set the results
s	pointer 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 751 of file bufr2tac_x12.c.

{
  if ( t == NULL )
    {
      return 1;
    }
 
  switch ( s->a->desc.y )
    {
    case 101: // 0 12 101. Temperature/dry-bulb temperature (scale 2)
      if ( s->rep > 0 && s->r->n > 0 )
        {
          if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
            {
              s->r->raw[s->r->n - 1].T = MISSING_REAL;
            }
          else
            {
              s->r->raw[s->r->n - 1].T = s->val;
            }
        }
      break;
 
    case 103: // 0 12 103. Dew-point temperature (scale 2)
      if ( s->rep > 0 && s->r->n > 0 )
        {
          if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
            {
              s->r->raw[s->r->n - 1].Td = MISSING_REAL;
            }
          else
            {
              s->r->raw[s->r->n - 1].Td = s->val;
            }
        }
      break;
 
    default:
      if ( BUFR2TAC_DEBUG_LEVEL > 1 && (s->a->mask & DESCRIPTOR_VALUE_MISSING) == 0 ) 
        bufr2tac_set_error ( s, 0, "temp_parse_x12()", "Descriptor not parsed" );
      break;
    }
 
  return 0;
}

References bufr2tac_subset_state::a, BUFR2TAC_DEBUG_LEVEL, bufr2tac_set_error(), bufr_atom_data::desc, DESCRIPTOR_VALUE_MISSING, bufr_atom_data::mask, MISSING_REAL, temp_raw_data::n, bufr2tac_subset_state::r, temp_raw_data::raw, bufr2tac_subset_state::rep, temp_raw_point_data::T, temp_raw_point_data::Td, bufr2tac_subset_state::val, 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:

temp_parse_x20()

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

Parse a expanded descriptor with X = 20.

Parameters

t	pointer to a struct temp_chunks where to set the results
s	pointer 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 1354 of file bufr2tac_x20.c.

{
 
  switch ( s->a->desc.y )
    {
    case 11: // 0 20 011 . Cloud amount
      if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
        {
          return 0;
        }
      if ( s->ival <= 8 )
        {
          sprintf ( t->b.s8.Nh, "%1d", abs(s->ival) % 10 );
        }
      else if ( s->ival <= 10 )
        {
          sprintf ( t->b.s8.Nh, "9" );
        }
      else if ( s->ival == 15 )
        {
          sprintf ( t->b.s8.Nh, "/" );
        }
      t->b.mask |= TEMP_SEC_8;
      break;
 
    case 12: // 0 20 012 . Cloud type
      if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
        {
          return 0;
        }
      if ( s->ival >= 10 && s->ival < 20 )
        {
          sprintf ( t->b.s8.Ch, "%1d", s->ival % 10 );
        }
      else if ( s->ival >= 20 && s->ival < 30 )
        {
          sprintf ( t->b.s8.Cm, "%1d", s->ival % 10 );
        }
      else if ( s->ival >= 30 && s->ival < 40 )
        {
          sprintf ( t->b.s8.Cl, "%1d", s->ival % 10 );
        }
      else if ( s->ival == 59 )
        {
          sprintf ( t->b.s8.Nh, "/" );
        }
      else if ( s->ival == 60 )
        {
          sprintf ( t->b.s8.Ch, "/" );
        }
      else if ( s->ival == 61 )
        {
          sprintf ( t->b.s8.Cm, "/" );
        }
      else if ( s->ival == 62 )
        {
          sprintf ( t->b.s8.Cl, "/" );
        }
      t->b.mask |= TEMP_SEC_8;
      break;
 
    case 13: // 0 20 013 . Height of base of cloud
      if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
        {
          return 0;
        }
      m_to_h ( t->b.s8.h, s->val );
      break;
 
    default:
      if ( BUFR2TAC_DEBUG_LEVEL > 1 && (s->a->mask & DESCRIPTOR_VALUE_MISSING) == 0 ) 
        bufr2tac_set_error ( s, 0, "temp_parse_x20()", "Descriptor not parsed" );
      break;
    }
  return 0;
}

References bufr2tac_subset_state::a, temp_chunks::b, BUFR2TAC_DEBUG_LEVEL, bufr2tac_set_error(), temp_b_sec8::Ch, temp_b_sec8::Cl, temp_b_sec8::Cm, bufr_atom_data::desc, DESCRIPTOR_VALUE_MISSING, temp_b_sec8::h, bufr2tac_subset_state::ival, m_to_h(), bufr_atom_data::mask, temp_b::mask, temp_b_sec8::Nh, temp_b::s8, TEMP_SEC_8, bufr2tac_subset_state::val, 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:

temp_parse_x22()

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

Parse a expanded descriptor with X = 22.

Parameters

t	pointer to a struct temp_chunks where to set the results
s	pointer 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 289 of file bufr2tac_x22.c.

{
  char aux[16];
 
  if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
    return 0;
 
  switch ( s->a->desc.y )
    {
    case 43:
      if ( kelvin_to_snTTT ( aux, s->val ) )
        {
          t->a.s7.sn[0] = aux[0];
          t->b.s7.sn[0] = aux[0];
          t->c.s7.sn[0] = aux[0];
          t->d.s7.sn[0] = aux[0];
          strcpy ( t->a.s7.TwTwTw, aux + 1 );
          strcpy ( t->b.s7.TwTwTw, aux + 1 );
          strcpy ( t->c.s7.TwTwTw, aux + 1 );
          strcpy ( t->d.s7.TwTwTw, aux + 1 );
          t->a.mask |= TEMP_SEC_7; // have sec7 data
        }
      break;
 
    default:
      if ( BUFR2TAC_DEBUG_LEVEL > 1 && (s->a->mask & DESCRIPTOR_VALUE_MISSING) == 0 ) 
        bufr2tac_set_error ( s, 0, "temp_parse_x22()", "Descriptor not parsed" );
      break;
    }
 
  return 0;
}

References bufr2tac_subset_state::a, temp_chunks::a, temp_chunks::b, BUFR2TAC_DEBUG_LEVEL, bufr2tac_set_error(), temp_chunks::c, temp_chunks::d, bufr_atom_data::desc, DESCRIPTOR_VALUE_MISSING, kelvin_to_snTTT(), bufr_atom_data::mask, temp_a::mask, temp_a::s7, temp_b::s7, temp_c::s7, temp_d::s7, temp_sec7::sn, TEMP_SEC_7, temp_sec7::TwTwTw, bufr2tac_subset_state::val, 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:

temp_parse_x31()

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

Parse a expanded descriptor with X = 31.

Parameters

t	pointer to a struct temp_chunks where to set the results
s	pointer 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 120 of file bufr2tac_x31.c.

{
  if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
    {
      return 0;
    }
 
  if ( t == NULL )
    {
      return 1;
    }
 
  switch ( s->a->desc.y )
    {
    case 0: // 0 31 000 .  Short delayed descriptor replication factor
      // It is no meaning here
      break;
    case 1: // 0 31 001 .  Replicator
      // It is supposed that it is the extended replicator used when describing
      // wind shear points in raiosonde
      // It is the amount of points of wind shear data at pressure level
      if ( s->ival < TEMP_NMAX_POINTS )
        {
          s->itval = s->ival;
          s->rep = 0;  // used to mark it is a share point in sequent descriptors
        }
      else
        {
          return 1;  // too much points
        }
      s->k_itval = s->i;
      s->w->n = 0;
      break;
 
    case 2: // 0 31 002 . Extended replicator
      // It is supposed that it is the extended replicator used when describing
      // Temperature, dew-point and wind data at a pressure level with radiosonde position
      // So the integer value of repliactor IS the amount of points
      s->rep = s->ival; // replications and points we need. Also Used to mark this type of point
      s->itval = 0;
      s->k_rep = s->i;
      s->r->n = 0;
      break;
    default:
      if ( BUFR2TAC_DEBUG_LEVEL > 1 && (s->a->mask & DESCRIPTOR_VALUE_MISSING) == 0 ) 
        bufr2tac_set_error ( s, 0, "temp_parse_x31()", "Descriptor not parsed" );
      break;
    }
  return 0;
}

References bufr2tac_subset_state::a, BUFR2TAC_DEBUG_LEVEL, bufr2tac_set_error(), bufr_atom_data::desc, DESCRIPTOR_VALUE_MISSING, bufr2tac_subset_state::i, bufr2tac_subset_state::itval, bufr2tac_subset_state::ival, bufr2tac_subset_state::k_itval, bufr2tac_subset_state::k_rep, bufr_atom_data::mask, temp_raw_data::n, temp_raw_wind_shear_data::n, bufr2tac_subset_state::r, bufr2tac_subset_state::rep, TEMP_NMAX_POINTS, bufr2tac_subset_state::w, 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:

temp_parse_x33()

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

Parse a expanded descriptor with X = 33.

Parameters

t	pointer to a struct temp_chunks where to set the results
s	pointer 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 100 of file bufr2tac_x33.c.

{
 
  switch ( s->a->desc.y )
    {
    case 24: // 0 33 024. Station elevation quality mark (for mobile stations)
      if ( s->a->mask & DESCRIPTOR_VALUE_MISSING )
        {
          strcpy ( t->a.s1.im, "/" );
          strcpy ( t->b.s1.im, "/" );
          strcpy ( t->c.s1.im, "/" );
          strcpy ( t->d.s1.im, "/" );
          return 0;
        }
 
      if ( s->ival >= 0 && s->ival < 9 )
        {
          sprintf ( t->a.s1.im, "%d", s->ival );
          sprintf ( t->a.s1.im, "%d", s->ival );
          sprintf ( t->a.s1.im, "%d", s->ival );
          sprintf ( t->a.s1.im, "%d", s->ival );
        }
      else
        {
          strcpy ( t->a.s1.im, "/" );
          strcpy ( t->b.s1.im, "/" );
          strcpy ( t->c.s1.im, "/" );
          strcpy ( t->d.s1.im, "/" );
        }
      break;  
    default:
      if ( BUFR2TAC_DEBUG_LEVEL > 1 && (s->a->mask & DESCRIPTOR_VALUE_MISSING) == 0 ) 
        bufr2tac_set_error ( s, 0, "temp_parse_x33()", "Descriptor not parsed" );
      break;
    }
  return 0;
}

References bufr2tac_subset_state::a, temp_chunks::a, temp_chunks::b, BUFR2TAC_DEBUG_LEVEL, bufr2tac_set_error(), temp_chunks::c, temp_chunks::d, bufr_atom_data::desc, DESCRIPTOR_VALUE_MISSING, temp_acd_sec1::im, temp_b_sec1::im, bufr2tac_subset_state::ival, bufr_atom_data::mask, temp_a::s1, temp_b::s1, temp_c::s1, temp_d::s1, 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:

three_bytes_to_uint()

three_bytes_to_uint

(

const unsigned char *

source

)

returns the integer value from an array of three bytes, most significant first

Definition at line 30 of file bufr2tac_utils.c.

{
  return ( source[2] + source[1] * 256 + source[0] * 65536 );
}

Referenced by read_bufr().

Here is the caller graph for this function:

time_period_duration()

int time_period_duration

(

struct bufr2tac_subset_state *

s

)

Get time period duration in seconds.

Parameters

s	pinter to struct bufr2tac_subset_state

Returns -1 if no duration is computed. Otherwise returns time duration in seconds

Definition at line 33 of file bufr2tac_x04.c.

{
  if ( s->k_itval == ( s->k_jtval + 1 ) )
    {
      // two consecutive time period displacements
      if ( ( s->itmask & DESCRIPTOR_VALUE_MISSING ) == 0  &&
           ( s->jtmask & DESCRIPTOR_VALUE_MISSING ) == 0 )
        {
          return ( abs ( s->itval - s->jtval ) );
        }
      else if ( ( s->itmask & DESCRIPTOR_VALUE_MISSING )  &&
                ( s->jtmask & DESCRIPTOR_VALUE_MISSING ) )
        {
          return 0;
        }
      else if ( ( s->itmask & DESCRIPTOR_VALUE_MISSING ) == 0 &&
                ( s->jtmask & DESCRIPTOR_VALUE_MISSING ) )
        {
          return ( abs ( s->itval ) );
        }
      else if ( ( s->jtmask & DESCRIPTOR_VALUE_MISSING ) == 0 &&
                ( s->itmask & DESCRIPTOR_VALUE_MISSING ) )
        {
          return -1;
        }
    }
 
  // just a single time period displacement
  if ( ( s->itmask & DESCRIPTOR_VALUE_MISSING ) == 0 )
    {
      return ( abs ( s->itval ) );
    }
  else
    {
      return 0;
    }
}

References DESCRIPTOR_VALUE_MISSING, bufr2tac_subset_state::itmask, bufr2tac_subset_state::itval, bufr2tac_subset_state::jtmask, bufr2tac_subset_state::jtval, bufr2tac_subset_state::k_itval, and bufr2tac_subset_state::k_jtval.

Referenced by syn_parse_x12(), syn_parse_x13(), and syn_parse_x14().

Here is the caller graph for this function:

total_snow_depth_to_sss()

char * total_snow_depth_to_sss	(	char *	target,
		double	r
	)

converts tatal snow depth in m to sss (code table 3889)

Parameters

r	recent snow depth in meters
target	the resulting string

Definition at line 124 of file bufr2tac_x13.c.

{
  int i;
  if ( r >= 0.0 )
    i = ( int ) ( r * 100.0 + 0.5 ); // convert to cm
  else
    i = ( int ) ( r * 100.0 - 0.5 ); // convert to cm
 
  if ( i > 0 && i <= 996 )
    {
      sprintf ( target, "%03d", i );
    }
  else if ( i == -1 )
    {
      sprintf ( target, "997" );
    }
  else if ( i == -2 )
    {
      sprintf ( target, "998" );
    }
  else
    {
      sprintf ( target, "999" );
    }
  return target;
}

Referenced by syn_parse_x13().

Here is the caller graph for this function:

vism_to_VV()

char * vism_to_VV	(	char *	target,
		double	V
	)

Convert horizontal visibilty in meters to a VV string.

Parameters

V	the visibility (m)
target	the resulting VV string

Definition at line 226 of file bufr2tac_x20.c.

{
  if ( V < 100.0 )
    {
      strcpy ( target, "00" );
    }
  else if ( V <= 5000.0 )
    {
      sprintf ( target, "%02d", ( int ) ( V + 0.1 ) / 100 );
    }
  else if ( V < 6000.0 )
    {
      sprintf ( target, "50" );  // this is to avoid 51-55 range
    }
  else if ( V <= 30000.0 )
    {
      sprintf ( target, "%02d", ( int ) ( V + 0.1 ) / 1000 + 50 );
    }
  else if ( V <= 70000.0 )
    {
      sprintf ( target, "%02d", ( int ) ( V - 30000.0 ) / 5000 + 80 );
    }
  else
    {
      strcpy ( target, "89" );
    }
  return target;
}

Referenced by syn_parse_x20().

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.

{
  int ix;
 
  if ( dd == MISSING_REAL || ff == MISSING_REAL )
    {
      strcpy ( target, "/////" );
      return target;
    }
 
  ix = ( int ) ( ( dd + 2.5 ) / 5 ) * 5 * 100 + ( int ) ( ff + 0.5 );
  sprintf ( target, "%05d", ix );
  return target;
}

References MISSING_REAL.

Referenced by parse_temp_raw_data().

Here is the caller graph for this function:

YYYYMMDDHHmm_to_met_datetime()

int YYYYMMDDHHmm_to_met_datetime	(	struct met_datetime *	t,
		const char *	source
	)

Parse the string YYYYMMDDHHmm[ss] and set a struct met_datetime.

Parameters

source	string with date in YYYYMMDDHHmm[ss] format
t	pointer to a struct met_datetime where to set the results

Definition at line 156 of file bufr2tac_utils.c.

{
  if ( strlen ( source ) != 12  && strlen ( source ) != 14 )
    return 1;
  memset ( &t->tim, 0, sizeof ( struct tm ) );
  if ( strlen ( source ) == 12 )
    {
      strptime ( source, "%Y%m%d%H%M", &t->tim );
    }
  else
    {
      strptime ( source, "%Y%m%d%H%M%S", &t->tim );
    }
  strcpy ( t->datime, source );
  t->t = mktime ( &t->tim );
  return 0;
}

References met_datetime::datime, met_datetime::t, and met_datetime::tim.

Referenced by parse_subset_as_buoy(), parse_subset_as_climat(), parse_subset_as_synop(), and parse_subset_as_temp().

Here is the caller graph for this function:

Variable Documentation

BUFR2TAC_DEBUG_LEVEL

int BUFR2TAC_DEBUG_LEVEL

extern

Set debug level. 0 -> no debug. 1 -> debug. 2 -> verbose debug

Definition at line 31 of file bufr2tac.c.

Referenced by bufr2tac_set_debug_level(), buoy_parse_x01(), buoy_parse_x02(), buoy_parse_x04(), buoy_parse_x05(), buoy_parse_x06(), buoy_parse_x07(), buoy_parse_x08(), buoy_parse_x10(), buoy_parse_x11(), buoy_parse_x12(), buoy_parse_x13(), buoy_parse_x14(), buoy_parse_x20(), buoy_parse_x22(), buoy_parse_x31(), buoy_parse_x33(), climat_parse_x01(), climat_parse_x02(), climat_parse_x04(), climat_parse_x05(), climat_parse_x06(), climat_parse_x07(), climat_parse_x08(), climat_parse_x10(), climat_parse_x11(), climat_parse_x12(), climat_parse_x13(), climat_parse_x14(), parse_subset_sequence(), syn_parse_x01(), syn_parse_x02(), syn_parse_x04(), syn_parse_x05(), syn_parse_x06(), syn_parse_x07(), syn_parse_x08(), syn_parse_x10(), syn_parse_x11(), syn_parse_x12(), syn_parse_x13(), syn_parse_x14(), syn_parse_x20(), syn_parse_x22(), syn_parse_x31(), temp_parse_x01(), temp_parse_x02(), temp_parse_x04(), temp_parse_x05(), temp_parse_x06(), temp_parse_x07(), temp_parse_x08(), temp_parse_x10(), temp_parse_x11(), temp_parse_x12(), temp_parse_x20(), temp_parse_x22(), temp_parse_x31(), and temp_parse_x33().