/* Name- processCOSMIC590.c Language- C Type- MAIN Version- 1.0 Date- 1/30/2017 Programmer- Mike Pettey (IMSG) Function- This program extracts data from P72 EDR files in HDF5 format and writes the data to an EDGE orbital file. The selected data is defined in the run script. Also in the run script are the starting date (YYYYMMDD) and hour and the ending date and hour. */ #include #include #include #include #include #include #include "nprovs_to_netcdf.h" #define ERR(e) {printf("Error: %s, error num = %d\n", nc_strerror(e),e);} //#define PRESSURE_NAME PRESSURE #define NDIMS 1 //#define MISSING_VALUE -32768 int defineVariable(int nc_group_id, char *var_name, nc_type var_type, int ndims, int *dimids, char *attr_string, char *attr); void writeVariableFloat(int group_id, int var_id, size_t *index, size_t *num_vals, float value); void writeVariableShort(int group_id, int var_id, size_t *index, size_t *num_vals, short value); void writeVariableInteger(int group_id, int var_id, size_t *index, size_t *num_vals, long value); void writeArrayFloat(int group_id, int var_id, size_t *index, size_t *num_vals, float *value); void writeVariableByte(int group_id, int var_id, size_t *index, size_t *num_vals, char value); void writeAttributeShort(int grp, char *attrVariable, short attrValue); void writeAttributeText(int grp, char *attrVariable, char *attrValue); void processCOSMIC590(int date_to_process, struct file_data *files, struct platform *platform_ptr, int num_collocations, int platform_index, int data_type, int nc_date_group) { int n, i, date_type, recnum, collocation_num, retval; int nc_group_id, collocation_group_id; size_t num_colls, index[1], num_vals[1], index_2D[2], num_vals_2D[2]; float missing_float, latitude, longitude, derived_values[200]; float gfs_data[50], raw_data[300]; int year, month, day, hour, minute, second; long offset, yyyymmdd, hhmmss; char col_dir_name[50]; // unsigned char fiducial_id[5], file_stamp[25], proc_center[13], error_string[20]; unsigned char file_stamp[25], source_code_version[11], inverter[31]; char *string[1]; int *buffer; int col_dim_scalar; int dim_scalar, dim_wet, dim_ecmwf, dim_avn, dim_dry; int dimid_scalar[1], col_dimid_scalar[1]; int dimid_wet[2], dimid_ecmwf[2], dimid_avn[2], dimid_dry[2]; int col_vid_lat, col_vid_lon, col_vid_date, col_vid_time; int vid_lat, vid_lon, vid_date, vid_time; int vid_qc, vid_fstamp; int vid_version, vid_inverter, vid_terrain, vid_terr_height; int vid_geod_height, vid_curv_dist, vid_nom_azimuth, vid_signal_track; int vid_occ_mode, vid_realtime, vid_mdl, vid_num_loops; int vid_type_ob, vid_diag_oe, vid_diag_be, vid_type_be; int vid_type_cvp, vid_type_cvq, vid_type_wvp; int vid_num_orig_ob, vid_num_thinned_ob, vid_num_mdl_levels; int vid_fgs_min_altitude, vid_fgs_max_altitude, vid_anl_min_altitude, vid_mdl_top_altitude; int vid_ducting_threshold, vid_fgs_shows_ducting, vid_ducting_layer_top; int vid_number_iterations; int vid_wet_alt, vid_wet_lat, vid_wet_lon, vid_wet_gph, vid_wet_temp; int vid_wet_press, vid_wet_vp, vid_wet_sph, vid_wet_rh, vid_wet_wvmr; int vid_wet_ref, vid_atm_press, vid_atm_temp; int vid_wv_altitudes, vid_ecmwf_temps, vid_ecmwf_press, vid_ecmwf_vpress; int vid_ecmwf_sh, vid_ecmwf_rh, vid_ecmwf_wvmr; int vid_avn_temps, vid_avn_press, vid_avn_vpress; int vid_avn_sh, vid_avn_rh, vid_avn_wvmr; FILE *in; num_colls = (size_t)num_collocations; missing_float = -32768.0; // If this is the baseline platform, then create another subgroup // for the collocation information if (platform_index == 0) { sprintf(col_dir_name, "Collocation_Info"); if ((retval = nc_def_grp(nc_date_group, col_dir_name, &collocation_group_id))) { if (retval != -42) ERR(retval); } writeAttributeShort(collocation_group_id, "Baseline_Data_Type", platform_ptr->type); writeAttributeText(collocation_group_id, "Baseline_Platform", platform_ptr->description); writeAttributeShort(collocation_group_id, "Baseline_Platform_ID", platform_ptr->id); } // Create a subgroup for this system platform if ((retval = nc_def_grp(nc_date_group, platform_ptr->dir_name, &nc_group_id))) { //if (retval != -42) ERR(retval); } // Set the platform type attribute to the data group type writeAttributeText(nc_group_id, "Platform_Name", platform_ptr->description); // clean_description? writeAttributeShort(nc_group_id, "Platform_ID", platform_ptr->id); writeAttributeShort(nc_group_id, "Platform_Type", platform_ptr->type); writeAttributeText(nc_group_id, "Platform_Data_Source", "COSMIC-2 PlanetIQ (590)"); //writeAttributeText(nc_group_id, "Platform_NPROVS_Source_Name", nprovs_name); writeAttributeText(nc_group_id, "Platform_NPROVS_Source_Name", platform_ptr->description); // clean_description? // Define the dimensions if ((retval = nc_def_dim(nc_group_id, "Num_Collocations", num_colls, &dim_scalar))) ERR(retval); dimid_scalar[0] = dim_scalar; if ((retval = nc_def_dim(nc_group_id, "Derived_Levels", 200, &dim_wet))) ERR(retval); dimid_wet[0] = dim_scalar; dimid_wet[1] = dim_wet; if ((retval = nc_def_dim(nc_group_id, "ECMWF_Levels", 200, &dim_ecmwf))) ERR(retval); dimid_ecmwf[0] = dim_scalar; dimid_ecmwf[1] = dim_ecmwf; if ((retval = nc_def_dim(nc_group_id, "AVN_Levels", 200, &dim_avn))) ERR(retval); dimid_avn[0] = dim_scalar; dimid_avn[1] = dim_avn; if ((retval = nc_def_dim(nc_group_id, "Dry_Levels", 200, &dim_dry))) ERR(retval); dimid_dry[0] = dim_scalar; dimid_dry[1] = dim_dry; if (platform_index == 0) { if ((retval = nc_def_dim(collocation_group_id, "Num_Collocations", num_colls, &col_dim_scalar))) ERR(retval); col_dimid_scalar[0] = col_dim_scalar; } // Define the variables if (platform_index == 0) { col_vid_lat = defineVariable(collocation_group_id, "latitude", NC_FLOAT, 1, col_dimid_scalar, "units", "degrees_north"); col_vid_lon = defineVariable(collocation_group_id, "longitude", NC_FLOAT, 1, col_dimid_scalar, "units", "degrees_east"); col_vid_date = defineVariable(collocation_group_id, "date", NC_INT, 1, col_dimid_scalar, "format", "yyyymmdd"); col_vid_time = defineVariable(collocation_group_id, "time", NC_INT, 1, col_dimid_scalar, "format", "hhmmss"); } vid_lat = defineVariable(nc_group_id, "latitude", NC_FLOAT, 1, dimid_scalar, "units", "degrees_north"); vid_lon = defineVariable(nc_group_id, "longitude", NC_FLOAT, 1, dimid_scalar, "units", "degrees_east"); vid_date = defineVariable(nc_group_id, "date", NC_INT, 1, dimid_scalar, "format", "yyyymmdd"); vid_time = defineVariable(nc_group_id, "time", NC_INT, 1, dimid_scalar, "format", "hhmmss"); vid_qc = defineVariable(nc_group_id, "quality_flag", NC_BYTE, 1, dimid_scalar, "values", "0=good, 1=bad"); vid_fstamp = defineVariable(nc_group_id, "file_stamp", NC_STRING, 1, dimid_scalar, "string_length", "24"); vid_version = defineVariable(nc_group_id, "source_code_version", NC_STRING, 1, dimid_scalar, "string_length", "10"); vid_inverter = defineVariable(nc_group_id, "inverter", NC_STRING, 1, dimid_scalar, "string_length", "30"); vid_terrain = defineVariable(nc_group_id, "landmask", NC_BYTE, 1, dimid_scalar, "values", "0=ocean (including islands but no lakes), 1=land (inclusive of lakes and ice shelf)"); vid_terr_height = defineVariable(nc_group_id, "terrain_height", NC_FLOAT, 1, dimid_scalar, "units", "km"); vid_geod_height = defineVariable(nc_group_id, "geoidal_surface_height", NC_FLOAT, 1, dimid_scalar, "units", "m"); vid_curv_dist = defineVariable(nc_group_id, "distance_from_local_curvature_center", NC_FLOAT, 1, dimid_scalar, "units", "km"); vid_nom_azimuth = defineVariable(nc_group_id, "nominal_azimuth_angle", NC_FLOAT, 1, dimid_scalar, "units", "deg"); vid_signal_track = defineVariable(nc_group_id, "signal_tracking", NC_BYTE, 1, dimid_scalar, "values", "OL (=1) otherwise PLL"); vid_occ_mode = defineVariable(nc_group_id, "occultation_mode", NC_BYTE, 1, dimid_scalar, "values", "rising (=1) or setting (-1)"); vid_realtime = defineVariable(nc_group_id, "realtime", NC_BYTE, 1, dimid_scalar, "values", "0 = standard processing mode"); vid_mdl = defineVariable(nc_group_id, "compact_mdl_domain", NC_BYTE, 1, dimid_scalar, "values", "1 = computational grid does not cover altitudes lower than ob bottom"); vid_num_loops = defineVariable(nc_group_id, "num_outer_loops_used_for_J_minimization", NC_SHORT, 1, dimid_scalar, NULL, NULL); vid_type_ob = defineVariable(nc_group_id, "type_ob", NC_BYTE, 1, dimid_scalar, "values", "3 = refractivity derived from variational BA optimization"); vid_diag_oe = defineVariable(nc_group_id, "diag_oe", NC_BYTE, 1, dimid_scalar, "values", "2 = diagonal elements of R: Hollingsworth-Lonnberg (monthly, 5 deg zonal)"); vid_diag_be = defineVariable(nc_group_id, "diag_be", NC_BYTE, 1, dimid_scalar, "values", "2 = diagonal elements of B: Hollingsworth-Lonnberg (monthly, 5 deg zonal)"); vid_type_be = defineVariable(nc_group_id, "type_be", NC_BYTE, 1, dimid_scalar, "values", "4 = NMC Multivariate (T-q-p)"); vid_type_cvp = defineVariable(nc_group_id, "type_cvp", NC_BYTE, 1, dimid_scalar, "values", "2 = type of pressure control variable: lowest-level pressure"); vid_type_cvq = defineVariable(nc_group_id, "type_cvq", NC_BYTE, 1, dimid_scalar, "values", "4 = type of pressure control variable: pseudo relative humidity"); vid_type_wvp = defineVariable(nc_group_id, "type_wvp", NC_BYTE, 1, dimid_scalar, "values", "1 = type of WVP formulation: Hyland and Wexler (liquid/ice)"); vid_num_orig_ob = defineVariable(nc_group_id, "number_original_ob", NC_SHORT, 1, dimid_scalar, NULL, NULL); vid_num_thinned_ob = defineVariable(nc_group_id, "number_thinned_ob", NC_SHORT, 1, dimid_scalar, NULL, NULL); vid_num_mdl_levels = defineVariable(nc_group_id, "number_mdl_levels", NC_SHORT, 1, dimid_scalar, NULL, NULL); vid_fgs_min_altitude = defineVariable(nc_group_id, "fgs_min_altitude", NC_FLOAT, 1, dimid_scalar, "units", "km"); vid_fgs_max_altitude = defineVariable(nc_group_id, "fgs_max_altitude", NC_FLOAT, 1, dimid_scalar, "units", "km"); vid_anl_min_altitude = defineVariable(nc_group_id, "fgs_anl_altitude", NC_FLOAT, 1, dimid_scalar, "units", "km"); vid_mdl_top_altitude = defineVariable(nc_group_id, "mdl_top_altitude", NC_FLOAT, 1, dimid_scalar, "units", "km"); vid_ducting_threshold = defineVariable(nc_group_id, "ducting_threshold", NC_FLOAT, 1, dimid_scalar, "units", "N-unit/km"); vid_fgs_shows_ducting = defineVariable(nc_group_id, "fgs_shows_ducting", NC_BYTE, 1, dimid_scalar, "values", "0 = fgs shows no indication of atmospheric ducting, 1 = suggested occurence of critical refraction"); vid_ducting_layer_top = defineVariable(nc_group_id, "ducting_layer_top", NC_FLOAT, 1, dimid_scalar, "units", "km"); vid_number_iterations = defineVariable(nc_group_id, "number_iterations", NC_SHORT, 1, dimid_scalar, NULL, NULL); vid_wet_alt = defineVariable(nc_group_id, "MSL_alt", NC_FLOAT, 2, dimid_wet, "units", "km"); vid_wet_lat = defineVariable(nc_group_id, "lat", NC_FLOAT, 2, dimid_wet, "units", "degrees_north"); vid_wet_lon = defineVariable(nc_group_id, "lon", NC_FLOAT, 2, dimid_wet, "units", "degrees_east"); vid_wet_gph = defineVariable(nc_group_id, "gph", NC_FLOAT, 2, dimid_wet, "units", "km"); vid_wet_temp = defineVariable(nc_group_id, "Temp", NC_FLOAT, 2, dimid_wet, "units", "deg K"); vid_wet_press = defineVariable(nc_group_id, "Pres", NC_FLOAT, 2, dimid_wet, "units", "hPa"); vid_wet_vp = defineVariable(nc_group_id, "Vp", NC_FLOAT, 2, dimid_wet, "units", "hPa"); vid_wet_sph = defineVariable(nc_group_id, "sph", NC_FLOAT, 2, dimid_wet, "units", "g/kg"); vid_wet_rh = defineVariable(nc_group_id, "rh", NC_FLOAT, 2, dimid_wet, "units", "pct"); vid_wet_wvmr = defineVariable(nc_group_id, "water_vapor_mixing_ratio", NC_FLOAT, 2, dimid_wet, "units", "g/kg"); vid_wet_ref = defineVariable(nc_group_id, "ref", NC_FLOAT, 2, dimid_wet, "units", "N-unit"); vid_atm_press = defineVariable(nc_group_id, "pres_dry", NC_FLOAT, 2, dimid_dry, "units", "hPa"); vid_atm_temp = defineVariable(nc_group_id, "temp_dry", NC_FLOAT, 2, dimid_dry, "units", "degrees K"); vid_wv_altitudes = defineVariable(nc_group_id, "MSL_alt_wvd", NC_FLOAT, 2, dimid_ecmwf, "units", "m"); vid_ecmwf_temps = defineVariable(nc_group_id, "T_wvd_ECM", NC_FLOAT, 2, dimid_ecmwf, "units", "degrees K"); vid_ecmwf_press = defineVariable(nc_group_id, "P_wvd_ECM", NC_FLOAT, 2, dimid_ecmwf, "units", "hPa"); vid_ecmwf_vpress = defineVariable(nc_group_id, "Pwv_wvd_ECM", NC_FLOAT, 2, dimid_ecmwf, "units", "hPa"); vid_ecmwf_sh = defineVariable(nc_group_id, "q_wvd_ECM", NC_FLOAT, 2, dimid_ecmwf, "units", "g/kg"); vid_ecmwf_rh = defineVariable(nc_group_id, "RH_wvd_ECM", NC_FLOAT, 2, dimid_ecmwf, "units", "percent"); vid_ecmwf_wvmr = defineVariable(nc_group_id, "WVMR_wvd_ECM", NC_FLOAT, 2, dimid_ecmwf, "units", "g/kg"); vid_avn_temps = defineVariable(nc_group_id, "T_wvd_AVN", NC_FLOAT, 2, dimid_avn, "units", "degrees K"); vid_avn_press = defineVariable(nc_group_id, "P_wvd_AVN", NC_FLOAT, 2, dimid_avn, "units", "hPa"); vid_avn_vpress = defineVariable(nc_group_id, "Pwv_wvd_AVN", NC_FLOAT, 2, dimid_avn, "units", "hPa"); vid_avn_sh = defineVariable(nc_group_id, "q_wvd_AVN", NC_FLOAT, 2, dimid_avn, "units", "g/kg"); vid_avn_rh = defineVariable(nc_group_id, "RH_wvd_AVN", NC_FLOAT, 2, dimid_avn, "units", "percent"); vid_avn_wvmr = defineVariable(nc_group_id, "WVMR_wvd_AVN", NC_FLOAT, 2, dimid_ecmwf, "units", "g/kg"); // Allocate the memory used by the data buffer buffer = (short *)malloc(platform_ptr->length); collocation_num = -1; // Loop through each record in all of the files and read the data for // this data group into the buffer for (date_type=0; date_type<3; date_type++) { if (date_type == 0) { if ((in=fopen("prev_day.file", "r")) == NULL) { printf("\n\nThe previous day file could not be opened for input.\n"); printf("It will be skipped.\n\n"); in = NULL; } } else if (date_type == 1) { if ((in=fopen("in.file", "r")) == NULL) { printf("\n\nThe input file could not be opened for input.\n"); printf("It will be skipped.\n\n"); in = NULL; } } else { if ((in=fopen("next_day.file", "r")) == NULL) { printf("\n\nThe next day file could not be opened for input.\n"); printf("It will be skipped.\n\n"); in = NULL; } } for (recnum=0; recnumoffset; fseek(in, offset, SEEK_SET); fread(buffer, platform_ptr->length, 1, in); // Process this record if it matches the date to process if (files[date_type].use_record[recnum] == TRUE) { collocation_num++; // Index and num_vals are used to save a single value within the // variable array index[0] = collocation_num; num_vals[0] = 1; // Latitude and longitude if (buffer[3] != -32768) latitude = buffer[3] / 128.0; else latitude = -32768.0; if (buffer[4] != -32768) longitude = buffer[4] / 128.0; else longitude = -32768.0; writeVariableFloat(nc_group_id, vid_lat, index, num_vals, latitude); writeVariableFloat(nc_group_id, vid_lon, index, num_vals, longitude); // Date and time if ((buffer[5] != -32768) && (buffer[6] != -32768) && (buffer[7] != -32768) && (buffer[8] != -32768)) { year = buffer[5]; month = buffer[6] / 100; day = buffer[6] % 100; hour = buffer[7]; minute = buffer[8] / 100; second = buffer[8] % 100; yyyymmdd = (year * 10000) + (month * 100) + day; hhmmss = (hour * 10000) + (minute * 100) + second; } else { yyyymmdd = -32768; hhmmss = -32768; } writeVariableInteger(nc_group_id, vid_date, index, num_vals, yyyymmdd); writeVariableInteger(nc_group_id, vid_time, index, num_vals, hhmmss); // If this is the baseline system, save the collocation information if (platform_index == 0) { writeVariableFloat(collocation_group_id, col_vid_lat, index, num_vals, latitude); writeVariableFloat(collocation_group_id, col_vid_lon, index, num_vals, longitude); writeVariableInteger(collocation_group_id, col_vid_date, index, num_vals, yyyymmdd); writeVariableInteger(collocation_group_id, col_vid_time, index, num_vals, hhmmss); } // Start saving the parameters beginning with the quality flag if (buffer[13] != -32768) writeVariableByte(nc_group_id, vid_qc, index, num_vals, (char)buffer[13]); else writeVariableByte(nc_group_id, vid_qc, index, num_vals, (char)-128); // File stamp /*if ((buffer[17] == -32768) || (buffer[18] == -32768) || (buffer[19] == -32768) || (buffer[20] == -32768) || (buffer[21] == -32768) || (buffer[22] == -32768) || (buffer[23] == -32768) || (buffer[24] == -32768) || (buffer[25] == -32768) || (buffer[26] == -32768) || (buffer[27] == -32768) || (buffer[28] == -32768) || (buffer[29] == -32768) || (buffer[30] == -32768) || (buffer[31] == -32768) || (buffer[32] == -32768) || (buffer[33] == -32768) || (buffer[34] == -32768) || (buffer[35] == -32768) || (buffer[36] == -32768) || (buffer[37] == -32768) || (buffer[38] == -32768) || (buffer[39] == -32768) || (buffer[40] == -32768)) { for (i=0; i<24; i++) file_stamp[i] = ' '; file_stamp[24] = '\0'; } else { for (i=0; i<24; i++) { file_stamp[i] = (char)buffer[17+i]; } file_stamp[24] = '\0'; }*/ for (i=0; i<24; i++) { if (buffer[17+i] != -32768) file_stamp[i] = (char)buffer[17+i]; else file_stamp[i] = ' '; } file_stamp[24] = '\0'; string[0] = file_stamp; if (retval = nc_put_vara_string(nc_group_id, vid_fstamp, index, num_vals, (const char **)string)) ERR(retval); // Source code version for (i=0; i<10; i++) { if (buffer[41+i] != -32768) source_code_version[i] = (char)buffer[41+i]; else source_code_version[i] = ' '; } source_code_version[10] = '\0'; string[0] = source_code_version; if (retval = nc_put_vara_string(nc_group_id, vid_version, index, num_vals, (const char **)string)) ERR(retval); // Inverter for (i=0; i<30; i++) { if (buffer[51+i] != -32768) inverter[i] = (char)buffer[51+i]; else inverter[i] = ' '; } inverter[30] = '\0'; string[0] = inverter; if (retval = nc_put_vara_string(nc_group_id, vid_inverter, index, num_vals, (const char **)string)) ERR(retval); // Terrain and terrain height if (buffer[81] != -32768) writeVariableByte(nc_group_id, vid_terrain, index, num_vals, (char)buffer[81]); else writeVariableByte(nc_group_id, vid_terrain, index, num_vals, (char)-128); if (buffer[82] != -32768) writeVariableFloat(nc_group_id, vid_terr_height, index, num_vals, (float)(buffer[82]/100.0)); else writeVariableFloat(nc_group_id, vid_terr_height, index, num_vals, -32768.0); // Geoidal surface height, distance from curvature center and azimuth angle if (buffer[83] != -32768) writeVariableFloat(nc_group_id, vid_geod_height, index, num_vals, (float)(buffer[83]/100.0)); else writeVariableFloat(nc_group_id, vid_geod_height, index, num_vals, -32768.0); if (buffer[84] != -32768) writeVariableFloat(nc_group_id, vid_curv_dist, index, num_vals, (float)(buffer[84]/1.0)); else writeVariableFloat(nc_group_id, vid_curv_dist, index, num_vals, -32768.0); if (buffer[85] != -32768) writeVariableFloat(nc_group_id, vid_nom_azimuth, index, num_vals, (float)(buffer[85]/100.0)); else writeVariableFloat(nc_group_id, vid_nom_azimuth, index, num_vals, -32768.0); // Signal tracking, occultation mode, realtime and compact mdl domain if (buffer[86] != -32768) writeVariableByte(nc_group_id, vid_signal_track, index, num_vals, (char)buffer[86]); else writeVariableByte(nc_group_id, vid_signal_track, index, num_vals, (char)-128); if (buffer[87] != -32768) writeVariableByte(nc_group_id, vid_occ_mode, index, num_vals, (char)buffer[87]); else writeVariableByte(nc_group_id, vid_occ_mode, index, num_vals, (char)-128); if (buffer[88] != -32768) writeVariableByte(nc_group_id, vid_realtime, index, num_vals, (char)buffer[88]); else writeVariableByte(nc_group_id, vid_realtime, index, num_vals, (char)-128); if (buffer[89] != -32768) writeVariableByte(nc_group_id, vid_mdl, index, num_vals, (char)buffer[89]); else writeVariableByte(nc_group_id, vid_mdl, index, num_vals, (char)-128); // Number of j minimization loops writeVariableShort(nc_group_id, vid_num_loops, index, num_vals, buffer[90]); // Various flags if (buffer[91] != -32768) writeVariableByte(nc_group_id, vid_type_ob, index, num_vals, (char)buffer[91]); else writeVariableByte(nc_group_id, vid_type_ob, index, num_vals, (char)-128); if (buffer[92] != -32768) writeVariableByte(nc_group_id, vid_diag_oe, index, num_vals, (char)buffer[92]); else writeVariableByte(nc_group_id, vid_diag_oe, index, num_vals, (char)-128); if (buffer[93] != -32768) writeVariableByte(nc_group_id, vid_diag_be, index, num_vals, (char)buffer[93]); else writeVariableByte(nc_group_id, vid_diag_be, index, num_vals, (char)-128); if (buffer[94] != -32768) writeVariableByte(nc_group_id, vid_type_be, index, num_vals, (char)buffer[94]); else writeVariableByte(nc_group_id, vid_type_be, index, num_vals, (char)-128); if (buffer[95] != -32768) writeVariableByte(nc_group_id, vid_type_cvp, index, num_vals, (char)buffer[95]); else writeVariableByte(nc_group_id, vid_type_cvp, index, num_vals, (char)-128); if (buffer[96] != -32768) writeVariableByte(nc_group_id, vid_type_cvq, index, num_vals, (char)buffer[96]); else writeVariableByte(nc_group_id, vid_type_cvq, index, num_vals, (char)-128); if (buffer[97] != -32768) writeVariableByte(nc_group_id, vid_type_wvp, index, num_vals, (char)buffer[97]); else writeVariableByte(nc_group_id, vid_type_wvp, index, num_vals, (char)-128); // Number of levels writeVariableShort(nc_group_id, vid_num_orig_ob, index, num_vals, buffer[98]); writeVariableShort(nc_group_id, vid_num_thinned_ob, index, num_vals, buffer[99]); writeVariableShort(nc_group_id, vid_num_mdl_levels, index, num_vals, buffer[100]); // Minimum and maximum altitudes if (buffer[101] != -32768) writeVariableFloat(nc_group_id, vid_fgs_min_altitude, index, num_vals, (float)(buffer[101]/100.0)); else writeVariableFloat(nc_group_id, vid_fgs_min_altitude, index, num_vals, -32768.0); if (buffer[102] != -32768) writeVariableFloat(nc_group_id, vid_fgs_max_altitude, index, num_vals, (float)(buffer[102]/100.0)); else writeVariableFloat(nc_group_id, vid_fgs_max_altitude, index, num_vals, -32768.0); if (buffer[103] != -32768) writeVariableFloat(nc_group_id, vid_anl_min_altitude, index, num_vals, (float)(buffer[103]/100.0)); else writeVariableFloat(nc_group_id, vid_anl_min_altitude, index, num_vals, -32768.0); if (buffer[104] != -32768) writeVariableFloat(nc_group_id, vid_mdl_top_altitude, index, num_vals, (float)(buffer[104]/100.0)); else writeVariableFloat(nc_group_id, vid_mdl_top_altitude, index, num_vals, -32768.0); // Ducting threshold, fgs ducting flag, ducting layer top and number of iterations if (buffer[105] != -32768) writeVariableFloat(nc_group_id, vid_ducting_threshold, index, num_vals, (float)(buffer[105]/100.0)); else writeVariableFloat(nc_group_id, vid_ducting_threshold, index, num_vals, -32768.0); if (buffer[106] != -32768) writeVariableByte(nc_group_id, vid_fgs_shows_ducting, index, num_vals, (char)buffer[106]); else writeVariableByte(nc_group_id, vid_fgs_shows_ducting, index, num_vals, (char)-128); if (buffer[107] != -32768) writeVariableFloat(nc_group_id, vid_ducting_layer_top, index, num_vals, (float)(buffer[107]/100.0)); else writeVariableFloat(nc_group_id, vid_ducting_layer_top, index, num_vals, -32768.0); writeVariableShort(nc_group_id, vid_number_iterations, index, num_vals, buffer[108]); // Wet level data index_2D[0] = collocation_num; index_2D[1] = 0; num_vals_2D[0] = 1; num_vals_2D[1] = 200; // Altitude for (n=0; n<200; n++) { if (buffer[200+n] != -32768) derived_values[n] = buffer[200+n] / 10.0; else derived_values[n] = -32768.0; } writeArrayFloat(nc_group_id, vid_wet_alt, index_2D, num_vals_2D, derived_values); for (n=0; n<200; n++) { if (buffer[2800+n] != -32768) derived_values[n] = buffer[2800+n] / 10.0; else derived_values[n] = -32768.0; } writeArrayFloat(nc_group_id, vid_wv_altitudes, index_2D, num_vals_2D, derived_values); // Latitude for (n=0; n<200; n++) { if (buffer[400+n] != -32768) derived_values[n] = buffer[400+n] / 128.0; else derived_values[n] = -32768.0; } writeArrayFloat(nc_group_id, vid_wet_lat, index_2D, num_vals_2D, derived_values); // Longitude for (n=0; n<200; n++) { if (buffer[600+n] != -32768) derived_values[n] = buffer[600+n] / 128.0; else derived_values[n] = -32768.0; } writeArrayFloat(nc_group_id, vid_wet_lon, index_2D, num_vals_2D, derived_values); // Geopotential height for (n=0; n<200; n++) { if (buffer[800+n] != -32768) derived_values[n] = buffer[800+n] / 100.0; else derived_values[n] = -32768.0; } writeArrayFloat(nc_group_id, vid_wet_gph, index_2D, num_vals_2D, derived_values); // Temperature for (n=0; n<200; n++) { if (buffer[1400+n] != -32768) derived_values[n] = buffer[1400+n] / 64.0; else derived_values[n] = -32768.0; } writeArrayFloat(nc_group_id, vid_wet_temp, index_2D, num_vals_2D, derived_values); // Pressure for (n=0; n<200; n++) { if (buffer[1000+n] != -32768) derived_values[n] = buffer[1000+n] / 1000.0; else derived_values[n] = -32768.0; } writeArrayFloat(nc_group_id, vid_wet_press, index_2D, num_vals_2D, derived_values); // Water vapor pressure for (n=0; n<200; n++) { if (buffer[1200+n] != -32768) derived_values[n] = buffer[1200+n] / 1000000.0; else derived_values[n] = -32768.0; } writeArrayFloat(nc_group_id, vid_wet_vp, index_2D, num_vals_2D, derived_values); // Specific humidity for (n=0; n<200; n++) { if (buffer[1600+n] != -32768) derived_values[n] = buffer[1600+n] / 1000000.0; else derived_values[n] = -32768.0; } writeArrayFloat(nc_group_id, vid_wet_sph, index_2D, num_vals_2D, derived_values); // Relative humidity for (n=0; n<200; n++) { if (buffer[1800+n] != -32768) derived_values[n] = buffer[1800+n] / 1000000.0; else derived_values[n] = -32768.0; } writeArrayFloat(nc_group_id, vid_wet_rh, index_2D, num_vals_2D, derived_values); // Water vapor mixing ratio for (n=0; n<200; n++) { if (buffer[2000+n] != -32768) derived_values[n] = buffer[2000+n] / 1000000.0; else derived_values[n] = -32768.0; } writeArrayFloat(nc_group_id, vid_wet_wvmr, index_2D, num_vals_2D, derived_values); // Refractivity for (n=0; n<200; n++) { if (buffer[2200+n] != -32768) derived_values[n] = buffer[2200+n] / 100000.0; else derived_values[n] = -32768.0; } writeArrayFloat(nc_group_id, vid_wet_ref, index_2D, num_vals_2D, derived_values); // Dry level data index_2D[0] = collocation_num; index_2D[1] = 0; num_vals_2D[0] = 1; num_vals_2D[1] = 200; // Pressure for (n=0; n<200; n++) { if (buffer[2400+n] != -32768) raw_data[n] = buffer[2400+n] / 1000.0; else raw_data[n] = -32768.0; } writeArrayFloat(nc_group_id, vid_atm_press, index_2D, num_vals_2D, raw_data); // Temperature for (n=0; n<200; n++) { if (buffer[2600+n] != -32768) raw_data[n] = buffer[2600+n] / 64.0; else raw_data[n] = -32768.0; } writeArrayFloat(nc_group_id, vid_atm_temp, index_2D, num_vals_2D, raw_data); // ECMWF data index_2D[0] = collocation_num; index_2D[1] = 0; num_vals_2D[0] = 1; num_vals_2D[1] = 200; // Temperature for (n=0; n<200; n++) { if (buffer[3000+n] != -32768) raw_data[n] = buffer[3000+n] / 64.0; else raw_data[n] = -32768.0; } writeArrayFloat(nc_group_id, vid_ecmwf_temps, index_2D, num_vals_2D, raw_data); // Pressure for (n=0; n<200; n++) { if (buffer[3200+n] != -32768) raw_data[n] = buffer[3200+n] / 1000.0; else raw_data[n] = -32768.0; } writeArrayFloat(nc_group_id, vid_ecmwf_press, index_2D, num_vals_2D, raw_data); // Vapor pressure for (n=0; n<200; n++) { if (buffer[3400+n] != -32768) raw_data[n] = buffer[3400+n] / 1000000.0; else raw_data[n] = -32768.0; } writeArrayFloat(nc_group_id, vid_ecmwf_vpress, index_2D, num_vals_2D, raw_data); // Specific humidity for (n=0; n<200; n++) { if (buffer[3600+n] != -32768) raw_data[n] = buffer[3600+n] / 1000000.0; else raw_data[n] = -32768.0; } writeArrayFloat(nc_group_id, vid_ecmwf_sh, index_2D, num_vals_2D, raw_data); // Relative humidity for (n=0; n<200; n++) { if (buffer[3800+n] != -32768) raw_data[n] = buffer[3800+n] / 1000000.0; else raw_data[n] = -32768.0; } writeArrayFloat(nc_group_id, vid_ecmwf_rh, index_2D, num_vals_2D, raw_data); // Water vapor mixing ratio for (n=0; n<200; n++) { if (buffer[4000+n] != -32768) raw_data[n] = buffer[4000+n] / 64.0; else raw_data[n] = -32768.0; } writeArrayFloat(nc_group_id, vid_ecmwf_wvmr, index_2D, num_vals_2D, raw_data); // AVN data index_2D[0] = collocation_num; index_2D[1] = 0; num_vals_2D[0] = 1; num_vals_2D[1] = 200; // Temperature for (n=0; n<200; n++) { if (buffer[4200+n] != -32768) raw_data[n] = buffer[4200+n] / 64.0; else raw_data[n] = -32768.0; } writeArrayFloat(nc_group_id, vid_avn_temps, index_2D, num_vals_2D, raw_data); // Pressure for (n=0; n<200; n++) { if (buffer[4400+n] != -32768) raw_data[n] = buffer[4400+n] / 1000.0; else raw_data[n] = -32768.0; } writeArrayFloat(nc_group_id, vid_avn_press, index_2D, num_vals_2D, raw_data); // Vapor pressure for (n=0; n<200; n++) { if (buffer[4600+n] != -32768) raw_data[n] = buffer[4600+n] / 1000000.0; else raw_data[n] = -32768.0; } writeArrayFloat(nc_group_id, vid_avn_vpress, index_2D, num_vals_2D, raw_data); // Specific humidity for (n=0; n<200; n++) { if (buffer[4800+n] != -32768) raw_data[n] = buffer[4800+n] / 1000000.0; else raw_data[n] = -32768.0; } writeArrayFloat(nc_group_id, vid_avn_sh, index_2D, num_vals_2D, raw_data); // Relative humidity for (n=0; n<200; n++) { if (buffer[5000+n] != -32768) raw_data[n] = buffer[5000+n] / 1000000.0; else raw_data[n] = -32768.0; } writeArrayFloat(nc_group_id, vid_avn_rh, index_2D, num_vals_2D, raw_data); // Water vapor mixing ratio for (n=0; n<200; n++) { if (buffer[5200+n] != -32768) raw_data[n] = buffer[5200+n] / 64.0; else raw_data[n] = -32768.0; } writeArrayFloat(nc_group_id, vid_avn_wvmr, index_2D, num_vals_2D, raw_data); } // if (yyyymmdd == date_to_process... } // for (recnum=0... if (in != NULL) fclose(in); } // for (date_type=0... // Free the memory used by the buffer free(buffer); } // end of file