sddssplit.c File Reference

Utility for splitting SDDS files into multiple files, one page per file. More...

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

Go to the source code of this file.

Enumerations
enum	option_type {   SET_BINARY , SET_ASCII , SET_DIGITS , SET_ROOTNAME ,   SET_FIRST_PAGE , SET_LAST_PAGE , SET_INTERVAL , SET_EXTENSION ,   SET_PIPE , SET_NAMEPARAMETER , SET_OFFSET , SET_MAJOR_ORDER ,   SET_GROUPPARAMETER , N_OPTIONS }

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

Variables
static char *	option [N_OPTIONS]
static char *	USAGE

Detailed Description

Utility for splitting SDDS files into multiple files, one page per file.

This program reads an SDDS (Self Describing Data Set) file and splits its contents into multiple files, with each page saved as a separate SDDS file. It supports both binary and ASCII output formats and allows customization of output filenames using various parameters.

Features:

• Splits an SDDS file into multiple output files based on pages.
• Allows customization of output filenames via rootname, digits, and extension.
• Supports grouping pages using a specified parameter.
• Provides options for setting the output file format (binary or ASCII).
• Supports row-major and column-major order for output.

Command-line Options:

• -binary, -ascii: Specify the output format.
• -digits=<number>: Number of digits in the output filename indices.
• -rootname=<string>: Rootname for output filenames.
• -firstPage=<number>: First page of the input file to include.
• -lastPage=<number>: Last page of the input file to include.
• -interval=<number>: Interval between pages to include in output.
• -extension=<string>: Extension for output files (default is "sdds").
• -groupParameter=<parameterName>: Parameter for grouping pages into output files.
• -nameParameter=<filenameParameter>: Parameter for naming output files.
• -offset=<integer>: Offset for computing output filename indices.
• -majorOrder=row|column: Select output order (row-major or column-major).

Usage Example:

sddssplit input.sdds -binary -rootname=output -digits=4 -firstPage=1 -interval=2

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 sddssplit.c.

Enumeration Type Documentation

option_type

enum option_type

Definition at line 51 of file sddssplit.c.

             {
  SET_BINARY,
  SET_ASCII,
  SET_DIGITS,
  SET_ROOTNAME,
  SET_FIRST_PAGE,
  SET_LAST_PAGE,
  SET_INTERVAL,
  SET_EXTENSION,
  SET_PIPE,
  SET_NAMEPARAMETER,
  SET_OFFSET,
  SET_MAJOR_ORDER,
  SET_GROUPPARAMETER,
  N_OPTIONS
} option_type;

Function Documentation

main()

int main	(	int	argc,
		char **	argv )

Definition at line 118 of file sddssplit.c.

                                {
  SDDS_DATASET sdds_dataset, sdds_orig;
  long i_arg, offset = 0;
  SCANNED_ARG *s_arg;
  char *input = NULL, *rootname = NULL, name[500], format[100], *extension = "sdds";
  long ascii_output = 0, binary_output = 0, retval, digits = 3;
  long first_page = 0, last_page = 0, interval = 0;
  unsigned long pipe_flags = 0, major_order_flag = 0;
  char *file_parameter = NULL, *name_from_parameter = NULL, *group_parameter_name = NULL;
  char *last_group_parameter = NULL, *this_group_parameter = NULL;
  short column_major_order = -1, file_active = 0;
 
  SDDS_RegisterProgramName(argv[0]);
  argc = scanargs(&s_arg, argc, argv);
  if (argc < 2) {
    fprintf(stderr, "%s", USAGE);
    return 1;
  }
 
  for (i_arg = 1; i_arg < argc; i_arg++) {
    if (s_arg[i_arg].arg_type == OPTION) {
      delete_chars(s_arg[i_arg].list[0], "_");
      switch (match_string(s_arg[i_arg].list[0], option, N_OPTIONS, 0)) {
      case SET_MAJOR_ORDER:
        major_order_flag = 0;
        s_arg[i_arg].n_items--;
        if (s_arg[i_arg].n_items > 0 &&
            !scanItemList(&major_order_flag, 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)) {
          fprintf(stderr, "Error: Invalid -majorOrder syntax/values\n");
          return 1;
        }
        column_major_order = (major_order_flag & SDDS_COLUMN_MAJOR_ORDER) ? 1 : 0;
        break;
      case SET_BINARY:
        binary_output = 1;
        ascii_output = 0;
        break;
      case SET_ASCII:
        ascii_output = 1;
        binary_output = 0;
        break;
      case SET_DIGITS:
        if (s_arg[i_arg].n_items != 2 || sscanf(s_arg[i_arg].list[1], "%ld", &digits) != 1 || digits <= 0) {
          fprintf(stderr, "Error: Invalid -digits syntax\n");
          return 1;
        }
        break;
      case SET_ROOTNAME:
        if (s_arg[i_arg].n_items != 2) {
          fprintf(stderr, "Error: Invalid -rootname syntax\n");
          return 1;
        }
        rootname = s_arg[i_arg].list[1];
        break;
      case SET_FIRST_PAGE:
        if (s_arg[i_arg].n_items != 2 || sscanf(s_arg[i_arg].list[1], "%ld", &first_page) != 1 || first_page <= 0) {
          fprintf(stderr, "Error: Invalid -firstPage syntax\n");
          return 1;
        }
        break;
      case SET_LAST_PAGE:
        if (s_arg[i_arg].n_items != 2 || sscanf(s_arg[i_arg].list[1], "%ld", &last_page) != 1 || last_page <= 0) {
          fprintf(stderr, "Error: Invalid -lastPage syntax\n");
          return 1;
        }
        break;
      case SET_INTERVAL:
        if (s_arg[i_arg].n_items != 2 || sscanf(s_arg[i_arg].list[1], "%ld", &interval) != 1 || interval <= 0) {
          fprintf(stderr, "Error: Invalid -interval syntax\n");
          return 1;
        }
        break;
      case SET_EXTENSION:
        if (s_arg[i_arg].n_items != 2) {
          fprintf(stderr, "Error: Invalid -extension syntax\n");
          return 1;
        }
        extension = s_arg[i_arg].list[1];
        break;
      case SET_OFFSET:
        if (s_arg[i_arg].n_items != 2 || sscanf(s_arg[i_arg].list[1], "%ld", &offset) != 1) {
          fprintf(stderr, "Error: Invalid -offset syntax\n");
          return 1;
        }
        break;
      case SET_PIPE:
        pipe_flags = USE_STDIN;
        break;
      case SET_NAMEPARAMETER:
        if (s_arg[i_arg].n_items != 2) {
          fprintf(stderr, "Error: Invalid -nameParameter syntax\n");
          return 1;
        }
        file_parameter = s_arg[i_arg].list[1];
        break;
      case SET_GROUPPARAMETER:
        if (s_arg[i_arg].n_items != 2) {
          fprintf(stderr, "Error: Invalid -groupParameter syntax\n");
          return 1;
        }
        group_parameter_name = s_arg[i_arg].list[1];
        break;
      default:
        fprintf(stderr, "Error: Unknown switch: %s\n", s_arg[i_arg].list[0]);
        fprintf(stderr, "%s", USAGE);
        return 1;
      }
    } else {
      if (!input) {
        input = s_arg[i_arg].list[0];
      } else {
        fprintf(stderr, "Error: Too many filenames\n");
        return 1;
      }
    }
  }
 
  if (!input && !(pipe_flags & USE_STDIN)) {
    fprintf(stderr, "Error: Missing input filename\n");
    return 1;
  }
 
  if (pipe_flags & USE_STDIN && !file_parameter && !rootname) {
    fprintf(stderr, "Error: Provide -rootname or -nameParameter with -pipe\n");
    return 1;
  }
 
  if (!rootname && !file_parameter) {
    if ((rootname = strrchr(input, '.'))) {
      *rootname = 0;
      SDDS_CopyString(&rootname, input);
      input[strlen(input)] = '.';
    } else {
      SDDS_CopyString(&rootname, input);
    }
  }
 
  if (first_page && last_page && first_page > last_page) {
    fprintf(stderr, "Error: firstPage > lastPage\n");
    return 1;
  }
 
  if (!SDDS_InitializeInput(&sdds_orig, input)) {
    SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
    return 1;
  }
 
  if (!extension || SDDS_StringIsBlank(extension)) {
    extension = NULL;
    snprintf(format, sizeof(format), "%%s%%0%ldld", digits);
  } else {
    snprintf(format, sizeof(format), "%%s%%0%ldld.%s", digits, extension);
  }
 
  if (file_parameter &&
      SDDS_CheckParameter(&sdds_orig, file_parameter, NULL, SDDS_STRING, stderr) != SDDS_CHECK_OKAY) {
    fprintf(stderr, "Error: Filename parameter not present or wrong type\n");
    return 1;
  }
 
  last_group_parameter = NULL;
  while ((retval = SDDS_ReadPage(&sdds_orig)) > 0) {
    if (first_page && retval < first_page) {
      continue;
    }
    if (last_page && retval > last_page) {
      break;
    }
    if (interval) {
      if (first_page) {
        if ((retval - first_page) % interval != 0) {
          continue;
        }
      } else if ((retval - 1) % interval != 0) {
        continue;
      }
    }
    if (file_parameter) {
      if (!SDDS_GetParameter(&sdds_orig, file_parameter, &name_from_parameter)) {
        SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
        return 1;
      }
      strncpy(name, name_from_parameter, sizeof(name) - 1);
      name[sizeof(name) - 1] = '\0';
      free(name_from_parameter);
    } else {
      snprintf(name, sizeof(name), format, rootname, retval - offset);
    }
    if (group_parameter_name) {
      if (!SDDS_GetParameterAsString(&sdds_orig, group_parameter_name, &this_group_parameter)) {
        SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
        return 1;
      }
    }
    if (!group_parameter_name || !last_group_parameter ||
        (group_parameter_name && strcmp(this_group_parameter, last_group_parameter))) {
      if (file_active && !SDDS_Terminate(&sdds_dataset)) {
        SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
        return 1;
      }
      file_active = 0;
      if (!SDDS_InitializeCopy(&sdds_dataset, &sdds_orig, name, "w")) {
        SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
        return 1;
      }
      if ((ascii_output && sdds_dataset.layout.data_mode.mode != SDDS_ASCII) ||
          (binary_output && sdds_dataset.layout.data_mode.mode != SDDS_BINARY)) {
        sdds_dataset.layout.data_mode.mode = ascii_output ? SDDS_ASCII : SDDS_BINARY;
      }
      sdds_dataset.layout.data_mode.column_major = (column_major_order != -1) ? column_major_order : sdds_orig.layout.data_mode.column_major;
      if (!SDDS_WriteLayout(&sdds_dataset)) {
        SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
        return 1;
      }
      file_active = 1;
    }
    if (group_parameter_name) {
      free(last_group_parameter);
      last_group_parameter = this_group_parameter;
      this_group_parameter = NULL;
    }
    if (!SDDS_CopyPage(&sdds_dataset, &sdds_orig) || !SDDS_WritePage(&sdds_dataset)) {
      SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
      return 1;
    }
  }
  if (retval == 0) {
    SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
    return 1;
  }
  if (!SDDS_Terminate(&sdds_orig)) {
    SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
    return 1;
  }
  return 0;
}

Variable Documentation

option

char* option[N_OPTIONS]

static

Initial value:

= {
  "binary",
  "ascii",
  "digits",
  "rootname",
  "firstpage",
  "lastpage",
  "interval",
  "extension",
  "pipe",
  "nameparameter",
  "offset",
  "majorOrder",
  "groupparameter"}

Definition at line 68 of file sddssplit.c.

                                 {
  "binary",
  "ascii",
  "digits",
  "rootname",
  "firstpage",
  "lastpage",
  "interval",
  "extension",
  "pipe",
  "nameparameter",
  "offset",
  "majorOrder",
  "groupparameter"};

USAGE

char* USAGE

static

Definition at line 83 of file sddssplit.c.