citi2sdds.c File Reference

Detailed Description

Converts a data file from Hewlett-Packard/Keysight Technologies' CITI format to SDDS format.

This program reads a waveform data file in Hewlett-Packard/Keysight Technologies' CITI format (Common Instrumentation Transfer and Interchange file) and converts it into the SDDS (Self Describing Data Sets) format. It supports various options to customize the output, including setting descriptions, MPL labels, and specifying the major order of data.

Usage

citi2sdds <inputfile> <outputfile>
          [-description=<text>,<contents>]
          [-mpllabels=<title>,<topline>] 
          [-majorOrder=row|column]

Options

Optional	Description
-description	Adds a description text and content to the SDDS output file.
-mpllabels	Sets MPL (Matplotlib) title and top-line labels for the SDDS output.
-majorOrder	Specifies the major order of data in the SDDS output. Defaults to row-major order.

Incompatibilities

• Only one of the following options may be specified:
  • -description
  • -mpllabels

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

Definition in file citi2sdds.c.

#include "mdb.h"
#include "SDDS.h"
#include "scan.h"
#include "match_string.h"

Go to the source code of this file.

Functions
long	read_CITI_var_list (FILE *fpi, double *var_list, long points)
long	read_CITI_data (FILE *fpi, double *real_data, double *imag_data, long points)
long	read_CITI_seg_list (FILE *fpi, double *seg_list, long points)
void	alter_data_name (char *name)
int	main (int argc, char **argv)
char *	process_column_definition (char **argv, long argc)

Function Documentation

alter_data_name()

void alter_data_name

(

char *

name

)

Definition at line 456 of file citi2sdds.c.

                                 {
  char *ptr;
  if ((ptr = strchr(name, '[')))
    strcpy_ss(ptr, ptr + 1);
  if ((ptr = strchr(name, ']')))
    strcpy_ss(ptr, ptr + 1);
  if ((ptr = strchr(name, ',')))
    strcpy_ss(ptr, ptr + 1);
}

main()

int main	(	int	argc,
		char **	argv )

Definition at line 99 of file citi2sdds.c.

                                {
  SDDS_TABLE SDDS_table;
  SCANNED_ARG *scanned;
  long i, i_arg, points;
  char *input, *output, *name, *indep_var, *var_list_format;
  char *mpl_title, *mpl_topline, *descrip_text, *descrip_contents;
  FILE *fpi;
  char buffer[BUFSIZE], buffer0[BUFSIZE], buffer1[BUFSIZE];
  char *ptr, *ptr1, *ptr2;
  char **data_name, *package_name, *data_format;
  long data_names, data_sets_seen, data_sets_expected, realIndex, imagIndex;
  double **real_data, **imag_data, *var_list;
  unsigned long majorOrderFlag;
  short columnMajorOrder = 0;
 
  argc = scanargs(&scanned, argc, argv);
  if (argc < 3) {
    fprintf(stderr, "%s", USAGE);
    return EXIT_FAILURE;
  }
 
  input = output = package_name = data_format = indep_var = var_list_format = ptr = NULL;
  mpl_title = mpl_topline = descrip_text = descrip_contents = NULL;
  data_names = realIndex = imagIndex = 0;
  data_name = NULL;
  real_data = imag_data = NULL;
  var_list = NULL;
  data_sets_expected = data_sets_seen = 0;
  points = 0;
 
  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_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");
  }
 
  fpi = fopen_e(input, "r", 0);
  if (!fgets(buffer, BUFSIZE, fpi) || strncmp(buffer, CITIFILE_TAG, strlen(CITIFILE_TAG)) != 0 || !(ptr = strchr(buffer, ' '))) {
    SDDS_Bomb("valid CITIFILE version line not found");
  }
  *ptr++ = 0;
  ptr[strlen(ptr) - 1] = 0;
  if (strncmp(ptr, CITIFILE_VERSION, strlen(CITIFILE_VERSION)) != 0)
    fprintf(stderr, "warning: the CITIFILE version is %s--this program is only designed for version %s\n", ptr, CITIFILE_VERSION);
 
  if (!SDDS_InitializeOutput(&SDDS_table, SDDS_BINARY, 0, descrip_text, descrip_contents, output))
    SDDS_PrintErrors(stderr, SDDS_EXIT_PrintErrors | SDDS_VERBOSE_PrintErrors);
  SDDS_table.layout.data_mode.column_major = columnMajorOrder;
  if ((mpl_title && SDDS_DefineParameter(&SDDS_table, "mplTitle", NULL, NULL, NULL, NULL, SDDS_STRING, mpl_title) < 0) ||
      (mpl_topline && SDDS_DefineParameter(&SDDS_table, "mplTopline", NULL, NULL, NULL, NULL, SDDS_STRING, mpl_topline) < 0))
    SDDS_PrintErrors(stderr, SDDS_EXIT_PrintErrors | SDDS_VERBOSE_PrintErrors);
 
  while (fgets(buffer, BUFSIZE, fpi)) {
#if DEBUG
    fputs(buffer, stderr);
#endif
    buffer[strlen(buffer) - 1] = 0;
    strcpy(buffer0, buffer);
    ptr1 = NULL;
    if ((ptr1 = strchr(buffer, ' ')))
      *ptr1++ = 0;
    switch (match_string(buffer, citi_keyword, N_CITI_KEYWORDS, EXACT_MATCH)) {
    case CITI_NA_KEYWORD:
      name = buffer + 1;
      if (!*ptr1 || !(ptr2 = strchr(ptr1, ' '))) {
        fprintf(stderr, "The following line contains an apparently invalid #NA keyword:\n%s\n", buffer0);
        return EXIT_FAILURE;
      }
      *(ptr1 - 1) = '_';
      *ptr2++ = 0;
      if (SDDS_DefineParameter(&SDDS_table, name, NULL, NULL, NULL, NULL, SDDS_STRING, ptr2) < 0) {
        SDDS_SetError(buffer0);
        SDDS_SetError("Problem creating parameter for #NA keyword in the following line:");
        SDDS_PrintErrors(stderr, SDDS_EXIT_PrintErrors | SDDS_VERBOSE_PrintErrors);
      }
      break;
    case CITI_NAME_KEYWORD:
      if (!ptr1 || SDDS_StringIsBlank(ptr1)) {
        fprintf(stderr, "The following line contains erroneous input:\n%s\n", buffer0);
        return EXIT_FAILURE;
      }
#if DEBUG
      fprintf(stderr, "NAME: %s\n", ptr1);
#endif
      cp_str(&package_name, ptr1);
      if (SDDS_DefineParameter(&SDDS_table, "CITIPackageName", NULL, NULL, NULL, NULL, SDDS_STRING, package_name) < 0) {
        SDDS_SetError(buffer0);
        SDDS_SetError("Problem creating parameter for NAME keyword in the following line:");
        SDDS_PrintErrors(stderr, SDDS_EXIT_PrintErrors | SDDS_VERBOSE_PrintErrors);
      }
      break;
    case CITI_VAR_KEYWORD:
      if (!ptr1 || SDDS_StringIsBlank(ptr1)) {
        fprintf(stderr, "The following line contains erroneous input:\n%s\n", buffer0);
        return EXIT_FAILURE;
      }
#if DEBUG
      fprintf(stderr, "VAR: %s\n", ptr1);
#endif
      if (!(indep_var = get_token(ptr1)) || !(var_list_format = get_token(ptr1)) || !get_long(&points, ptr1) || points <= 0) {
        fprintf(stderr, "The following line contains erroneous input:\n%s\n", buffer0);
        return EXIT_FAILURE;
      }
      if (SDDS_DefineColumn(&SDDS_table, indep_var, NULL, NULL, NULL, NULL, SDDS_DOUBLE, 0) < 0) {
        SDDS_SetError(buffer0);
        SDDS_SetError("Problem creating column for data element in the following line:");
        SDDS_PrintErrors(stderr, SDDS_EXIT_PrintErrors | SDDS_VERBOSE_PrintErrors);
      }
      break;
    case CITI_CONSTANT_KEYWORD:
      if (!ptr1 || !(ptr2 = strchr(ptr1, ' '))) {
        fprintf(stderr, "The following line contains erroneous input:\n%s\n", buffer0);
        return EXIT_FAILURE;
      }
#if DEBUG
      fprintf(stderr, "CONSTANT: %s\n", ptr1);
#endif
      *ptr2++ = 0;
      if (SDDS_DefineParameter(&SDDS_table, ptr1, NULL, NULL, NULL, NULL, SDDS_STRING, ptr2) < 0) {
        SDDS_SetError(buffer0);
        SDDS_SetError("Problem creating parameter for CONSTANT keyword in the following line:");
        SDDS_PrintErrors(stderr, SDDS_EXIT_PrintErrors | SDDS_VERBOSE_PrintErrors);
      }
      break;
    case CITI_COMMENT_KEYWORD:
      if (!ptr1 || SDDS_StringIsBlank(ptr1)) {
        fprintf(stderr, "The following line contains erroneous input:\n%s\n", buffer0);
        return EXIT_FAILURE;
      }
#if DEBUG
      fprintf(stderr, "COMMENT: %s\n", ptr1);
#endif
      break;
    case CITI_DATA_KEYWORD:
      if (!ptr1 || !(ptr2 = strchr(ptr1, ' '))) {
        fprintf(stderr, "The following line contains erroneous input:\n%s\n", buffer0);
        return EXIT_FAILURE;
      }
#if DEBUG
      fprintf(stderr, "DATA: %s\n", ptr1);
#endif
      *ptr2++ = 0;
      cp_str(&data_format, ptr2);
      data_name = trealloc(data_name, sizeof(*data_name) * (data_names + 1));
      cp_str(data_name + data_names, ptr1);
      alter_data_name(data_name[data_names]);
      real_data = trealloc(real_data, sizeof(*real_data) * (data_names + 1));
      imag_data = trealloc(imag_data, sizeof(*imag_data) * (data_names + 1));
      sprintf(buffer, "%sReal", data_name[data_names]);
      sprintf(buffer1, "%sImag", data_name[data_names]);
      if ((realIndex = SDDS_DefineColumn(&SDDS_table, buffer, NULL, NULL, NULL, NULL, SDDS_DOUBLE, 0)) < 0 ||
          (imagIndex = SDDS_DefineColumn(&SDDS_table, buffer1, NULL, NULL, NULL, NULL, SDDS_DOUBLE, 0)) < 0) {
        SDDS_SetError(buffer0);
        SDDS_SetError("Problem creating column for data element in the following line:");
        SDDS_PrintErrors(stderr, SDDS_EXIT_PrintErrors | SDDS_VERBOSE_PrintErrors);
      }
      data_names++;
      break;
    case CITI_VAR_LIST_KEYWORD:
      if (ptr1 && !SDDS_StringIsBlank(ptr1)) {
        fprintf(stderr, "The following line contains erroneous input:\n%s\n", buffer0);
        return EXIT_FAILURE;
      }
#if DEBUG
      fprintf(stderr, "VAR_LIST_BEGIN seen\n");
#endif
      if (points == 0)
        SDDS_Bomb("VAR_LIST_BEGIN statement seen without prior VAR statement");
      var_list = tmalloc(sizeof(*var_list) * points);
      if (!read_CITI_var_list(fpi, var_list, points))
        SDDS_Bomb("unable to read VAR_LIST");
      break;
    case CITI_BEGIN_KEYWORD:
      if (ptr1 && !SDDS_StringIsBlank(ptr1)) {
        fprintf(stderr, "The following line contains erroneous input:\n%s\n", buffer0);
        return EXIT_FAILURE;
      }
#if DEBUG
      fprintf(stderr, "BEGIN seen\n");
#endif
      if (points == 0)
        SDDS_Bomb("BEGIN statement seen without prior VAR statement");
      real_data[data_sets_seen] = tmalloc(sizeof(**real_data) * points);
      imag_data[data_sets_seen] = tmalloc(sizeof(**imag_data) * points);
      if (!read_CITI_data(fpi, real_data[data_sets_seen], imag_data[data_sets_seen], points))
        SDDS_Bomb("problem reading data section");
      data_sets_seen++;
      break;
    case CITI_SEG_LIST_BEGIN:
      if (ptr1 && !SDDS_StringIsBlank(ptr1)) {
        fprintf(stderr, "The following line contains erroneous input:\n%s\n", buffer0);
        return EXIT_FAILURE;
      }
#if DEBUG
      fprintf(stderr, "SEG_LIST_BEGIN seen\n");
#endif
      if (points == 0)
        SDDS_Bomb("SEG_LIST_BEGIN statement seen without prior SEG statement");
      var_list = tmalloc(sizeof(*var_list) * points);
      if (!read_CITI_seg_list(fpi, var_list, points))
        SDDS_Bomb("unable to read SEG_LIST");
      break;
    default:
      fprintf(stderr, "Unidentifiable line in file--not CITI format:\n\"%s\"\n", buffer0);
      return EXIT_FAILURE;
      break;
    }
  }
  if (!points)
    SDDS_Bomb("no data in file");
  if (data_sets_seen != (data_sets_expected = data_names))
    SDDS_Bomb("fewer data sets than expected were actually present");
  if (!var_list) {
    fprintf(stderr, "warning: no independent variable data---supplying index\n");
    var_list = tmalloc(sizeof(*var_list) * points);
    for (i = 0; i < points; i++)
      var_list[i] = i;
  }
  if (!SDDS_WriteLayout(&SDDS_table) || !SDDS_StartTable(&SDDS_table, points))
    SDDS_PrintErrors(stderr, SDDS_EXIT_PrintErrors | SDDS_VERBOSE_PrintErrors);
  if (!SDDS_SetColumn(&SDDS_table, SDDS_SET_BY_NAME, (void *)var_list, points, indep_var))
    SDDS_PrintErrors(stderr, SDDS_EXIT_PrintErrors | SDDS_VERBOSE_PrintErrors);
  for (i = 0; i < data_sets_expected; i++) {
    if (!SDDS_SetColumn(&SDDS_table, SDDS_SET_BY_INDEX, (void *)real_data[i], points, realIndex) ||
        !SDDS_SetColumn(&SDDS_table, SDDS_SET_BY_INDEX, (void *)imag_data[i], points, imagIndex)) {
      fprintf(stderr, "Problem setting data for column(s) %s\n", data_name[i]);
      SDDS_PrintErrors(stderr, SDDS_EXIT_PrintErrors | SDDS_VERBOSE_PrintErrors);
    }
  }
  if (!SDDS_WriteTable(&SDDS_table) || !SDDS_Terminate(&SDDS_table))
    SDDS_PrintErrors(stderr, SDDS_EXIT_PrintErrors | SDDS_VERBOSE_PrintErrors);
 
  return EXIT_SUCCESS;
}

process_column_definition()

char * process_column_definition	(	char **	argv,
		long	argc )

Definition at line 378 of file citi2sdds.c.

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

read_CITI_data()

long read_CITI_data	(	FILE *	fpi,
		double *	real_data,
		double *	imag_data,
		long	points )

Definition at line 416 of file citi2sdds.c.

                                                                                  {
  long i;
  char buffer[BUFSIZE];
 
  i = 0;
  while (fgets(buffer, BUFSIZE, fpi) && i < points) {
    buffer[strlen(buffer) - 1] = 0;
    if (strcmp(buffer, "END") == 0)
      break;
    if (!get_double(real_data + i, buffer) || !get_double(imag_data + i, buffer))
      return (0);
    i++;
  }
  if (i != points)
    return (0);
  return (1);
}

read_CITI_seg_list()

long read_CITI_seg_list	(	FILE *	fpi,
		double *	seg_list,
		long	points )

Definition at line 434 of file citi2sdds.c.

                                                                  {
  char buffer[BUFSIZE];
  long i;
  double start, end, delta;
 
  if (!fgets(buffer, BUFSIZE, fpi) || !get_double(&start, buffer) || !get_double(&end, buffer) || !get_long(&i, buffer))
    return (0);
  if (i != points)
    return (0);
  delta = (end - start) / (points - 1);
 
  if (!fgets(buffer, BUFSIZE, fpi))
    return (0);
  buffer[strlen(buffer) - 1] = 0;
  if (strcmp(buffer, "SEG_LIST_END") != 0)
    return (0);
 
  for (i = 0; i < points; i++)
    seg_list[i] = start + i * delta;
  return (1);
}

read_CITI_var_list()

long read_CITI_var_list	(	FILE *	fpi,
		double *	var_list,
		long	points )

Definition at line 398 of file citi2sdds.c.

                                                                  {
  long i;
  char buffer[BUFSIZE];
 
  i = 0;
  while (fgets(buffer, BUFSIZE, fpi) && i < points) {
    buffer[strlen(buffer) - 1] = 0;
    if (strcmp(buffer, "VAR_LIST_END") == 0)
      break;
    if (!get_double(var_list + i, buffer))
      return (0);
    i++;
  }
  if (i != points)
    return (0);
  return (1);
}