mpl2sdds.c File Reference

Detailed Description

Converts M. Borland's older mpl (Multi-Purpose Library) files into a single SDDS file.

This program processes multiple mpl (Multi-Purpose Library) files and consolidates their data into a single SDDS (Self Describing Data Set) file. It supports both ASCII and binary formats for the output SDDS file and provides options to overwrite existing data or create a new file.

The program ensures consistent formatting of the resulting SDDS file, handling cases such as differing numbers of rows in input files or existing data conflicts.

Usage

mpl2sdds <mpl-filename> [<mpl-filename>...] -output=<SDDS-filename> [-erase] [-binary]

Options

Required	Description
-output	Specifies the output SDDS file.

Optional	Description
-erase	Erase existing data in the output SDDS file before adding new data.
-binary	Write the SDDS file in binary format instead of ASCII.

Incompatibilities

• -erase is incompatible with loading existing data from the specified output file.

Requirements

• Input MPL files must have matching numbers of rows.

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.

Authors

M. Borland, C. Saunders, R. Soliday

Definition in file mpl2sdds.c.

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

Go to the source code of this file.

Functions
void	extract_name_and_unit (char **name, char **unit, char *label)
long	add_definition (SDDS_DATASET *SDDS_dataset, char *label, char *filename)
void	fix_mpl_name (char *name)
int	main (int argc, char **argv)

Function Documentation

add_definition()

long add_definition	(	SDDS_DATASET *	SDDS_dataset,
		char *	label,
		char *	filename )

Definition at line 226 of file mpl2sdds.c.

                                                                             {
  char *symbol, *name, *unit;
  long index;
 
  extract_name_and_unit(&symbol, &unit, label);
  SDDS_CopyString(&name, symbol);
  fix_mpl_name(name);
 
  if (SDDS_GetColumnIndex(SDDS_dataset, name) >= 0) {
    fprintf(stderr, "Warning: Column name '%s' from file '%s' already exists and will be ignored.\n", name, filename);
    return -1;
  }
 
  if ((index = SDDS_DefineColumn(SDDS_dataset, name, symbol, unit, NULL, NULL, SDDS_DOUBLE, 0)) < 0) {
    SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
    return -1;
  }
 
  return index;
}

extract_name_and_unit()

void extract_name_and_unit	(	char **	name,
		char **	unit,
		char *	label )

Definition at line 247 of file mpl2sdds.c.

                                                                  {
  char *ptr, *uptr;
 
  if ((uptr = strchr(label, '('))) {
    *uptr++ = '\0';
    if ((ptr = strchr(uptr, ')'))) {
      *ptr = '\0';
    }
    SDDS_CopyString(unit, uptr);
  } else {
    *unit = NULL;
  }
 
  /* Trim trailing spaces from label */
  ptr = label + strlen(label) - 1;
  while (ptr != label && *ptr == ' ') {
    *ptr-- = '\0';
  }
  SDDS_CopyString(name, label);
}

fix_mpl_name()

void fix_mpl_name

(

char *

name

)

Definition at line 268 of file mpl2sdds.c.

                              {
  char *ptr, *ptr1;
 
  ptr = name;
  while ((ptr = strchr(ptr, '$'))) {
    switch (*(ptr + 1)) {
    case 'a':
    case 'b':
    case 'n':
    case 'g':
    case 'r':
    case 's':
    case 'e':
      strcpy_ss(ptr, ptr + 2);
      break;
    default:
      ptr += 1;
      break;
    }
  }
 
  ptr = name;
  while ((ptr = strchr(ptr, ' '))) {
    ptr1 = ptr;
    while (*ptr1 == ' ') {
      ptr1++;
    }
    strcpy_ss(ptr, ptr1);
  }
}

main()

int main	(	int	argc,
		char **	argv )

Definition at line 81 of file mpl2sdds.c.

                                {
  SDDS_DATASET SDDS_dataset;
  TABLE *mpl_data;
  SCANNED_ARG *scanned;
  char **input;
  long i, j, i_arg, inputs;
  char *output;
  long erase, rows, new_columns, SDDS_rows;
  double **data;
  long *index;
  long binary;
 
  SDDS_RegisterProgramName(argv[0]);
  argc = scanargs(&scanned, argc, argv);
  if (argc < 3) {
    bomb(NULL, USAGE);
  }
 
  input = NULL;
  output = NULL;
  inputs = erase = binary = 0;
 
  for (i_arg = 1; i_arg < argc; i_arg++) {
    if (scanned[i_arg].arg_type == OPTION) {
      /* Process options here */
      switch (match_string(scanned[i_arg].list[0], option, N_OPTIONS, 0)) {
      case SET_ERASE:
        erase = 1;
        break;
      case SET_OUTPUT:
        if (scanned[i_arg].n_items != 2) {
          bomb("Invalid syntax for -output option.", USAGE);
        }
        output = scanned[i_arg].list[1];
        break;
      case SET_BINARY:
        if (scanned[i_arg].n_items != 1) {
          bomb("Invalid syntax for -binary option.", USAGE);
        }
        binary = 1;
        break;
      default:
        bomb("Unknown option provided.", USAGE);
      }
    } else {
      input = trealloc(input, (inputs + 1) * sizeof(*input));
      input[inputs++] = scanned[i_arg].list[0];
    }
  }
 
  if (!output) {
    bomb("The -output option must be specified.", USAGE);
  }
  if (!input) {
    bomb("No input MPL files provided.", USAGE);
  }
 
  if (!erase && fexists(output)) {
    /* Load data from existing file */
    if (!SDDS_InitializeInput(&SDDS_dataset, output)) {
      fprintf(stderr, "Error: Unable to read SDDS layout from %s.\n", output);
      SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
      return EXIT_FAILURE;
    }
    if (!SDDS_ReadPage(&SDDS_dataset)) {
      fprintf(stderr, "Error: Unable to read data table from %s.\n", output);
      SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
      return EXIT_FAILURE;
    }
    SDDS_rows = SDDS_CountRowsOfInterest(&SDDS_dataset);
    fclose(SDDS_dataset.layout.fp);
    SDDS_dataset.layout.fp = fopen_e(output, "w", 0);
  } else {
    /* Start a new file */
    if (!SDDS_InitializeOutput(&SDDS_dataset, binary ? SDDS_BINARY : SDDS_ASCII, 1, NULL, NULL, output)) {
      fprintf(stderr, "Error: Unable to initialize output SDDS structure for %s.\n", output);
      SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
      return EXIT_FAILURE;
    }
    SDDS_rows = -1;
  }
 
  rows = 0;
  mpl_data = tmalloc(sizeof(*mpl_data) * inputs);
  data = tmalloc(sizeof(*data) * (2 * inputs));
  index = tmalloc(sizeof(*index) * (2 * inputs));
  new_columns = 0;
 
  for (i = 0; i < inputs; i++) {
    if (!get_table(&mpl_data[i], input[i], 1, 0)) {
      fprintf(stderr, "Warning: Unable to read data from %s. Continuing with other files.\n", input[i]);
      continue;
    }
 
    if (!rows) {
      if (!(rows = mpl_data[i].n_data)) {
        fprintf(stderr, "Warning: No data in file %s. Continuing with other files.\n", input[i]);
        continue;
      }
    } else if (rows != mpl_data[i].n_data) {
      SDDS_Bomb("All MPL files must have the same number of data points.");
    } else if (SDDS_rows != -1 && rows != SDDS_rows) {
      SDDS_Bomb("Number of data points in MPL files must match the number of rows in the SDDS file.");
    }
 
    if ((index[new_columns] = add_definition(&SDDS_dataset, mpl_data[i].xlab, input[i])) < 0) {
      free(mpl_data[i].c1);
    } else {
      data[new_columns++] = mpl_data[i].c1;
    }
 
    if ((index[new_columns] = add_definition(&SDDS_dataset, mpl_data[i].ylab, input[i])) < 0) {
      free(mpl_data[i].c2);
    } else {
      data[new_columns++] = mpl_data[i].c2;
    }
  }
 
  if (!rows || !new_columns) {
    SDDS_Bomb("All input files are empty or invalid.");
  }
 
  if (!SDDS_WriteLayout(&SDDS_dataset)) {
    SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
    return EXIT_FAILURE;
  }
  if (!SDDS_StartPage(&SDDS_dataset, rows)) {
    SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
    return EXIT_FAILURE;
  }
 
  for (i = 0; i < new_columns; i++) {
    for (j = 0; j < rows; j++) {
      SDDS_SetRowValues(&SDDS_dataset, SDDS_SET_BY_INDEX | SDDS_PASS_BY_VALUE, j, index[i], data[i][j], -1);
    }
  }
 
  if (!SDDS_WritePage(&SDDS_dataset)) {
    SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
    return EXIT_FAILURE;
  }
 
  return EXIT_SUCCESS;
}