sddsmatrix2column.c File Reference

Detailed Description

Converts a matrix into a single-column SDDS file format.

This program reads an SDDS file containing an optional string column and multiple numerical columns and outputs an SDDS file with two columns: a string column and a data column. The string column is a combination of the input string column (or generated row names) and the input data column names. It supports various options for row names, data column names, and matrix traversal order, making it flexible for diverse data transformation needs.

Usage

sddsmatrix2column [<inputfile>] [<outputfile>]
                  [-pipe=[input][,output]]
                  [-rowNameColumn=<string>] 
                  [-dataColumnName=<string>]
                  [-rootnameColumnName=<string>]
                  [-majorOrder=row|column]

Options

Optional	Description
-pipe	Specifies pipe flags for input and/or output.
-rowNameColumn	Specifies the column name for row names in the input file.
-dataColumnName	Specifies the column name for the data column in the output file.
-rootnameColumnName	Specifies the column name for the string column in the output file.
-majorOrder	Determines the matrix traversal order (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.

Authors

H. Shang, R. Soliday

Definition in file sddsmatrix2column.c.

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

Go to the source code of this file.

Functions
int	main (int argc, char **argv)

Function Documentation

main()

int main	(	int	argc,
		char **	argv )

Definition at line 99 of file sddsmatrix2column.c.

                                {
  SDDS_DATASET SDDS_dataset, SDDS_orig;
  char tmpName[1024];
  long i_arg, tmpfile_used = 0, j, column_major;
  SCANNED_ARG *s_arg;
  int32_t page, numCols, columns, columnType;
  int64_t i, rows, outputRows, outputRow;
  char *inputfile, *outputfile;
  char *rowColName, *dataColName, *rootnameColName, **rowName, **columnName;
  double data;
  unsigned long pipeFlags, majorOrderFlag;
 
  inputfile = outputfile = rowColName = dataColName = rootnameColName = NULL;
  pipeFlags = 0;
  rowName = columnName = NULL;
  majorOrderFlag = 0;
  column_major = 1; /* Default as column major */
 
  SDDS_RegisterProgramName(argv[0]);
  argc = scanargs(&s_arg, argc, argv);
  if (argc < 2) {
    fprintf(stderr, "%s\n", USAGE);
    return 1;
  }
 
  for (i_arg = 1; i_arg < argc; i_arg++) {
    if (s_arg[i_arg].arg_type == OPTION) {
      switch (match_string(s_arg[i_arg].list[0], option, N_OPTIONS, 0)) {
      case SET_MAJOR_ORDER:
        s_arg[i_arg].n_items -= 1;
        if (s_arg[i_arg].n_items > 0 &&
            (!scanItemList(&majorOrderFlag, s_arg[i_arg].list + 1, &s_arg[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)
          column_major = 1;
        if (majorOrderFlag & SDDS_ROW_MAJOR_ORDER)
          column_major = 0;
        break;
      case SET_ROW_COLUMN_NAME:
        if (s_arg[i_arg].n_items != 2) {
          fprintf(stderr, "Error (%s): invalid -rowNameColumn syntax\n", argv[0]);
          return 1;
        }
        rowColName = s_arg[i_arg].list[1];
        break;
      case SET_DATA_COLUMN_NAME:
        if (s_arg[i_arg].n_items != 2) {
          fprintf(stderr, "Error (%s): invalid -dataColumnName syntax\n", argv[0]);
          return 1;
        }
        dataColName = s_arg[i_arg].list[1];
        break;
      case SET_ROOTNAME_COLUMN_NAME:
        if (s_arg[i_arg].n_items != 2) {
          fprintf(stderr, "Error (%s): invalid -rootnameColumnName syntax\n", argv[0]);
          return 1;
        }
        rootnameColName = s_arg[i_arg].list[1];
        break;
      case SET_PIPE:
        if (!processPipeOption(s_arg[i_arg].list + 1, s_arg[i_arg].n_items - 1, &pipeFlags)) {
          fprintf(stderr, "Error (%s): invalid -pipe syntax\n", argv[0]);
          return 1;
        }
        break;
      default:
        fprintf(stderr, "Error: unknown option -- %s provided.\n", s_arg[i_arg].list[0]);
        return 1;
      }
    } else {
      if (inputfile == NULL)
        inputfile = s_arg[i_arg].list[0];
      else if (outputfile == NULL)
        outputfile = s_arg[i_arg].list[0];
      else {
        fprintf(stderr, "Error (%s): too many filenames\n", argv[0]);
        return 1;
      }
    }
  }
 
  if ((!pipeFlags && !outputfile)) {
    fprintf(stderr, "Error: output file not provided.\n");
    return 1;
  }
  processFilenames("sddsmatrix2column", &inputfile, &outputfile, pipeFlags, 0, &tmpfile_used);
 
  numCols = 0;
  if (!SDDS_InitializeInput(&SDDS_orig, inputfile)) {
    SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
    return 1;
  }
  if (!SDDS_InitializeOutput(&SDDS_dataset, SDDS_orig.layout.data_mode.mode, 1, NULL, NULL, outputfile) ||
      !SDDS_DefineSimpleColumn(&SDDS_dataset, rootnameColName ? rootnameColName : "Rootname", NULL, SDDS_STRING) ||
      !SDDS_DefineSimpleColumn(&SDDS_dataset, dataColName ? dataColName : "Data", NULL, SDDS_DOUBLE) ||
      !SDDS_DefineSimpleParameter(&SDDS_dataset, "InputFile", NULL, SDDS_STRING) ||
      !SDDS_WriteLayout(&SDDS_dataset)) {
    SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
    return 1;
  }
  if (!(columnName = (char **)SDDS_GetColumnNames(&SDDS_orig, &columns))) {
    SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
    return 1;
  }
  numCols = 0;
  for (i = 0; i < columns; i++) {
    if (SDDS_NUMERIC_TYPE(columnType = SDDS_GetColumnType(&SDDS_orig, i))) {
      numCols++;
    }
  }
 
  while ((page = SDDS_ReadPage(&SDDS_orig)) > 0) {
    if ((rows = SDDS_CountRowsOfInterest(&SDDS_orig)) < 0) {
      fprintf(stderr, "Error: problem counting rows in input page\n");
      SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
      return 1;
    }
    outputRows = rows * numCols;
    if (!SDDS_StartPage(&SDDS_dataset, outputRows)) {
      fprintf(stderr, "Error: problem starting output page\n");
      SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
      return 1;
    }
    if (rows > 0) {
      if (rowColName) {
        if (SDDS_CheckColumn(&SDDS_orig, rowColName, NULL, SDDS_STRING, NULL) == SDDS_CHECK_OK) {
          rowName = (char **)SDDS_GetColumn(&SDDS_orig, rowColName);
        } else {
          fprintf(stderr, "Error %s column does not exist or not string type in input file %s\n", rowColName, inputfile);
          return 1;
        }
      }
      outputRow = 0;
      if (!column_major) {
        for (i = 0; i < rows; i++) {
          for (j = 0; j < columns; j++) {
            if (SDDS_NUMERIC_TYPE(columnType = SDDS_GetColumnType(&SDDS_orig, j))) {
              if (rowColName) {
                snprintf(tmpName, sizeof(tmpName), "%s%s", rowName[i], SDDS_orig.layout.column_definition[j].name);
              } else {
                snprintf(tmpName, sizeof(tmpName), "Row%" PRId64 "%s", i, SDDS_orig.layout.column_definition[j].name);
              }
              switch (columnType) {
              case SDDS_LONGDOUBLE:
                data = ((long double *)SDDS_orig.data[j])[i];
                break;
              case SDDS_DOUBLE:
                data = ((double *)SDDS_orig.data[j])[i];
                break;
              case SDDS_FLOAT:
                data = ((float *)SDDS_orig.data[j])[i];
                break;
              case SDDS_LONG64:
                data = ((int64_t *)SDDS_orig.data[j])[i];
                break;
              case SDDS_ULONG64:
                data = ((uint64_t *)SDDS_orig.data[j])[i];
                break;
              case SDDS_LONG:
                data = ((int32_t *)SDDS_orig.data[j])[i];
                break;
              case SDDS_ULONG:
                data = ((uint32_t *)SDDS_orig.data[j])[i];
                break;
              case SDDS_SHORT:
                data = ((short *)SDDS_orig.data[j])[i];
                break;
              case SDDS_USHORT:
                data = ((unsigned short *)SDDS_orig.data[j])[i];
                break;
              default:
                data = 0.0; /* Fallback for unsupported types */
              }
 
              if (!SDDS_SetRowValues(&SDDS_dataset, SDDS_SET_BY_INDEX | SDDS_PASS_BY_VALUE, outputRow, 0, tmpName, 1, data, -1)) {
                SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
                return 1;
              }
              outputRow++;
            }
          }
        }
      } else {
        for (j = 0; j < columns; j++) {
          if (!SDDS_NUMERIC_TYPE(columnType = SDDS_GetColumnType(&SDDS_orig, j)))
            continue;
          for (i = 0; i < rows; i++) {
            if (rowColName) {
              snprintf(tmpName, sizeof(tmpName), "%s%s", SDDS_orig.layout.column_definition[j].name, rowName[i]);
            } else {
              snprintf(tmpName, sizeof(tmpName), "%sRow%" PRId64, SDDS_orig.layout.column_definition[j].name, i);
            }
            switch (columnType) {
            case SDDS_LONGDOUBLE:
              data = ((long double *)SDDS_orig.data[j])[i];
              break;
            case SDDS_DOUBLE:
              data = ((double *)SDDS_orig.data[j])[i];
              break;
            case SDDS_FLOAT:
              data = ((float *)SDDS_orig.data[j])[i];
              break;
            case SDDS_LONG64:
              data = ((int64_t *)SDDS_orig.data[j])[i];
              break;
            case SDDS_ULONG64:
              data = ((uint64_t *)SDDS_orig.data[j])[i];
              break;
            case SDDS_LONG:
              data = ((int32_t *)SDDS_orig.data[j])[i];
              break;
            case SDDS_ULONG:
              data = ((uint32_t *)SDDS_orig.data[j])[i];
              break;
            case SDDS_SHORT:
              data = ((short *)SDDS_orig.data[j])[i];
              break;
            case SDDS_USHORT:
              data = ((unsigned short *)SDDS_orig.data[j])[i];
              break;
            default:
              data = 0.0; /* Fallback for unsupported types */
            }
 
            if (!SDDS_SetRowValues(&SDDS_dataset, SDDS_SET_BY_INDEX | SDDS_PASS_BY_VALUE, outputRow, 0, tmpName, 1, data, -1)) {
              SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
              return 1;
            }
            outputRow++;
          }
        }
      }
    }
    if (!SDDS_SetParameters(&SDDS_dataset, SDDS_SET_BY_NAME | SDDS_PASS_BY_VALUE, "InputFile", inputfile ? inputfile : "pipe", NULL) ||
        !SDDS_WritePage(&SDDS_dataset)) {
      fprintf(stderr, "Error: problem writing page to file %s\n", outputfile);
      SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
      return 1;
    }
    if (rowColName) {
      SDDS_FreeStringArray(rowName, rows);
      rowName = NULL;
    }
  }
  if (!SDDS_Terminate(&SDDS_orig) || !SDDS_Terminate(&SDDS_dataset)) {
    SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
    return 1;
  }
  if (tmpfile_used && !replaceFileAndBackUp(inputfile, outputfile)) {
    return 1;
  }
 
  free_scanargs(&s_arg, argc);
  return 0;
}