hpwf2sdds.c

Go to the documentation of this file.

/**
 * @file hpwf2sdds.c
 * @brief Converts waveform data from the older HP oscilloscope's verbose format to SDDS (Self Describing Data Sets) format.
 *
 * This program reads a waveform from an HP scope output file and converts it into the SDDS format,
 * which is widely used for storing and sharing scientific data. The user can specify various
 * options to customize the conversion process, including setting signal names, descriptions,
 * MPL (Matplotlib) labels, and the major order of data storage.
 *
 * ## Usage
 *
 * ```
 * hpwf2sdds <inputfile> <outputfile> [options]
 * ```
 *
 * - `<inputfile>`: Path to the input file containing the HP waveform data.
 * - `<outputfile>`: Path where the converted SDDS file will be saved.
 *
 * ## Options
 *
 * - `-signalname=<name>`: Specifies the name of the signal in the SDDS file.
 * - `-description=<text>,<contents>`: Provides a description for the SDDS data set.
 * - `-mpllabels=<title>,<topline>`: Sets the title and topline labels for MPL (Matplotlib) plots.
 * - `-majorOrder=row|column`: Determines the major order of data storage, either row-major or column-major.
 *
 * @copyright
 *   - (c) 2002 The University of Chicago, as Operator of Argonne National Laboratory.
 *   - (c) 2002 The Regents of the University of California, as Operator of Los Alamos National Laboratory.
 *
 * @license
 * This file is distributed under the terms of the Software License Agreement
 * found in the file LICENSE included with this distribution.
 *
 * @author M. Borland, C. Saunders, R. Soliday, H. Shang
 */
 
#include "mdb.h"
#include "SDDS.h"
#include "scan.h"
#include "match_string.h"
 
/* Enumeration for option types */
enum option_type {
  SET_SIGNAL_NAME,
  SET_DESCRIPTION,
  SET_MPL_LABELS,
  SET_MAJOR_ORDER,
  N_OPTIONS
};
 
static char *option[N_OPTIONS] = {
  "signalname", "description", "mpllabels", "majorOrder"};
 
char *USAGE =
  "Usage: hpwf2sdds <inputfile> <outputfile> [options]\n"
  "\n"
  "Options:\n"
  "  -signalname=<name>                 Specify the signal name in the SDDS file.\n"
  "  -description=<text>,<contents>     Provide a description for the SDDS data set.\n"
  "  -mpllabels=<title>,<topline>       Set the title and topline labels for MPL plots.\n"
  "  -majorOrder=row|column              Set the major order of data storage.\n"
  "\n"
  "Example:\n"
  "  hpwf2sdds waveform.txt waveform.sdds -signalname=Voltage -description=\"Test Signal\",\"Generated by HP oscilloscope\" \\\n"
  "              -mpllabels=\"Voltage Signal\",\"Time (s)\" -majorOrder=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;      /* Name of the parameter in HP format */
  char *SDDS_name;    /* Corresponding name in SDDS format */
  char *value_string; /* Value as a string */
  long type;          /* Data type in SDDS format */
} HP_PARAMETER;
typedef struct  {…};
 
#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) {
    fprintf(stderr, "Error: Insufficient arguments provided.\n\n%s", USAGE);
    return EXIT_FAILURE;
  }
 
  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)) {
          fprintf(stderr, "Error: Invalid syntax or value for -majorOrder option.\n");
          return EXIT_FAILURE;
        }
        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) {
          fprintf(stderr, "Error: Invalid syntax for -signalname option.\n");
          return EXIT_FAILURE;
        }
        signal_name = scanned[i_arg].list[1];
        break;
      case SET_DESCRIPTION:
        if (scanned[i_arg].n_items != 3) {
          fprintf(stderr, "Error: Invalid syntax for -description option.\n");
          return EXIT_FAILURE;
        }
        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) {
          fprintf(stderr, "Error: Invalid syntax for -mpllabels option.\n");
          return EXIT_FAILURE;
        }
        mpl_title = scanned[i_arg].list[1];
        mpl_topline = scanned[i_arg].list[2];
        break;
      default:
        fprintf(stderr, "Error: Unrecognized option '%s'.\n", scanned[i_arg].list[0]);
        return EXIT_FAILURE;
      }
    } else {
      if (!input)
        input = scanned[i_arg].list[0];
      else if (!output)
        output = scanned[i_arg].list[0];
      else {
        fprintf(stderr, "Error: Too many filenames provided.\n");
        return EXIT_FAILURE;
      }
    }
  }
 
  if (!input) {
    fprintf(stderr, "Error: Input file not specified.\n\n%s", USAGE);
    return EXIT_FAILURE;
  }
  if (!output) {
    fprintf(stderr, "Error: Output file not specified.\n\n%s", USAGE);
    return EXIT_FAILURE;
  }
  if (!signal_name) {
    fprintf(stderr, "Error: -signalname option not specified.\n\n%s", USAGE);
    return EXIT_FAILURE;
  }
 
  fpi = fopen_e(input, "r", 0);
  parameter_name = buffer;
  while (fgets(buffer, BUFSIZE, fpi)) {
    if (!(ptr = strchr(buffer, ':'))) {
      fprintf(stderr, "Error: Missing colon in parameter tag '%s'.\n", buffer);
      return EXIT_FAILURE;
    }
    *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: Unrecognized parameter name '%s'.\n", parameter_name);
      return EXIT_FAILURE;
    }
    if (HP_parameter[index].value_string) {
      fprintf(stderr, "Error: Duplicate entry for parameter '%s'.\n", parameter_name);
      return EXIT_FAILURE;
    }
    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_VERBOSE_PrintErrors);
    return EXIT_FAILURE;
  }
  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) {
        fprintf(stderr, "Error: Unable to parse value for X increment.\n");
        return EXIT_FAILURE;
      }
    } else if (strcmp(HP_parameter[index].HP_name, HP_XOriginName) == 0) {
      if (sscanf(HP_parameter[index].value_string, "%lf", &xOrigin) != 1) {
        fprintf(stderr, "Error: Unable to parse value for X origin.\n");
        return EXIT_FAILURE;
      }
    } else if (strcmp(HP_parameter[index].HP_name, HP_XReferenceName) == 0) {
      if (sscanf(HP_parameter[index].value_string, "%lf", &xReference) != 1) {
        fprintf(stderr, "Error: Unable to parse value for X reference.\n");
        return EXIT_FAILURE;
      }
    } 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) {
        fprintf(stderr, "Error: Unable to parse value for number of points.\n");
        return EXIT_FAILURE;
      }
    }
    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_VERBOSE_PrintErrors);
      return EXIT_FAILURE;
    }
    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_VERBOSE_PrintErrors);
    return EXIT_FAILURE;
  }
 
  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_VERBOSE_PrintErrors);
    return EXIT_FAILURE;
  }
  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)) {
      fprintf(stderr, "Error: Insufficient data in input file.\n");
      return EXIT_FAILURE;
    }
    time[i] = xOrigin + (i - xReference) * xIncrement;
    if (sscanf(buffer, "%lf", &data[i]) != 1) {
      fprintf(stderr, "Error: Invalid data format in input file at line %ld.\n", i + 1);
      return EXIT_FAILURE;
    }
  }
 
  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_VERBOSE_PrintErrors);
    return EXIT_FAILURE;
  }
 
  free(data);
  free(time);
  fclose(fpi);
  return EXIT_SUCCESS;
}
 
char *process_column_definition(char **argv, long argc) {
  char buffer[SDDS_MAXLINE], *ptr;
  long i;
 
  if (argc < 1)
    return NULL;
  snprintf(buffer, sizeof(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;
}