/* Name- processATOVS1500.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 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 processATOVS1500(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, temp_level_values[42], wvap_level_values[19]; float channel_data[35], forty_levels[40], layer_data[15], layer20_data[20], mhs_data[5]; float gfs_temps[24], gfs_wvaps[17]; int year, month, day, hour, minute, second; long offset, yyyymmdd, hhmmss; char col_dir_name[50]; char *string[1]; short *buffer; int col_scalar_dim; int scalar_dim, dim_temp_levels, dim_wvap_levels, dim_channels; int dim_40, dim_15, dim_20, dim_hirs, dim_mhs, dim_gfs_temps, dim_gfs_wvaps; int dimid_scalar[1], col_dimid_scalar[1]; int dimid_temp_levels[2], dimid_wvap_levels[2], dimid_channels[2]; int dimid_40[2], dimid_15[2], dimid_20[2], dimid_mhs[2], dimid_gfs_temps[2], dimid_gfs_wvaps[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_begorbit, vid_endorbit, vid_elevation, vid_confidence, vid_gridpt; int vid_precip, vid_surftype, vid_daynight, vid_version, vid_procflag; int vid_bin, vid_solzen, vid_loczen, vid_solazimuth, vid_spot, vid_node; int vid_superad, vid_obqual, vid_retflag, vid_filtertest, vid_chancomb; int vid_temp_press, vid_temp, vid_wvap_press, vid_wvmr, vid_heights; int vid_fgtemp, vid_fgwvmr, vid_nolimbbtemps, vid_adjbtemps; int vid_tropo_press, vid_tropo_temp, vid_tpw, vid_layerpw, vid_layertemp; int vid_layerthick, vid_sst, vid_sml; int vid_skintemp, vid_surftemp, vid_hirs8, vid_surftemp8, vid_surftemp18; int vid_surftemp19, vid_fgbtemps, vid_fcstpress, vid_adjfcstpress; int vid_fcstdate, vid_fcsttime, vid_fcsttemp, vid_fcstrelhum, vid_fcstsurftemp; int vid_timedep, vid_stabdep, vid_lowdep, vid_hidep, vid_timediff, vid_fcstinc; int vid_clw, vid_ctp, vid_ctt, vid_ca, vid_ozone; int vid_tpw1, vid_tpw2, vid_tpw3, vid_polar; int vid_longwave, vid_lcr1, vid_lcr2, vid_lcr3, vid_lcr4; int vid_cldcomp, vid_libsearch, vid_superlevel; int vid_gross, vid_chan1, vid_chan2, vid_chan3; int vid_amsu_flag, vid_mhs_flag, vid_shrunk_btemps; int vid_mhs_limb, vid_mhs_nonlimb, vid_mhs_shrunk, vid_avhrr_btemps; int vid_filter_flag, vid_precip_flag, vid_fg_supersat; int vid_mhs_spot, vid_ozone_flag; int vid_gfs_temp_pressures, vid_gfs_wvap_pressures, vid_gfs_temps, vid_gfs_wvaps; FILE *in; float pressures[42] = { 0.1, 0.2, 0.5, 1.0, 1.5, 2.0, 3.0, 4.0, 5.0, 7.0, 10.0, 15.0, 20.0, 25.0, 30.0, 50.0, 60.0, 70.0, 85.0, 100.0, 115.0, 135.0, 150.0, 200.0, 250.0, 300.0, 350.0, 400.0, 430.0, 475.0, 500.0, 570.0, 620.0, 670.0, 700.0, 780.0, 850.0, 920.0, 950.0, 1000.0, 1012.0, 1030.0 }; float wvap_pressures[19] = { 200.0, 250.0, 300.0, 350.0, 400.0, 430.0, 475.0, 500.0, 570.0, 620.0, 670.0, 700.0, 780.0, 850.0, 920.0, 950.0, 1000.0, 1012.0, 1030.0 }; float gfs_temp_pressures[24] = { 10.0, 20.0, 30.0, 50.0, 70.0, 100.0, 150.0, 200.0, 250.0, 300.0, 350.0, 400.0, 450.0, 500.0, 550.0, 600.0, 650.0, 700.0, 750.0, 800.0, 850.0, 900.0, 950.0, 1000.0 }; float gfs_wvap_pressures[17] = { 200.0, 250.0, 300.0, 350.0, 400.0, 450.0, 500.0, 550.0, 600.0, 650.0, 700.0, 750.0, 800.0, 850.0, 900.0, 950.0, 1000.0 }; num_colls = (size_t)num_collocations; missing_float = -32768.0; // If this is the baseline platform, then create another subgroup // for the collocation information if (platform_index == 0) { sprintf(col_dir_name, "Collocation_Info"); if ((retval = nc_def_grp(nc_date_group, col_dir_name, &collocation_group_id))) { if (retval != -42) ERR(retval); } writeAttributeShort(collocation_group_id, "Baseline_Data_Type", platform_ptr->type); writeAttributeText(collocation_group_id, "Baseline_Platform", platform_ptr->description); writeAttributeShort(collocation_group_id, "Baseline_Platform_ID", platform_ptr->id); } // Create a subgroup for this system platform if ((retval = nc_def_grp(nc_date_group, platform_ptr->dir_name, &nc_group_id))) { //if (retval != -42) ERR(retval); } // Set the platform type attribute to the data group type writeAttributeText(nc_group_id, "Platform_Name", platform_ptr->description); // clean_description? writeAttributeShort(nc_group_id, "Platform_ID", platform_ptr->id); writeAttributeShort(nc_group_id, "Platform_Type", platform_ptr->type); writeAttributeText(nc_group_id, "Platform_Data_Source", "ATOVS (1500 bytes)"); //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, "Temperature_Levels", 42, &dim_temp_levels))) ERR(retval); dimid_temp_levels[0] = scalar_dim; dimid_temp_levels[1] = dim_temp_levels; if ((retval = nc_def_dim(nc_group_id, "Moisture_Levels", 19, &dim_wvap_levels))) ERR(retval); dimid_wvap_levels[0] = scalar_dim; dimid_wvap_levels[1] = dim_wvap_levels; if ((retval = nc_def_dim(nc_group_id, "Channels", 35, &dim_channels))) ERR(retval); dimid_channels[0] = scalar_dim; dimid_channels[1] = dim_channels; if ((retval = nc_def_dim(nc_group_id, "BTemp_Levels", 40, &dim_40))) ERR(retval); dimid_40[0] = scalar_dim; dimid_40[1] = dim_40; if ((retval = nc_def_dim(nc_group_id, "Layers", 15, &dim_15))) ERR(retval); dimid_15[0] = scalar_dim; dimid_15[1] = dim_15; if ((retval = nc_def_dim(nc_group_id, "Thickness_Layers", 20, &dim_20))) ERR(retval); dimid_20[0] = scalar_dim; dimid_20[1] = dim_20; if ((retval = nc_def_dim(nc_group_id, "AVHRR_and_MHS_Channels", 5, &dim_mhs))) ERR(retval); dimid_mhs[0] = scalar_dim; dimid_mhs[1] = dim_mhs; if ((retval = nc_def_dim(nc_group_id, "GFS_Temperature_Levels", 24, &dim_gfs_temps))) ERR(retval); dimid_gfs_temps[0] = scalar_dim; dimid_gfs_temps[1] = dim_gfs_temps; if ((retval = nc_def_dim(nc_group_id, "GFS_Moisture_Levels", 17, &dim_gfs_wvaps))) ERR(retval); dimid_gfs_wvaps[0] = scalar_dim; dimid_gfs_wvaps[1] = dim_gfs_wvaps; 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_begorbit = defineVariable(nc_group_id, "beginning_orbit_number", NC_INT, 1, dimid_scalar, NULL, NULL); vid_endorbit = defineVariable(nc_group_id, "ending_orbit_number", NC_INT, 1, dimid_scalar, NULL, NULL); vid_elevation = defineVariable(nc_group_id, "surface_elevation", NC_INT, 1, dimid_scalar, NULL, NULL); vid_confidence = defineVariable(nc_group_id, "spot_confidence", NC_SHORT, 1, dimid_scalar, NULL, NULL); vid_gridpt = defineVariable(nc_group_id, "grid_point_number", NC_SHORT, 1, dimid_scalar, NULL, NULL); vid_precip = defineVariable(nc_group_id, "precipitation_flag", NC_BYTE, 1, dimid_scalar, "values", "0=no precipitation, 1=precipitation"); vid_surftype = defineVariable(nc_group_id, "surface_type", NC_BYTE, 1, dimid_scalar, "values", "0=sea, 1=land, 2=coast, 10=ice, 11=snow"); vid_daynight = defineVariable(nc_group_id, "day_night_flag", NC_BYTE, 1, dimid_scalar, "values", "0=night, 1=day"); vid_version = defineVariable(nc_group_id, "production_version_number", NC_SHORT, 1, dimid_scalar, NULL, NULL); vid_procflag = defineVariable(nc_group_id, "processing_flag", NC_BYTE, 1, dimid_scalar, "values", "0=unsuccessful, 1=successfully processed"); vid_bin = defineVariable(nc_group_id, "bin_number", NC_BYTE, 1, dimid_scalar, NULL, NULL); vid_solzen = defineVariable(nc_group_id, "solar_zenith_angle", NC_FLOAT, 1, dimid_scalar, "units", "degrees"); vid_loczen = defineVariable(nc_group_id, "local_zenith_angle", NC_FLOAT, 1, dimid_scalar, "units", "degrees"); vid_solazimuth = defineVariable(nc_group_id, "solar_azimuth_angle", NC_FLOAT, 1, dimid_scalar, "units", "degrees"); vid_spot = defineVariable(nc_group_id, "hirs_spot_number", NC_BYTE, 1, dimid_scalar, NULL, NULL); vid_node = defineVariable(nc_group_id, "orbital_node", NC_BYTE, 1, dimid_scalar, "values", "0=ascending, 1=descending"); vid_superad = defineVariable(nc_group_id, "superadiabatic_flag", NC_BYTE, 1, dimid_scalar, "values", "0=not superadiabatic, 1=superad between 700hPa and 1000hPa, 2=superad between 500hPa and 700 hPa, 3=superad between 100hPa and 500 hPa, 4=superad above 100hPa"); vid_obqual = defineVariable(nc_group_id, "observation_quality_flag", NC_BYTE, 1, dimid_scalar, "values", "0=good, 2=failed gross temperature limits for HIRS and AMSU-A or is polar redundant or is superadiabatic"); vid_retflag = defineVariable(nc_group_id, "retrieval_flag", NC_BYTE, 1, dimid_scalar, "values", "0=clear, 16=N*, 32=cloudy, 48=no HIRS"); vid_filtertest = defineVariable(nc_group_id, "filter_test_flag", NC_BYTE, 1, dimid_scalar, "values", "0=good, 1=questionable, 4=bad"); vid_chancomb = defineVariable(nc_group_id, "channel_combination", NC_INT, 1, dimid_scalar, NULL, NULL); vid_temp_press = defineVariable(nc_group_id, "temperature_pressure", NC_FLOAT, 2, dimid_temp_levels, "units", "hPa"); vid_temp = defineVariable(nc_group_id, "temperature", NC_FLOAT, 2, dimid_temp_levels, "units", "K"); vid_wvap_press = defineVariable(nc_group_id, "moisture_pressure", NC_FLOAT, 2, dimid_wvap_levels, "units", "hPa"); vid_wvmr = defineVariable(nc_group_id, "water_vapor_mixing_ratio", NC_FLOAT, 2, dimid_wvap_levels, "units", "g/kg"); vid_fgtemp = defineVariable(nc_group_id, "first_guess_temperature", NC_FLOAT, 2, dimid_temp_levels, "units", "K"); vid_fgwvmr = defineVariable(nc_group_id, "first_guess_water_vapor_mixing_ratio", NC_FLOAT, 2, dimid_wvap_levels, "units", "g/kg"); vid_heights = defineVariable(nc_group_id, "geopotential_heights", NC_FLOAT, 2, dimid_temp_levels, "units", "m"); vid_nolimbbtemps = defineVariable(nc_group_id, "non_limb_corrected_brightness_temperatures", NC_FLOAT, 2, dimid_channels, "units", "K"); vid_adjbtemps = defineVariable(nc_group_id, "limb_corrected_brightness_temperatures", NC_FLOAT, 2, dimid_40, "units", "K"); vid_fgbtemps = defineVariable(nc_group_id, "first_guess_brightness_temperatures", NC_FLOAT, 2, dimid_channels, "units", "K"); vid_tropo_press = defineVariable(nc_group_id, "tropopause_pressure", NC_FLOAT, 1, dimid_scalar, "units", "hPa"); vid_tropo_temp = defineVariable(nc_group_id, "tropopause_temperature", NC_FLOAT, 1, dimid_scalar, "units", "K"); vid_tpw = defineVariable(nc_group_id, "total_precipitable_water", NC_FLOAT, 1, dimid_scalar, "units", "mm"); vid_layerpw = defineVariable(nc_group_id, "layer_precipitable_water", NC_FLOAT, 2, dimid_15, "units", "mm"); vid_layertemp = defineVariable(nc_group_id, "layer_mean_virtual_temperature", NC_FLOAT, 2, dimid_15, "units", "K"); vid_layerthick = defineVariable(nc_group_id, "layer_thickness", NC_FLOAT, 2, dimid_20, "units", "m"); vid_sst = defineVariable(nc_group_id, "sea_surface_temperature", NC_FLOAT, 1, dimid_scalar, "units", "K"); vid_skintemp = defineVariable(nc_group_id, "skin_temperature", NC_FLOAT, 1, dimid_scalar, "units", "K"); vid_sml = defineVariable(nc_group_id, "surface_model_level", NC_BYTE, 1, dimid_scalar, NULL, NULL); vid_surftemp = defineVariable(nc_group_id, "surface_temperature", NC_FLOAT, 1, dimid_scalar, "units", "K"); vid_hirs8 = defineVariable(nc_group_id, "water_vapor_corrected_hirs_channel_8", NC_FLOAT, 1, dimid_scalar, "units", "K"); vid_surftemp8 = defineVariable(nc_group_id, "hirs_8_surface_temperature_estimate", NC_FLOAT, 1, dimid_scalar, "units", "K"); vid_surftemp18 = defineVariable(nc_group_id, "hirs_18_surface_temperature_estimate", NC_FLOAT, 1, dimid_scalar, "units", "K"); vid_surftemp19 = defineVariable(nc_group_id, "hirs_19_surface_temperature_estimate", NC_FLOAT, 1, dimid_scalar, "units", "K"); vid_fcstdate = defineVariable(nc_group_id, "forecast_date", NC_INT, 1, dimid_scalar, NULL, NULL); vid_fcsttime = defineVariable(nc_group_id, "forecast_time", NC_BYTE, 1, dimid_scalar, NULL, NULL); vid_timedep = defineVariable(nc_group_id, "potential_temperature_time_minus_forecast_time", NC_FLOAT, 1, dimid_scalar, NULL, NULL); vid_fcstpress = defineVariable(nc_group_id, "ncep_forecast_pressure", NC_FLOAT, 1, dimid_scalar, "units", "hPa"); vid_adjfcstpress = defineVariable(nc_group_id, "adjusted_ncep_forecast_surface_pressure", NC_FLOAT, 1, dimid_scalar, "units", "hPa"); vid_fcsttemp = defineVariable(nc_group_id, "ncep_forecast_potential_temperature", NC_FLOAT, 1, dimid_scalar, "units", "K"); vid_fcstrelhum = defineVariable(nc_group_id, "ncep_forecast_relative_humidity", NC_FLOAT, 1, dimid_scalar, NULL, NULL); vid_fcstsurftemp = defineVariable(nc_group_id, "ncep_forecast_surface_temperature", NC_FLOAT, 1, dimid_scalar, "units", "K"); vid_stabdep = defineVariable(nc_group_id, "stability_departure", NC_FLOAT, 1, dimid_scalar, NULL, NULL); vid_lowdep = defineVariable(nc_group_id, "lower_departure", NC_FLOAT, 1, dimid_scalar, NULL, NULL); vid_hidep = defineVariable(nc_group_id, "upper_departure", NC_FLOAT, 1, dimid_scalar, NULL, NULL); vid_timediff = defineVariable(nc_group_id, "satellite_minus_forecast_time_difference", NC_BYTE, 1, dimid_scalar, NULL, NULL); vid_fcstinc = defineVariable(nc_group_id, "stability_forecast_increment", NC_BYTE, 1, dimid_scalar, NULL, NULL); vid_clw = defineVariable(nc_group_id, "cloud_liquid_water", NC_SHORT, 1, dimid_scalar, "units", "mm"); vid_ctp = defineVariable(nc_group_id, "cloud_top_pressure", NC_SHORT, 1, dimid_scalar, "values", "1250=clear, -777=missing"); vid_ctt = defineVariable(nc_group_id, "cloud_top_temperature", NC_FLOAT, 1, dimid_scalar, "values", "0=clear, -777=missing"); vid_ca = defineVariable(nc_group_id, "cloud_amount", NC_FLOAT, 1, dimid_scalar, "values", "0=clear, -777=missing"); vid_ozone = defineVariable(nc_group_id, "total_ozone", NC_SHORT, 1, dimid_scalar, "units", "dobson"); vid_tpw1 = defineVariable(nc_group_id, "total_precipitable_water_300hPa_to_500hPa", NC_FLOAT, 1, dimid_scalar, NULL, NULL); vid_tpw2 = defineVariable(nc_group_id, "total_precipitable_water_500hPa_to_700hPa", NC_FLOAT, 1, dimid_scalar, NULL, NULL); vid_tpw3 = defineVariable(nc_group_id, "total_precipitable_water_700hPa_to_1000hPa", NC_FLOAT, 1, dimid_scalar, NULL, NULL); vid_polar = defineVariable(nc_group_id, "polar_redundancy_flag", NC_BYTE, 1, dimid_scalar, "values", "0=not redundant, 1=redundant"); vid_longwave = defineVariable(nc_group_id, "outgoing_longwave_radiation", NC_FLOAT, 1, dimid_scalar, NULL, NULL); vid_lcr1 = defineVariable(nc_group_id, "layer_cooling_rate_240hPa_to_10hPa", NC_FLOAT, 1, dimid_scalar, NULL, NULL); vid_lcr2 = defineVariable(nc_group_id, "layer_cooling_rate_500hPa_to_240hPa", NC_FLOAT, 1, dimid_scalar, NULL, NULL); vid_lcr3 = defineVariable(nc_group_id, "layer_cooling_rate_700hPa_to_500hPa", NC_FLOAT, 1, dimid_scalar, NULL, NULL); vid_lcr4 = defineVariable(nc_group_id, "layer_cooling_rate_1000hPa_to_700hPa", NC_FLOAT, 1, dimid_scalar, NULL, NULL); vid_cldcomp = defineVariable(nc_group_id, "cloud_comparison_flag", NC_BYTE, 1, dimid_scalar, "values", "0=clear+clear cloud (good), 1=clear+cloudy cloud (bad), 2=cloudy+clear cloud (so-so), 4=cloudy+cloudy cloud (good)"); vid_libsearch = defineVariable(nc_group_id, "library_search_closeness", NC_BYTE, 1, dimid_scalar, NULL, NULL); vid_superlevel = defineVariable(nc_group_id, "superadiabatic_level", NC_BYTE, 1, dimid_scalar, NULL, NULL); vid_gross = defineVariable(nc_group_id, "hirs_and_amsu-a_gross_temperature_flag", NC_BYTE, 1, dimid_scalar, "values", "0=all within limits, 1=temperatures out of bounds"); vid_chan1 = defineVariable(nc_group_id, "hirs_1_to_16_channel_flags", NC_INT, 1, dimid_scalar, NULL, NULL); vid_chan2 = defineVariable(nc_group_id, "hirs_17_to_20_amsu-a_1_to_12_flags", NC_INT, 1, dimid_scalar, NULL, NULL); vid_chan3 = defineVariable(nc_group_id, "channel_bit_flags", NC_INT, 1, dimid_scalar, NULL, NULL); vid_amsu_flag = defineVariable(nc_group_id, "amsua_btemp_sigma_flag", NC_BYTE, 1, dimid_scalar, "values", "0=pass, 1=fail"); vid_mhs_flag = defineVariable(nc_group_id, "mhs_btemp_sigma_flag_(ch18_19_20)", NC_BYTE, 1, dimid_scalar, "values", "0=all pass, 1=mixed but 20 passed, 2=mixed but 20 failed, 3=all three failed"); vid_shrunk_btemps = defineVariable(nc_group_id, "shrunk_brightness_temperatures", NC_FLOAT, 2, dimid_channels, "units", "K"); vid_mhs_nonlimb = defineVariable(nc_group_id, "mhs_uncorrected_brightness_temperatures", NC_FLOAT, 2, dimid_mhs, "units", "K"); vid_mhs_limb = defineVariable(nc_group_id, "mhs_limb_corrected_brightness_temperatures", NC_FLOAT, 2, dimid_mhs, "units", "K"); vid_mhs_shrunk = defineVariable(nc_group_id, "mhs_shrunk_brightness_temperatures", NC_FLOAT, 2, dimid_mhs, "units", "K"); vid_avhrr_btemps = defineVariable(nc_group_id, "average_avhrr_brightness_temperatures", NC_FLOAT, 2, dimid_mhs, "units", "K"); vid_filter_flag = defineVariable(nc_group_id, "median_filter_flag", NC_BYTE, 1, dimid_scalar, "values", "0=no precipitation, 1=not tested, 4=precip over sea, 5=precip over nonsea"); vid_precip_flag = defineVariable(nc_group_id, "precipitation_test_flag", NC_BYTE, 1, dimid_scalar, "values", "0=no precipitation, 1=median filter flag or precip filter flag (not both) shows precip, 2=both median filter flag and precip filter flag show precip"); vid_fg_supersat = defineVariable(nc_group_id, "first_guess_supersaturated_flag", NC_BYTE, 1, dimid_scalar, "values", "0=not supersaturated, 1=supersaturated over terrain 1000 meters or lower, 2=supersaturared over terrain higher than 1000 meters"); vid_mhs_spot = defineVariable(nc_group_id, "collocated_mhs_spot_number", NC_BYTE, 1, dimid_scalar, NULL, NULL); vid_ozone_flag = defineVariable(nc_group_id, "ozone_quality_flag", NC_BYTE, 1, dimid_scalar, "values", "1=ozone>350hpa"); vid_gfs_temp_pressures = defineVariable(nc_group_id, "gfs_temperature_pressure", NC_FLOAT, 2, dimid_temp_levels, "units", "hPa"); vid_gfs_temps = defineVariable(nc_group_id, "gfs_temperature", NC_FLOAT, 2, dimid_temp_levels, "units", "K"); vid_gfs_wvap_pressures = defineVariable(nc_group_id, "gfs_moisture_pressure", NC_FLOAT, 2, dimid_wvap_levels, "units", "hPa"); vid_gfs_wvaps = defineVariable(nc_group_id, "gfs_water_vapor_mixing_ratio", NC_FLOAT, 2, dimid_wvap_levels, "units", "g/kg"); // Allocate the memory used by the data buffer buffer = (short *)malloc(platform_ptr->length); collocation_num = -1; // Loop through each record in all of the files and read the data for // this data group into the buffer for (date_type=0; date_type<3; date_type++) { if (date_type == 0) { if ((in=fopen("prev_day.file", "r")) == NULL) { printf("\n\nThe previous day file could not be opened for input.\n"); printf("It will be skipped.\n\n"); in = NULL; } } else if (date_type == 1) { if ((in=fopen("in.file", "r")) == NULL) { printf("\n\nThe input file could not be opened for input.\n"); printf("It will be skipped.\n\n"); in = NULL; } } else { if ((in=fopen("next_day.file", "r")) == NULL) { printf("\n\nThe next day file could not be opened for input.\n"); printf("It will be skipped.\n\n"); in = NULL; } } for (recnum=0; recnumoffset; fseek(in, offset, SEEK_SET); fread(buffer, platform_ptr->length, 1, in); // Process this record if it matches the date to process if (files[date_type].use_record[recnum] == TRUE) { collocation_num++; // Index and num_vals are used to save a single value within the // variable array index[0] = collocation_num; num_vals[0] = 1; index_2D[0] = collocation_num; index_2D[1] = 0; num_vals_2D[0] = 1; num_vals_2D[1] = 42; // Latitude and longitude if (buffer[23] != -32768) latitude = buffer[23] / 128.0; else latitude = -32768.0; if (buffer[24] != -32768) longitude = buffer[24] / 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[18] != -32768) && (buffer[25] != -32768) && (buffer[26] != -32768) && (buffer[27] != -32768)) { year = buffer[18]; month = buffer[25] % 100; day = buffer[26] / 100; hour = buffer[26] % 100; minute = buffer[27] / 100; second = buffer[27] % 100; yyyymmdd = (year * 10000) + (month * 100) + day; hhmmss = (hour * 10000) + (minute * 100) + second; } else { yyyymmdd = -32768; hhmmss = -32768; } writeVariableInteger(nc_group_id, vid_date, index, num_vals, yyyymmdd); writeVariableInteger(nc_group_id, vid_time, index, num_vals, hhmmss); // If this is the baseline system, save the collocation information if (platform_index == 0) { writeVariableFloat(collocation_group_id, col_vid_lat, index, num_vals, latitude); writeVariableFloat(collocation_group_id, col_vid_lon, index, num_vals, longitude); writeVariableInteger(collocation_group_id, col_vid_date, index, num_vals, yyyymmdd); writeVariableInteger(collocation_group_id, col_vid_time, index, num_vals, hhmmss); } // Start saving the remaining variables writeVariableInteger(nc_group_id, vid_begorbit, index, num_vals, buffer[3]); writeVariableInteger(nc_group_id, vid_endorbit, index, num_vals, buffer[4]); writeVariableInteger(nc_group_id, vid_elevation, index, num_vals, buffer[10]); writeVariableShort(nc_group_id, vid_confidence, index, num_vals, buffer[21]); writeVariableShort(nc_group_id, vid_gridpt, index, num_vals, buffer[22]); if (buffer[28] != -32768) writeVariableByte(nc_group_id, vid_precip, index, num_vals, (char)buffer[28]); else writeVariableByte(nc_group_id, vid_precip, index, num_vals, (char)-128); if (buffer[29] != -32768) writeVariableByte(nc_group_id, vid_surftype, index, num_vals, (char)buffer[29]); else writeVariableByte(nc_group_id, vid_surftype, index, num_vals, (char)-128); if (buffer[30] != -32768) writeVariableByte(nc_group_id, vid_daynight, index, num_vals, (char)buffer[30]); else writeVariableByte(nc_group_id, vid_daynight, index, num_vals, (char)-128); writeVariableShort(nc_group_id, vid_version, index, num_vals, buffer[31]); if (buffer[32] != -32768) writeVariableByte(nc_group_id, vid_procflag, index, num_vals, (char)buffer[32]); else writeVariableByte(nc_group_id, vid_procflag, index, num_vals, (char)-128); if (buffer[35] != -32768) writeVariableByte(nc_group_id, vid_bin, index, num_vals, (char)buffer[35]); else writeVariableByte(nc_group_id, vid_bin, 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); if (buffer[34] != -32768) writeVariableFloat(nc_group_id, vid_loczen, index, num_vals, (buffer[34]/128.0)); else writeVariableFloat(nc_group_id, vid_loczen, index, num_vals, -32768.0); if (buffer[36] != -32768) writeVariableFloat(nc_group_id, vid_solazimuth, index, num_vals, (buffer[36]/128.0)); else writeVariableFloat(nc_group_id, vid_solazimuth, index, num_vals, -32768.0); if (buffer[37] != -32768) writeVariableByte(nc_group_id, vid_spot, index, num_vals, (char)buffer[37]); else writeVariableByte(nc_group_id, vid_spot, index, num_vals, (char)-128); // Orbital node if (buffer[38] == 1) writeVariableByte(nc_group_id, vid_node, index, num_vals, (char)0); else if (buffer[38] == 2) writeVariableByte(nc_group_id, vid_node, index, num_vals, (char)1); else writeVariableByte(nc_group_id, vid_node, index, num_vals, (char)-128); if (buffer[39] != -32768) writeVariableByte(nc_group_id, vid_superad, index, num_vals, (char)buffer[39]); else writeVariableByte(nc_group_id, vid_superad, index, num_vals, (char)-128); if (buffer[40] != -32768) writeVariableByte(nc_group_id, vid_obqual, index, num_vals, (char)buffer[40]); else writeVariableByte(nc_group_id, vid_obqual, index, num_vals, (char)-128); if (buffer[41] != -32768) writeVariableByte(nc_group_id, vid_retflag, index, num_vals, (char)buffer[41]); else writeVariableByte(nc_group_id, vid_retflag, index, num_vals, (char)-128); if (buffer[42] != -32768) writeVariableByte(nc_group_id, vid_filtertest, index, num_vals, (char)buffer[42]); else writeVariableByte(nc_group_id, vid_filtertest, index, num_vals, (char)-128); writeVariableInteger(nc_group_id, vid_chancomb, index, num_vals, buffer[43]); // Pressures and temperatures index_2D[0] = collocation_num; index_2D[1] = 0; num_vals_2D[0] = 1; num_vals_2D[1] = 42; writeArrayFloat(nc_group_id, vid_temp_press, index_2D, num_vals_2D, pressures); for (n=0; n<42; n++) { if (buffer[44+n] == -32768) temp_level_values[n] = -32768.0; else temp_level_values[n] = buffer[44+n] / 64.0; } writeArrayFloat(nc_group_id, vid_temp, index_2D, num_vals_2D, temp_level_values); // Pressures and water vapors index_2D[0] = collocation_num; index_2D[1] = 0; num_vals_2D[0] = 1; num_vals_2D[1] = 19; writeArrayFloat(nc_group_id, vid_wvap_press, index_2D, num_vals_2D, wvap_pressures); for (n=0; n<19; n++) { if (buffer[238+n] != -32768) wvap_level_values[n] = (float)(exp(buffer[238+n]/1024.0)); else wvap_level_values[n] = -32768.0; } writeArrayFloat(nc_group_id, vid_wvmr, index_2D, num_vals_2D, wvap_level_values); // First guess temperature and water vapor index_2D[0] = collocation_num; index_2D[1] = 0; num_vals_2D[0] = 1; num_vals_2D[1] = 42; for (n=0; n<42; n++) { if (buffer[330+n] == -32768) temp_level_values[n] = -32768.0; else temp_level_values[n] = buffer[330+n] / 64.0; } writeArrayFloat(nc_group_id, vid_fgtemp, index_2D, num_vals_2D, temp_level_values); index_2D[0] = collocation_num; index_2D[1] = 0; num_vals_2D[0] = 1; num_vals_2D[1] = 19; for (n=0; n<19; n++) { if (buffer[372+n] != -32768) wvap_level_values[n] = (float)(exp(buffer[372+n]/1024.0)); else wvap_level_values[n] = -32768.0; // The first guess water vapors have bogus vaules of 1.0 in the // bottom two spots so they will be replaced with missing values if (n >= 17) wvap_level_values[n] = -32768.0; } writeArrayFloat(nc_group_id, vid_fgwvmr, index_2D, num_vals_2D, wvap_level_values); // Brightness temperatures index_2D[0] = collocation_num; index_2D[1] = 0; num_vals_2D[0] = 1; num_vals_2D[1] = 35; for (n=0; n<35; n++) { if (buffer[161+n] != -32768) channel_data[n] = buffer[161+n] / 64.0; else channel_data[n] = -32768.0; } writeArrayFloat(nc_group_id, vid_nolimbbtemps, index_2D, num_vals_2D, channel_data); for (n=0; n<35; n++) { if (buffer[391+n] != -32768) channel_data[n] = buffer[391+n] / 64.0; else channel_data[n] = -32768.0; } writeArrayFloat(nc_group_id, vid_fgbtemps, index_2D, num_vals_2D, channel_data); for (n=0; n<35; n++) { if (buffer[500+n] != -32768) channel_data[n] = buffer[500+n] / 64.0; else channel_data[n] = -32768.0; } writeArrayFloat(nc_group_id, vid_shrunk_btemps, index_2D, num_vals_2D, channel_data); // Adjusted brightness temperatures index_2D[0] = collocation_num; index_2D[1] = 0; num_vals_2D[0] = 1; num_vals_2D[1] = 40; for (n=0; n<40; n++) { if (buffer[86+n] != -32768) forty_levels[n] = buffer[86+n] / 64.0; else forty_levels[n] = -32768.0; } writeArrayFloat(nc_group_id, vid_adjbtemps, index_2D, num_vals_2D, forty_levels); // Geopotential heights index_2D[0] = collocation_num; index_2D[1] = 0; num_vals_2D[0] = 1; num_vals_2D[1] = 42; for (n=0; n<42; n++) { if (buffer[196+n] == -32768) temp_level_values[n] = -32768.0; else if (n < 20) temp_level_values[n] = buffer[196+n] / 1.0; else temp_level_values[n] = buffer[196+n] / 10.0; } writeArrayFloat(nc_group_id, vid_heights, index_2D, num_vals_2D, temp_level_values); // Tropopause if (buffer[258] != -32768) writeVariableFloat(nc_group_id, vid_tropo_press, index, num_vals, (buffer[258]/1.0)); else writeVariableFloat(nc_group_id, vid_tropo_press, index, num_vals, -32768.0); if (buffer[257] != -32768) writeVariableFloat(nc_group_id, vid_tropo_temp, index, num_vals, (buffer[257]/64.0)); else writeVariableFloat(nc_group_id, vid_tropo_temp, index, num_vals, -32768.0); if (buffer[259] != -32768) writeVariableFloat(nc_group_id, vid_tpw, index, num_vals, (buffer[259]/128.0)); else writeVariableFloat(nc_group_id, vid_tpw, index, num_vals, -32768.0); // Layer precipitable water and virtual temp index_2D[0] = collocation_num; index_2D[1] = 0; num_vals_2D[0] = 1; num_vals_2D[1] = 15; for (n=0; n<15; n++) { if (buffer[260+n] != -32768) layer_data[n] = buffer[260+n] / 128.0; else layer_data[n] = -32768.0; } writeArrayFloat(nc_group_id, vid_layerpw, index_2D, num_vals_2D, layer_data); for (n=0; n<15; n++) { if (buffer[275+n] != -32768) layer_data[n] = buffer[275+n] / 64.0; else layer_data[n] = -32768.0; } writeArrayFloat(nc_group_id, vid_layertemp, index_2D, num_vals_2D, layer_data); index_2D[0] = collocation_num; index_2D[1] = 0; num_vals_2D[0] = 1; num_vals_2D[1] = 20; for (n=0; n<20; n++) { if (buffer[290+n] != -32768) layer20_data[n] = buffer[290+n] / 128.0; else layer20_data[n] = -32768.0; } writeArrayFloat(nc_group_id, vid_layerthick, index_2D, num_vals_2D, layer20_data); // SST and skin temp if (buffer[322] != -32768) writeVariableFloat(nc_group_id, vid_sst, index, num_vals, (buffer[322]/64.0)); else writeVariableFloat(nc_group_id, vid_sst, index, num_vals, -32768.0); if (buffer[323] != -32768) writeVariableFloat(nc_group_id, vid_skintemp, index, num_vals, (buffer[323]/64.0)); else writeVariableFloat(nc_group_id, vid_skintemp, index, num_vals, -32768.0); if (buffer[324] != -32768) writeVariableByte(nc_group_id, vid_sml, index, num_vals, (char)buffer[324]); else writeVariableByte(nc_group_id, vid_sml, index, num_vals, (char)-128); if (buffer[325] != -32768) writeVariableFloat(nc_group_id, vid_surftemp, index, num_vals, (buffer[325]/64.0)); else writeVariableFloat(nc_group_id, vid_surftemp, index, num_vals, -32768.0); if (buffer[326] != -32768) writeVariableFloat(nc_group_id, vid_hirs8, index, num_vals, (buffer[326]/64.0)); else writeVariableFloat(nc_group_id, vid_hirs8, index, num_vals, -32768.0); if (buffer[327] != -32768) writeVariableFloat(nc_group_id, vid_surftemp8, index, num_vals, (buffer[327]/64.0)); else writeVariableFloat(nc_group_id, vid_surftemp8, index, num_vals, -32768.0); if (buffer[328] != -32768) writeVariableFloat(nc_group_id, vid_surftemp18, index, num_vals, (buffer[328]/64.0)); else writeVariableFloat(nc_group_id, vid_surftemp18, index, num_vals, -32768.0); if (buffer[329] != -32768) writeVariableFloat(nc_group_id, vid_surftemp19, index, num_vals, (buffer[329]/64.0)); else writeVariableFloat(nc_group_id, vid_surftemp19, index, num_vals, -32768.0); // Forecast variables yyyymmdd = -32768; hour = -32768; if ((buffer[19] != -32768) && (buffer[20] != -32768)) { year = 2000 + (buffer[19] / 100); month = buffer[19] % 100; day = buffer[20] / 100; hour = buffer[20] % 100; yyyymmdd = (year * 10000) + (month * 100) + day; } writeVariableInteger(nc_group_id, vid_fcstdate, index, num_vals, yyyymmdd); writeVariableByte(nc_group_id, vid_fcsttime, index, num_vals, hour); if (buffer[431] != -32768) writeVariableFloat(nc_group_id, vid_timedep, index, num_vals, (buffer[431]/100.0)); else writeVariableFloat(nc_group_id, vid_timedep, index, num_vals, -32768.0); if (buffer[430] != -32768) writeVariableFloat(nc_group_id, vid_fcstpress, index, num_vals, (buffer[430]/10.0)); else writeVariableFloat(nc_group_id, vid_fcstpress, index, num_vals, -32768.0); if (buffer[429] != -32768) writeVariableFloat(nc_group_id, vid_adjfcstpress, index, num_vals, (buffer[429]/10.0)); else writeVariableFloat(nc_group_id, vid_adjfcstpress, index, num_vals, -32768.0); if (buffer[426] != -32768) writeVariableFloat(nc_group_id, vid_fcsttemp, index, num_vals, (buffer[426]/64.0)); else writeVariableFloat(nc_group_id, vid_fcsttemp, index, num_vals, -32768.0); if (buffer[427] != -32768) writeVariableFloat(nc_group_id, vid_fcstrelhum, index, num_vals, (buffer[427]/256.0)); else writeVariableFloat(nc_group_id, vid_fcstrelhum, index, num_vals, -32768.0); if (buffer[428] != -32768) writeVariableFloat(nc_group_id, vid_fcstsurftemp, index, num_vals, (buffer[428]/64.0)); else writeVariableFloat(nc_group_id, vid_fcstsurftemp, index, num_vals, -32768.0); // Stability departure if (buffer[432] != -32768) writeVariableFloat(nc_group_id, vid_stabdep, index, num_vals, (buffer[432]/512.0)); else writeVariableFloat(nc_group_id, vid_stabdep, index, num_vals, -32768.0); if (buffer[433] != -32768) writeVariableFloat(nc_group_id, vid_lowdep, index, num_vals, (buffer[433]/512.0)); else writeVariableFloat(nc_group_id, vid_lowdep, index, num_vals, -32768.0); if (buffer[434] != -32768) writeVariableFloat(nc_group_id, vid_hidep, index, num_vals, (buffer[434]/512.0)); else writeVariableFloat(nc_group_id, vid_hidep, index, num_vals, -32768.0); if (buffer[435] != -32768) writeVariableByte(nc_group_id, vid_timediff, index, num_vals, (char)buffer[435]); else writeVariableByte(nc_group_id, vid_timediff, index, num_vals, (char)-128); if (buffer[436] != -32768) writeVariableByte(nc_group_id, vid_fcstinc, index, num_vals, (char)buffer[436]); else writeVariableByte(nc_group_id, vid_fcstinc, index, num_vals, (char)-128); // Cloud data writeVariableShort(nc_group_id, vid_clw, index, num_vals, buffer[437]); writeVariableShort(nc_group_id, vid_ctp, index, num_vals, buffer[439]); if (buffer[438] != -32768) writeVariableFloat(nc_group_id, vid_ctt, index, num_vals, (buffer[438]/64.0)); else writeVariableFloat(nc_group_id, vid_ctt, index, num_vals, -32768.0); if (buffer[440] != -32768) writeVariableFloat(nc_group_id, vid_ca, index, num_vals, (buffer[440]/100.0)); else writeVariableFloat(nc_group_id, vid_ca, index, num_vals, -32768.0); writeVariableShort(nc_group_id, vid_ozone, index, num_vals, buffer[441]); // TPW if (buffer[442] != -32768) writeVariableFloat(nc_group_id, vid_tpw1, index, num_vals, (buffer[442]/128.0)); else writeVariableFloat(nc_group_id, vid_tpw1, index, num_vals, -32768.0); if (buffer[443] != -32768) writeVariableFloat(nc_group_id, vid_tpw2, index, num_vals, (buffer[443]/128.0)); else writeVariableFloat(nc_group_id, vid_tpw2, index, num_vals, -32768.0); if (buffer[444] != -32768) writeVariableFloat(nc_group_id, vid_tpw3, index, num_vals, (buffer[444]/128.0)); else writeVariableFloat(nc_group_id, vid_tpw3, index, num_vals, -32768.0); // Polar redundancy if (buffer[446] == -32768) writeVariableByte(nc_group_id, vid_polar, index, num_vals, (char)-128); else if (buffer[446] == -1) writeVariableByte(nc_group_id, vid_polar, index, num_vals, (char)0); else writeVariableByte(nc_group_id, vid_polar, index, num_vals, (char)buffer[446]); if (buffer[447] != -32768) writeVariableFloat(nc_group_id, vid_longwave, index, num_vals, (buffer[447]/10.0)); else writeVariableFloat(nc_group_id, vid_longwave, index, num_vals, -32768.0); if (buffer[448] != -32768) writeVariableFloat(nc_group_id, vid_lcr1, index, num_vals, (buffer[448]/1000.0)); else writeVariableFloat(nc_group_id, vid_lcr1, index, num_vals, -32768.0); if (buffer[449] != -32768) writeVariableFloat(nc_group_id, vid_lcr2, index, num_vals, (buffer[449]/1000.0)); else writeVariableFloat(nc_group_id, vid_lcr2, index, num_vals, -32768.0); if (buffer[450] != -32768) writeVariableFloat(nc_group_id, vid_lcr3, index, num_vals, (buffer[450]/1000.0)); else writeVariableFloat(nc_group_id, vid_lcr3, index, num_vals, -32768.0); if (buffer[451] != -32768) writeVariableFloat(nc_group_id, vid_lcr4, index, num_vals, (buffer[451]/1000.0)); else writeVariableFloat(nc_group_id, vid_lcr4, index, num_vals, -32768.0); // Cloud comparison flag if (buffer[452] != -32768) writeVariableByte(nc_group_id, vid_cldcomp, index, num_vals, (char)buffer[452]); else writeVariableByte(nc_group_id, vid_cldcomp, index, num_vals, (char)-128); if (buffer[453] != -32768) writeVariableByte(nc_group_id, vid_libsearch, index, num_vals, (char)buffer[453]); else writeVariableByte(nc_group_id, vid_libsearch, index, num_vals, (char)-128); if (buffer[454] != -32768) writeVariableByte(nc_group_id, vid_superlevel, index, num_vals, (char)buffer[454]); else writeVariableByte(nc_group_id, vid_superlevel, index, num_vals, (char)-128); if (buffer[455] != -32768) writeVariableByte(nc_group_id, vid_gross, index, num_vals, (char)buffer[455]); else writeVariableByte(nc_group_id, vid_gross, index, num_vals, (char)-128); writeVariableInteger(nc_group_id, vid_chan1, index, num_vals, buffer[456]); writeVariableInteger(nc_group_id, vid_chan2, index, num_vals, buffer[457]); writeVariableInteger(nc_group_id, vid_chan3, index, num_vals, buffer[458]); // Being the copy of parameters that are unique to the 1500 byte ATOVS record if (buffer[5] != -32768) writeVariableByte(nc_group_id, vid_amsu_flag, index, num_vals, (char)buffer[5]); else writeVariableByte(nc_group_id, vid_amsu_flag, index, num_vals, (char)-128); if (buffer[6] != -32768) writeVariableByte(nc_group_id, vid_mhs_flag, index, num_vals, (char)buffer[6]); else writeVariableByte(nc_group_id, vid_mhs_flag, index, num_vals, (char)-128); // MHS Brightness temperatures 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[465+n] != -32768) mhs_data[n] = buffer[465+n] / 64.0; else mhs_data[n] = -32768.0; } writeArrayFloat(nc_group_id, vid_mhs_nonlimb, index_2D, num_vals_2D, mhs_data); for (n=0; n<5; n++) { if (buffer[460+n] != -32768) mhs_data[n] = buffer[460+n] / 64.0; else mhs_data[n] = -32768.0; } writeArrayFloat(nc_group_id, vid_mhs_limb, index_2D, num_vals_2D, mhs_data); for (n=0; n<5; n++) { if (buffer[535+n] != -32768) mhs_data[n] = buffer[535+n] / 64.0; else mhs_data[n] = -32768.0; } writeArrayFloat(nc_group_id, vid_mhs_shrunk, index_2D, num_vals_2D, mhs_data); // AVHRR btemps for (n=0; n<5; n++) { if (buffer[121+n] != -32768) mhs_data[n] = buffer[121+n] / 64.0; else mhs_data[n] = -32768.0; } writeArrayFloat(nc_group_id, vid_avhrr_btemps, index_2D, num_vals_2D, mhs_data); // Median filter, precip and guess supersat flags if (buffer[313] != -32768) writeVariableByte(nc_group_id, vid_filter_flag, index, num_vals, (char)buffer[313]); else writeVariableByte(nc_group_id, vid_filter_flag, index, num_vals, (char)-128); if (buffer[314] != -32768) writeVariableByte(nc_group_id, vid_precip_flag, index, num_vals, (char)buffer[314]); else writeVariableByte(nc_group_id, vid_precip_flag, index, num_vals, (char)-128); if (buffer[315] != -32768) writeVariableByte(nc_group_id, vid_fg_supersat, index, num_vals, (char)buffer[315]); else writeVariableByte(nc_group_id, vid_fg_supersat, index, num_vals, (char)-128); // MHS spot number and ozone flag if (buffer[459] != -32768) writeVariableByte(nc_group_id, vid_mhs_spot, index, num_vals, (char)buffer[459]); else writeVariableByte(nc_group_id, vid_mhs_spot, index, num_vals, (char)-128); if (buffer[470] != -32768) writeVariableByte(nc_group_id, vid_ozone_flag, index, num_vals, (char)buffer[470]); else writeVariableByte(nc_group_id, vid_ozone_flag, index, num_vals, (char)-128); // GFS pressures and temperatures index_2D[0] = collocation_num; index_2D[1] = 0; num_vals_2D[0] = 1; num_vals_2D[1] = 24; writeArrayFloat(nc_group_id, vid_gfs_temp_pressures, index_2D, num_vals_2D, gfs_temp_pressures); for (n=0; n<24; n++) { if (buffer[126+n] == -32768) gfs_temps[n] = -32768.0; else gfs_temps[n] = buffer[126+n] / 64.0; } writeArrayFloat(nc_group_id, vid_gfs_temps, index_2D, num_vals_2D, gfs_temps); // GFS pressures and water vapors index_2D[0] = collocation_num; index_2D[1] = 0; num_vals_2D[0] = 1; num_vals_2D[1] = 17; writeArrayFloat(nc_group_id, vid_gfs_wvap_pressures, index_2D, num_vals_2D, gfs_wvap_pressures); for (n=0; n<17; n++) { if (buffer[471+n] != -32768) gfs_wvaps[n] = (float)(exp(buffer[471+n]/1024.0)); else gfs_wvaps[n] = -32768.0; } writeArrayFloat(nc_group_id, vid_gfs_wvaps, index_2D, num_vals_2D, gfs_wvaps); } // 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