/*
   Name- processNUCAPS01.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 <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <string.h>
#include <math.h>
#include <netcdf.h>

#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 writeVariableFloat(int group_id, int var_id, size_t *index, size_t *num_vals, float value);

void writeVariableShort(int group_id, int var_id, size_t *index, size_t *num_vals, short value);

void writeVariableInteger(int group_id, int var_id, size_t *index, size_t *num_vals, long value);

void writeArrayFloat(int group_id, int var_id, size_t *index, size_t *num_vals, float *value);
void writeVariableByte(int group_id, int var_id, size_t *index, size_t *num_vals, char value);
void writeAttributeShort(int grp, char *attrVariable, short attrValue);
void writeAttributeText(int grp, char *attrVariable, char *attrValue);



void processNUCAPS01(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_values[100];
  float   rspares[262], clouds[8], spectral_values[16];
  float   pressures[100], eff_pressures[100];
  short   ispares[129];
  int     year, month, day, hour, minute, second;
  long    offset, yyyymmdd, hhmmss;
  char    col_dir_name[50], byte_values[100], granule_name[101];

  char    *string[1];

  short   *buffer;

  int     col_scalar_dim;
  int     scalar_dim, dim_levels;
  int     dim_spectralpts, dim_hingepts, dim_cldlayers;
  int     dim_stabparms, dim_ispares, dim_rspares;

  int     dimid_scalar[1], col_dimid_scalar[1];
  int     dimid_levels[2], dimid_spectralpts[2], dimid_hingepts[2], dimid_cldlayers[2];
  int     dimid_stabparms[2], dimid_ispares[2], dimid_rspares[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_node, vid_granule, vid_scanline, vid_fov, vid_qc;
  int     vid_solzen, vid_viewangle, vid_satheight, vid_avgco2;
  int     vid_surfheight, vid_landfrac, vid_surfclass, vid_surfemmis;
  int     vid_surfpress, vid_skintemp, vid_mit_skintemp, vid_fg_skintemp;
  int     vid_numcld, vid_ctp, vid_ctf;
  int     vid_pressure, vid_effpress, vid_temp, vid_mittemp, vid_fgtemp;
  int     vid_wvmr, vid_mitwvmr, vid_fgwvmr;

  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;

  eff_pressures[0]  = 0.0090F;
  eff_pressures[1]  = 0.025F;
  eff_pressures[2]  = 0.055F;
  eff_pressures[3]  = 0.104F;
  eff_pressures[4]  = 0.177F;
  eff_pressures[5]  = 0.28F;
  eff_pressures[6]  = 0.42F;
  eff_pressures[7]  = 0.604F;
  eff_pressures[8]  = 0.837F;
  eff_pressures[9]  = 1.128F;
  eff_pressures[10] = 1.483F;
  eff_pressures[11] = 1.91F;
  eff_pressures[12] = 2.416F;
  eff_pressures[13] = 3.009F;
  eff_pressures[14] = 3.696F;
  eff_pressures[15] = 4.485F;
  eff_pressures[16] = 5.384F;
  eff_pressures[17] = 6.401F;
  eff_pressures[18] = 7.544F;
  eff_pressures[19] = 8.821F;
  eff_pressures[20] = 10.2F;
  eff_pressures[21] = 11.8F;
  eff_pressures[22] = 13.5F;
  eff_pressures[23] = 15.4F;
  eff_pressures[24] = 17.4F;
  eff_pressures[25] = 19.7F;
  eff_pressures[26] = 22.1F;
  eff_pressures[27] = 24.7F;
  eff_pressures[28] = 27.6F;
  eff_pressures[29] = 30.6F;
  eff_pressures[30] = 33.9F;
  eff_pressures[31] = 37.4F;
  eff_pressures[32] = 41.1F;
  eff_pressures[33] = 45.1F;
  eff_pressures[34] = 49.3F;
  eff_pressures[35] = 53.7F;
  eff_pressures[36] = 58.5F;
  eff_pressures[37] = 63.5F;
  eff_pressures[38] = 68.7F;
  eff_pressures[39] = 74.3F;
  eff_pressures[40] = 80.1F;
  eff_pressures[41] = 86.3F;
  eff_pressures[42] = 92.7F;
  eff_pressures[43] = 99.5F;
  eff_pressures[44] = 106.5F;
  eff_pressures[45] = 113.9F;
  eff_pressures[46] = 121.6F;
  eff_pressures[47] = 129.7F;
  eff_pressures[48] = 138.0F;
  eff_pressures[49] = 146.7F;
  eff_pressures[50] = 155.8F;
  eff_pressures[51] = 165.2F;
  eff_pressures[52] = 175.0F;
  eff_pressures[53] = 185.1F;
  eff_pressures[54] = 195.6F;
  eff_pressures[55] = 206.4F;
  eff_pressures[56] = 217.6F;
  eff_pressures[57] = 229.2F;
  eff_pressures[58] = 241.2F;
  eff_pressures[59] = 253.6F;
  eff_pressures[60] = 266.3F;
  eff_pressures[61] = 279.5F;
  eff_pressures[62] = 293.0F;
  eff_pressures[63] = 307.0F;
  eff_pressures[64] = 321.3F;
  eff_pressures[65] = 336.0F;
  eff_pressures[66] = 351.2F;
  eff_pressures[67] = 366.7F;
  eff_pressures[68] = 382.7F;
  eff_pressures[69] = 399.1F;
  eff_pressures[70] = 415.9F;
  eff_pressures[71] = 433.1F;
  eff_pressures[72] = 450.7F;
  eff_pressures[73] = 468.7F;
  eff_pressures[74] = 487.2F;
  eff_pressures[75] = 506.1F;
  eff_pressures[76] = 525.4F;
  eff_pressures[77] = 545.1F;
  eff_pressures[78] = 565.2F;
  eff_pressures[79] = 585.8F;
  eff_pressures[80] = 606.8F;
  eff_pressures[81] = 628.2F;
  eff_pressures[82] = 650.1F;
  eff_pressures[83] = 672.3F;
  eff_pressures[84] = 695.0F;
  eff_pressures[85] = 718.1F;
  eff_pressures[86] = 741.6F;
  eff_pressures[87] = 765.6F;
  eff_pressures[88] = 790.0F;
  eff_pressures[89] = 814.8F;
  eff_pressures[90] = 840.0F;
  eff_pressures[91] = 865.6F;
  eff_pressures[92] = 891.6F;
  eff_pressures[93] = 918.1F;
  eff_pressures[94] = 944.9F;
  eff_pressures[95] = 972.2F;
  eff_pressures[96] = 1000.0F;
  eff_pressures[97] = 1028.0F;
  eff_pressures[98] = 1056.5F;
  eff_pressures[99] = 1085.3F;


  // 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", "NUCAPS 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;

  // levels

  if ((retval = nc_def_dim(nc_group_id, "Levels", 100, &dim_levels)))
    ERR(retval);

  dimid_levels[0] = scalar_dim;
  dimid_levels[1] = dim_levels;

  // spectral points

  if ((retval = nc_def_dim(nc_group_id, "Spectral_Pts", 16, &dim_spectralpts)))
    ERR(retval);

  dimid_spectralpts[0] = scalar_dim;
  dimid_spectralpts[1] = dim_spectralpts;

  // hinge points

  if ((retval = nc_def_dim(nc_group_id, "Hinge_Pts", 100, &dim_hingepts)))
    ERR(retval);

  dimid_hingepts[0] = scalar_dim;
  dimid_hingepts[1] = dim_hingepts;

  // cloud layers

  if ((retval = nc_def_dim(nc_group_id, "Cloud_Layers", 8, &dim_cldlayers)))
    ERR(retval);

  dimid_cldlayers[0] = scalar_dim;
  dimid_cldlayers[1] = dim_cldlayers;

  // stability parameters

  if ((retval = nc_def_dim(nc_group_id, "Stability_Parameters", 16, &dim_stabparms)))
    ERR(retval);

  dimid_stabparms[0] = scalar_dim;
  dimid_stabparms[1] = dim_stabparms;

  // i spares

  if ((retval = nc_def_dim(nc_group_id, "Ispares", 129, &dim_ispares)))
    ERR(retval);

  dimid_ispares[0] = scalar_dim;
  dimid_ispares[1] = dim_ispares;

  // r spares

  if ((retval = nc_def_dim(nc_group_id, "Rspares", 262, &dim_rspares)))
    ERR(retval);

  dimid_rspares[0] = scalar_dim;
  dimid_rspares[1] = dim_rspares;

  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_node = defineVariable(nc_group_id, "orbital_node", NC_BYTE, 1, dimid_scalar,
  			    "values", "0=ascending, 1=descending");

  vid_granule = defineVariable(nc_group_id, "granule_number", NC_SHORT, 1, dimid_scalar,
  			       NULL, NULL);

  vid_scanline = defineVariable(nc_group_id, "scan_line", NC_SHORT, 1, dimid_scalar,
  				NULL, NULL);

  vid_fov = defineVariable(nc_group_id, "field_of_view", NC_SHORT, 1, dimid_scalar,
  			   NULL, NULL);

  vid_qc = defineVariable(nc_group_id, "retrieval_quality_flag", NC_BYTE, 1, dimid_scalar,
  			  "values", "0=accepted, 1=reject_physical, 2=reject_MIT, 4=reject_NOAA_reg, 8=reject_iMIT, 9=rej_phy_and_iMIT, 16=reject_iNOAA, 17=reject_phy_and_iNOAA, 24=reject_iMIT_and_iNOAA, 25=reject_phy_and_iMIT_and_iNOAA");

  vid_solzen = defineVariable(nc_group_id, "solar_zenith_angle", NC_FLOAT, 1, dimid_scalar,
  			      "units", "deg");

  vid_viewangle = defineVariable(nc_group_id, "view_angle", NC_FLOAT, 1, dimid_scalar,
  				 "units", "deg");

  vid_satheight = defineVariable(nc_group_id, "satellite_height", NC_FLOAT, 1, dimid_scalar,
  				 "units", "km");

  vid_avgco2 = defineVariable(nc_group_id, "column_averaged_CO2", NC_FLOAT, 1, dimid_scalar,
  			      "units", "ppm");

  vid_surfheight = defineVariable(nc_group_id, "surface_height", NC_SHORT, 1, dimid_scalar,
  				  "units", "m");

  vid_landfrac = defineVariable(nc_group_id, "land_fraction", NC_FLOAT, 1, dimid_scalar, NULL, NULL);

  vid_surfclass = defineVariable(nc_group_id, "microwave_surface_class", NC_BYTE, 1, dimid_scalar, 
  				 "values", "0=coast, 1=land, 2=sea, 3=ice, 4=ice, 5=snow, 6=glacier, 7=snow");

  vid_surfemmis = defineVariable(nc_group_id, "surface_emmisivity", NC_FLOAT, 1, dimid_scalar,
  				 NULL, NULL);

  vid_surfpress = defineVariable(nc_group_id, "surface_pressure", NC_FLOAT, 1, dimid_scalar,
  				 "units", "hPa");

  vid_skintemp = defineVariable(nc_group_id, "skin_temperature", NC_FLOAT, 1, dimid_scalar,
  				"units", "K");

  vid_mit_skintemp = defineVariable(nc_group_id, "microwave_skin_temperature", NC_FLOAT, 1, dimid_scalar,
  				    "units", "K");

  vid_fg_skintemp = defineVariable(nc_group_id, "first_guess_skin_temperature", NC_FLOAT, 1, dimid_scalar,
  				   "units", "K");

  vid_numcld = defineVariable(nc_group_id, "number_of_cloud_layers_per_fov", NC_SHORT, 1, dimid_scalar,
  			      NULL, NULL);

  vid_ctp = defineVariable(nc_group_id, "cloud_top_pressure", NC_FLOAT, 2, dimid_cldlayers, "unit", "hPa");

  vid_ctf = defineVariable(nc_group_id, "cloud_top_fraction", NC_FLOAT, 2, dimid_cldlayers, NULL, NULL);

  vid_pressure = defineVariable(nc_group_id, "pressure", NC_FLOAT, 2, dimid_levels, "units", "hPa");

  vid_effpress = defineVariable(nc_group_id, "effective_pressure", NC_FLOAT, 2, dimid_levels, "units", "hPa");

  vid_temp = defineVariable(nc_group_id, "temperature", NC_FLOAT, 2, dimid_levels, "units", "K");

  vid_mittemp = defineVariable(nc_group_id, "microwave_temperature", NC_FLOAT, 2, dimid_levels, "units", "K");

  vid_fgtemp = defineVariable(nc_group_id, "first_guess_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/g");

  vid_mitwvmr = defineVariable(nc_group_id, "microwave_water_vapor_mixing_ratio", NC_FLOAT, 2, dimid_levels, 
  			       "units", "g/g");

  vid_fgwvmr = defineVariable(nc_group_id, "first_guess_water_vapor_mixing_ratio", NC_FLOAT, 2, dimid_levels, 
  			      "units", "g/g");


  // 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; recnum<files[date_type].num_collocations; recnum++)
      {
      offset = (long)files[date_type].header_length +
               ((long)recnum * (long)files[date_type].record_length) +
               platform_ptr->offset;
      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] = 91;

        // 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);
          }

        // Save the orbital node

        if (buffer[11] != -32768)
          writeVariableByte(nc_group_id, vid_node, index, num_vals, (char)buffer[11]);
        else
          writeVariableByte(nc_group_id, vid_node, index, num_vals, (char)-128);

        writeVariableShort(nc_group_id, vid_granule, index, num_vals, buffer[12]);
        writeVariableShort(nc_group_id, vid_scanline, index, num_vals, buffer[13]);
        writeVariableShort(nc_group_id, vid_fov, index, num_vals, buffer[14]);

        // Retrieval quality flag

        if (buffer[33] != -32768)
          writeVariableByte(nc_group_id, vid_qc, index, num_vals, (char)buffer[33]);
        else
          writeVariableByte(nc_group_id, vid_qc, index, num_vals, (char)-128);

        if (buffer[22] != -32768)
          writeVariableFloat(nc_group_id, vid_solzen, index, num_vals, (buffer[22]/128.0));
        else
          writeVariableFloat(nc_group_id, vid_solzen, index, num_vals, -32768.0);

        if (buffer[19] != -32768)
          writeVariableFloat(nc_group_id, vid_viewangle, index, num_vals, (buffer[19]/64.0));
        else
          writeVariableFloat(nc_group_id, vid_viewangle, index, num_vals, -32768.0);

        if (buffer[20] != -32768)
          writeVariableFloat(nc_group_id, vid_satheight, index, num_vals, (buffer[20]/10.0));
        else
          writeVariableFloat(nc_group_id, vid_satheight, index, num_vals, -32768.0);

        if (buffer[21] != -32768)
          writeVariableFloat(nc_group_id, vid_avgco2, index, num_vals, (buffer[21]/10.0));
        else
          writeVariableFloat(nc_group_id, vid_avgco2, index, num_vals, -32768.0);

        writeVariableShort(nc_group_id, vid_surfheight, index, num_vals, buffer[23]);

        if (buffer[24] != -32768)
          writeVariableFloat(nc_group_id, vid_landfrac, index, num_vals, (buffer[24]/100.0));
        else
          writeVariableFloat(nc_group_id, vid_landfrac, index, num_vals, -32768.0);

        if (buffer[29] != -32768)
          writeVariableByte(nc_group_id, vid_surfclass, index, num_vals, (char)buffer[29]);
        else
          writeVariableByte(nc_group_id, vid_surfclass, index, num_vals, (char)-128);

        if (buffer[30] != -32768)
          writeVariableFloat(nc_group_id, vid_surfemmis, index, num_vals, (buffer[30]/100.0));
        else
          writeVariableFloat(nc_group_id, vid_surfemmis, index, num_vals, -32768.0);

        if (buffer[25] != -32768)
          writeVariableFloat(nc_group_id, vid_surfpress, index, num_vals, (buffer[25]/10.0));
        else
          writeVariableFloat(nc_group_id, vid_surfpress, index, num_vals, -32768.0);

        if ((buffer[26] != -32768) && (buffer[26] != 6400))
          writeVariableFloat(nc_group_id, vid_skintemp, index, num_vals, (buffer[26]/64.0));
        else
          writeVariableFloat(nc_group_id, vid_skintemp, index, num_vals, -32768.0);

        if (buffer[27] != -32768)
          writeVariableFloat(nc_group_id, vid_mit_skintemp, index, num_vals, (buffer[27]/64.0));
        else
          writeVariableFloat(nc_group_id, vid_mit_skintemp, index, num_vals, -32768.0);

        if (buffer[28] != -32768)
          writeVariableFloat(nc_group_id, vid_fg_skintemp, index, num_vals, (buffer[28]/64.0));
        else
          writeVariableFloat(nc_group_id, vid_fg_skintemp, index, num_vals, -32768.0);


        // Cloud parameters

        writeVariableShort(nc_group_id, vid_numcld, index, num_vals, buffer[274]);

        index_2D[0]    = collocation_num;
        index_2D[1]    = 0;
        num_vals_2D[0] = 1;
        num_vals_2D[1] = 8;

        for (n=0; n<8; n++)
          {
          if (buffer[275+n] == -32768)
          clouds[n] = -32768.0;
          else
          clouds[n] = buffer[275+n] / 10.0;
          }

        writeArrayFloat(nc_group_id, vid_ctp, index_2D, num_vals_2D, clouds);

        for (n=0; n<8; n++)
          {
          if (buffer[283+n] == -32768)
          clouds[n] = -32768.0;
          else
          clouds[n] = buffer[283+n] / 100.0;
          }

        writeArrayFloat(nc_group_id, vid_ctf, index_2D, num_vals_2D, clouds);


        // Pressures

        index_2D[0]    = collocation_num;
        index_2D[1]    = 0;
        num_vals_2D[0] = 1;
        num_vals_2D[1] = 100;

        for (n=0; n<100; n++)
          level_values[n] = pressures[n];

        writeArrayFloat(nc_group_id, vid_pressure, index_2D, num_vals_2D, level_values);


        for (n=0; n<100; n++)
          level_values[n] = eff_pressures[n];

        writeArrayFloat(nc_group_id, vid_effpress, index_2D, num_vals_2D, level_values);

        // Temperatures

        for (n=0; n<100; n++)
          {
          if (buffer[499+n] != -32768)
      level_values[n] = buffer[499+n] / 64.0;
          else
      level_values[n] = -32768.0;
          }

        writeArrayFloat(nc_group_id, vid_temp, index_2D, num_vals_2D, level_values);

        for (n=0; n<100; n++)
          {
          if (buffer[599+n] != -32768)
      level_values[n] = buffer[599+n] / 64.0;
          else
      level_values[n] = -32768.0;
          }

        writeArrayFloat(nc_group_id, vid_mittemp, index_2D, num_vals_2D, level_values);

        for (n=0; n<100; n++)
          {
          if (buffer[699+n] != -32768)
      level_values[n] = buffer[699+n] / 64.0;
          else
      level_values[n] = -32768.0;
          }

        writeArrayFloat(nc_group_id, vid_fgtemp, index_2D, num_vals_2D, level_values);


        // Water vapor mixing ratios

        for (n=0; n<100; n++)
          {
          if (buffer[799+n] == -32768)
          level_values[n] = -32768.0;
          else
          level_values[n] = (float)(exp(buffer[799+n]/1024.0));
          }

        writeArrayFloat(nc_group_id, vid_wvmr, index_2D, num_vals_2D, level_values);

        for (n=0; n<100; n++)
          {
          if (buffer[899+n] == -32768)
          level_values[n] = -32768.0;
          else
          level_values[n] = (float)(exp(buffer[899+n]/1024.0));
          }

        writeArrayFloat(nc_group_id, vid_mitwvmr, index_2D, num_vals_2D, level_values);

        for (n=0; n<100; n++)
          {
          if (buffer[999+n] == -32768)
          level_values[n] = -32768.0;
          else
          level_values[n] = (float)(exp(buffer[999+n]/1024.0));
          }

        writeArrayFloat(nc_group_id, vid_fgwvmr, index_2D, num_vals_2D, level_values);
        }  // 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