hpwf2sdds.c

/*************************************************************************\
 * Copyright (c) 2002 The University of Chicago, as Operator of Argonne
 * National Laboratory.
 * Copyright (c) 2002 The Regents of the University of California, as
 * Operator of Los Alamos National Laboratory.
 * This file is distributed subject to a Software License Agreement found
 * in the file LICENSE that is included with this distribution. 
\*************************************************************************/
 
/* program: hpwf2sdds.c
 * purpose: converts a waveform from an HP scope to 
 *          SDDS format
 *
 * M. Borland, 1994
 $Log: not supported by cvs2svn $
 Revision 1.4  2001/01/23 19:14:55  soliday
 Standardized usage message.
 
 Revision 1.3  1999/05/25 19:02:49  soliday
 Removed compiler warning on linux.
 
 Revision 1.2  1995/09/06 14:55:50  saunders
 First test release of SDDS1.5
 
*/
#include "mdb.h"
#include "SDDS.h"
#include "scan.h"
#include "match_string.h"
 
#define SET_SIGNAL_NAME 0
#define SET_DESCRIPTION 1
#define SET_MPL_LABELS 2
#define SET_MAJOR_ORDER 3
#define N_OPTIONS 4
 
static char *option[N_OPTIONS] = {
  "signalname", "description", "mpllabels", "majorOrder"};
 
char *USAGE = "hpwf2sdds <inputfile> <outputfile>\n\
 -signalname=<name> [-description=<text>,<contents>]\n\
 [-mpllabels=<title>,<topline>] [-majorOrder=row|column] \n\n\
This program converts HP verbose format waveforms to SDDS format.\n\n\
Program by Michael Borland (" __DATE__ " " __TIME__ ", SVN revision: " SVN_VERSION ")\n";
 
typedef struct
{
  char *HP_name, *SDDS_name, *value_string;
  long type;
} HP_PARAMETER;
 
#define HP_PARAMETERS 23
HP_PARAMETER HP_parameter[HP_PARAMETERS] = {
  {"Type", "Type", NULL, SDDS_STRING},
  {"Points", "Points", NULL, SDDS_LONG},
  {"Count", "Count", NULL, SDDS_LONG},
  {"XInc", "XInc", NULL, SDDS_DOUBLE},
  {"XOrg", "XOrg", NULL, SDDS_DOUBLE},
  {"XRef", "XRef", NULL, SDDS_DOUBLE},
  {"YData range", "YDataRange", NULL, SDDS_DOUBLE},
  {"YData center", "YDataCenter", NULL, SDDS_DOUBLE},
  {"Coupling", "Coupling", NULL, SDDS_STRING},
  {"XRange", "XRange", NULL, SDDS_DOUBLE},
  {"XOffset", "XOffset", NULL, SDDS_DOUBLE},
  {"YRange", "YRange", NULL, SDDS_DOUBLE},
  {"YOffset", "YOffset", NULL, SDDS_DOUBLE},
  {"Date", "Date", NULL, SDDS_STRING},
  {"Time", "Time", NULL, SDDS_STRING},
  {"Frame", "Frame", NULL, SDDS_STRING},
  {"Acq mode", "AcqMode", NULL, SDDS_STRING},
  {"Completion", "Completion", NULL, SDDS_STRING},
  {"X Units", "XUnits", NULL, SDDS_STRING},
  {"Y Units", "YUnits", NULL, SDDS_STRING},
  {"Max Bandwidth", "MaxBandwidth", NULL, SDDS_DOUBLE},
  {"Min Bandwidth", "MinBandwidth", NULL, SDDS_DOUBLE},
  {NULL, NULL, NULL, 0},
};
 
char *HP_DataMarker = "Data";
char *HP_XIncrementName = "XInc";
char *HP_XOriginName = "XOrg";
char *HP_XReferenceName = "XRef";
char *HP_XUnitsName = "X Units";
char *HP_YUnitsName = "Y Units";
char *HP_PointsName = "Points";
 
#define BUFSIZE 256
 
int main(int argc, char **argv) {
  SDDS_TABLE SDDS_table;
  SCANNED_ARG *scanned;
  long i, i_arg, index, points;
  char *input, *output, buffer[BUFSIZE];
  char *signal_name, *ptr, *parameter_name;
  char *mpl_title, *mpl_topline, *descrip_text, *descrip_contents;
  FILE *fpi;
  double xIncrement, xOrigin, xReference;
  char *xUnits, *yUnits;
  double *time, *data;
  unsigned long majorOrderFlag;
  short columnMajorOrder = -1;
 
  argc = scanargs(&scanned, argc, argv);
  if (argc < 3)
    bomb(NULL, USAGE);
 
  input = output = signal_name = xUnits = yUnits = NULL;
  mpl_title = mpl_topline = descrip_text = descrip_contents = NULL;
 
  for (i_arg = 1; i_arg < argc; i_arg++) {
    if (scanned[i_arg].arg_type == OPTION) {
      delete_chars(scanned[i_arg].list[0], "_");
      /* process options here */
      switch (match_string(scanned[i_arg].list[0], option, N_OPTIONS, 0)) {
      case SET_MAJOR_ORDER:
        majorOrderFlag = 0;
        scanned[i_arg].n_items--;
        if (scanned[i_arg].n_items > 0 && (!scanItemList(&majorOrderFlag, scanned[i_arg].list + 1, &scanned[i_arg].n_items, 0, "row", -1, NULL, 0, SDDS_ROW_MAJOR_ORDER, "column", -1, NULL, 0, SDDS_COLUMN_MAJOR_ORDER, NULL)))
          SDDS_Bomb("invalid -majorOrder syntax/values");
        if (majorOrderFlag & SDDS_COLUMN_MAJOR_ORDER)
          columnMajorOrder = 1;
        else if (majorOrderFlag & SDDS_ROW_MAJOR_ORDER)
          columnMajorOrder = 0;
        break;
      case SET_SIGNAL_NAME:
        if (scanned[i_arg].n_items != 2)
          SDDS_Bomb("invalid -signalname syntax");
        signal_name = scanned[i_arg].list[1];
        break;
      case SET_DESCRIPTION:
        if (scanned[i_arg].n_items != 3)
          SDDS_Bomb("invalid -description syntax");
        descrip_text = scanned[i_arg].list[1];
        descrip_contents = scanned[i_arg].list[2];
        break;
      case SET_MPL_LABELS:
        if (scanned[i_arg].n_items != 3)
          SDDS_Bomb("invalid -mpllabels syntax");
        mpl_title = scanned[i_arg].list[1];
        mpl_topline = scanned[i_arg].list[2];
        break;
      default:
        SDDS_Bomb("invalid option seen");
        break;
      }
    } else {
      if (!input)
        input = scanned[i_arg].list[0];
      else if (!output)
        output = scanned[i_arg].list[0];
      else
        SDDS_Bomb("too many filenames");
    }
  }
  if (!input)
    SDDS_Bomb("input file not seen");
  if (!output)
    SDDS_Bomb("output file not seen");
  if (!signal_name)
    SDDS_Bomb("-signal_name not seen");
 
  fpi = fopen_e(input, "r", 0);
  parameter_name = buffer;
  while (fgets(buffer, BUFSIZE, fpi)) {
    if (!(ptr = strchr(buffer, ':')))
      SDDS_Bomb("error parsing input file--missing colon on parameter tag");
    *ptr++ = 0;
    if (strcmp(HP_DataMarker, parameter_name) == 0)
      break;
    index = 0;
    while (HP_parameter[index].HP_name) {
      if (strcmp(HP_parameter[index].HP_name, parameter_name) == 0)
        break;
      index++;
    }
    if (!HP_parameter[index].HP_name) {
      fprintf(stderr, "error: parameter name %s is not recognized\n", parameter_name);
      exit(1);
    }
    if (HP_parameter[index].value_string) {
      fprintf(stderr, "error: duplicate entries for parameter %s\n", parameter_name);
      exit(1);
    }
    SDDS_RemovePadding(ptr);
    cp_str(&HP_parameter[index].value_string, ptr);
  }
 
  if (!SDDS_InitializeOutput(&SDDS_table, SDDS_BINARY, 0, descrip_text, descrip_contents, output))
    SDDS_PrintErrors(stderr, SDDS_EXIT_PrintErrors | SDDS_VERBOSE_PrintErrors);
  if (columnMajorOrder != -1)
    SDDS_table.layout.data_mode.column_major = columnMajorOrder;
 
  index = 0;
  while (HP_parameter[index].HP_name) {
    if (!HP_parameter[index].value_string) {
      index++;
      continue;
    }
    if (strcmp(HP_parameter[index].HP_name, HP_XIncrementName) == 0) {
      if (sscanf(HP_parameter[index].value_string, "%lf", &xIncrement) != 1)
        SDDS_Bomb("unable to scan value for x increment");
    } else if (strcmp(HP_parameter[index].HP_name, HP_XOriginName) == 0) {
      if (sscanf(HP_parameter[index].value_string, "%lf", &xOrigin) != 1)
        SDDS_Bomb("unable to scan value for x origin");
    } else if (strcmp(HP_parameter[index].HP_name, HP_XReferenceName) == 0) {
      if (sscanf(HP_parameter[index].value_string, "%lf", &xReference) != 1)
        SDDS_Bomb("unable to scan value for x reference");
    } else if (strcmp(HP_parameter[index].HP_name, HP_XUnitsName) == 0) {
      xUnits = HP_parameter[index].value_string;
    } else if (strcmp(HP_parameter[index].HP_name, HP_YUnitsName) == 0) {
      yUnits = HP_parameter[index].value_string;
    } else if (strcmp(HP_parameter[index].HP_name, HP_PointsName) == 0) {
      if (sscanf(HP_parameter[index].value_string, "%ld", &points) != 1)
        SDDS_Bomb("unable to scan value for number of points");
    }
    if (SDDS_DefineParameter(&SDDS_table, HP_parameter[index].SDDS_name, NULL, NULL, HP_parameter[index].HP_name, NULL, HP_parameter[index].type, HP_parameter[index].value_string) < 0)
      SDDS_PrintErrors(stderr, SDDS_EXIT_PrintErrors | SDDS_VERBOSE_PrintErrors);
    index++;
  }
 
  if (mpl_title && (SDDS_DefineParameter(&SDDS_table, "mplTitle", NULL, NULL, NULL, NULL, SDDS_STRING, mpl_title) < 0 || SDDS_DefineParameter(&SDDS_table, "mplTopline", NULL, NULL, NULL, NULL, SDDS_STRING, mpl_topline) < 0))
    SDDS_PrintErrors(stderr, SDDS_EXIT_PrintErrors | SDDS_VERBOSE_PrintErrors);
 
  if (SDDS_DefineColumn(&SDDS_table, "t", NULL, xUnits, NULL, NULL, SDDS_DOUBLE, 0) < 0 || SDDS_DefineColumn(&SDDS_table, signal_name, NULL, yUnits, NULL, NULL, SDDS_DOUBLE, 0) < 0 || !SDDS_WriteLayout(&SDDS_table) || !SDDS_StartTable(&SDDS_table, points))
    SDDS_PrintErrors(stderr, SDDS_EXIT_PrintErrors | SDDS_VERBOSE_PrintErrors);
  fflush(SDDS_table.layout.fp);
 
  data = tmalloc(sizeof(*data) * points);
  time = tmalloc(sizeof(*time) * points);
  for (i = 0; i < points; i++) {
    if (!fgets(buffer, BUFSIZE, fpi))
      SDDS_Bomb("insufficient data in input file");
    time[i] = xOrigin + (i - xReference) * xIncrement;
    if (sscanf(buffer, "%lf", data + i) != 1)
      SDDS_Bomb("invalid data in input file");
  }
 
  if (!SDDS_SetColumn(&SDDS_table, SDDS_SET_BY_NAME, time, points, "t") || !SDDS_SetColumn(&SDDS_table, SDDS_SET_BY_NAME, data, points, signal_name) || !SDDS_WriteTable(&SDDS_table) || !SDDS_Terminate(&SDDS_table))
    SDDS_PrintErrors(stderr, SDDS_EXIT_PrintErrors | SDDS_VERBOSE_PrintErrors);
  return (0);
}
 
char *process_column_definition(char **argv, long argc) {
  char buffer[SDDS_MAXLINE], *ptr;
  long i;
 
  if (argc < 1)
    return (NULL);
  sprintf(buffer, "&column name=%s, ", argv[0]);
  for (i = 1; i < argc; i++) {
    if (!strchr(argv[i], '='))
      return (NULL);
    strcat(buffer, argv[i]);
    strcat(buffer, ", ");
  }
  if (!strstr(buffer, "type="))
    strcat(buffer, "type=character ");
  strcat(buffer, "&end");
  cp_str(&ptr, buffer);
  return (ptr);
}