ingest_datachunk.c

Go to the documentation of this file.

/*******************************************************************************
*
*  COPYRIGHT (C) 2006 Battelle Memorial Institute.  All Rights Reserved.
*
********************************************************************************
*
*  Author:
*     name:  Brian Ermold
*     phone: (509) 375-2277
*     email: brian.ermold@pnl.gov
*
********************************************************************************
*
*  RCS INFORMATION:
*    $RCSfile: ingest_datachunk.c,v $
*    $Revision: 1.38 $
*    $Locker: ermold $
*    $Date: 2006/09/05 19:05:23 $
*    $State: ds-dsutil-ingest_lib-1.4-0 $
*
*******************************************************************************/


#include <ctype.h>
#include <errno.h>
#include <string.h>
#include <unistd.h>
#include <utime.h>
#include <sys/stat.h>

#include "dslibc/version.h"
#include "ingest_lib/ingest_datachunk.h"
#include "ingest_lib/ingest_util.h"
#include "ingest_lib/ingest_stats.h"
#include "ingest_lib/sds_util.h"
#include "ingest_lib/sds_status.h"
#include "ingest_lib/sds_log.h"
#include "ingest_lib/sds_tdb.h"
#include "ingest_lib/version.h"

/*******************************************************************************
*  Private Variables:
*/

static DataChunk *prev_dc = NULL; /* Used to store the previous datachunk */

static struct {
    char dsc_name[32];
    char dsc_level[8];
    char base_name[32];
} gOutDirMap[16];

static int gOutDirMapCount = 0;

/* End Private Variables */

/*******************************************************************************
*
* Description:
*   The append_global function will append to a Global Attribute in the datachuck
*   that is passed.
*
* Inputs:
*   dc:       DataChunk with Global Attribute to append to.
*
*   attname:  Name of the Global Attribute.
*
*   attvalue: Value to be appended to Global Attribute.
*
* Outputs:
*   dc:       DataChunk with changed Global Attribute.
*
* Returns:
*   1 on success,
*   or 0 on failure or no change.
*
*******************************************************************************/
int append_global(DataChunk *dc, char *attname, char *attvalue)
{
    char newvalue[MAXSTRLEN];
    char *oldvalue;

    if ((oldvalue = dc_GetGlobalAttr(dc, attname)) == NULL) {
        strcpy(newvalue, attvalue);
    }
    else {
        sprintf(newvalue, "%s%s", oldvalue, attvalue);
    }
    return(change_global(dc, attname, newvalue));
}

/*******************************************************************************
*
* Description:
*   The get_dc_platform_ds_class function will extract the datastream name and
*   level from the data chunk platform name.
*
* Inputs:
*   dc:        The DataChunk containing the platform name to parse.
*
*   dsc_name:  A pointer to the datastream class name to set.
*
*   dsc_level: A pointer to the datastream class level to set.
*
* Outputs:
*   dsc_name:  The datastream name extracted from the data chunk platform name.
*
*   dsc_level: The datastream level extracted from the data chunk platform name.
*
* Returns:
*   None.
*
*******************************************************************************/
int get_dc_platform_ds_class(
    DataChunk *dc,
    char      *dsc_name,
    char      *dsc_level)
{
    const char *site;
    const char *facility;
    char        dc_platform[MAXPLATNAME];
    char       *chrp;

    site     = get_process_site();
    facility = get_process_facility();

    /* Get the data chunk platform name */

    sprintf(dc_platform, "%s", ds_PlatformName(dc->dc_Platform));

    /* Extract the datastream level */

    chrp = (char *)strrchr(dc_platform, '.');
    strcpy(dsc_level, ++chrp);

    /* Extract the datastream name */

    chrp = strstr(dc_platform, facility);

    if (chrp == NULL) {
        append_log_msg(__FILE__, __LINE__,
            "Could not find facility (%s) in platform name: %s\n",
            facility, dc_platform);
        current_status(STATUS_BADPLATNAME);
        return(FAILURE);
    }

    *chrp = '\0';

    sprintf(dsc_name, dc_platform + strlen(site));

    return(SUCCESS);
}

int get_tdb_plat_names(
    DataChunk *dc,
    char      *tdb_plat_base,
    char      *tdb_plat_name,
    char      *tdb_alias_base,
    char      *tdb_alias_name)
{
    int   status;
    char  dsc_name[MAXPLATNAME];
    char  dsc_level[MAXPLATNAME];
    int   tdb_inst_num;
    char *alias;

    status = get_dc_platform_ds_class(dc, dsc_name, dsc_level);
    if (status == FAILURE) {
        return(FAILURE);
    }

    tdb_inst_num = get_tdb_inst_num();

    if (tdb_plat_base) {
        strcpy(tdb_plat_base, dsc_name);
    }

    if (tdb_plat_name) {
        sprintf(tdb_plat_name, "%s%d", dsc_name, tdb_inst_num);
    }

    if (tdb_alias_base || tdb_alias_name) {
        if ((alias = get_tdb_alias(tdb_plat_base)) != NULL) {

            if (tdb_alias_base) {
                strcpy(tdb_alias_base, alias);
            }

            if (tdb_alias_name) {
                sprintf(tdb_alias_name, "%s%d", alias, tdb_inst_num);
            }
        }
        else {
            if (tdb_alias_base) {
                strcpy(tdb_alias_base, tdb_plat_base);
            }

            if (tdb_alias_name) {
                strcpy(tdb_alias_name, tdb_plat_name);
            }
        }
    }

    return(SUCCESS);
}

/*******************************************************************************
*
* Description:
*   The change_flattr function will change a Field Level ATTRibute in the
*   datachuck that is passed.
*
* Inputs:
*   dc:           DataChunk with Field Level Attribute to change.
*
*   field_name:   Name of the field which contains FLATTR.
*
*   flattr_name:  Name of FLATTR to change.
*
*   flattr_value: New value of FLATTR.
*
* Outputs:
*   dc:           DataChunk with new Field Level Attribute.
*
* Returns:
*   1 on success,
*   or 0 on failure or no change.
*
*******************************************************************************/
int change_flattr (DataChunk *dc, char *field_name, char *flattr_name, char *flattr_value)
{
    char     message[MAXSTRLEN];
    FieldId  fid;
    char    *lastvalue;

  /*  If fid is less then 0, it has not been defined.
   */
    if ((fid = F_Declared(field_name)) < 0) {
        append_log_msg(__FILE__, __LINE__,
            "Field %s is not in the TDB Platform Dictionary!", field_name);
    }
    else {

      /*  Set the New Field Level Attribute
       */
        dc_SetFieldAttr(dc, fid, flattr_name, flattr_value);

      /*  Return 1 if changed (or created), 0 no change.
       */
        lastvalue = get_previous_flattr(dc, fid, flattr_name);

        if (strcmp(lastvalue, flattr_value) != 0) {
            append_log_msg(__FILE__, __LINE__,
                "Field attribute changed: %s:%s\n\tfrom:%s\n\tto:  %s\n",
                field_name, flattr_name, lastvalue, flattr_value);
            return (1);
        }
        else {
            print_debug(__FILE__, __LINE__,
                "flatter %s for field %s has not changed\n",
                flattr_name, field_name);
        }
    }

    return (0);
}

/*******************************************************************************
*
* Description:
*   The change_global function will change a Global Attribute in the datachuck
*   that is passed.
*
* Inputs:
*   dc:           DataChunk with Global Attribute to change.
*
*   glattr_name:  Name of the Global Attribute.
*
*   glattr_value: New value of Global Attribute.
*
* Outputs:
*   dc:           DataChunk with changed Global Attribute.
*
* Returns:
*   1 on success,
*   or 0 on failure or no change.
*
*******************************************************************************/
int change_global(DataChunk *dc, char *glattr_name, char *glattr_value)
{
    char message[MAXSTRLEN];
    char *lastvalue;

  /*  If the value is 0, global_name has not been defined.
   */
    if (!dc_GetGlobalAttr(dc, glattr_name)) {
        print_debug(__FILE__, __LINE__,
            "Metadata for %s was not previously defined.\n", glattr_name);
    }

  /*  Set the New Global Attribute
   */
    dc_SetGlobalAttr(dc, glattr_name, glattr_value);

  /*  Return 1 if changed (or created), 0 no change.
   */
    lastvalue = get_previous_glattr(dc, glattr_name);

    if (strcmp(lastvalue, glattr_value) != 0) {
        append_log_msg(__FILE__, __LINE__,
            "Global attribute changed: %s\n\tfrom:%s\n\tto:  %s\n",
            glattr_name, lastvalue, glattr_value);
        return (1);
    }
    else {
        print_debug(__FILE__, __LINE__,
            "glattr %s has not changed\n", glattr_name);
    }

    return (0);
}

/*******************************************************************************
*
* Description:
*   The check_for_std_metadata_changes function checks for changes in standard
*   metadata (global attributes) from one dc to the next. It checks that all
*   metadata from the current datachunk matches the metadata in the previous
*   datachunk.  If there has been a change in the metadata then newfile gets set
*   to TRUE so that a new output file will be created when the current dc is
*   stored by Zebra.
*
* Inputs:
*   dc: The current datachunk.
*
* Outputs:
*   newfile:  Indicates whether a new output file should be created
*             when the current dc is stored by Zeb.
*
* Returns:
*   1 if there was a change,
*   or 0 if no change.
*
*******************************************************************************/
int check_for_std_metadata_changes(DataChunk *dc, int *new_file)
{
    char       message[MAXSTRLEN];
    char      *newvalue;
    char      *oldvalue;
    int        index;
    int        status;
    static char *std_glattrs[] = {

        "ingest_software",
        "proc_level"     ,
        "site_id"        ,
        "facility_id"    ,
        "sample_int"     ,
        "averaging_int"  ,
        "serial_number"  ,
        "comment"        ,
        "resolution_description",
        (char *)NULL
    };

    status = 0;

    prev_dc = get_previous_dc(dc);

    if (prev_dc != (DataChunk *)NULL) {

        for(index = 0; std_glattrs[index] != NULL; index ++) {
            newvalue = dc_GetGlobalAttr(dc, std_glattrs[index]);
            oldvalue = dc_GetGlobalAttr(prev_dc, std_glattrs[index]);

            if (strcmp(newvalue, oldvalue) != 0) {
                append_log_msg(__FILE__, __LINE__,
                    "Global attribute changed: %s\n\tfrom:%s\n\tto:  %s\n",
                    std_glattrs[index], oldvalue, newvalue);
                status = 1;
                *new_file = 1;
            }
        }
    }
    return(status);
}

/*******************************************************************************
*
* Description:
*   The check_for_plat_metadata_changes function checks for changes in platform
*   specific global attributes from one datachunk to the next. It checks that
*   all metadata from the current datachunk matches the metadata in the previous
*   datachunk. If there has been a change in the metadata then newfile gets set
*   to TRUE so that a new output file will be created when the current dc is
*   stored by Zebra.
*
* Inputs:
*   dc:      The current datachunk.
*
* Outputs:
*   newfile: Indicates whether a new output file should be created
*            when the current dc is stored by Zeb.
*
* Returns:
*   1 if there was a change,
*   or 0 if no change.
*
*******************************************************************************/
int check_for_plat_metadata_changes(DataChunk *dc, int *newfile)
{
    char       message[MAXSTRLEN];
    char       tdb_plat_base[SHORTSTRLEN];
    char       tdb_plat_name[SHORTSTRLEN];
    char       tdb_alias_base[SHORTSTRLEN];
    char       tdb_alias_name[SHORTSTRLEN];
    int        attnum;
    char      *attname;
    char      *newvalue;
    char      *oldvalue;
    int        ndiffs     = 0;

    prev_dc = get_previous_dc(dc);

    if (prev_dc != (DataChunk *)NULL) {

        if (!db_reconnect()) {
            return(0);
        }

        get_tdb_plat_names(
            dc,
            tdb_plat_base,
            tdb_plat_name,
            tdb_alias_base,
            tdb_alias_name);

        for(attnum = 1; attnum < MAX_METADATA; attnum++) {

            attname  = get_glattr_name(
                attnum,
                tdb_plat_name,
                tdb_plat_base,
                tdb_alias_name,
                tdb_alias_base);

            if (attname == NULL) {
                break;
            }

            if (strcmp(attname, "end_global_attributes") == NULL) {
                shared_tdb_free(attname);
                break;
            }

            newvalue = dc_GetGlobalAttr(dc, attname);
            oldvalue = dc_GetGlobalAttr(prev_dc, attname);

            if (oldvalue == (char *) NULL) {
                append_log_msg(__FILE__, __LINE__,
                    "Global attribute added: %s\n", attname);
                ndiffs++;
                *newfile = 1;
            }
            else if (strcmp(newvalue, oldvalue) != 0) {
                append_log_msg(__FILE__, __LINE__,
                    "Global attribute changed: %s\n\tfrom:%s\n\tto:  %s\n",
                    attname, oldvalue, newvalue);
                ndiffs++;
                *newfile = 1;
            }
            shared_tdb_free(attname);
        }

        db_disconnect();
    }

    return(ndiffs);
}

/*******************************************************************************
*
* Description:
*   The check_for_location_changes function checks for changes in location from
*   one datachunk to the next. It checks that all metadata from the current
*   datachunk matches the metadata in the previous datachunk. If there has been
*   a change in the metadata then newfile gets set to TRUE so that a new output
*   file will be created when the current dc is stored by Zebra.
*
* Inputs:
*   dc:      The current datachunk.
*
* Outputs:
*   newfile: Indicates whether a new output file should be created
*            when the current dc is stored by Zeb.
*
* Returns:
*   1 if there was a change,
*   or 0 if no change.
*
*******************************************************************************/
int check_for_location_changes(DataChunk *dc, int *newfile)
{
    char       message[MAXSTRLEN];
    Location   curr_loc;
    Location   prev_loc;

    prev_dc = get_previous_dc(dc);

    if (prev_dc != (DataChunk *)NULL) {

        dc_GetLoc(dc, 0, &curr_loc);
        dc_GetLoc(prev_dc, 0, &prev_loc);

        if ((curr_loc.l_alt != prev_loc.l_alt) ||
            (curr_loc.l_lat != prev_loc.l_lat) ||
            (curr_loc.l_lon != prev_loc.l_lon)) {

            append_log_msg(__FILE__, __LINE__,
                "Location changed: %s\n", ds_PlatformName(dc->dc_Platform));
            *newfile = 1;
            return(1);
        }
    }
    return(0);
}

/*******************************************************************************
*
* Description:
*   The check_for_metadata_changes function checks that all metadata from the
*   current datachunk matches the metadata in the previous datachunk. If there
*   has been a change in the metadata then newfile gets set to TRUE so that a
*   new output file will be created when the current dc is stored by Zeb.
*
* Inputs:
*   dc:      The current datachunk.
*
* Outputs:
*   newfile: Indicates whether a new output file should be created
*            when the current dc is stored by Zeb.
*
* Returns:
*   None.
*
*******************************************************************************/
void check_for_metadata_changes(DataChunk *dc, int *newfile)
{
    check_for_std_metadata_changes(dc, newfile);
    check_for_plat_metadata_changes(dc, newfile);
    check_for_location_changes(dc, newfile);
}

/*******************************************************************************
*
*  Description:
*   The define_dimsizes will define the dimension sizes PERMANENTLY by storing
*   the dim_size array in the TDB. This is needed because some instruments, like
*   the AERI, change dimension sizes often and tell us the sizes in the raw data.
*
*  Inputs:
*   dc:       The data chunk which to change dim sizes for.
*
*   ndims:    The number of dimensions for this dc.
*
*   dimsizes: The size of the dimensions for this dc.
*
* Outputs:
*   None.
*
* Returns:
*   SUCCESS || FAILURE
*
*******************************************************************************/
int define_dimsizes(DataChunk *dc, int ndims, int *dimsizes)
{
    char  tdb_plat_name[SHORTSTRLEN];
    char  datalevel[8];
    int   dimnum;
    char *chrp;
    int   retval;

    get_tdb_plat_names(dc, NULL, tdb_plat_name, NULL, NULL);

    get_dc_platform_datalevel(dc, datalevel);

    /*  First, check the dimension size values */

    for (dimnum = 1; dimnum < ndims + 1; dimnum++) {
        if ((dimsizes[dimnum - 1] < 1) || (dimsizes[dimnum - 1] > MAX_DIMSIZE)) {
            append_log_msg(__FILE__, __LINE__,
                "Dimension size (%d) is out of range for platform %s, dimnum %d.\n",
                dimsizes[dimnum - 1], tdb_plat_name, dimnum);
            return(FAILURE);
        }
    }

    if (!db_reconnect()) {
        return(FAILURE);
    }

    retval = SUCCESS;

    for (dimnum = 1; dimnum < ndims + 1; dimnum++) {
        if (!set_dim_size(tdb_plat_name, datalevel, dimnum, dimsizes[dimnum - 1])) {
            retval = FAILURE;
            break;
        }
    }

    db_disconnect();

    return(retval);
}

/*******************************************************************************
*
* Description:
*   The set_dc_platform function sets the zebra platform name in the data chunk.
*
* Inputs:
*   dc:        The datachunk to store the platform name in.
*
*   platbase:  The base platform name (i.e. vceil25k).
*
*   datalevel: The data level.
*
* Outputs:
*   dc:        The data chunk with the platform name defined.
*
* Returns:
*   SUCCESS || FAILURE
*
*******************************************************************************/
int set_dc_platform(DataChunk *dc, char *platbase, char *datalevel)
{
    const char *site;
    const char *facility;

    char  platform[SHORTSTRLEN];

    site     = get_process_site();
    facility = get_process_facility();

    if (dc) {
        sprintf (platform, "%s%s%s.%s", site, platbase, facility, datalevel);

        print_debug(__FILE__, __LINE__,
            "Looking up zebra platform: %s\n", platform);

        if ((dc->dc_Platform = ds_LookupPlatform(platform)) == BadPlatform) {
            current_status(STATUS_INITDC);
            append_log_msg(__FILE__, __LINE__,
                "ds_LookupPlatform failed for platform %s\n", platform);
            return(FAILURE);
        }
    }
    else {
        current_status(STATUS_INITDC);
        append_log_msg(__FILE__, __LINE__,
            "Datachunk sent to do_lookup is NULL\n");
        return(FAILURE);
    }

    return(SUCCESS);
}

/*******************************************************************************
*
* Description:
*   The freeDC function will free the DataChunk passed.
*
* Inputs:
*   dc: The DataChunk which should be destroyed.
*
* Outputs:
*   None.
*
* Returns:
*   dc: A NULL pointer to a DataChunk.
*
*******************************************************************************/
DataChunk *freeDC(DataChunk *dc)
{
    if (dc) {
        dc_DestroyDC(dc);
    }
    return((DataChunk *)NULL);
}

/*******************************************************************************
*
* Description:
*   The get_dc_platform_datalevel function will get the datalevel from the
*   data chunk platform name.
*
* Inputs:
*   dc:   The DataChunk to get the datalevel from.
*
* Outputs:
*   datalevel: The data level from the platform name.
*
* Returns:
*   1 if the data level was found,
*   or 0 if the datalevel could no be determined
*
*******************************************************************************/
int get_dc_platform_datalevel(DataChunk *dc, char *datalevel)
{
    char *chrp;

  /*  Get the data level from the platform name
   */
    if ((chrp = (char *)strrchr(ds_PlatformName(dc->dc_Platform), '.')) != NULL) {
        sprintf(datalevel, ++chrp);
    }
    else {
        datalevel[0] = '\0';
        return(0);
    }

    return(1);
}

/*******************************************************************************
*
* Description:
*   The get_field_type function will get the DC_ElemType corresponding to the
*   specified field type name. If the field type name is not valid float
*   will be used. Valid field type names are:<blockquote><p>
*
*       float<br>
*       double<br>
*       long double<br>
*       char<br>
*       unsigned char<br>
*       short int<br>
*       unsigned short<br>
*       int<br>
*       unsigned int<br>
*       long int<br>
*       unsigned long<br>
*       string</p></blockquote>
*
* Inputs:
*   field_type: The name of the field type.
*
* Outputs:
*   None.
*
* Returns:
*   The DC_ElemType.
*
*******************************************************************************/
DC_ElemType get_field_type(char *field_type)
{
    int   field_type_num;

    field_type_num = (int)DCT_Unknown;

    while (strcmp(DC_ElemTypeNames[field_type_num++], field_type)) {
        if (field_type_num == (int)DCT_Element) {
            field_type_num = (int)DCT_Unknown;
            print_debug(__FILE__, __LINE__,
                "Field type %s not found, using float instead.\n", field_type);
            break;
        }
    }

    if (field_type_num == (int)DCT_Unknown) {
        while (strcmp(DC_ElemTypeNames[field_type_num++], "float"))
            { /* do nothing */ };
    }
    field_type_num--;

    return((DC_ElemType)field_type_num);
}

/*******************************************************************************
*
* Description:
*   The get_previous_dc function gets a datachunk from a time slice just
*   previous to the current datachunk.
*
* Inputs:
*   dc:   The current datachunk.
*
* Outputs:
*   None.
*
* Returns:
*   The datachunk from the previous time slice.
*
*******************************************************************************/
DataChunk *get_previous_dc(DataChunk *dc)
{
    ZebTime  curtime;
    ZebTime  when;
    ZebTime  start;
    ZebTime  end;
    FieldId  fields[MAX_FIELDS];
    int      nflds = 0;
    int      nfield;

 /*  If the dc requested does not match prev_dc, clean up.
  *  Note that store_datachunk will free the prev_dc because once
  *  a new datachunk is stored prev_dc will no longer be correct.
  */
    if (prev_dc != (DataChunk *)NULL ) {
        if (prev_dc->dc_Platform != dc->dc_Platform) {
            prev_dc = freeDC(prev_dc);
        }
    }

 /*  If prev_dc has not been set up already then do it,
  *  otherwise just return
  */
    if (prev_dc == (DataChunk *)NULL) {

      /*  Fill up the when ZebTime structure with the last datatime
       */
        dc_GetTime(dc, 0, &curtime);

        when.zt_Sec = when.zt_MicroSec = 0;

        ds_DataTimes(dc->dc_Platform, &curtime, 1, DsBefore, &when);

     /*  When dealing with datastreams that use microseconds we can get roundoff
      *  error in the zt_MicroSec value. This is because the time is stored in
      *  the NetCDF file as a double but is then converted to seconds and
      *  microseconds in the ZebTime structure. To get arround this we need to
      *  use a range arround the returned previous sample time. Since this is
      *  roundoff error an offset of 1 should work but lets use 2 to be on the
      *  safe side.
      */
        start = end = when;

        start.zt_MicroSec -= 2;
        end.zt_MicroSec   += 2;

        if (start.zt_MicroSec < 0) {
            start.zt_Sec      -= 1;
            start.zt_MicroSec += 1e6;
        }

        if (end.zt_MicroSec >= 1e6) {
            end.zt_Sec      += 1;
            end.zt_MicroSec -= 1e6;
        }

      /*  This needs to be set for ds_GetFields.
       */
        nfield = MAX_FIELDS;

      /*  Grab the field IDs from the data store
       */
        nflds = ds_GetFields(dc->dc_Platform, &when, &nfield, fields);

        if (nflds) {

          /*  Fetch the data chunk for the last sample
           */
            prev_dc = ds_Fetch(dc->dc_Platform, dc->dc_Class, &start,
                &end, fields, nfield, 0, 0);
        }
        else {
            append_log_msg(__FILE__, __LINE__,
                "Could not get fields from Data Store in get_previous_dc()!\n");
        }
    }
    return(prev_dc);
}

/*******************************************************************************
*
* Description:
*   The get_previous_flattr function will get the value of a field level attribute
*   just prior to the current datachunk.
*
* Inputs:
*   dc:          The current datachunk.
*
*   fid:         The field id of the field to look in.
*
*   flattr_name: The name of the field's attribute.
*
* Outputs:
*   None.
*
* Returns:
*   The previous attribute value.
*
*******************************************************************************/
char *get_previous_flattr(DataChunk *dc, FieldId fid, char *flattr_name)
{
    static char  flattr_value[MAXSTRLEN];
    char        *previous_flattr;

    flattr_value[0] = '\0';

  /*  Fetch the data chunk for the last sample stored.
   */
    prev_dc = get_previous_dc(dc);

    if (prev_dc != (DataChunk *)NULL) {

      /*  Get the Value of the FLATTR
       */
        previous_flattr = dc_GetFieldAttr(prev_dc, fid, flattr_name);
        if (previous_flattr) {
            sprintf(flattr_value, "%s", previous_flattr);
        }
        else {
            flattr_value[0] = '\0';
        }
    }
    return(flattr_value);
}

/*******************************************************************************
*
* Description:
*   The get_previous_glattr function will get the value of a global level attribute just prior
*   to the current datachunk.
*
* Inputs:
*   dc:          The current datachunk.
*
*   glattr_name: The name of the global attribute.
*
* Outputs:
*   None.
*
* Returns:
*   The previous attribute value.
*
*******************************************************************************/
char *get_previous_glattr(DataChunk *dc, char *glattr_name)
{
    static char  glattr_value[MAXSTRLEN];
    char        *previous_glattr;

    glattr_value[0] = '\0';

  /*  Fetch the data chunk for the last sample
   */
    prev_dc = get_previous_dc(dc);

    if (prev_dc != (DataChunk *)NULL) {

      /*  Get the Value of the Global Attribute
       */
        previous_glattr = dc_GetGlobalAttr(prev_dc, glattr_name);
        if (previous_glattr) {
            sprintf(glattr_value, "%s", previous_glattr);
        }
        else {
            glattr_value[0] = '\0';
        }
    }
    return(glattr_value);
}

void set_rename_raw_map_dir(char *dsc_name, char *dsc_level, char *base_name)
{
    strcpy(gOutDirMap[gOutDirMapCount].dsc_name, dsc_name);
    strcpy(gOutDirMap[gOutDirMapCount].dsc_level, dsc_name);
    strcpy(gOutDirMap[gOutDirMapCount].base_name, base_name);

    gOutDirMapCount++;
}

char *get_rename_raw_map_dir(char *dsc_name, char *dsc_level)
{
    int i;

    for (i = 0; i < gOutDirMapCount; i++) {
        if ((strcmp(gOutDirMap[i].dsc_name, dsc_name) == 0) &&
            (strcmp(gOutDirMap[i].dsc_level, dsc_level) == 0) ) {

            return(gOutDirMap[i].base_name);
        }
    }

    return((char *)NULL);
}

/*******************************************************************************
*
* Description:
*   The rename_raw function is used to rename files into the datastream area.
*   The file_move function is used to do the atuall move.  The path to the
*   datastream directory is determined using the <b>get_datastream_home</b>
*   function.
*
* Inputs:
*   filename:   The full path of the file to rename.
*
*   start_time: The time (in seconds since 1970) of the first record in the file.
*
*   end_time:   The time (in seconds since 1970) of the last record in the file.
*
*   dsc_name:   The data stream class name this file belongs to.
*
*   dsc_level:  The data stream class level this file belongs to.
*
*   extension:  The extension to use when renaming the file.
*
*   preserve_dots: This is used to specify how much of the original file name
*                  to preserve when renaming the file.  It specifies the number
*                  of dots from the end of the file name.  For example, if a 2
*                  is specified everything after the second to the last dot in
*                  the original file name will be used in the new file name.
*
* Outputs:
*   None.
*
* Returns:
*   SUCCESS || FAILURE
*
*******************************************************************************/
int rename_raw(
    char      *filename,
    time_t     start_time,
    time_t     end_time,
    char      *dsc_name,
    char      *dsc_level,
    char      *extension,
    int        preserve_dots)
{
    char       *datastream_home;
    const char *site;
    const char *facility;
    struct tm  *start_tm;
    char       *chrp;
    char        out_dir[MAXPATHNAME];
    char        time_string[32];
    char        orig_name[MAXPATHNAME];
    char        dest_file[MAXPATHNAME];
    int         dot_count;
    char       *dir_base_name;

    /*  Verify that the specified data stream class
     *  is a known output for this process.
     */

    if (!validate_ingest_output_dsc(dsc_name, dsc_level)) {
        return(FAILURE);
    }

    site     = get_process_site();
    facility = get_process_facility();

    /*  Determine the time stamp to use for this raw file
     */

    if (start_time > 0) {
        start_tm = gmtime(&start_time);
    }
    else {
        append_log_msg(__FILE__, __LINE__,
            "Bad start time specified for: %s\n", filename);
        current_status(STATUS_NOMOVERAW);
        return(FAILURE);
    }

    strftime(time_string, 32, "%Y%m%d.%H%M%S", start_tm);

    /*  Build the output directory path and create it if it doesn't exist
     */

    datastream_home = get_datastream_home();
    if (!datastream_home) {
        return(FAILURE);
    }

    dir_base_name = get_rename_raw_map_dir(dsc_name, dsc_level);
    if (!dir_base_name) {
        dir_base_name = dsc_name;
    }

    sprintf(out_dir, "%s/%s/%s%s%s.%s",
        datastream_home, site, site, dsc_name, facility, dsc_level);

    if (!check_path(out_dir)) {

        print_debug(__FILE__, __LINE__,
            "Creating datastream directory: %s\n", out_dir);

        if (mkdir(out_dir, 00775) != 0) {
            append_log_msg(__FILE__, __LINE__,
                "Error #%i creating datastream directory: %s\n -> %s\n",
                errno, out_dir, strerror(errno));
            current_status(STATUS_NOMOVERAW);
            return(FAILURE);
        }
    }

    /*  Generate the full path to the destination file
     */

    sprintf(dest_file, "%s/%s%s%s.%s.%s",
        out_dir, site, dsc_name, facility, dsc_level, time_string);

    if (extension) {
        strcat(dest_file, ".");
        strcat(dest_file, extension);
    }

    if (preserve_dots > 0) {

        strcat(dest_file, ".");

        chrp = strrchr(filename, '/');
        strcpy(orig_name, ++chrp);

        chrp = orig_name + strlen(orig_name) - 1;
        for (dot_count = 0;; chrp--) {

            if (*chrp == '.') dot_count++;

            if (dot_count == preserve_dots) {
                strcat(dest_file, ++chrp);
                break;
            }
            else if (chrp == orig_name) {
                strcat(dest_file, orig_name);
                break;
            }
        }
    }

    /*  Rename the file into the datastream directory
     */

    if (!file_move(filename, dest_file)) {
        current_status(STATUS_NOMOVERAW);
        return(FAILURE);
    }

    /*  Record the stats for this file.
     */

    set_file_stats(dest_file);

    if (!end_time) {
        end_time = start_time;
    }

    update_datastream_times(dsc_name, dsc_level, start_time, end_time);

    /*  Now we will update the file time.  This should ensure it's getting
     *  transferred
     */

    if(utime(dest_file, NULL) < 0) {
        append_log_msg(__FILE__, __LINE__,
            "Error #%i updating file time for: %s\n -> %s\n",
            errno, dest_file, strerror(errno));
        current_status(STATUS_NOUTIME);
        return(FAILURE);
    }

    return(SUCCESS);
}

/*******************************************************************************
*
* Description:
*   The move_ingested_raw function is used to move a file that has been ingested
*   into its proper datastream directory.  The rename_raw function is used to do
*   the actuall file renaming.  If a dsc_name is not specified the data chunk
*   platform name will be used to determine it.
*
*   A file will be marked as bad if the data chunk is NULL or has zero samples.
*   When this happens the badtime value must be specified or the move will fail.
*
* Inputs:
*   dc:        The ZEBRA datachunk relating to the raw data.
*
*   dsc_name:  The data stream class name this file belongs to.
*
*   filename:  The full path to the raw file.
*
*   badtime:   The reference time of the file in seconds since 1970.
*              It is used as the file time is the data chunk is NULL
*              or has zero samples.
*
* Outputs:
*   None.
*
* Returns:
*   SUCCESS || FAILURE
*
*******************************************************************************/
int move_ingested_raw(
    DataChunk *dc,
    char      *dsc_name,
    char      *filename,
    time_t     badtime)
{
    const char      *site;
    const char      *facility;
    char            *extension;
    char             dc_platform[MAXPLATNAME];
    char            *chrp;
    int              nsamples;
    ZebTime          zeb_time;
    time_t           start_time;
    time_t           end_time;
    int              status;

    /*  If the dsc_name was not specified, get it from the data chunck
     */

    if (dsc_name == NULL) {

        site     = get_process_site();
        facility = get_process_facility();

        if (dc == NULL) {
            append_log_msg(__FILE__, __LINE__,
                "Null Datachunk and NULL dsc_name while trying to move file: %s\n", filename);
            current_status(STATUS_NOMOVERAW);
            return(FAILURE);
        }

        sprintf(dc_platform, "%s", ds_PlatformName(dc->dc_Platform));

        dsc_name = dc_platform + strlen(site);

        chrp = strstr(dsc_name, facility);

        if (chrp == NULL) {
            append_log_msg(__FILE__, __LINE__,
                "Could not find facility (%s) in platform name: %s\n",
                facility, dc_platform);
            current_status(STATUS_NOMOVERAW);
            return(FAILURE);
        }

        *chrp = '\0';
    }

    /*  Determine the time of this file
     */

    if (dc) {
        nsamples = dc_GetNSample(dc);
    }
    else {
        nsamples = 0;
    }

    if (nsamples > 0) {

        dc_GetTime(dc, 0, &zeb_time);
        start_time = zeb_time.zt_Sec;

        dc_GetTime(dc, nsamples - 1, &zeb_time);
        end_time = zeb_time.zt_Sec;

        extension = "raw";
    }
    else {
        if (badtime > 0) {
            start_time = end_time = badtime;
        }
        else {
            append_log_msg(__FILE__, __LINE__,
                "Could not determine time for bad file: %s\n", filename);
            current_status(STATUS_NOMOVERAW);
            return(FAILURE);
        }

        extension = "bad";

        append_log_msg(__FILE__, __LINE__,
            "Null DataChunk after processing file: %s\n", filename);

        /*  Set status to bad data file but don't return failure.  We do this
         *  so the ingest will move the raw file marking it as bad and then
         *  continue to work on the remaining files.
         */

        current_status(STATUS_NULLDC);
    }

    status = rename_raw(
        filename, start_time, end_time, dsc_name, "00", extension, 2);

    return(status);
}

/*******************************************************************************
*
* Description:
*   The parse_dimension_string function will parse the tdbkey which contains
*   information about the dimension(s) for the given field.
*
* Inputs:
*   parse_string: The string containing the dimension information.
*
* Outputs:
*   dim_num:   An array of dimension numbers which gets parsed out
*              of the parse_string.
*
*   is_static: Boolean which we set to TRUE (1) if this is a static
*              field. We pass this value by reference.
*
* Returns:
*   The number of dimensions.
*
*******************************************************************************/
int parse_dimension_string(char *parse_string, int *dim_num, int *is_static)
{
    int     i;
    int     num;
    int     pstrlen;
    char    c;

    pstrlen = strlen(parse_string);

    for(i = 0, num = 0; i < pstrlen; num++) {

        while(!isdigit(parse_string[i])) {
            if(i > pstrlen) break;
            i++;
        }

        dim_num[num] = 0;
        while(isdigit(parse_string[i])) {
            c = parse_string[i];
            dim_num[num] = 10 * dim_num[num] + atoi(&c);
            i++;
        }

      /*  0 dimension means Static.
       */
        if(dim_num[num] == 0) {
            *is_static = 1;

          /*  We don't want to return this dimension.
           */
            num--;
        }
    }

    return(num);
}

/*******************************************************************************
*
* Description:
*   The set_fields function will set up the fields and thier attributes in
*   the given NSpace datachunk for the specified dc platform name and number.
*   When setting the field attributes the standard attributes valid_min,
*   valid_max, valid_delta, and resolution will have the same data type
*   as the field they are defined for. The missing_value attribute will
*   be defined as -9999 for all fields unless otherwise specified.  If the
*   specified value of missing_value is NA, the missing_value attribute will
*   not be created for that field.
*
* Inputs:
*   dc:       The datachunk to define the fields in.
*
*   fields:   The array of FieldIds to fill up.
*
*   num_dims: A pointer to the integer to store the number of dimensions in
*             or NULL if you don't need this information passed to the calling
*             procedure.
*
*   dimsizes: The array of dimension sizes to fill up or NULL if you don't
*             need this information passed to the calling procedure.
*
*   make_dims_fields: set to 1 to make the dimensions fields,
*
* Outputs:
*   dc:       The data chunk with the fields defined.
*
*   fields:   The array of FieldIds.
*
*   num_dims: The number of dimensions for this dc if the input value wasn't NULL.
*
*   dimsizes: The sizes of the dimensions for this dc if the input value wasn't NULL.
*
* Returns:
*   The number of fields defined in the datachunk.
*
*******************************************************************************/
int set_fields(DataChunk *dc,
           FieldId   *fields,
           int       *num_dims,
           int       *dimsizes,
           int        make_dims_fields)
{
    char  tdb_plat_base[SHORTSTRLEN];
    char  tdb_plat_name[SHORTSTRLEN];
    char  tdb_plat[SHORTSTRLEN];
    char  datalevel[8];
    int   pindex;
    char *chrp;
    int   ndims;
    int   ndimatts;
    int   nflds;
    int   nflds_total;
    int   natts;
    char *tdbvalue;
    char *tdbdimsize;
    char *datatype;
    unsigned long dimsize;
    FieldId dimids[DC_MaxDimension];
    FieldId vardims[DC_MaxDimension];
    int     dim_nums[DC_MaxDimension];
    int     ndim_fields;
    int     fielddims;
    int     is_static;
    int     i;
    int     j;

    int          make_qc_field;
    FieldId      qc_fid;
    FieldId      qc_time_fid;

    char         qc_name[MAX_QC_NAME_LENGTH];
    char         qc_descrip[MAX_QC_DESCRIP_LENGTH];
    char         qc_units[9];
    DC_ElemType  qc_fieldtype;

  /* These variables eliminate the need for reading keys from the
   * TDB if we need to come in here multiple times (mutiple files
   * being ingested).  This was done to increase performance when
   * ingesting multiple files and to reduce the demand on the TDB.
   * These changes increased the performance of the ecor_ingest from
   * 1.5 files/minute to 6 files per minute.
   */

  /*  Dimensions
   */
    static DC_ElemType dimtype[MAX_DCS][MAX_FIELDS];
    static char *dimname[MAX_DCS][MAX_DIMS];
    static char *dimdescrip[MAX_DCS][MAX_DIMS];
    static char *dimunits[MAX_DCS][MAX_DIMS];
    static char *dimres[MAX_DCS][MAX_DIMS];
    static char *dimattname[MAX_DCS][MAX_DIMS][MAX_FLDATTS];
    static char *dimattvalue[MAX_DCS][MAX_DIMS][MAX_FLDATTS];

  /*  Fields
   */
    static DC_ElemType fieldtype[MAX_DCS][MAX_FIELDS];
    static char *name[MAX_DCS][MAX_FIELDS];
    static char *dim[MAX_DCS][MAX_FIELDS];
    static char *descrip[MAX_DCS][MAX_FIELDS];
    static char *units[MAX_DCS][MAX_FIELDS];

    static int   qc_fields[MAX_DCS][MAX_FIELDS];

  /*  Standard flattrs
   */
    static char *min[MAX_DCS][MAX_FIELDS];
    static char *max[MAX_DCS][MAX_FIELDS];
    static char *delta[MAX_DCS][MAX_FIELDS];
    static char *missing[MAX_DCS][MAX_FIELDS];
    static char *res[MAX_DCS][MAX_FIELDS];

  /*  Platform flatters
   */
    static char *attname[MAX_DCS][MAX_FIELDS][MAX_FLDATTS];
    static char *attvalue[MAX_DCS][MAX_FIELDS][MAX_FLDATTS];
    static int   fields_done[MAX_DCS];
    static char  qc_comm[1800];
    static char  qc_min_delta[64];
    static char  qc_check_prior[64];
    static char  qc_max_delta[64];
    int          status;
    double       d_min_expected;
    double       d_max_expected;
    double       d_check_prior;

    print_debug(__FILE__, __LINE__,
        "Entering set_fields for platform: %s\n", ds_PlatformName(dc->dc_Platform));

    if (!db_reconnect()) {
        return(0);
    }

    pindex = set_pindex(dc);

    /*  Get the TDB platform base and name
     */

    get_tdb_plat_names(
            dc,
            tdb_plat_base,
            tdb_plat_name,
            NULL, NULL);

    /*  Get the data level from the platform name
     */

    get_dc_platform_datalevel(dc, datalevel);

    print_debug(__FILE__, __LINE__,
        "TDB lookup info: tdb_plat_base = '%s', tdb_plat_name = '%s', datalevel = '%s'\n",
        tdb_plat_base, tdb_plat_name, datalevel);

    /*  If the tdb_plat_name key is defined use that for the tdb_plat
     *  otherwise use tdb_plat_base for the tdb_plat.
     */

    tdbvalue = get_field_name(tdb_plat_name, datalevel, 1);
    if (tdbvalue) {
        strcpy(tdb_plat, tdb_plat_name);
        shared_tdb_free(tdbvalue);

        print_debug(__FILE__, __LINE__,
            "Using tdb_plat_name to set fields\n");
    }
    else if (is_db_error()) {
        db_disconnect();
        return(0);
    }
    else {
        strcpy(tdb_plat, tdb_plat_base);

        print_debug(__FILE__, __LINE__,
            "Using tdb_plat_base to set fields\n");
    }

    /*  Setup the qc_time field if it is needed
     */

    if (strcmp (datalevel, "b1") == 0) {

        /* If we're working on a b1 file, before we add any fields, we will add
         * the "qc_time" field, if there is an entry in the TDB for the qc_time
         * stuff.
         */

        status = get_qc_time_interval(tdb_plat_base, tdb_plat_name,
                    &d_min_expected, &d_max_expected, &d_check_prior);

        if (status) {

            strcpy (qc_name,    "qc_time");
            strcpy (qc_descrip, "Results of quality checks on sample time");
            strcpy (qc_units,   "unitless");

            qc_time_fid = F_DeclareField(qc_name, qc_descrip, qc_units);

            print_debug(__FILE__, __LINE__,
                "Making QC field named: %s fid=%d\n", qc_name, qc_time_fid);

            dc_SetFieldAttr(dc, qc_time_fid, "long_name", qc_descrip);
            dc_SetFieldAttr(dc, qc_time_fid, "units", qc_units);

            qc_comm[0] = (char) NULL;

            /* Construct the comment */

            strcat(qc_comm, "The qc_time values are calculated by comparing each sample\n");
            strcat(qc_comm, "time with the previous time (i.e. delta_t = t[n] - t[n-1]).\n");
            strcat(qc_comm, "If the 'qc_check_prior' flag is set the first sample time\n");
            strcat(qc_comm, "from a new raw file will be compared against the time just\n");
            strcat(qc_comm, "previous to it in the stored data. If the 'qc_check_prior'\n");
            strcat(qc_comm, "flag is not set the qc_time value for the first sample time\n");
            strcat(qc_comm, "will be set to 0\n");
            strcat(qc_comm, "\n");
            strcat(qc_comm, "The qc_time bit values are as follows:\n");
            strcat(qc_comm, "=========================================================\n");
            strcat(qc_comm, "0x0 = delta time is within the specified range\n");
            strcat(qc_comm, "0x1 = delta time is equal to 0, duplicate sample times\n");
            strcat(qc_comm, "0x2 = delta time is less than the 'delta_t_lower_limit'\n");
            strcat(qc_comm, "0x4 = delta time is greater than the 'delta_t_upper_limit'\n");
            strcat(qc_comm, "\n");

            dc_SetFieldAttr(dc, qc_time_fid, "description", qc_comm);

            sprintf (qc_min_delta, "%lf", d_min_expected);
            sprintf (qc_max_delta, "%lf", d_max_expected);
            sprintf (qc_check_prior,"%lf", d_check_prior);

            set_flattr(dc, qc_time_fid,
                "delta_t_lower_limit", DCT_Integer, 1, qc_min_delta);
            set_flattr(dc, qc_time_fid,
                "delta_t_upper_limit", DCT_Integer, 1, qc_max_delta);

            set_flattr(dc, qc_time_fid,
                "prior_sample_flag", DCT_Integer, 1, qc_check_prior);

            fielddims = 0;
            is_static = 0;

            dc_NSDefineVariable (dc,
                                 qc_time_fid,
                                 fielddims,
                                 vardims,
                                 is_static);

        } /* End of "if (status == 1)" block */
    }

    /*  Setup the Dimensions
     */

    print_debug(__FILE__, __LINE__,
        "Setting up the dimensions\n", ds_PlatformName(dc->dc_Platform));

    ndim_fields = 0;
    for(ndims = 1; ndims < DC_MaxDimension; ndims++) {

        if (fields_done[pindex]) {
            if (!dimname[pindex][ndims]) {
                break;
            }
        }
        else {
            if ((dimname[pindex][ndims]
                = get_dimension_name(tdb_plat, datalevel, ndims)) == NULL) {
                break;
            }

            if (strcmp(dimname[pindex][ndims], "end_dimensions") == 0) {
                shared_tdb_free(dimname[pindex][ndims]);
                dimname[pindex][ndims] = NULL;
                break;
            }

            if ((datatype = get_dimension_key(TDBFLDTYPE, tdb_plat, datalevel, ndims)) == NULL) {
                dimtype[pindex][ndims] = get_field_type("float");
            }
            else {
                dimtype[pindex][ndims] = get_field_type(datatype);
                shared_tdb_free(datatype);
            }

            if ((dimdescrip[pindex][ndims]
                = get_dimension_key(TDBFLDDESCRIP, tdb_plat, datalevel, ndims)) == NULL) {
                dimdescrip[pindex][ndims] = (char *)malloc(2 * sizeof(char));
                strcpy(dimdescrip[pindex][ndims], " ");
            }
            if ((dimunits[pindex][ndims]
                = get_dimension_key(TDBFLDUNITS, tdb_plat, datalevel, ndims)) == NULL) {
                dimunits[pindex][ndims] = (char *)malloc(2 * sizeof(char));
                strcpy(dimunits[pindex][ndims], " ");
            }

            dimres[pindex][ndims] = get_dlattr_key(TDBFLDRES, tdb_plat, datalevel, ndims);
        }

        /*  Some ingests need to be able to set the dimension sizes on the fly.
         *  This means we must first look for an instrument specific dimension
         *  size before looking for the global one.
         */

        if ((tdbdimsize = get_dlattr_key(TDBDIMSIZE, tdb_plat_name, datalevel, ndims)) == NULL) {
            if ((tdbdimsize = get_dlattr_key(TDBDIMSIZE, tdb_plat_base, datalevel, ndims)) == NULL) {
                break;
            }
        }

        sscanf(tdbdimsize, "%d", &dimsize);
        shared_tdb_free(tdbdimsize);

        dimids[ndims - 1] = F_DeclareField(dimname[pindex][ndims],
            dimdescrip[pindex][ndims], dimunits[pindex][ndims]);

        dc_NSDefineDimension(dc, dimids[ndims - 1], dimsize);
        if (dimsizes != NULL) dimsizes[ndims - 1] = dimsize;

      /*  We are going to create a coordinate variable for each dimension.
       */

        if (make_dims_fields) {

            print_debug(__FILE__, __LINE__,
                "Making the dimensions fields\n");

            ndim_fields++;
            fields[ndims - 1] = dimids[ndims - 1];

            dc_NSDefineVariable(dc, fields[ndims - 1], 1, &dimids[ndims - 1], TRUE);

            if (dimres[pindex][ndims]) {
                set_flattr(dc, dimids[ndims - 1], "resolution", dimtype[pindex][ndims], 1, dimres[pindex][ndims]);
            }

          /*  Loop through field attrs in TDB.  Stop when there are no more
           */
            for (ndimatts = 1; ndimatts < MAX_FLDATTS; ndimatts++) {

                if (fields_done[pindex]) {
                    if (!dimattname[pindex][ndims][ndimatts]) {
                        break;
                    }
                }
                else {
                    if ((dimattname[pindex][ndims][ndimatts]
                        = get_dlattr_name(tdb_plat, datalevel, ndims, ndimatts)) == NULL) {
                        break;
                    }
                    dimattvalue[pindex][ndims][ndimatts]
                        = get_dlattr_value(tdb_plat, datalevel, ndims, ndimatts);
                }

                if (dimattvalue[pindex][ndims][ndimatts]) {
                    dc_SetFieldAttr(dc, dimids[ndims - 1],
                        dimattname[pindex][ndims][ndimatts], dimattvalue[pindex][ndims][ndimatts]);
                }
            }
        }
    } /* end for(ndims ... */
    ndims--;

    if (num_dims != NULL) *num_dims = ndims;

    print_debug(__FILE__, __LINE__,
        "Setup %i dimensions\n", ndims);

  /************************************************************
   *  Setup the Fields
   */
    print_debug(__FILE__, __LINE__,
        "Setting up the fields\n", ds_PlatformName(dc->dc_Platform));

    for (nflds = 1; nflds < MAX_FIELDS - ndim_fields; nflds++) {

        make_qc_field = 0; /* We won't create a qc_<name> field unless one of min/max/delta is specified */

        print_debug (__FILE__, __LINE__,
           "Starting out with make_qc_field = 0 for nflds=%d\n", nflds);

        if (fields_done[pindex]) {
            if (!name[pindex][nflds]) {
                break;
            }
        }
        else {
            if ((name[pindex][nflds] = get_field_name(tdb_plat, datalevel, nflds)) == NULL) {
                break;
            }
            if (strcmp(name[pindex][nflds], "end_fields") == 0) {
                shared_tdb_free(name[pindex][nflds]);
                name[pindex][nflds] = NULL;
                break;
            }

            if ((descrip[pindex][nflds] = get_field_key(TDBFLDDESCRIP, tdb_plat, datalevel, nflds)) == NULL) {
                descrip[pindex][nflds] = (char *)malloc(2 * sizeof(char));
                strcpy(descrip[pindex][nflds], " ");
            }
            if ((units[pindex][nflds] = get_field_key(TDBFLDUNITS, tdb_plat, datalevel, nflds)) == NULL) {
                units[pindex][nflds] = (char *)malloc(2 * sizeof(char));
                strcpy(units[pindex][nflds], " ");
            }

            if ((datatype = get_field_key(TDBFLDTYPE, tdb_plat, datalevel, nflds)) == NULL) {
                fieldtype[pindex][nflds] = get_field_type("float");
            }
            else {
                fieldtype[pindex][nflds] = get_field_type(datatype);
                shared_tdb_free(datatype);
            }

            dim[pindex][nflds]     = get_field_key(TDBFLDDIMS, tdb_plat, datalevel, nflds);
            missing[pindex][nflds] = get_field_key(TDBFLDMISSING, tdb_plat, datalevel, nflds);

            min[pindex][nflds]     = get_flattr_key(TDBFLDMIN, tdb_plat, datalevel, nflds);
            max[pindex][nflds]     = get_flattr_key(TDBFLDMAX, tdb_plat, datalevel, nflds);
            delta[pindex][nflds]   = get_flattr_key(TDBFLDDELTA, tdb_plat, datalevel, nflds);
            res[pindex][nflds]     = get_flattr_key(TDBFLDRES, tdb_plat, datalevel, nflds);

            for (natts = 1; natts < MAX_FLDATTS; natts++) {
                if ((attname[pindex][nflds][natts] = get_flattr_name(tdb_plat, datalevel, nflds, natts)) == NULL) {
                    break;
                }
                if (strcmp(attname[pindex][nflds][natts], "end_field_attributes") == 0) {
                    shared_tdb_free(attname[pindex][nflds][natts]);
                    attname[pindex][nflds][natts] = NULL;
                    break;
                }

                attvalue[pindex][nflds][natts] = get_flattr_value(tdb_plat, datalevel, nflds, natts);
            }
        }

        fields[nflds + ndim_fields - 1] = F_DeclareField(name[pindex][nflds],
                               descrip[pindex][nflds],
                               units[pindex][nflds]);

        print_debug (__FILE__, __LINE__,
             "Making non-QC field named %s with fid=%d\n",
             name[pindex][nflds], fields[nflds + ndim_fields - 1]);

      /*  We need to leave these in here, otherwise we may not get the
       *  expected attributes.  Zeb will use the attributes that were
       *  first set the first time a field name is used
       */
        dc_SetFieldAttr(dc, fields[nflds + ndim_fields - 1],
            "long_name", descrip[pindex][nflds]);
        dc_SetFieldAttr(dc, fields[nflds + ndim_fields - 1],
            "units", units[pindex][nflds]);

        print_debug(__FILE__, __LINE__,
            "Setting standard attributes for field: %s\n", name[pindex][nflds]);

        if (min[pindex][nflds]) {
            set_flattr(dc, fields[nflds + ndim_fields - 1],
                "valid_min", fieldtype[pindex][nflds], 1, min[pindex][nflds]);

            make_qc_field = 1;
            print_debug (__FILE__, __LINE__,
                "set make_qc_field=1 because we have min=%s\n", min[pindex][nflds]);
        }
        if (max[pindex][nflds]) {
            set_flattr(dc, fields[nflds + ndim_fields - 1],
                "valid_max", fieldtype[pindex][nflds], 1, max[pindex][nflds]);

            make_qc_field = 1;
            print_debug (__FILE__, __LINE__,
                "set make_qc_field=1 because we have max=%s\n", max[pindex][nflds]);
        }
        if (delta[pindex][nflds]) {
            set_flattr(dc, fields[nflds + ndim_fields - 1],
                "valid_delta", fieldtype[pindex][nflds], 1, delta[pindex][nflds]);

            make_qc_field = 1;
            print_debug (__FILE__, __LINE__,
                "set make_qc_field=1 because we have delta=%s\n", delta[pindex][nflds]);
        }
        if (res[pindex][nflds]) {
            set_flattr(dc, fields[nflds + ndim_fields - 1],
                "resolution", fieldtype[pindex][nflds], 1, res[pindex][nflds]);
        }
        if (missing[pindex][nflds]) {
            if (strcmp(missing[pindex][nflds], "NA") != 0) {
                set_flattr(dc, fields[nflds + ndim_fields - 1],
                    "missing_value", fieldtype[pindex][nflds], 1, missing[pindex][nflds]);
            }
        }
        else {
            set_flattr(dc, fields[nflds + ndim_fields - 1],
                "missing_value", fieldtype[pindex][nflds], 1, DEFAULT_MISSING);
        }

      /*  Loop through field attrs.
       */
        print_debug(__FILE__, __LINE__,
            "Setting non-standard attributes for field: %s\n", name[pindex][nflds]);

        for (natts = 1; natts < MAX_FLDATTS; natts++) {

            if (attname[pindex][nflds][natts] == NULL) {
                break;
            }

            if (attvalue[pindex][nflds][natts] != NULL) {
                dc_SetFieldAttr(dc, fields[nflds + ndim_fields - 1],
                    attname[pindex][nflds][natts], attvalue[pindex][nflds][natts]);
            }
        }

      /*  Loop through dimensions
       *
       * parse_dimension_string will load dimNum up with an array of dimension
       * numbers.  We need to subtract 1 from the dimNum to get the
       * corresponding fieldId.  These Ids are loaded into an array
       * of FieldIds (vardims) and are then passed at the Dimensions
       * to dc_NSDefineVariable.
       */
        fielddims = 0;
        is_static = 0;
        if(dim[pindex][nflds]) {
            fielddims = parse_dimension_string(dim[pindex][nflds], dim_nums, &is_static);
            for(i = 0; i < fielddims; i++) {
                vardims[i] = dimids[dim_nums[i] - 1];
            }
        }
        dc_NSDefineVariable(dc, fields[nflds + ndim_fields - 1],
            fielddims, vardims, is_static);

        print_debug(__FILE__, __LINE__,
            "Finished declaring field: %s\n", name[pindex][nflds]);

        if (make_qc_field == 1 && strcmp(datalevel, "b1") == 0) {

            print_debug (__FILE__, __LINE__,
                "make_qc_field is 1 for %s\n", name[pindex][nflds]);
            /* We need to generate a qc_<name> field */

            sprintf (qc_name, "qc_%s", name[pindex][nflds]);
            sprintf (qc_descrip, "Quality check results on field: %s", descrip[pindex][nflds]);
            sprintf (qc_units, "unitless");

            qc_fid = F_DeclareField(qc_name,
                                    qc_descrip,
                                    qc_units);

            print_debug(__FILE__, __LINE__,
                "Making QC field named: %s fid=%d\n", qc_name, qc_fid);

            dc_NSDefineVariable(dc,
                                qc_fid,
                                fielddims,
                                vardims,
                                is_static);

            /* We need to remember which fields we defined
             * as QC fields so that we can set the type
             * of those fields below
             */

            qc_fields[pindex][qc_fid] = 1;
        }
    } /* End of nflds loop */
    nflds--;

    nflds_total = nflds;

  /*  Disconnect from the database if we made the connection
   */

    db_disconnect();

  /*  Close out definition and set the field types
   */
    dc_NSDefineComplete (dc);

    for(i = 1; i <= ndim_fields; i++) {
        dc_SetType(dc, fields[i - 1], dimtype[pindex][i]);
    }

    if (strcmp (datalevel, "b1") == 0) {

        /* We have to set the field type for the qc_time to "int" */

        qc_fieldtype = get_field_type("int");
        dc_SetType (dc, qc_time_fid, qc_fieldtype);
    }

    for(nflds = 1; nflds <= nflds_total; nflds++) {

        dc_SetType(dc,
                   fields[nflds + ndim_fields - 1],
                   fieldtype[pindex][nflds]);

        print_debug(__FILE__, __LINE__,
            "Set field type for fid=%d\n",
            fields[nflds + ndim_fields - 1]);
    }

    for (i=1; i < MAX_FIELDS; i++) {

        if (qc_fields[pindex][i] == 1) {
            dc_SetType (dc, i, DCT_Integer);
            print_debug(__FILE__, __LINE__,
                "Set field type for fid=%d (QC field) \n", i);
        }
    }

    if (nflds_total) {
        fields_done[pindex] = 1;
        print_debug(__FILE__, __LINE__,
            "Set %d fields for platform %s\n", nflds_total, tdb_plat);
    }
    else {
        append_log_msg(__FILE__, __LINE__,
            "Failed to set fields for: %s\n", tdb_plat);
        current_status(STATUS_INITDC);
        return(0);
    }

    return(nflds_total);
}

/*******************************************************************************
*
* Description:
*   The set_flattr function sets a field attribute in the datachunck.  If an
*   invalid atttype is specified the attribute will be stored as a string.
*
* Inputs:
*   dc:           The datachunk to store the field attribute in.
*
*   field:        The FieldId of the field to set the attribute for.
*
*   attname:      The name of the attribute.
*
*   atttype:      The DC_ElemType of the attribute.
*
*   attvalue:     A string containing the attribute value.
*
* Outputs:
*   None.
*
* Returns:
*   None.
*
*******************************************************************************/
void set_flattr(DataChunk *dc, FieldId field, char *attname,
                DC_ElemType atttype, int nelems, char *attvalue)
{
    float          fdata;
    double         ddata;
    long double    lddata;
    unsigned char  bytes;
    short          sdata;
    unsigned short usdata;
    int            idata;
    unsigned int   uidata;
    long           ldata;
    unsigned long  uldata;

    switch (atttype) {
        case DCT_Float:
            fdata = (float)atof(attvalue);
            dc_SetFieldAttrArray(dc, field, attname, DCT_Float, 1, (void *)&fdata);
            break;
        case DCT_Double:
            ddata = atof(attvalue);
            dc_SetFieldAttrArray(dc, field, attname, DCT_Double, 1, (void *)&ddata);
            break;
        case DCT_LongDouble:
            lddata = (long double)atof(attvalue);
            dc_SetFieldAttrArray(dc, field, attname, DCT_LongDouble, 1, (void *)&lddata);
            break;
        case DCT_Char:
            dc_SetFieldAttrArray(dc, field, attname, DCT_Char, strlen(attvalue), (void *)attvalue);
            break;
        case DCT_UnsignedChar:
            bytes = (unsigned char)atoi(attvalue);
            dc_SetFieldAttrArray(dc, field, attname, DCT_UnsignedChar, 1, (void *)&bytes);
            break;
        case DCT_ShortInt:
            sdata = (short)atoi(attvalue);
            dc_SetFieldAttrArray(dc, field, attname, DCT_ShortInt, 1, (void *)&sdata);
            break;
        case DCT_UnsignedShort:
            usdata = (unsigned short)atoi(attvalue);
            dc_SetFieldAttrArray(dc, field, attname, DCT_UnsignedShort, 1, (void *)&usdata);
            break;
        case DCT_Integer:
            idata = atoi(attvalue);
            dc_SetFieldAttrArray(dc, field, attname, DCT_Integer, 1, (void *)&idata);
            break;
        case DCT_UnsignedInt:
            uidata = (unsigned int)atoi(attvalue);
            dc_SetFieldAttrArray(dc, field, attname, DCT_UnsignedInt, 1, (void *)&uidata);
            break;
        case DCT_LongInt:
            ldata = atol(attvalue);
            dc_SetFieldAttrArray(dc, field, attname, DCT_LongInt, 1, (void *)&ldata);
            break;
        case DCT_UnsignedLong:
            uldata = (unsigned long)atol(attvalue);
            dc_SetFieldAttrArray(dc, field, attname, DCT_UnsignedLong, 1, (void *)&uldata);
            break;
        default:
            dc_SetFieldAttrArray(dc, field, attname, DCT_String, 1, (void *)attvalue);
            break;
    }
}

/*******************************************************************************
*
* Description:
*   The set_flattr_value function will set the value of a predefined field level
*   attribute in the datachuck that is passed.
*
* Inputs:
*   dc:           DataChunk with Field Level Attribute to change.
*
*   field_name:   Name of the field which contains FLATTR.
*
*   flattr_name:  Name of FLATTR to change.
*
*   flattr_value: New value of FLATTR.
*
* Outputs:
*   dc:           DataChunk with new Field Level Attribute.
*
* Returns:
*   1 on success,
*   or 0 if the field name doesn't exist in the datachunk.
*
*******************************************************************************/
int set_flattr_value (DataChunk *dc, char *field_name, char *flattr_name, char *flattr_value)
{
    FieldId  fid;

  /*  If fid is less then 0, it has not been defined.
   */
    if ((fid = F_Declared(field_name)) < 0) {
        append_log_msg(__FILE__, __LINE__,
            "Field %s is not in the specified datachunk!", field_name);
        return(0);
    }

  /*  Set the New Field Level Attribute
   */
    dc_SetFieldAttr(dc, fid, flattr_name, flattr_value);
    print_debug(__FILE__, __LINE__,
        "Set flatter value, %s:%s = '%s'\n",
            field_name, flattr_name, flattr_value);

    return (1);
}


/*******************************************************************************
*
* Description:
*   The set_global function will set up the global attributes in the datachunk.
*
* Inputs:
*   dc:       The data chunk to define the global attributes in.
*
*   filename: The name of the file which is being ingested.
*
* Outputs:
*   dc:    The data chunk with the global attributes defined.
*
* Returns:
*   None.
*
*******************************************************************************/
int set_global(DataChunk *dc, char *filename)
{
    char  ingest_version[128];
    char  tdb_plat_base[SHORTSTRLEN];
    char  tdb_plat_name[SHORTSTRLEN];
    char  tdb_alias_base[SHORTSTRLEN];
    char  tdb_alias_name[SHORTSTRLEN];
    char  datalevel[8];
    char  input_source[MAXSTRLEN];
    char  facility_loc[SHORTSTRLEN];

    const char *rcsid;
    const char *rcsstate;
    const char *site_name;
    const char *facility;
    ProcLoc    *proc_loc;

    char    *chrp;
    char    *fld_ind_descrip;
    char    *res_descrip;
    char    *tdbvalue;

    int   attnum;
    char *attname;
    char *attvalue;

    print_debug(__FILE__, __LINE__,
        "Setting global attributes for platform: %s\n", ds_PlatformName(dc->dc_Platform));

    if (!db_reconnect()) {
        return(FAILURE);
    }

    /*  Get the TDB platform base and name
     */

    get_tdb_plat_names(
            dc,
            tdb_plat_base,
            tdb_plat_name,
            tdb_alias_base,
            tdb_alias_name);

    rcsid     = get_ingest_rcsid();
    rcsstate  = get_ingest_rcsstate();
    site_name = get_process_site();
    facility  = get_process_facility();
    proc_loc  = get_ingest_location();

  /*  First, we want to set the Standard global attributes
        ingest_software
        proc_level
        input_source
        site_id
        facility_id
        sample_int
        averaging_int
        serial_number
        comment
        resolution_description
   */

  /*  Set the ingest_version to the rcs state
   */
    dslib_trim_rcs_string(rcsstate, ingest_version, 128);
    dc_SetGlobalAttr(dc, "ingest_version", ingest_version);

  /*  Set ingest_lib_version
   */
    dc_SetGlobalAttr(dc, "libingest_version", get_ingest_lib_version());

  /*  Set dslibc_version
   */
    dc_SetGlobalAttr(dc, "libdslibc_version", dslib_get_version());

  /*  Set dsdb_lib_version
   */
    dc_SetGlobalAttr(dc, "libdsdb_version", dsdb_get_version());

  /*  Set the ingest_software to the rcsid.
   */
    dc_SetGlobalAttr(dc, "ingest_software", (char *)&rcsid[4]);

  /*  Get the data level from the platform name
   */
    get_dc_platform_datalevel(dc, datalevel);
    dc_SetGlobalAttr(dc, "proc_level", datalevel);

  /*  At this level we know that our data is coming from the instrument
   */
    sprintf(input_source, "%s", filename);
    dc_SetGlobalAttr(dc, "input_source", input_source);

  /*  Set the ingest_site from tdb and set site_id
   */
    dc_SetGlobalAttr(dc,"site_id", (char *)site_name);

  /*  Set the facility location from the TDB based on aliasplatname
   */

    sprintf(facility_loc, "%s: %s", facility, proc_loc->name);

    dc_SetGlobalAttr(dc,"facility_id", facility_loc);

  /*  Set the SDS-mode to the mode passed from ingest module
   *
   * dc_SetGlobalAttr(dc, "sds-mode", get_sds_mode());
   */

  /*  Set the sample interval. Sample will be looked for in this order:
   *      platname_sample       30ebbr13_sample
   *      platbase_sample       30ebbr_sample
   *      aliasplatname_sample  ebbr13_sample
   *      aliasplatbase_sample  ebbr_sample
   */
    tdbvalue = get_glattr_key("sample",
        tdb_plat_name, tdb_plat_base,
        tdb_alias_name, tdb_alias_base);

    if (tdbvalue != NULL) {
        dc_SetGlobalAttr(dc, "sample_int", tdbvalue);
        shared_tdb_free(tdbvalue);
    }
    else {
        dc_SetGlobalAttr(dc, "sample_int", "Not Specified");
    }

  /*  Set the averaging interval. Averaging will be looked for in this order:
   *      platname_averaging       30ebbr13_averaging
   *      platbase_averaging       30ebbr_averaging
   *      aliasplatname_averaging  ebbr13_averaging
   *      aliasplatbase_averaging  ebbr_averaging
   */
    tdbvalue = get_glattr_key("averaging",
        tdb_plat_name, tdb_plat_base,
        tdb_alias_name, tdb_alias_base);

    if (tdbvalue != NULL) {
        dc_SetGlobalAttr(dc, "averaging_int", tdbvalue);
        shared_tdb_free(tdbvalue);
    }
    else {
        dc_SetGlobalAttr(dc, "averaging_int", "None");
    }

  /*  Set the serial number
   */
    tdbvalue = get_glattr_key("serial",
        tdb_plat_name, tdb_plat_base,
        tdb_alias_name, tdb_alias_base);

    if (tdbvalue != NULL) {
        dc_SetGlobalAttr(dc, "serial_number", tdbvalue);
        shared_tdb_free(tdbvalue);
    }
    else {
        dc_SetGlobalAttr(dc,"serial_number", "Not Specified");
    }

  /*  Set the missing data value
   *
   * tdbvalue = get_glattr_key("missing", platname, platbase, aliasplatname, aliasplatbase);
   * if (tdbvalue != NULL) {
   *     dc_SetGlobalAttr(dc, "missing-data", tdbvalue);
   *     shared_tdb_free(tdbvalue);
   * }
   * else {
   *     dc_SetGlobalAttr(dc, "missing-data", "N/A");
   * }
   */

  /*  Set the comment field. Comment will be looked for in this order:
   *      platname_comment       30ebbr13_comment
   *      platbase_comment       30ebbr_comment
   *      aliasplatname_comment  ebbr13_comment
   *      aliasplatbase_comment  ebbr_comment
   */
    tdbvalue = get_glattr_key("comment",
        tdb_plat_name, tdb_plat_base,
        tdb_alias_name, tdb_alias_base);

    if (tdbvalue != NULL) {
        dc_SetGlobalAttr(dc, "comment", tdbvalue);
        shared_tdb_free(tdbvalue);
    }
    else {
        dc_SetGlobalAttr(dc, "comment", "");
    }

  /*  Fetch the field_indices glattr (global attribute) now
   *
   * if ((fld_ind_descrip = get_field_indices_descrip()) == NULL) {
   *     dc_SetGlobalAttr(dc, "field_indices", " ");
   * }
   * else {
   *     dc_SetGlobalAttr(dc, "field_indices", fld_ind_descrip);
   * }
   */

  /*  Fetch the resolution_description glattr (global attribute) now
   */
    if ((res_descrip = get_resolution_descrip()) == NULL) {
        dc_SetGlobalAttr(dc, "resolution_description", "Not Specified");
    }
    else {
        dc_SetGlobalAttr(dc,"resolution_description", res_descrip);
    }

  /*  Now set the platform specific metatdata
   */
    for(attnum = 1; attnum < MAX_METADATA; attnum++) {

        attname  = get_glattr_name(attnum,
                        tdb_plat_name, tdb_plat_base,
                        tdb_alias_name, tdb_alias_base);

        if (attname == NULL) {
            break;
        }
        if (strcmp(attname, "end_global_attributes") == 0) {
            shared_tdb_free(attname);
            break;
        }

        attvalue = get_glattr_value(attnum,
                        tdb_plat_name, tdb_plat_base,
                        tdb_alias_name, tdb_alias_base);

        if (attvalue != NULL) {
            dc_SetGlobalAttr(dc, attname, attvalue);
            shared_tdb_free(attvalue);
        }
        else {
            dc_SetGlobalAttr(dc, attname, "");
        }
        shared_tdb_free(attname);
    }

    db_disconnect();

    return(SUCCESS);
}

/*******************************************************************************
*
* Description:
*   The set_location function will set up the location values in the
*   given datachunk.
*
* Inputs:
*   dc:       The dc in which to set the location.
*
* Outputs:
*   dc:   The data chunk with the location set.
*
* Returns:
*   None.
*
*******************************************************************************/
ProcLoc *set_location(DataChunk *dc)
{
    static Location  loc;
    ProcLoc         *proc_loc;

    print_debug(__FILE__, __LINE__,
        "Setting location for platform: %s\n", ds_PlatformName(dc->dc_Platform));

    proc_loc = get_ingest_location();

    if (proc_loc) {
        loc.l_alt = proc_loc->alt;
        loc.l_lat = proc_loc->lat;
        loc.l_lon = proc_loc->lon;
    }
    else {
        loc.l_alt = 0;
        loc.l_lat = 0;
        loc.l_lon = 0;
    }

    dc_SetStaticLoc(dc, &loc);

    return(proc_loc);
}

/*******************************************************************************
*
* Description:
*   The set_location_from_data function sets the location portion of the dc
*   statically using values passed as parameters.
*
* Inputs:
*   dc:   The dc in which to set the location.
*
*   lat:  The latitude
*
*   lon:  The longitude
*
*   alt:  The altitude
*
* Outputs:
*   dc:   The data chunk with the location set.
*
* Returns:
*   None.
*
*******************************************************************************/
void set_location_from_data(DataChunk *dc, float *lat, float *lon, float *alt)
{
    Location loc;

    print_debug(__FILE__, __LINE__,
        "Setting location for platform: %s\n", ds_PlatformName(dc->dc_Platform));

    loc.l_lat = *lat;
    loc.l_lon = *lon;
    loc.l_alt = *alt;

    dc_SetStaticLoc(dc, &loc);

}

/*******************************************************************************
*
* Description:
*   The set_pindex will return a unique platform index based on dc platform
*   name. We need to keep an array of platform names because set_fields can be
*   used for multiple platforms in the same ingest.  We will index into the
*   field name, descrip, etc arrays based on the pindex assigned using the
*   platform names.
*
* Inputs:
*   dc:  The datachunk to get the platform index for.
*
* Outputs:
*   None.
*
* Returns:
*   The platform index.
*
*******************************************************************************/
int set_pindex(DataChunk *dc)
{
    static char platform_names[MAX_DCS][MAXSTRLEN];
    int pindex = 0;

  /*  Now, we need to figure out the pindex
   */
    while (platform_names[pindex][0] != '\0') {
        if (strcmp(platform_names[pindex], ds_PlatformName(dc->dc_Platform)) == 0) {
            break;
        }
        pindex++;
    }

    if (platform_names[pindex][0] == '\0') {

      /*  We haven't seen this platname before, so put it in our list
       */
        sprintf(platform_names[pindex], ds_PlatformName(dc->dc_Platform));
    }

    return(pindex);
}

/*******************************************************************************
*
* Description:
*   The set_mobile_location_from_data function sets the location portion of
*   the dc statically using values passed as parameters.
*
* Inputs:
*   dc:    The dc in which to set the location.
*
*   nlocs: The number of locations stored.
*
*   lat:   The latitude array
*
*   lon:   The longitude array
*
*   alt:   The altitude array
*
* Outputs:
*   dc:   The data chunk with the locations set.
*
* Returns:
*   None.
*
*******************************************************************************/
void set_mobile_location_from_data(DataChunk *dc, int nlocs,
                                   float *lat, float *lon, float *alt)
{
    int      i;
    Location loc;

    print_debug(__FILE__, __LINE__,
        "Setting location for platform: %s\n", ds_PlatformName(dc->dc_Platform));

    for(i = 0; i < nlocs; i++) {
        loc.l_lat = lat[i];
        loc.l_lon = lon[i];
        loc.l_alt = alt[i];

        dc_SetLoc(dc, i, &loc);
    }

}

/*******************************************************************************
*
* Description:
*   This function will fill up the ZebTime variable dotime based on hourmin,
*   day and year. This function will also check to make sure that the year is
*   greater than or equal to 1990 and the calculated time is not in the future.
*
* Inputs:
*   hourmin: Hour and minute in the form HHMM
*
*   jday:    The julian day.
*
*   year:    The year since 1900.  (actually any year format will work
*            but this was only added to be more forgiving.)
*
* Outputs:
*   dotime:  The ZebTime struct with the correct time filled in.
*
* Returns:
*   SUCCESS or FAILURE
*
*******************************************************************************/
int set_sample_time(int hourmin, int jday, int year, ZebTime *dotime)
{
    int total_days;

  /*  Make sure year is years since 1900.
   */
    year = four_digit_year(year);
    year -= 1900;

  /* We will not accept the sample if the year is less than 1990 or greater
   * than The current year.
   */
    if (year < 90 ) {
        print_debug(__FILE__, __LINE__,
            "In set_sample_time the year is less than 90.\n");
        return (FAILURE);
    }

  /* We will not accept the sample if the day is less than 1 or greater than
   * 366.  This will ensure a proper date came accross in the raw data file.
   */
    if ((jday < 1) || (jday > 366)) {
        print_debug(__FILE__, __LINE__,
            "In set_sample_time the jday is not in the range 1-366.\n");
        return (FAILURE);
    }

  /* We will not accept the sample if the hhmm is less than 0 or greater than
   * 2400.  This will ensure a proper time came across in the raw data file.
   */
    if ((hourmin < 0) || (hourmin > 2400)) {
        print_debug(__FILE__, __LINE__,
            "In set_sample_time the hourmin is not in the range 0-2400.\n");
        return (FAILURE);
    }

    total_days = days_since1970(year) + jday - 1;
    dotime->zt_Sec =
        (total_days * 86400L)
        + (((int)(hourmin * .01)) * 3600)
        + (((int)(hourmin % 100)) * 60);
    dotime->zt_MicroSec = 0;

  /*  Now make sure this time isn't in the future.
   */
    if (dotime->zt_Sec > time(NULL)) {
        print_debug(__FILE__, __LINE__,
            "In set_sample_time the calculated time is in the future.\n");
        dotime->zt_Sec = 0;
    }

    return (SUCCESS);
}

/*******************************************************************************
*
* Description:
*   This function will call the appropriate ZEB data store calls to store the
*   dc. Newfile tells the data store if a new file should be created. This will
*   clean up the prev_dc since it will no longer be correct after this
*   datachunk is stored.
*
* Inputs:
*   dc:       The filled DataChunk which is to be stored.
*
*   newfile:  1 for new file, 0 no new file.
*
* Outputs:
*   None.
*
* Returns:
*   None.
*
*******************************************************************************/
void store_datachunk(DataChunk *dc, int newfile)
{
  /*  Set an alarm for 30 minutes.  Not sure why it is for so long but I'm not
   *  going to change it.  It could be that and ingest for and entire day
   *  could take this long (but I really doubt it!!).
   */
    alarm(30*60);

  /*  Record stats for this DataChunk
   */
    set_dc_stats(dc);

  /*  Store the data using current ZEB calls
   */
    ds_StoreBlocks(dc, newfile, NULL, 0);

  /*  Turn off the alarm if done
   */
    alarm(0);

  /*  Now clean up dc_last, we are done with it at this point
   */
    prev_dc = freeDC(prev_dc);
}

---