/* Name- processRaob05.c Language- C Type- MAIN Version- 1.0 Date- 2/02/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 NDIMS 1 #define SIGNIFICANT 0 #define STANDARD 1 #define TRUE 0 #define FALSE 1 int defineVariable(int nc_group_id, char *var_name, nc_type var_type, int ndims, int *dimids, char *attr_string, char *attr); void writeVariableByte(int group_id, int var_id, size_t *index, size_t *num_vals, char value); 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 writeVariableText(int group_id, char *var_name, char *var_value); void writeArrayByte(int group_id, int var_id, size_t *index, size_t *num_vals, char *value); void writeArrayShort(int group_id, int var_id, size_t *index, size_t *num_vals, short *value); void writeArrayFloat(int group_id, int var_id, size_t *index, size_t *num_vals, float *value); void writeAttributeShort(int grp, char *attrVariable, short attrValue); void writeAttributeText(int grp, char *attrVariable, char *attrValue); float dwptToWvmr(float pressure, float dwpt); float* calculateRelativeHumidities(float *temp_pressures, float *temps, int num_temp_levels, float *wvap_pressures, float *wvaps, int num_wvap_levels, float surf_pressure); float calculateTPW(float *wvap_pressures, float *wvaps, int num_wvap_levels, float surf_pressure, float surf_wvap); void processRaob05(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, level, level_inserted; 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, gfs_pressures[26], pressure; float level_data[118], pressures[118], rev_pressures[118], lpw[18], tropo[5]; char byte_level_data[118]; int year, month, day, hour, minute, second; long offset, yyyymmdd, hhmmss; char col_dir_name[50]; char sonde_id[9]; char *string[1]; short *buffer; int col_scalar_dim; int scalar_dim, dim_levels, dim_lpw, dim_tropo; int dimid_scalar[1], col_dimid_scalar[1]; int dimid_levels[2], dimid_lpw[2], dimid_tropo[2]; int col_vid_lat, col_vid_lon, col_vid_date, col_vid_time; int vid_sonde_id, vid_lat, vid_lon, vid_date, vid_time, vid_synoptic_hour; int vid_elevation, vid_report_type, vid_instrument_type, vid_terrain; int vid_radcor, vid_lo_interp_press, vid_hi_interp_press, vid_firstincrease; int vid_qc_flag, vid_nprovs_qc, vid_vert_ext, vid_prof_cap, vid_superad, vid_inversion; int vid_tpw_cat, vid_moisture_cap, vid_surf_data_flag, vid_max_inv_depth; int vid_calc_tropo_pres, vid_sbl_flag, vid_hi_interp_moisture; int vid_wvmr_anomaly, vid_wvmr_event_1, vid_wvmr_extreme_1, vid_wvmr_event_2; int vid_wvmr_neg_event, vid_wvmr_extreme_neg, vid_utls_anomaly, vid_inversion_type; int vid_dwpt_depress, vid_duplicate, vid_tier_2, vid_screen_adjust; int vid_sbl_top, vid_tropo_press; int vid_surf_wvmr, vid_low_wvmr, vid_high_wvmr; int vid_suan, vid_gcos, vid_gruan, vid_tpw, vid_lpw; int vid_utls_pressure, vid_temp_extrap, vid_climate_limit, vid_dwpt_flag; int vid_vert_extent, vid_temp_gap, vid_moisture_gap, vid_ncep_screen; int vid_radcor_code, vid_text_flag, vid_solzen, vid_daynight; int vid_temp_cap_press, vid_moisture_cap_press; int vid_tropo_rep_press, vid_tropo_calc_press, vid_tropo_deflect, vid_tropo_qc; int vid_surf_press, vid_surf_temp, vid_surf_dwpt, vid_surf_relhum; int vid_surf_wind_dir, vid_surf_wind_speed, vid_gdpstatus; int vid_numlevels, vid_press, vid_press_err, vid_temps, vid_temp_err, vid_wvmr, vid_radcor_temp; int vid_drift_time, vid_drift_lat, vid_drift_lon, vid_height, vid_wind_dir, vid_wind_speed; int vid_missing_flag, vid_zonalwind, vid_meridwind, vid_wind_speed_err, vid_wind_dir_err; int vid_ascent, vid_temp_sd, vid_frosttemp, vid_relhum, vid_relhum_corr, vid_relhum_err; int vid_relhum_sd; int vid_rh; FILE *in; float temp_pressures[118], temps[118], wvap_pressures[118], wvaps[118]; float surf_pressure, tpw; float *relative_humidities; num_colls = (size_t)num_collocations; missing_float = -32768.0; // If this is the baseline platform, then create a 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", "Radiosonde Version 5"); //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, &scalar_dim))) ERR(retval); dimid_scalar[0] = scalar_dim; if ((retval = nc_def_dim(nc_group_id, "Levels", 118, &dim_levels))) ERR(retval); if ((retval = nc_def_dim(nc_group_id, "LPW_Layers", 18, &dim_lpw))) ERR(retval); if ((retval = nc_def_dim(nc_group_id, "Tropopause_Levels", 5, &dim_tropo))) ERR(retval); dimid_levels[0] = scalar_dim; dimid_levels[1] = dim_levels; dimid_lpw[0] = scalar_dim; dimid_lpw[1] = dim_lpw; dimid_tropo[0] = scalar_dim; dimid_tropo[1] = dim_tropo; if (platform_index == 0) { if ((retval = nc_def_dim(collocation_group_id, "Num_Collocations", num_colls, &col_scalar_dim))) ERR(retval); col_dimid_scalar[0] = col_scalar_dim; } // 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_sonde_id = defineVariable(nc_group_id, "sonde_station_id", NC_STRING, 1, dimid_scalar, "string_length", "9"); vid_synoptic_hour = defineVariable(nc_group_id, "synoptic_hour", NC_BYTE, 1, dimid_scalar, "values", "1 = 00Z, 2 = 06Z, 3 = 12Z, 4 = 18Z"); vid_elevation = defineVariable(nc_group_id, "elevation", NC_INT, 1, dimid_scalar, NULL, NULL); vid_report_type = defineVariable(nc_group_id, "report_type", NC_SHORT, 1, dimid_scalar, NULL, NULL); vid_instrument_type = defineVariable(nc_group_id, "instrument_type", NC_SHORT, 1, dimid_scalar, "source", "NCEP Common Code Table S-2: Radiosonde/Sounding System Used"); vid_terrain = defineVariable(nc_group_id, "terrain", NC_BYTE, 1, dimid_scalar, "values", "0=Island Coast, 1=Mainland Inland, 2=Mainland Coast, 3=Island Inland, 4=Ship"); vid_lo_interp_press = defineVariable(nc_group_id, "lowest_interpolated_pressure", NC_FLOAT, 1, dimid_scalar, "units", "hPa"); vid_hi_interp_press = defineVariable(nc_group_id, "highest_interpolated_pressure", NC_FLOAT, 1, dimid_scalar, "units", "hPa"); vid_firstincrease = defineVariable(nc_group_id, "first_increasing_pressure", NC_FLOAT, 1, dimid_scalar, "units", "hPa"); vid_qc_flag = defineVariable(nc_group_id, "sonde_qc", NC_BYTE, 1, dimid_scalar, "values", "0=pass, 1=fail"); vid_nprovs_qc = defineVariable(nc_group_id, "nprovs_qc", NC_BYTE, 1, dimid_scalar, "values", "0=pass, 1=fail"); vid_radcor = defineVariable(nc_group_id, "ncep_radiation_corrected_flag", NC_BYTE, 1, dimid_scalar, "values", "0=not corrected, 1=corrected"); vid_vert_ext = defineVariable(nc_group_id, "vertical_extent_flag", NC_BYTE, 1, dimid_scalar, "values", "0=greater than 5 km, 1=less than 5 km"); vid_prof_cap = defineVariable(nc_group_id, "temperature_profile_capped", NC_BYTE, 1, dimid_scalar, "values", "0=not capped, 1=capped"); vid_superad = defineVariable(nc_group_id, "profile_superadiabatic", NC_BYTE, 1, dimid_scalar, "values", "0=not superadiabatic, 1=marginal, 2=moderate, 3=severe"); vid_inversion = defineVariable(nc_group_id, "profile_inversion", NC_BYTE, 1, dimid_scalar, "values", "0=no inversion, 1=depth<2.5km, 2=depth>2.5km"); vid_tpw_cat = defineVariable(nc_group_id, "total_precipitable_water_category", NC_BYTE, 1, dimid_scalar, "values", "0=tpw < 0 mm, 1=between 0 and 15mm, 2=between 15 and 30mm, 3=between 30 and 45 mm, 4=between 45 and 60mm, 5=greater than 60mm"); vid_moisture_cap = defineVariable(nc_group_id, "moisture_profile_cap_flag", NC_BYTE, 1, dimid_scalar, "values", "0=not capped, 1=capped"); vid_surf_data_flag = defineVariable(nc_group_id, "surface_data_flag", NC_BYTE, 1, dimid_scalar, "values", "0=not missing, 1=missing"); vid_max_inv_depth = defineVariable(nc_group_id, "maximum_inversion_depth", NC_FLOAT, 1, dimid_scalar, "units", "km"); vid_calc_tropo_pres = defineVariable(nc_group_id, "tropopause_pressure_(calculated)", NC_FLOAT, 1, dimid_scalar, "units", "hPa"); vid_sbl_flag = defineVariable(nc_group_id, "moisture_surface_boundary_layer", NC_BYTE, 1, dimid_scalar, "values", "0=no anomalies, 1=anomaly detected"); vid_hi_interp_moisture = defineVariable(nc_group_id, "highest_interpolated_moisture_pressure", NC_FLOAT, 1, dimid_scalar, "units", "hPa"); vid_wvmr_anomaly = defineVariable(nc_group_id, "wvmr_anomaly", NC_BYTE, 1, dimid_scalar, "values", "0=no anomalies, 1=anomaly detected"); vid_wvmr_event_1 = defineVariable(nc_group_id, "wvmr_event_1_detected", NC_BYTE, 1, dimid_scalar, "values", "0=no, 1=yes"); vid_wvmr_extreme_1 = defineVariable(nc_group_id, "wvmr_extreme_event_1_detected", NC_BYTE, 1, dimid_scalar, "values", "0=no, 1=yes"); vid_wvmr_event_2 = defineVariable(nc_group_id, "wvmr_event_2_detected", NC_BYTE, 1, dimid_scalar, "values", "0=no, 1=yes"); vid_wvmr_neg_event = defineVariable(nc_group_id, "wvmr_negative_event_detected", NC_BYTE, 1, dimid_scalar, "values", "0=no, 1=yes"); vid_wvmr_extreme_neg = defineVariable(nc_group_id, "wvmr_extreme_negative_event_detected", NC_BYTE, 1, dimid_scalar, "values", "0=no, 1=yes"); vid_utls_anomaly = defineVariable(nc_group_id, "utls_anomaly_detected", NC_BYTE, 1, dimid_scalar, "values", "0=no, 1=yes"); vid_inversion_type = defineVariable(nc_group_id, "inversion_type", NC_BYTE, 1, dimid_scalar, "values", "0=no inversion, 1=surface inversion"); vid_dwpt_depress = defineVariable(nc_group_id, "constant_dewpoint_depression", NC_BYTE, 1, dimid_scalar, "values", "0=none, 1=all within 5 deg, 2=all within 2.5 deg, 3=all within 1 deg"); vid_duplicate = defineVariable(nc_group_id, "duplicate_sonde_flag", NC_BYTE, 1, dimid_scalar, "values", "0=no duplicate, 1=accepted duplicate, 2=rejected duplicate"); vid_tier_2 = defineVariable(nc_group_id, "moisture_screening_tier_2_score", NC_BYTE, 1, dimid_scalar, NULL, NULL); vid_screen_adjust = defineVariable(nc_group_id, "moisture_screening_adjustment", NC_BYTE, 1, dimid_scalar, "values", "0=flag not set, 1=additional anomalies found"); vid_sbl_top = defineVariable(nc_group_id, "top_of_surface_boundary_layer", NC_FLOAT, 1, dimid_scalar, "units", "hPa"); vid_tropo_press = defineVariable(nc_group_id, "tropopause_pressure", NC_FLOAT, 1, dimid_scalar, "units", "hPa"); //vid_surf_press = defineVariable(nc_group_id, "surface_pressure", NC_FLOAT, 1, dimid_scalar, // "units", "hPa"); //vid_surf_temp = defineVariable(nc_group_id, "surface_temperature", NC_FLOAT, 1, dimid_scalar, // "units", "K"); vid_surf_wvmr = defineVariable(nc_group_id, "surface_water_vapor_mixing_ratio", NC_FLOAT, 1, dimid_scalar, "units", "g/kg"); //vid_surf_dwpt = defineVariable(nc_group_id, "surface_dewpoint_temperature", NC_FLOAT, 1, dimid_scalar, // "units", "K"); vid_low_wvmr = defineVariable(nc_group_id, "lowest_level_water_vapor_mixing_ratio", NC_FLOAT, 1, dimid_scalar, "units", "g/kg"); vid_high_wvmr = defineVariable(nc_group_id, "highest_level_water_vapor_mixing_ratio", NC_FLOAT, 1, dimid_scalar, "units", "g/kg"); vid_suan = defineVariable(nc_group_id, "suan_network_flag", NC_BYTE, 1, dimid_scalar, "values", "0=not in network, 1=in network"); vid_gcos = defineVariable(nc_group_id, "gcos_network_flag", NC_BYTE, 1, dimid_scalar, "values", "0=not in network, 1=in network"); vid_gruan = defineVariable(nc_group_id, "gruan_network_flag", NC_BYTE, 1, dimid_scalar, "values", "0=not in network, 1=in network"); vid_tpw = defineVariable(nc_group_id, "total_precipitable_water", NC_FLOAT, 1, dimid_scalar, "units", "mm"); vid_lpw = defineVariable(nc_group_id, "layer_precipitable_water", NC_FLOAT, 2, dimid_lpw, "units", "mm"); vid_utls_pressure = defineVariable(nc_group_id, "pressure_above_utls_anomaly", NC_FLOAT, 1, dimid_scalar, "units", "hPa"); vid_temp_extrap = defineVariable(nc_group_id, "temperature_extrapolation_pressure", NC_FLOAT, 1, dimid_scalar, "units", "hPa"); vid_climate_limit = defineVariable(nc_group_id, "climatological_limits_flag", NC_BYTE, 1, dimid_scalar, "values", "0=passed, 1=failed"); vid_dwpt_flag = defineVariable(nc_group_id, "dewpoint_temperature_flag", NC_BYTE, 1, dimid_scalar, "values", "0=passed, 1=failed"); vid_vert_extent = defineVariable(nc_group_id, "uncapped_vertical_extent_flag", NC_BYTE, 1, dimid_scalar, "values", "0=passed, 1=failed"); vid_temp_gap = defineVariable(nc_group_id, "temperature_data_gap_flag", NC_BYTE, 1, dimid_scalar, "values", "0=no gap, 1=gap exists"); vid_moisture_gap = defineVariable(nc_group_id, "moisture_data_gap_flag", NC_BYTE, 1, dimid_scalar, "values", "0=no gap, 1=gap exists"); vid_ncep_screen = defineVariable(nc_group_id, "ncep_screening_flag", NC_BYTE, 1, dimid_scalar, "values", "0=no screen, 1=at least one level screened"); vid_tropo_deflect = defineVariable(nc_group_id, "tropopause_deflection_point_pressure", NC_FLOAT, 2, dimid_tropo, "units", "hPa"); vid_tropo_rep_press = defineVariable(nc_group_id, "reported_tropopause_pressure", NC_FLOAT, 2, dimid_tropo, "units", "hPa"); vid_tropo_calc_press = defineVariable(nc_group_id, "calculated_tropopause_pressure", NC_FLOAT, 2, dimid_tropo, "units", "hPa"); vid_tropo_qc = defineVariable(nc_group_id, "tropopause_qc_flag", NC_BYTE, 1, dimid_scalar, "values", "0=count<=2, 1=count>2, 2=pressure>=500hPa"); vid_surf_press = defineVariable(nc_group_id, "surface_pressure", NC_FLOAT, 1, dimid_scalar, "units", "hPa"); vid_surf_temp = defineVariable(nc_group_id, "surface_temperature", NC_FLOAT, 1, dimid_scalar, "units", "K"); vid_surf_dwpt = defineVariable(nc_group_id, "surface_dewpoint_temperature", NC_FLOAT, 1, dimid_scalar, "units", "percent"); vid_surf_relhum = defineVariable(nc_group_id, "surface_relative_humidity", NC_FLOAT, 1, dimid_scalar, "units", "K"); vid_surf_wind_dir = defineVariable(nc_group_id, "surface_wind_direction", NC_FLOAT, 1, dimid_scalar, "units", "degrees"); vid_surf_wind_speed = defineVariable(nc_group_id, "surface_wind_speed", NC_FLOAT, 1, dimid_scalar, "units", "knots"); vid_radcor_code = defineVariable(nc_group_id, "radiation_correction_code", NC_SHORT, 1, dimid_scalar, NULL, NULL); vid_text_flag = defineVariable(nc_group_id, "text_file_report_flag", NC_BYTE, 1, dimid_scalar, "units", "0=not special, 1=special"); vid_solzen = defineVariable(nc_group_id, "launch_point_solar_zenith_angle", NC_FLOAT, 1, dimid_scalar, "units", "degrees"); vid_daynight = defineVariable(nc_group_id, "day_night_flag", NC_BYTE, 1, dimid_scalar, "values", "0=day, 1=dusk, 2=night"); vid_temp_cap_press = defineVariable(nc_group_id, "temperature_cap_pressure", NC_FLOAT, 1, dimid_scalar, "units", "hPa"); vid_moisture_cap_press = defineVariable(nc_group_id, "moisture_cap_pressure", NC_FLOAT, 1, dimid_scalar, "units", "hPa"); vid_gdpstatus = defineVariable(nc_group_id, "gdp_product_status", NC_BYTE, 1, dimid_scalar, "values", "0=checked, 1=accepted"); // Significant level variables vid_numlevels = defineVariable(nc_group_id, "number_of_levels", NC_SHORT, 1, dimid_scalar, NULL, NULL); vid_press = defineVariable(nc_group_id, "pressure", NC_FLOAT, 2, dimid_levels, "units", "hPa"); vid_press_err = defineVariable(nc_group_id, "pressure_uncertainty", NC_FLOAT, 2, dimid_levels, "units", "hPa"); vid_temps = defineVariable(nc_group_id, "temperature", NC_FLOAT, 2, dimid_levels, "units", "K"); vid_temp_err = defineVariable(nc_group_id, "temperature_uncertainty", NC_FLOAT, 2, dimid_levels, "units", "K"); vid_temp_sd = defineVariable(nc_group_id, "standard_deviation_from_temperature_mean", NC_FLOAT, 2, dimid_levels, NULL, NULL); vid_radcor_temp = defineVariable(nc_group_id, "radiation_corrected_temperature", NC_FLOAT, 2, dimid_levels, "units", "K"); vid_wvmr = defineVariable(nc_group_id, "water_vapor_mixing_ratio", NC_FLOAT, 2, dimid_levels, "units", "g/kg"); vid_frosttemp = defineVariable(nc_group_id, "frost_point_temperature", NC_FLOAT, 2, dimid_levels, "units", "K"); vid_relhum = defineVariable(nc_group_id, "relative_humidity", NC_FLOAT, 2, dimid_levels, "units", "pct"); vid_rh = defineVariable(nc_group_id, "calculated_relative_humidity", NC_FLOAT, 2, dimid_levels, "units", "pct"); vid_relhum_corr = defineVariable(nc_group_id, "relative_humidity_correction", NC_FLOAT, 2, dimid_levels, "units", "pct"); vid_relhum_err = defineVariable(nc_group_id, "relative_humidity_uncertainty", NC_FLOAT, 2, dimid_levels, "units", "pct"); vid_relhum_sd = defineVariable(nc_group_id, "relative_humidity_standard_deviation", NC_FLOAT, 2, dimid_levels, "units", "pct"); vid_ascent = defineVariable(nc_group_id, "balloon_ascent_rate", NC_FLOAT, 2, dimid_levels, "units", "m/sec"); vid_drift_time = defineVariable(nc_group_id, "balloon_drift_time_delta", NC_FLOAT, 2, dimid_levels, "units", "hours"); vid_drift_lat = defineVariable(nc_group_id, "balloon_drift_latitude", NC_FLOAT, 2, dimid_levels, "units", "degrees_north"); vid_drift_lon = defineVariable(nc_group_id, "balloon_drift_longitude", NC_FLOAT, 2, dimid_levels, "units", "degrees_east"); vid_height = defineVariable(nc_group_id, "geopotential_height", NC_FLOAT, 2, dimid_levels, "units", "meters"); vid_wind_dir = defineVariable(nc_group_id, "wind_direction", NC_FLOAT, 2, dimid_levels, "units", "degrees"); vid_wind_dir_err = defineVariable(nc_group_id, "wind_direction_uncertainty", NC_FLOAT, 2, dimid_levels, "units", "degrees"); vid_wind_speed = defineVariable(nc_group_id, "wind_speed", NC_FLOAT, 2, dimid_levels, "units", "knots"); vid_wind_speed_err = defineVariable(nc_group_id, "wind_speed_uncertainty", NC_FLOAT, 2, dimid_levels, "units", "m/s"); vid_zonalwind = defineVariable(nc_group_id, "zonal_wind", NC_FLOAT, 2, dimid_levels, "units", "m/s"); vid_meridwind = defineVariable(nc_group_id, "meridonal_wind", NC_FLOAT, 2, dimid_levels, "units", "m/s"); vid_missing_flag = defineVariable(nc_group_id, "level_missing_flag", NC_BYTE, 2, dimid_levels, "values", "0=not missing, 1=missing"); // 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; index_2D[0] = collocation_num; index_2D[1] = 0; num_vals_2D[0] = 1; num_vals_2D[1] = 118; // Latitude and longitude latitude = buffer[39] / 128.0; longitude = buffer[40] / 128.0; writeVariableFloat(nc_group_id, vid_lat, index, num_vals, latitude); writeVariableFloat(nc_group_id, vid_lon, index, num_vals, longitude); // Date and time year = buffer[35]; month = buffer[36]; day = buffer[37]; hour = buffer[38] / 100; minute = buffer[38] % 100; second = 0; yyyymmdd = (year * 10000) + (month * 100) + day; hhmmss = (hour * 10000) + (minute * 100) + second; 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); } // Unpack and save the Sonde ID sonde_id[0] = buffer[29] / 100; sonde_id[1] = buffer[29] % 100; sonde_id[2] = buffer[30] / 100; sonde_id[3] = buffer[30] % 100; sonde_id[4] = buffer[31] / 100; sonde_id[5] = buffer[31] % 100; sonde_id[6] = ' '; sonde_id[7] = ' '; sonde_id[8] = '\0'; string[0] = sonde_id; if (retval = nc_put_vara_string(nc_group_id, vid_sonde_id, index, num_vals, (const char **)string)) ERR(retval); // Save the station elevation, report type, instrument type // and terrain if (buffer[2704] != -32768) writeVariableByte(nc_group_id, vid_synoptic_hour, index, num_vals, (char)buffer[2704]); else writeVariableByte(nc_group_id, vid_synoptic_hour, index, num_vals, (char)-128); writeVariableShort(nc_group_id, vid_elevation, index, num_vals, buffer[41]); writeVariableShort(nc_group_id, vid_report_type, index, num_vals, buffer[42]); if ((buffer[43] < 0) || (buffer[43] > 299)) writeVariableShort(nc_group_id, vid_instrument_type, index, num_vals, -32768); else writeVariableShort(nc_group_id, vid_instrument_type, index, num_vals, buffer[43]); if (buffer[44] != -32768) writeVariableByte(nc_group_id, vid_terrain, index, num_vals, (char)buffer[44]); else writeVariableByte(nc_group_id, vid_terrain, index, num_vals, (char)-128); // Lowest and highest pressures if (buffer[45] != -32768) writeVariableFloat(nc_group_id, vid_lo_interp_press, index, num_vals, (buffer[45]/10.0)); else writeVariableFloat(nc_group_id, vid_lo_interp_press, index, num_vals, missing_float); if (buffer[46] != -32768) writeVariableFloat(nc_group_id, vid_hi_interp_press, index, num_vals, (buffer[46]/10.0)); else writeVariableFloat(nc_group_id, vid_hi_interp_press, index, num_vals, missing_float); if (buffer[193] != -32768) writeVariableFloat(nc_group_id, vid_firstincrease, index, num_vals, (buffer[193]/10.0)); else writeVariableFloat(nc_group_id, vid_firstincrease, index, num_vals, missing_float); if (buffer[11] != -32768) writeVariableByte(nc_group_id, vid_radcor, index, num_vals, (char)buffer[11]); else writeVariableByte(nc_group_id, vid_radcor, index, num_vals, (char)-128); if (buffer[47] != -32768) writeVariableByte(nc_group_id, vid_qc_flag, index, num_vals, (char)buffer[47]); else writeVariableByte(nc_group_id, vid_qc_flag, index, num_vals, (char)-128); writeVariableByte(nc_group_id, vid_nprovs_qc, index, num_vals, (char)0); if (buffer[48] != -32768) writeVariableByte(nc_group_id, vid_vert_ext, index, num_vals, (char)buffer[48]); else writeVariableByte(nc_group_id, vid_vert_ext, index, num_vals, (char)-128); if (buffer[49] != -32768) writeVariableByte(nc_group_id, vid_prof_cap, index, num_vals, (char)buffer[49]); else writeVariableByte(nc_group_id, vid_prof_cap, index, num_vals, (char)-128); if ((buffer[50] >= 0) && (buffer[50] <= 3)) writeVariableByte(nc_group_id, vid_superad, index, num_vals, (char)buffer[50]); else writeVariableByte(nc_group_id, vid_superad, index, num_vals, (char)-128); if (buffer[51] != -32768) writeVariableByte(nc_group_id, vid_inversion, index, num_vals, (char)buffer[51]); else writeVariableByte(nc_group_id, vid_inversion, index, num_vals, (char)-128); if (buffer[52] != -32768) writeVariableByte(nc_group_id, vid_tpw_cat, index, num_vals, (char)buffer[52]); else writeVariableByte(nc_group_id, vid_tpw_cat, index, num_vals, (char)-128); if (buffer[53] != -32768) writeVariableByte(nc_group_id, vid_moisture_cap, index, num_vals, (char)buffer[53]); else writeVariableByte(nc_group_id, vid_moisture_cap, index, num_vals, (char)-128); if (buffer[54] != -32768) writeVariableByte(nc_group_id, vid_surf_data_flag, index, num_vals, (char)buffer[54]); else writeVariableByte(nc_group_id, vid_surf_data_flag, index, num_vals, (char)-128); if (buffer[55] != -32768) writeVariableFloat(nc_group_id, vid_max_inv_depth, index, num_vals, (buffer[55]/10.0)); else writeVariableFloat(nc_group_id, vid_max_inv_depth, index, num_vals, missing_float); writeVariableFloat(nc_group_id, vid_calc_tropo_pres, index, num_vals, (buffer[56]/1.0)); if (buffer[57] != -32768) writeVariableByte(nc_group_id, vid_sbl_flag, index, num_vals, (char)buffer[57]); else writeVariableByte(nc_group_id, vid_sbl_flag, index, num_vals, (char)-128); if (buffer[58] != -32768) writeVariableFloat(nc_group_id, vid_hi_interp_moisture, index, num_vals, (buffer[58]/10.0)); else writeVariableFloat(nc_group_id, vid_hi_interp_moisture, index, num_vals, missing_float); if (buffer[59] != -32768) writeVariableByte(nc_group_id, vid_wvmr_anomaly, index, num_vals, (char)buffer[59]); else writeVariableByte(nc_group_id, vid_wvmr_anomaly, index, num_vals, (char)-128); if (buffer[60] != -32768) writeVariableByte(nc_group_id, vid_wvmr_event_1, index, num_vals, (char)buffer[60]); else writeVariableByte(nc_group_id, vid_wvmr_event_1, index, num_vals, (char)-128); if (buffer[61] != -32768) writeVariableByte(nc_group_id, vid_wvmr_extreme_1, index, num_vals, (char)buffer[61]); else writeVariableByte(nc_group_id, vid_wvmr_extreme_1, index, num_vals, (char)-128); if (buffer[62] != -32768) writeVariableByte(nc_group_id, vid_wvmr_event_2, index, num_vals, (char)buffer[62]); else writeVariableByte(nc_group_id, vid_wvmr_event_2, index, num_vals, (char)-128); if (buffer[63] != -32768) writeVariableByte(nc_group_id, vid_wvmr_neg_event, index, num_vals, (char)buffer[63]); else writeVariableByte(nc_group_id, vid_wvmr_neg_event, index, num_vals, (char)-128); if (buffer[64] != -32768) writeVariableByte(nc_group_id, vid_wvmr_extreme_neg, index, num_vals, (char)buffer[64]); else writeVariableByte(nc_group_id, vid_wvmr_extreme_neg, index, num_vals, (char)-128); if (buffer[65] != -32768) writeVariableByte(nc_group_id, vid_utls_anomaly, index, num_vals, (char)buffer[65]); else writeVariableByte(nc_group_id, vid_utls_anomaly, index, num_vals, (char)-128); if (buffer[66] != -32768) writeVariableByte(nc_group_id, vid_inversion_type, index, num_vals, (char)buffer[66]); else writeVariableByte(nc_group_id, vid_inversion_type, index, num_vals, (char)-128); if (buffer[67] != -32768) writeVariableByte(nc_group_id, vid_dwpt_depress, index, num_vals, (char)buffer[67]); else writeVariableByte(nc_group_id, vid_dwpt_depress, index, num_vals, (char)-128); if (buffer[68] != -32768) writeVariableByte(nc_group_id, vid_duplicate, index, num_vals, (char)buffer[68]); else writeVariableByte(nc_group_id, vid_duplicate, index, num_vals, (char)-128); if (buffer[69] != -32768) writeVariableByte(nc_group_id, vid_tier_2, index, num_vals, (char)buffer[69]); else writeVariableByte(nc_group_id, vid_tier_2, index, num_vals, (char)-128); if (buffer[70] != -32768) writeVariableByte(nc_group_id, vid_screen_adjust, index, num_vals, (char)buffer[70]); else writeVariableByte(nc_group_id, vid_screen_adjust, index, num_vals, (char)-128); if (buffer[151] != -32768) writeVariableFloat(nc_group_id, vid_sbl_top, index, num_vals, (buffer[151]/1.0)); else writeVariableFloat(nc_group_id, vid_sbl_top, index, num_vals, missing_float); if (buffer[152] != -32768) writeVariableFloat(nc_group_id, vid_tropo_press, index, num_vals, (buffer[152]/1.0)); else writeVariableFloat(nc_group_id, vid_tropo_press, index, num_vals, missing_float); if (buffer[153] != -32768) writeVariableFloat(nc_group_id, vid_surf_press, index, num_vals, (buffer[153]/1.0)); else writeVariableFloat(nc_group_id, vid_surf_press, index, num_vals, missing_float); if (buffer[154] != -32768) writeVariableFloat(nc_group_id, vid_surf_temp, index, num_vals, (buffer[154]/64.0)); else writeVariableFloat(nc_group_id, vid_surf_temp, index, num_vals, missing_float); if (buffer[155] != -32768) writeVariableFloat(nc_group_id, vid_surf_wvmr, index, num_vals, (float)(exp(buffer[155]/1024.0))); else writeVariableFloat(nc_group_id, vid_surf_wvmr, index, num_vals, missing_float); if (buffer[156] != -32768) writeVariableFloat(nc_group_id, vid_surf_dwpt, index, num_vals, (buffer[156]/64.0)); else writeVariableFloat(nc_group_id, vid_surf_dwpt, index, num_vals, missing_float); if (buffer[157] != -32768) writeVariableFloat(nc_group_id, vid_low_wvmr, index, num_vals, (float)(exp(buffer[157]/1024.0))); else writeVariableFloat(nc_group_id, vid_low_wvmr, index, num_vals, missing_float); if (buffer[158] != -32768) writeVariableFloat(nc_group_id, vid_high_wvmr, index, num_vals, (float)(exp(buffer[158]/1024.0))); else writeVariableFloat(nc_group_id, vid_high_wvmr, index, num_vals, missing_float); if (buffer[159] != -32768) writeVariableByte(nc_group_id, vid_suan, index, num_vals, (char)buffer[159]); else writeVariableByte(nc_group_id, vid_suan, index, num_vals, (char)-128); if (buffer[160] != -32768) writeVariableByte(nc_group_id, vid_gcos, index, num_vals, (char)buffer[160]); else writeVariableByte(nc_group_id, vid_gcos, index, num_vals, (char)-128); if (buffer[161] != -32768) writeVariableByte(nc_group_id, vid_gruan, index, num_vals, (char)buffer[161]); else writeVariableByte(nc_group_id, vid_gruan, index, num_vals, (char)-128); if (buffer[162] != -32768) writeVariableFloat(nc_group_id, vid_tpw, index, num_vals, (buffer[162]/100.0)); else writeVariableFloat(nc_group_id, vid_tpw, index, num_vals, missing_float); // Layer precipitable water for (n=0; n<18; n++) { if (buffer[163+n] != -32768) lpw[n] = buffer[163+n] / 100.0; else lpw[n] = -32768; } index_2D[0] = collocation_num; index_2D[1] = 0; num_vals_2D[0] = 1; num_vals_2D[1] = 18; writeArrayFloat(nc_group_id, vid_lpw, index_2D, num_vals_2D, lpw); // More values if (buffer[181] != -32768) writeVariableFloat(nc_group_id, vid_utls_pressure, index, num_vals, (buffer[181]/10.0)); else writeVariableFloat(nc_group_id, vid_utls_pressure, index, num_vals, missing_float); if (buffer[182] != -32768) writeVariableFloat(nc_group_id, vid_temp_extrap, index, num_vals, (buffer[182]/10.0)); else writeVariableFloat(nc_group_id, vid_temp_extrap, index, num_vals, missing_float); if (buffer[183] != -32768) writeVariableByte(nc_group_id, vid_climate_limit, index, num_vals, (char)buffer[183]); else writeVariableByte(nc_group_id, vid_climate_limit, index, num_vals, (char)-128); if (buffer[184] != -32768) writeVariableByte(nc_group_id, vid_dwpt_flag, index, num_vals, (char)buffer[184]); else writeVariableByte(nc_group_id, vid_dwpt_flag, index, num_vals, (char)-128); if (buffer[185] != -32768) writeVariableByte(nc_group_id, vid_vert_extent, index, num_vals, (char)buffer[185]); else writeVariableByte(nc_group_id, vid_vert_extent, index, num_vals, (char)-128); if (buffer[186] != -32768) writeVariableByte(nc_group_id, vid_temp_gap, index, num_vals, (char)buffer[186]); else writeVariableByte(nc_group_id, vid_temp_gap, index, num_vals, (char)-128); if (buffer[187] != -32768) writeVariableByte(nc_group_id, vid_moisture_gap, index, num_vals, (char)buffer[187]); else writeVariableByte(nc_group_id, vid_moisture_gap, index, num_vals, (char)-128); if (buffer[188] != -32768) writeVariableByte(nc_group_id, vid_ncep_screen, index, num_vals, (char)buffer[188]); else writeVariableByte(nc_group_id, vid_ncep_screen, index, num_vals, (char)-128); // Tropopause data index_2D[0] = collocation_num; index_2D[1] = 0; num_vals_2D[0] = 1; num_vals_2D[1] = 5; for (n=0; n<5; n++) { if (buffer[2699+n] != -32768) tropo[n] = buffer[2699+n] / 10.0; else tropo[n] = -32768; } writeArrayFloat(nc_group_id, vid_tropo_deflect, index_2D, num_vals_2D, tropo); for (n=0; n<5; n++) { if (buffer[2705+n] != -32768) tropo[n] = buffer[2705+n] / 10.0; else tropo[n] = -32768; } writeArrayFloat(nc_group_id, vid_tropo_rep_press, index_2D, num_vals_2D, tropo); for (n=0; n<5; n++) { if (buffer[2729+n] != -32768) tropo[n] = buffer[2729+n] / 10.0; else tropo[n] = -32768; } writeArrayFloat(nc_group_id, vid_tropo_calc_press, index_2D, num_vals_2D, tropo); if (buffer[2734] != -32768) writeVariableByte(nc_group_id, vid_tropo_qc, index, num_vals, (char)buffer[2734]); else writeVariableByte(nc_group_id, vid_tropo_qc, index, num_vals, (char)-128); // Surface values if (buffer[2735] != -32768) writeVariableFloat(nc_group_id, vid_surf_press, index, num_vals, (buffer[2735]/10.0)); else writeVariableFloat(nc_group_id, vid_surf_press, index, num_vals, missing_float); if ((buffer[2736] != -32768) && (buffer[2736] != 0)) writeVariableFloat(nc_group_id, vid_surf_temp, index, num_vals, ((buffer[2736]/10.0)+273.15)); else writeVariableFloat(nc_group_id, vid_surf_temp, index, num_vals, missing_float); if ((buffer[2738] != -32768) && (buffer[2738] != 0)) writeVariableFloat(nc_group_id, vid_surf_dwpt, index, num_vals, ((buffer[2738]/10.0)+273.15)); else writeVariableFloat(nc_group_id, vid_surf_dwpt, index, num_vals, missing_float); if (buffer[2737] != -32768) writeVariableFloat(nc_group_id, vid_surf_relhum, index, num_vals, (buffer[2737]/1000.0)); else writeVariableFloat(nc_group_id, vid_surf_relhum, index, num_vals, missing_float); writeVariableFloat(nc_group_id, vid_surf_wind_dir, index, num_vals, (buffer[2742]/1.0)); writeVariableFloat(nc_group_id, vid_surf_wind_speed, index, num_vals, (buffer[2743]/1.0)); // Other variables writeVariableShort(nc_group_id, vid_radcor_code, index, num_vals, buffer[2747]); if (buffer[2753] != -32768) writeVariableByte(nc_group_id, vid_text_flag, index, num_vals, (char)buffer[2753]); else writeVariableByte(nc_group_id, vid_text_flag, index, num_vals, (char)-128); if (buffer[2754] != -32768) writeVariableFloat(nc_group_id, vid_solzen, index, num_vals, (buffer[2754]/128.0)); else writeVariableFloat(nc_group_id, vid_solzen, index, num_vals, missing_float); if (buffer[2755] != -32768) writeVariableByte(nc_group_id, vid_daynight, index, num_vals, (char)buffer[2755]); else writeVariableByte(nc_group_id, vid_daynight, index, num_vals, (char)-128); // Profile cap values if (buffer[2899] != -32768) writeVariableFloat(nc_group_id, vid_temp_cap_press, index, num_vals, (buffer[2899]/10.0)); else writeVariableFloat(nc_group_id, vid_temp_cap_press, index, num_vals, missing_float); if (buffer[2900] != -32768) writeVariableFloat(nc_group_id, vid_moisture_cap_press, index, num_vals, (buffer[2900]/10.0)); else writeVariableFloat(nc_group_id, vid_moisture_cap_press, index, num_vals, missing_float); // GDP product status if (buffer[535] != -32768) writeVariableFloat(nc_group_id, vid_gdpstatus, index, num_vals, (char)buffer[535]); else writeVariableFloat(nc_group_id, vid_gdpstatus, index, num_vals, (char)-128); // Significant level data index_2D[0] = collocation_num; index_2D[1] = 0; num_vals_2D[0] = 1; num_vals_2D[1] = 118; for (n=0; n<118; n++) { level_data[n] = missing_float; byte_level_data[n] = (char)-128; pressures[n] = missing_float; rev_pressures[n] = missing_float; } writeVariableShort(nc_group_id, vid_numlevels, index, num_vals, buffer[536]); // Pressures for (n=0; n<118; n++) { if (buffer[537+n] == -32768) { pressures[99-n] = missing_float; rev_pressures[n] = missing_float; } else { if ((buffer[2753] != 2) || ((537+n) < 617)) { pressures[99-n] = buffer[537+n] / 10.0; rev_pressures[n] = buffer[537+n] / 10.0; } else { pressures[99-n] = buffer[537+n] / 1000.0; rev_pressures[n] = buffer[537+n] / 1000.0; } } } writeArrayFloat(nc_group_id, vid_press, index_2D, num_vals_2D, pressures); for (n=0; n<118; n++) { if (buffer[3971+n] != -32768) level_data[99-n] = buffer[3971+n] / 1000.0; else level_data[99-n] = missing_float; } writeArrayFloat(nc_group_id, vid_press_err, index_2D, num_vals_2D, level_data); // Temperatures for (n=0; n<118; n++) { if (buffer[637+n] != -32768) level_data[99-n] = (buffer[637+n] / 10.0) + 273.15; else level_data[99-n] = missing_float; } writeArrayFloat(nc_group_id, vid_temps, index_2D, num_vals_2D, level_data); for (n=0; n<118; n++) { if (buffer[3371+n] != -32768) level_data[99-n] = buffer[3371+n] / 1000.0; else level_data[99-n] = missing_float; } writeArrayFloat(nc_group_id, vid_temp_err, index_2D, num_vals_2D, level_data); for (n=0; n<118; n++) { if (buffer[3071+n] != -32768) level_data[99-n] = buffer[3071+n] / 100.0; else level_data[99-n] = missing_float; } writeArrayFloat(nc_group_id, vid_temp_sd, index_2D, num_vals_2D, level_data); // Radcor temperature for (n=0; n<118; n++) { if (buffer[3271+n] != -32768) level_data[99-n] = buffer[3271+n] / 100.0; else level_data[99-n] = missing_float; } writeArrayFloat(nc_group_id, vid_radcor_temp, index_2D, num_vals_2D, level_data); // Dewpoint temperatures for (n=0; n<118; n++) { if (buffer[937+n] != -32768) level_data[99-n] = dwptToWvmr(rev_pressures[n], ((buffer[937+n]/10.0)+273.15)); else level_data[99-n] = missing_float; } writeArrayFloat(nc_group_id, vid_wvmr, index_2D, num_vals_2D, level_data); // Frost point temperatures for (n=0; n<118; n++) { if (buffer[3171+n] != -32768) level_data[99-n] = buffer[3171+n] / 10.0; else level_data[99-n] = missing_float; } writeArrayFloat(nc_group_id, vid_frosttemp, index_2D, num_vals_2D, level_data); // Relative humidity for (n=0; n<118; n++) { if (buffer[3471+n] != -32768) level_data[99-n] = buffer[3471+n] / 1000.0; else level_data[99-n] = missing_float; } writeArrayFloat(nc_group_id, vid_relhum, index_2D, num_vals_2D, level_data); //********************************** //********************************** //********************************** //********************************** //********************************** /* if (buffer[153] != -32768) surf_pressure = buffer[153] / 1.0; else surf_pressure = -32768.0; for (n=0; n<118; n++) { temp_pressures[117-n] = missing_float; wvap_pressures[117-n] = missing_float; temps[117-n] = missing_float; wvaps[117-n] = missing_float; if (buffer[537+n] != -32768) { if ((buffer[2753] != 2) || ((537+n) < 617)) { temp_pressures[117-n] = buffer[537+n] / 10.0; wvap_pressures[117-n] = buffer[537+n] / 10.0; rev_pressures[n] = buffer[537+n] / 10.0; } else { temp_pressures[117-n] = buffer[537+n] / 1000.0; wvap_pressures[117-n] = buffer[537+n] / 1000.0; rev_pressures[n] = buffer[537+n] / 1000.0; } } if (buffer[637+n] != -32768) temps[117-n] = (buffer[637+n] / 10.0) + 273.15; if (buffer[937+n] != -32768) wvaps[117-n] = dwptToWvmr(rev_pressures[n], ((buffer[937+n]/10.0)+273.15)); } relative_humidities = calculateRelativeHumidities(temp_pressures, temps, 118, wvap_pressures, wvaps, 118, surf_pressure); writeArrayFloat(nc_group_id, vid_rh, index_2D, num_vals_2D, relative_humidities); //printf("\n\nHumidity Comparison\n"); //for (n=0; n<118; n++) printf("%d\t%.1f\t%.2f\t%.2f %f %f %f %f\n", n, wvap_pressures[n], (level_data[n]*100.0), relative_humidities[n], temp_pressures[n], temps[n], wvap_pressures[n], wvaps[n]); free(relative_humidities); //tpw = calculateTPW(wvap_pressures, wvaps, 100, surf_pressure, -32768.0); //writeVariableFloat(nc_group_id, vid_tpw, index, num_vals, tpw); //printf("TPW Comparison\n"); //printf("%.2f\t%.2f\n", (buffer[162]/100.0), tpw); */ //********************************** //********************************** //********************************** //********************************** //********************************** for (n=0; n<118; n++) { if (buffer[3571+n] != -32768) level_data[99-n] = buffer[3571+n] / 1000.0; else level_data[99-n] = missing_float; } writeArrayFloat(nc_group_id, vid_relhum_corr, index_2D, num_vals_2D, level_data); for (n=0; n<118; n++) { if (buffer[3671+n] != -32768) level_data[99-n] = buffer[3671+n] / 1000.0; else level_data[99-n] = missing_float; } writeArrayFloat(nc_group_id, vid_relhum_err, index_2D, num_vals_2D, level_data); for (n=0; n<118; n++) { if (buffer[4071+n] != -32768) level_data[99-n] = buffer[4071+n] / 100.0; else level_data[99-n] = missing_float; } writeArrayFloat(nc_group_id, vid_relhum_sd, index_2D, num_vals_2D, level_data); // Drift time, lat and lon for (n=0; n<118; n++) { if (buffer[2971+n] != -32768) level_data[99-n] = buffer[2971+n] / 100.0; else level_data[99-n] = missing_float; } writeArrayFloat(nc_group_id, vid_ascent, index_2D, num_vals_2D, level_data); for (n=0; n<118; n++) { if (buffer[1237+n] != -32768) level_data[99-n] = buffer[1237+n] / 100.0; else level_data[99-n] = missing_float; } writeArrayFloat(nc_group_id, vid_drift_time, index_2D, num_vals_2D, level_data); for (n=0; n<118; n++) { if (buffer[1337+n] != -32768) level_data[99-n] = buffer[1337+n] / 128.0; else level_data[99-n] = missing_float; } writeArrayFloat(nc_group_id, vid_drift_lat, index_2D, num_vals_2D, level_data); for (n=0; n<118; n++) { if (buffer[1437+n] != -32768) level_data[99-n] = buffer[1437+n] / 128.0; else level_data[99-n] = missing_float; } writeArrayFloat(nc_group_id, vid_drift_lon, index_2D, num_vals_2D, level_data); // Geopotential height for (n=0; n<118; n++) { if (buffer[1537+n] == -32768) { level_data[99-n] = missing_float; } else { if ((rev_pressures[n] != missing_float) && (rev_pressures[n] < 80.0)) level_data[99-n] = buffer[1537+n] * 100.0; else level_data[99-n] = buffer[1537+n] / 1.0; } } writeArrayFloat(nc_group_id, vid_height, index_2D, num_vals_2D, level_data); // Wind direction and speed for (n=0; n<118; n++) { if (buffer[1637+n] != -32768) level_data[99-n] = buffer[1637+n] / 1.0; else level_data[99-n] = missing_float; } writeArrayFloat(nc_group_id, vid_wind_dir, index_2D, num_vals_2D, level_data); for (n=0; n<118; n++) { if (buffer[2799+n] != -32768) level_data[99-n] = buffer[2799+n] / 10.0; else level_data[99-n] = missing_float; } writeArrayFloat(nc_group_id, vid_wind_dir_err, index_2D, num_vals_2D, level_data); for (n=0; n<118; n++) { if (buffer[1737+n] != -32768) level_data[99-n] = buffer[1737+n] / 1.0; else level_data[99-n] = missing_float; } writeArrayFloat(nc_group_id, vid_wind_speed, index_2D, num_vals_2D, level_data); for (n=0; n<118; n++) { if (buffer[1137+n] != -32768) level_data[99-n] = buffer[1137+n] / 10.0; else level_data[99-n] = missing_float; } writeArrayFloat(nc_group_id, vid_wind_speed_err, index_2D, num_vals_2D, level_data); for (n=0; n<118; n++) { if (buffer[737+n] != -32768) level_data[99-n] = buffer[737+n] / 10.0; else level_data[99-n] = missing_float; } writeArrayFloat(nc_group_id, vid_zonalwind, index_2D, num_vals_2D, level_data); for (n=0; n<118; n++) { if (buffer[837+n] != -32768) level_data[99-n] = buffer[837+n] / 10.0; else level_data[99-n] = missing_float; } writeArrayFloat(nc_group_id, vid_meridwind, index_2D, num_vals_2D, level_data); // Level missing flag for (n=0; n<118; n++) { if (buffer[2337+n] != -32768) byte_level_data[99-n] = (char)buffer[2337+n]; else byte_level_data[99-n] = (char)-128; } writeArrayByte(nc_group_id, vid_missing_flag, index_2D, num_vals_2D, byte_level_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