/* Name- processRaob06.c Language- C Type- MAIN Version- 1.0 Date- 11/12/2024 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 processRaob06(FILE *in, int header_length, int record_length, int number_of_collocations, int group, char *nprovs_name, char *description, int group_id, char *dir_name, int group_type, int group_length, long group_offset, int nc_date_group) { int n, i, recnum, 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_temps, vid_radcor_temp, vid_dwpt, vid_wvmr; int vid_radcor_dwpt, vid_drift_time, vid_drift_lat, vid_drift_lon; int vid_height, vid_wind_dir, vid_wind_speed, vid_missing_flag; int vid_frosttemp, vid_radcor_for_temp, vid_temp_uncert; int vid_temp_spatial_uncert, vid_temp_temporal_uncert;; int vid_relhum, vid_relhum_corr, vid_relhum_uncert; int vid_relhum_spatial_uncert, vid_relhum_temporal_uncert; int vid_vol_mr, vid_geom_height; int vid_press_uncert, vid_press_spatial_uncert, vid_press_temporal_uncert; num_colls = (size_t)number_of_collocations; missing_float = -32768.0; // If this is the baseline platform, then create a subgroup // for the collocation information if (group == 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", group_type); writeAttributeText(collocation_group_id, "Baseline_Platform", description); writeAttributeShort(collocation_group_id, "Baseline_Platform_ID", group_id); } // Create a subgroup for this system platform if ((retval = nc_def_grp(nc_date_group, 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", description); writeAttributeShort(nc_group_id, "Platform_ID", group_id); writeAttributeShort(nc_group_id, "Platform_Type", group_type); writeAttributeText(nc_group_id, "Platform_Data_Source", "Radiosonde Version 5"); writeAttributeText(nc_group_id, "Platform_NPROVS_Source_Name", nprovs_name); // 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 (group == 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 (group == 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_wvmr = defineVariable(nc_group_id, "surface_water_vapor_mixing_ratio", NC_FLOAT, 1, dimid_scalar, "units", "g/kg"); 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_temps = defineVariable(nc_group_id, "temperature", NC_FLOAT, 2, dimid_levels, "units", "K"); vid_radcor_temp = defineVariable(nc_group_id, "radiation_corrected_temperature", NC_FLOAT, 2, dimid_levels, "units", "K"); vid_dwpt = defineVariable(nc_group_id, "dewpoint_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_radcor_dwpt = defineVariable(nc_group_id, "radcor_dewpoint_temperature", NC_FLOAT, 2, dimid_levels, "units", "K"); 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_speed = defineVariable(nc_group_id, "wind_speed", NC_FLOAT, 2, dimid_levels, "units", "knots"); vid_missing_flag = defineVariable(nc_group_id, "level_missing_flag", NC_BYTE, 2, dimid_levels, "values", "0=not missing, 1=missing"); vid_frosttemp = defineVariable(nc_group_id, "frost_point_temperature", NC_FLOAT, 2, dimid_levels, "units", "K"); vid_radcor_for_temp = defineVariable(nc_group_id, "temperature_radiation_correction", NC_FLOAT, 2, dimid_levels, "units", "K"); vid_temp_uncert = defineVariable(nc_group_id, "temperature_uncertainty", NC_FLOAT, 2, dimid_levels, "units", "K"); vid_temp_spatial_uncert = defineVariable(nc_group_id, "temperature_spatial_uncertainty", NC_FLOAT, 2, dimid_levels, "units", "K"); vid_temp_temporal_uncert = defineVariable(nc_group_id, "temperature_temporal_uncertainty", NC_FLOAT, 2, dimid_levels, "units", "K"); vid_relhum = defineVariable(nc_group_id, "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_uncert = defineVariable(nc_group_id, "relative_humidity_uncertainty", NC_FLOAT, 2, dimid_levels, "units", "pct"); vid_relhum_spatial_uncert = defineVariable(nc_group_id, "relative_humidity_spatial_uncertainty", NC_FLOAT, 2, dimid_levels, "units", "pct"); vid_relhum_temporal_uncert = defineVariable(nc_group_id, "relative_humidity_temporal_uncertainty", NC_FLOAT, 2, dimid_levels, "units", "pct"); vid_vol_mr = defineVariable(nc_group_id, "volume_mixing_ratio", NC_FLOAT, 2, dimid_levels, "units", "mol/mol"); vid_geom_height = defineVariable(nc_group_id, "geometric_height", NC_FLOAT, 2, dimid_levels, "units", "meters"); vid_press_uncert = defineVariable(nc_group_id, "pressure_uncertainty", NC_FLOAT, 2, dimid_levels, "units", "hPa"); vid_press_spatial_uncert = defineVariable(nc_group_id, "pressure_spatial_uncertainty", NC_FLOAT, 2, dimid_levels, "units", "hPa"); vid_press_temporal_uncert = defineVariable(nc_group_id, "pressure_temporal_uncertainty", NC_FLOAT, 2, dimid_levels, "units", "hPa"); // Allocate the memory used by the data buffer buffer = (short *)malloc(group_length); // Loop through each record in the file and read the data for // this data group into the buffer for (recnum=0; recnum 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] = recnum; 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] = recnum; 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] = recnum; 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); // 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); // 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] = (buffer[937+n]/10.0) + 273.15; else level_data[99-n] = missing_float; } writeArrayFloat(nc_group_id, vid_dwpt, index_2D, num_vals_2D, level_data); // Water vapor mixing ratios 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); // Radcor dewpoint temperatures for (n=0; n<118; n++) { if (buffer[1037+n] != -32768) level_data[99-n] = (buffer[1037+n]/10.0) + 273.15; else level_data[99-n] = missing_float; } writeArrayFloat(nc_group_id, vid_radcor_dwpt, index_2D, num_vals_2D, level_data); // Drift time 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 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); // Wind speed 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); // 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); // 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); // Temperature radiation correction for (n=0; n<118; n++) { if (buffer[3271+n] != -32768) level_data[99-n] = buffer[3271+n] / 1000.0; else level_data[99-n] = missing_float; } writeArrayFloat(nc_group_id, vid_radcor_for_temp, index_2D, num_vals_2D, level_data); // Temperature uncertainty 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_uncert, index_2D, num_vals_2D, level_data); // Temperature spatial uncertainty 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_temp_spatial_uncert, index_2D, num_vals_2D, level_data); // Temperature temporal uncertainty 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_temp_temporal_uncert, index_2D, num_vals_2D, level_data); // Relative humidity for (n=0; n<118; n++) { if (buffer[3671+n] != -32768) level_data[99-n] = buffer[3671+n] / 100.0; else level_data[99-n] = missing_float; } writeArrayFloat(nc_group_id, vid_relhum, index_2D, num_vals_2D, level_data); // Relative humidity correction for (n=0; n<118; n++) { if (buffer[3771+n] != -32768) level_data[99-n] = buffer[3771+n] / 1000.0; else level_data[99-n] = missing_float; } writeArrayFloat(nc_group_id, vid_relhum_corr, index_2D, num_vals_2D, level_data); // Relative humidity uncertainty for (n=0; n<118; n++) { if (buffer[3871+n] != -32768) level_data[99-n] = buffer[3871+n] / 1000.0; else level_data[99-n] = missing_float; } writeArrayFloat(nc_group_id, vid_relhum_uncert, index_2D, num_vals_2D, level_data); // Relative humidity spatial uncertainty 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_relhum_spatial_uncert, index_2D, num_vals_2D, level_data); // Relative humidity temporal uncertainty for (n=0; n<118; n++) { if (buffer[4071+n] != -32768) level_data[99-n] = buffer[4071+n] / 1000.0; else level_data[99-n] = missing_float; } writeArrayFloat(nc_group_id, vid_relhum_temporal_uncert, index_2D, num_vals_2D, level_data); // Volume mixing ratio for (n=0; n<118; n++) { if (buffer[4171+n] != -32768) level_data[99-n] = buffer[4171+n] / 1000.0; else level_data[99-n] = missing_float; } writeArrayFloat(nc_group_id, vid_vol_mr, index_2D, num_vals_2D, level_data); // Geometric height for (n=0; n<118; n++) { if (buffer[4271+n] != -32768) level_data[99-n] = buffer[4271+n] / 1.0; else level_data[99-n] = missing_float; } //writeArrayFloat(nc_group_id, vid_geom_height, index_2D, num_vals_2D, level_data); // Pressure uncertainty for (n=0; n<118; n++) { if (buffer[4371+n] != -32768) level_data[99-n] = buffer[4371+n] / 100.0; else level_data[99-n] = missing_float; } writeArrayFloat(nc_group_id, vid_press_uncert, index_2D, num_vals_2D, level_data); // Pressure spatial uncertainty for (n=0; n<118; n++) { if (buffer[4471+n] != -32768) level_data[99-n] = buffer[4471+n] / 100.0; else level_data[99-n] = missing_float; } writeArrayFloat(nc_group_id, vid_press_spatial_uncert, index_2D, num_vals_2D, level_data); // Pressure temporal uncertainty for (n=0; n<118; n++) { if (buffer[4571+n] != -32768) level_data[99-n] = buffer[4571+n] / 100.0; else level_data[99-n] = missing_float; } writeArrayFloat(nc_group_id, vid_press_temporal_uncert, index_2D, num_vals_2D, level_data); // for (n=0; n<118; n++) // printf("Data: %d %f\n", n, level_data[n]); } // for (recnum=0... // Free the memory used by the buffer free(buffer); } // end of file