/* Name- processAIRS01.c Language- C Type- MAIN Version- 1.0 Date- 4/08/2018 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 ERR(e) {printf("Error: %s, error num = %d\n", nc_strerror(e),e); return 2;} #define NDIMS 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 writeArrayFloat(int group_id, int var_id, size_t *index, size_t *num_vals, float *value); void writeArrayByte(int group_id, int var_id, size_t *index, size_t *num_vals, char *value); float interpolateValue(float pressure, int num_values, float *before_pressures, float *before_data); void writeAttributeShort(int grp, char *attrVariable, short attrValue); void writeAttributeText(int grp, char *attrVariable, char *attrValue); void processAIRS01(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, level_data[100], cloud_data[2]; float pressures[100], file_pressures[28], data28[28], data14[14]; float moisture_pressures[15], midpoint_pressures[14]; char level_byte_data[100], cloud_byte_data[2]; int year, month, day, hour, minute, second; long offset, yyyymmdd, hhmmss; char col_dir_name[50]; char string6[7], string10[11]; char *string[1]; short *buffer; int col_scalar_dim; int scalar_dim, dim_levels, dim_clouds; int dimid_scalar[1], col_dimid_scalar[1]; int dimid_levels[2], dimid_clouds[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_daynight, vid_node; int vid_topo, vid_topo_err, vid_landfrac, vid_landfrac_err; int vid_terrain, vid_solzen, vid_fg_surfpres, vid_fg_surfpres_qc; int vid_skintemp, vid_skintemp_qc, vid_skintemp_err; int vid_surftemp, vid_surftemp_qc, vid_surftemp_err; int vid_tropo_press, vid_tropo_press_qc, vid_tropo_temp, vid_tropo_temp_qc; int vid_tpw, vid_tpw_qc, vid_tpw_err, vid_ret1_surf_temp, vid_ret1_air_temp; int vid_last_layer, vid_max_press_0, vid_max_press_01, vid_high_index_0, vid_high_index_01; int vid_press, vid_temp, vid_temp_qc, vid_temp_err, vid_wvmr, vid_wvmr_qc, vid_wvmr_err; int vid_mw_temp, vid_mw_temp_qc, vid_mw_wvmr, vid_mw_wvmr_qc, vid_reg_temp, vid_reg_wvmr; int vid_tca, vid_tca_qc, vid_numclouds, vid_ctp, vid_ctp_qc, vid_ctt, vid_ctt_qc; int vid_ca, vid_ca_qc; FILE *in; num_colls = (size_t)num_collocations; missing_float = -32768.0; pressures[0] = 0.016F; pressures[1] = 0.038F; pressures[2] = 0.076F; pressures[3] = 0.136F; pressures[4] = 0.224F; pressures[5] = 0.345F; pressures[6] = 0.506F; pressures[7] = 0.713F; pressures[8] = 0.975F; pressures[9] = 1.297F; pressures[10] = 1.687F; pressures[11] = 2.152F; pressures[12] = 2.7F; pressures[13] = 3.339F; pressures[14] = 4.077F; pressures[15] = 4.92F; pressures[16] = 5.877F; pressures[17] = 6.956F; pressures[18] = 8.165F; pressures[19] = 9.511F; pressures[20] = 11.0F; pressures[21] = 12.6F; pressures[22] = 14.4F; pressures[23] = 16.4F; pressures[24] = 18.5F; pressures[25] = 20.9F; pressures[26] = 23.4F; pressures[27] = 26.1F; pressures[28] = 29.1F; pressures[29] = 32.2F; pressures[30] = 35.6F; pressures[31] = 39.2F; pressures[32] = 43.1F; pressures[33] = 47.1F; pressures[34] = 51.5F; pressures[35] = 56.1F; pressures[36] = 60.9F; pressures[37] = 66.1F; pressures[38] = 71.5F; pressures[39] = 77.2F; pressures[40] = 83.2F; pressures[41] = 89.5F; pressures[42] = 96.1F; pressures[43] = 103.0F; pressures[44] = 110.2F; pressures[45] = 117.7F; pressures[46] = 125.6F; pressures[47] = 133.8F; pressures[48] = 142.3F; pressures[49] = 151.2F; pressures[50] = 160.4F; pressures[51] = 170.0F; pressures[52] = 180.0F; pressures[53] = 190.3F; pressures[54] = 200.9F; pressures[55] = 212.0F; pressures[56] = 223.4F; pressures[57] = 235.2F; pressures[58] = 247.4F; pressures[59] = 259.9F; pressures[60] = 272.9F; pressures[61] = 286.2F; pressures[62] = 300.0F; pressures[63] = 314.1F; pressures[64] = 328.6F; pressures[65] = 343.6F; pressures[66] = 358.9F; pressures[67] = 374.7F; pressures[68] = 390.8F; pressures[69] = 407.4F; pressures[70] = 424.4F; pressures[71] = 441.8F; pressures[72] = 459.7F; pressures[73] = 477.9F; pressures[74] = 496.6F; pressures[75] = 515.7F; pressures[76] = 535.2F; pressures[77] = 555.1F; pressures[78] = 575.5F; pressures[79] = 596.3F; pressures[80] = 617.5F; pressures[81] = 639.1F; pressures[82] = 661.1F; pressures[83] = 683.6F; pressures[84] = 706.5F; pressures[85] = 729.8F; pressures[86] = 753.6F; pressures[87] = 777.7F; pressures[88] = 802.3F; pressures[89] = 827.3F; pressures[90] = 852.7F; pressures[91] = 878.6F; pressures[92] = 904.8F; pressures[93] = 931.5F; pressures[94] = 958.5F; pressures[95] = 986.0F; pressures[96] = 1013.9F; pressures[97] = 1042.2F; pressures[98] = 1070.9F; pressures[99] = 1100.0F; // 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", "AIRS version 1"); //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, "Layers", 100, &dim_levels))) ERR(retval); dimid_levels[0] = scalar_dim; dimid_levels[1] = dim_levels; if ((retval = nc_def_dim(nc_group_id, "Cloud_Layers", 2, &dim_clouds))) ERR(retval); dimid_clouds[0] = scalar_dim; dimid_clouds[1] = dim_clouds; 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_daynight = defineVariable(nc_group_id, "day_night_flag", NC_BYTE, 1, dimid_scalar, "values", "0=night, 1=day, 2=both, -1=unexpected value"); vid_node = defineVariable(nc_group_id, "orbital_node", NC_BYTE, 1, dimid_scalar, "values", "0=ascending, 1=descending, 2=north pole, 3=south pole, -1=unexpected value"); vid_topo = defineVariable(nc_group_id, "mean_topography", NC_FLOAT, 1, dimid_scalar, "units", "m"); vid_topo_err = defineVariable(nc_group_id, "mean_topography_error", NC_FLOAT, 1, dimid_scalar, "units", "m"); vid_landfrac = defineVariable(nc_group_id, "land_fraction", NC_FLOAT, 1, dimid_scalar, "units", "percent"); vid_landfrac_err = defineVariable(nc_group_id, "land_fraction_error", NC_FLOAT, 1, dimid_scalar, "units", "percent"); vid_terrain = defineVariable(nc_group_id, "surface_type", NC_BYTE, 1, dimid_scalar, "values", "0=coast, 1=land, 2=sea, 3=sea ice (high mw emiss), 4= sea ice (low emiss), 5=snow (high freq mw scattering), 6=glacier snow, 7=snow (low freq mw scattering)"); vid_solzen = defineVariable(nc_group_id, "solar_zenith_angle", NC_FLOAT, 1, dimid_scalar, "units", "degrees"); vid_fg_surfpres = defineVariable(nc_group_id, "first_guess_surface_pressure", NC_FLOAT, 1, dimid_scalar, "units", "hPa"); vid_fg_surfpres_qc = defineVariable(nc_group_id, "first_guess_surface_pressure_qc", NC_BYTE, 1, dimid_scalar, NULL, NULL); vid_skintemp = defineVariable(nc_group_id, "surface_skin_temperature", NC_FLOAT, 1, dimid_scalar, "units", "K"); vid_skintemp_qc = defineVariable(nc_group_id, "surface_skin_temperature_qc", NC_BYTE, 1, dimid_scalar, NULL, NULL); vid_skintemp_err = defineVariable(nc_group_id, "surface_skin_temperature_error", NC_FLOAT, 1, dimid_scalar, "units", "K"); vid_surftemp = defineVariable(nc_group_id, "surface_air_temperature", NC_FLOAT, 1, dimid_scalar, "units", "K"); vid_surftemp_qc = defineVariable(nc_group_id, "surface_air_temperature_qc", NC_BYTE, 1, dimid_scalar, NULL, NULL); vid_surftemp_err = defineVariable(nc_group_id, "surface_air_temperature_error", NC_FLOAT, 1, dimid_scalar, "units", "K"); vid_tropo_press = defineVariable(nc_group_id, "tropopause_pressure", NC_FLOAT, 1, dimid_scalar, "units", "hPa"); vid_tropo_press_qc = defineVariable(nc_group_id, "tropopause_pressure_qc", NC_BYTE, 1, dimid_scalar, NULL, NULL); vid_tropo_temp = defineVariable(nc_group_id, "tropopause_temperature", NC_FLOAT, 1, dimid_scalar, "units", "K"); vid_tropo_temp_qc = defineVariable(nc_group_id, "tropopause_temperature_qc", NC_BYTE, 1, dimid_scalar, NULL, NULL); vid_tpw = defineVariable(nc_group_id, "total_precipitable_water", NC_FLOAT, 1, dimid_scalar, "units", "kg/m^2"); vid_tpw_qc = defineVariable(nc_group_id, "total_preciptiable_water_qc", NC_BYTE, 1, dimid_scalar, NULL, NULL); vid_tpw_err = defineVariable(nc_group_id, "total_precipitable_water_error", NC_FLOAT, 1, dimid_scalar, "units", "kg/m^2"); vid_ret1_surf_temp = defineVariable(nc_group_id, "surface_temperature_after_first_retrieval", NC_FLOAT, 1, dimid_scalar, "units", "K"); vid_ret1_air_temp = defineVariable(nc_group_id, "surface_air_temperature_after_first_retrieval", NC_FLOAT, 1, dimid_scalar, "units", "K"); vid_last_layer = defineVariable(nc_group_id, "last_used_pressure_index", NC_SHORT, 1, dimid_scalar, NULL, NULL); vid_max_press_0 = defineVariable(nc_group_id, "max_pressure_temperature_qc=0", NC_FLOAT, 1, dimid_scalar, "units", "hPa"); vid_max_press_01 = defineVariable(nc_group_id, "max_pressure_temperature_qc=0_or_1", NC_FLOAT, 1, dimid_scalar, "units", "hPa"); vid_high_index_0 = defineVariable(nc_group_id, "high_pressure_index_qc=0", NC_SHORT, 1, dimid_scalar, NULL, NULL); vid_high_index_01 = defineVariable(nc_group_id, "high_pressure_index_qc=0_or_1", NC_SHORT, 1, dimid_scalar, NULL, NULL); vid_press = defineVariable(nc_group_id, "pressure", NC_FLOAT, 2, dimid_levels, "units", "hPa"); vid_temp = defineVariable(nc_group_id, "temperature", NC_FLOAT, 2, dimid_levels, "units", "K"); vid_temp_qc = defineVariable(nc_group_id, "temperature_qc", NC_BYTE, 2, dimid_levels, NULL, NULL); vid_temp_err = defineVariable(nc_group_id, "temperature_error", 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_wvmr_qc = defineVariable(nc_group_id, "water_vapor_mixing_ratio_qc", NC_BYTE, 2, dimid_levels, NULL, NULL); vid_wvmr_err = defineVariable(nc_group_id, "water_vapor_mixing_ratio_error", NC_FLOAT, 2, dimid_levels, "units", "g/kg"); vid_mw_temp = defineVariable(nc_group_id, "mw_only_temperature", NC_FLOAT, 2, dimid_levels, "units", "K"); vid_mw_temp_qc = defineVariable(nc_group_id, "mw_only_temperature_qc", NC_BYTE, 2, dimid_levels, NULL, NULL); vid_mw_wvmr = defineVariable(nc_group_id, "mw_only_water_vapor_mixing_ratio", NC_FLOAT, 2, dimid_levels, "units", "g/kg"); vid_mw_wvmr_qc = defineVariable(nc_group_id, "mw_only_water_vapor_mixing_ratio_qc", NC_BYTE, 2, dimid_levels, NULL, NULL); vid_reg_temp = defineVariable(nc_group_id, "after_regression_temperature", NC_FLOAT, 2, dimid_levels, "units", "K"); vid_reg_wvmr = defineVariable(nc_group_id, "after_regression_water_vapor_mixing_ratio", NC_FLOAT, 2, dimid_levels, "units", "g/kg"); vid_tca = defineVariable(nc_group_id, "total_cloud_amount", NC_FLOAT, 1, dimid_scalar, "units", "percent"); vid_tca_qc = defineVariable(nc_group_id, "total_cloud_amount_qc", NC_BYTE, 1, dimid_scalar, NULL, NULL); vid_numclouds = defineVariable(nc_group_id, "number_of_cloud_layers", NC_BYTE, 1, dimid_scalar, NULL, NULL); vid_ctp = defineVariable(nc_group_id, "cloud_top_pressure", NC_FLOAT, 2, dimid_clouds, "units", "hPa"); vid_ctp_qc = defineVariable(nc_group_id, "cloud_top_pressure_qc", NC_BYTE, 2, dimid_clouds, NULL, NULL); vid_ctt = defineVariable(nc_group_id, "cloud_top_temperature", NC_FLOAT, 2, dimid_clouds, "units", "K"); vid_ctt_qc = defineVariable(nc_group_id, "cloud_top_temperature_qc", NC_BYTE, 2, dimid_clouds, NULL, NULL); vid_ca = defineVariable(nc_group_id, "cloud_fraction", NC_FLOAT, 2, dimid_clouds, "units", "percent"); vid_ca_qc = defineVariable(nc_group_id, "cloud_fraction_qc", NC_BYTE, 2, dimid_clouds, NULL, NULL); // 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; 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); } // Orbital node if (buffer[30] == 65) writeVariableByte(nc_group_id, vid_node, index, num_vals, (char)0); else if (buffer[30] == 68) writeVariableByte(nc_group_id, vid_node, index, num_vals, (char)1); else writeVariableByte(nc_group_id, vid_node, index, num_vals, (char)-128); // Topography and land fraction if (buffer[38] != -32768) writeVariableFloat(nc_group_id, vid_topo, index, num_vals, (buffer[38]/1000.0)); else writeVariableFloat(nc_group_id, vid_topo, index, num_vals, -32768.0); if (buffer[39] != -32768) writeVariableFloat(nc_group_id, vid_topo_err, index, num_vals, (buffer[39]/1000.0)); else writeVariableFloat(nc_group_id, vid_topo_err, index, num_vals, -32768.0); if (buffer[40] != -32768) writeVariableFloat(nc_group_id, vid_landfrac, index, num_vals, (buffer[40]/1000.0)); else writeVariableFloat(nc_group_id, vid_landfrac, index, num_vals, -32768.0); if (buffer[41] != -32768) writeVariableFloat(nc_group_id, vid_landfrac_err, index, num_vals, (buffer[41]/1000.0)); else writeVariableFloat(nc_group_id, vid_landfrac_err, index, num_vals, -32768.0); // Surface type and zenith angle if (buffer[522] != -32768) writeVariableByte(nc_group_id, vid_terrain, index, num_vals, (char)buffer[522]); else writeVariableByte(nc_group_id, vid_terrain, index, num_vals, (char)-128); if (buffer[33] != -32768) writeVariableFloat(nc_group_id, vid_solzen, index, num_vals, (buffer[33]/128.0)); else writeVariableFloat(nc_group_id, vid_solzen, index, num_vals, -32768.0); // Surface data if (buffer[115] != -32768) writeVariableFloat(nc_group_id, vid_fg_surfpres, index, num_vals, (buffer[115]/10.0)); else writeVariableFloat(nc_group_id, vid_fg_surfpres, index, num_vals, -32768.0); if (buffer[114] != -32768) writeVariableByte(nc_group_id, vid_fg_surfpres_qc, index, num_vals, (char)buffer[114]); else writeVariableByte(nc_group_id, vid_fg_surfpres_qc, index, num_vals, (char)-128); if (buffer[187] != -32768) writeVariableFloat(nc_group_id, vid_skintemp, index, num_vals, (buffer[187]/64.0)); else writeVariableFloat(nc_group_id, vid_skintemp, index, num_vals, -32768.0); writeVariableByte(nc_group_id, vid_skintemp_qc, index, num_vals, (char)-128); if (buffer[188] != -32768) writeVariableFloat(nc_group_id, vid_skintemp_err, index, num_vals, (buffer[188]/64.0)); else writeVariableFloat(nc_group_id, vid_skintemp_err, index, num_vals, -32768.0); if (buffer[184] != -32768) writeVariableFloat(nc_group_id, vid_surftemp, index, num_vals, (buffer[184]/64.0)); else writeVariableFloat(nc_group_id, vid_surftemp, index, num_vals, -32768.0); writeVariableByte(nc_group_id, vid_surftemp_qc, index, num_vals, (char)-128); if (buffer[185] != -32768) writeVariableFloat(nc_group_id, vid_surftemp_err, index, num_vals, (buffer[185]/64.0)); else writeVariableFloat(nc_group_id, vid_surftemp_err, index, num_vals, -32768.0); // Tropopause data if (buffer[769] != -32768) writeVariableFloat(nc_group_id, vid_tropo_press, index, num_vals, (buffer[769]/10.0)); else writeVariableFloat(nc_group_id, vid_tropo_press, index, num_vals, -32768.0); writeVariableByte(nc_group_id, vid_tropo_press_qc, index, num_vals, (char)-128); if (buffer[770] != -32768) writeVariableFloat(nc_group_id, vid_tropo_temp, index, num_vals, (buffer[770]/64.0)); else writeVariableFloat(nc_group_id, vid_tropo_temp, index, num_vals, -32768.0); writeVariableByte(nc_group_id, vid_tropo_temp_qc, index, num_vals, (char)-128); // TPW if (buffer[575] != -32768) writeVariableFloat(nc_group_id, vid_tpw, index, num_vals, (float)(exp(buffer[575]/1024.0))); else writeVariableFloat(nc_group_id, vid_tpw, index, num_vals, -32768.0); writeVariableByte(nc_group_id, vid_tpw_qc, index, num_vals, (char)-128); if (buffer[576] != -32768) writeVariableFloat(nc_group_id, vid_tpw_err, index, num_vals, (float)(exp(buffer[576]/1024.0))); else writeVariableFloat(nc_group_id, vid_tpw_err, index, num_vals, -32768.0); // Surface temperatures writeVariableFloat(nc_group_id, vid_ret1_surf_temp, index, num_vals, -32768.0); writeVariableFloat(nc_group_id, vid_ret1_air_temp, index, num_vals, -32768.0); // QC values writeVariableShort(nc_group_id, vid_last_layer, index, num_vals, buffer[120]); if (buffer[121] != -32768) writeVariableFloat(nc_group_id, vid_max_press_0, index, num_vals, (buffer[121]/10.0)); else writeVariableFloat(nc_group_id, vid_max_press_0, index, num_vals, -32768.0); if (buffer[122] != -32768) writeVariableFloat(nc_group_id, vid_max_press_01, index, num_vals, (buffer[122]/10.0)); else writeVariableFloat(nc_group_id, vid_max_press_01, index, num_vals, -32768.0); writeVariableShort(nc_group_id, vid_high_index_0, index, num_vals, buffer[123]); writeVariableShort(nc_group_id, vid_high_index_01, index, num_vals, buffer[124]); // Pressures index_2D[0] = collocation_num; index_2D[1] = 0; num_vals_2D[0] = 1; num_vals_2D[1] = 100; for (n=0; n<28; n++) { if (buffer[42+n] != -32768) { //level_data[99-n] = buffer[42+n] / 10.0; file_pressures[27-n] = buffer[42+n] / 10.0; } } writeArrayFloat(nc_group_id, vid_press, index_2D, num_vals_2D, pressures); // Temperatures for (n=0; n<28; n++) { if (buffer[128+n] != -32768) data28[27-n] = buffer[128+n] / 64.0; else data28[27-n] = -32768.0; } for (n=0; n<100; n++) level_data[n] = interpolateValue(pressures[n], 28, file_pressures, data28); writeArrayFloat(nc_group_id, vid_temp, index_2D, num_vals_2D, level_data); for (n=0; n<100; n++) level_byte_data[n] = (char)-128; writeArrayByte(nc_group_id, vid_temp_qc, index_2D, num_vals_2D, level_byte_data); for (n=0; n<28; n++) { if (buffer[156+n] != -32768) data28[27-n] = buffer[156+n] / 64.0; else data28[27-n] = -32768.0; } for (n=0; n<100; n++) level_data[n] = interpolateValue(pressures[n], 28, file_pressures, data28); writeArrayFloat(nc_group_id, vid_temp_err, index_2D, num_vals_2D, level_data); // Calculate the midpoint moisture pressures for (n=0; n<15; n++) { if (buffer[70+n] != -32768) moisture_pressures[14-n] = buffer[70+n] / 10.0; else moisture_pressures[14-n] = -32768.0; } for (n=0; n<14; n++) { midpoint_pressures[n] = (moisture_pressures[n+1] - moisture_pressures[n]) / log(moisture_pressures[n+1] / moisture_pressures[n]); } // Water vapor mixing ratios for (n=0; n<14; n++) { if (buffer[547+n] != -32768) data14[13-n] = (float)(exp(buffer[547+n]/1024.0)); else data14[13-n] = -32768.0; } for (n=0; n<100; n++) level_data[n] = interpolateValue(pressures[n], 14, midpoint_pressures, data14); writeArrayFloat(nc_group_id, vid_wvmr, index_2D, num_vals_2D, level_data); // Water vapor QC for (n=0; n<100; n++) level_byte_data[n] = (char)-128; writeArrayByte(nc_group_id, vid_wvmr_qc, index_2D, num_vals_2D, level_byte_data); // Water vapor error for (n=0; n<14; n++) { if (buffer[561+n] != -32768) data14[13-n] = (float)(exp(buffer[561+n]/1024.0)); else data14[13-n] = -32768.0; } for (n=0; n<100; n++) level_data[n] = interpolateValue(pressures[n], 14, midpoint_pressures, data14); writeArrayFloat(nc_group_id, vid_wvmr_err, index_2D, num_vals_2D, level_data); // MW Temperatures for (n=0; n<28; n++) { if (buffer[494+n] != -32768) data28[27-n] = buffer[494+n] / 64.0; else data28[27-n] = -32768.0; } for (n=0; n<100; n++) level_data[n] = interpolateValue(pressures[n], 28, file_pressures, data28); writeArrayFloat(nc_group_id, vid_mw_temp, index_2D, num_vals_2D, level_data); for (n=0; n<100; n++) level_byte_data[n] = (char)-128; writeArrayByte(nc_group_id, vid_mw_temp_qc, index_2D, num_vals_2D, level_byte_data); // MW Water vapor mixing ratios for (n=0; n<100; n++) level_data[n] = -32768.0; writeArrayFloat(nc_group_id, vid_mw_wvmr, index_2D, num_vals_2D, level_data); for (n=0; n<100; n++) level_byte_data[n] = (char)-128; writeArrayByte(nc_group_id, vid_mw_wvmr_qc, index_2D, num_vals_2D, level_byte_data); // After regression temperatures and water vapors for (n=0; n<100; n++) level_data[n] = -32768.0; writeArrayFloat(nc_group_id, vid_reg_temp, index_2D, num_vals_2D, level_data); for (n=0; n<100; n++) level_data[n] = -32768.0; writeArrayFloat(nc_group_id, vid_reg_wvmr, index_2D, num_vals_2D, level_data); // Cloud data index_2D[0] = collocation_num; index_2D[1] = 0; num_vals_2D[0] = 1; num_vals_2D[1] = 2; writeVariableFloat(nc_group_id, vid_tca, index, num_vals, -32768.0); writeVariableByte(nc_group_id, vid_tca_qc, index, num_vals, (char)-128); if (buffer[830] != -32768) writeVariableByte(nc_group_id, vid_numclouds, index, num_vals, (char)buffer[830]); else writeVariableByte(nc_group_id, vid_numclouds, index, num_vals, (char)-128); // Cloud top pressure for (n=0; n<2; n++) { if (buffer[835+n] != -32768) cloud_data[n] = buffer[835+n] / 10.0; else cloud_data[n] = -32768.0; } writeArrayFloat(nc_group_id, vid_ctp, index_2D, num_vals_2D, cloud_data); for (n=0; n<2; n++) cloud_byte_data[n] = (char)-128; writeArrayByte(nc_group_id, vid_ctp_qc, index_2D, num_vals_2D, cloud_byte_data); // Cloud top temperature for (n=0; n<2; n++) { if (buffer[831+n] != -32768) cloud_data[n] = buffer[831+n] / 64.0; else cloud_data[n] = -32768.0; } writeArrayFloat(nc_group_id, vid_ctt, index_2D, num_vals_2D, cloud_data); for (n=0; n<2; n++) cloud_byte_data[n] = (char)-128; writeArrayByte(nc_group_id, vid_ctt_qc, index_2D, num_vals_2D, cloud_byte_data); // Cloud fraction for (n=0; n<2; n++) cloud_data[n] = -32768.0; writeArrayFloat(nc_group_id, vid_ca, index_2D, num_vals_2D, cloud_data); for (n=0; n<2; n++) cloud_byte_data[n] = (char)-128; writeArrayByte(nc_group_id, vid_ca_qc, index_2D, num_vals_2D, cloud_byte_data); // Other variables, if we figure out what they are } // 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