Converts 3D Vorpal output data into SDDS format compatible with sddscontour for plotting. More...

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

Macros
#define	USAGE_MESSAGE

Functions
static void	setup_output_file (SDDS_DATASET sdds_out, const char output, long yz, long output_columns, char **output_column)

static void	free_data_memory (double ****data, long output_columns, long pages, long ydim)

int	main (int argc, char **argv)

Detailed Description

Converts 3D Vorpal output data into SDDS format compatible with sddscontour for plotting.

This program converts 3D Vorpal output data into a format compatible with sddscontour for plotting variables such as Ex, Ey, Ez, Rho, Jx, Jy, Jz, etc. The input file contains 3D data with specific coordinates for x, y, and z. The output can be plotted for yz and xz planes.

Usage

sdds3dconvert <inputFile> [<outputRoot>]

<inputFile>: The input SDDS file containing 3D Vorpal data.
[<outputRoot>]: (Optional) The root name for output files. If not specified, the input file name is used as the root.

Definition in file sdds3dconvert.c.

Macro Definition Documentation

◆ USAGE_MESSAGE

#define USAGE_MESSAGE

Value:

  "Usage: sdds3dconvert <inputFile> [<outputRoot>]\n" \
  "Converts 3D Vorpal output data into SDDS format compatible with sddscontour.\n\n" \
  "Arguments:\n"                                                        \
  "  <inputFile>   Path to the input SDDS file containing 3D Vorpal data.\n" \
  "  <outputRoot>  (Optional) Root name for the output files. Defaults to <inputFile> name if not provided.\n\n" \
  "Link date: " __DATE__ " " __TIME__ ", SVN revision: " SVN_VERSION "\n"

Definition at line 26 of file sdds3dconvert.c.

#define USAGE_MESSAGE "Usage: sdds3dconvert <inputFile> [<outputRoot>]\n" \
  "Converts 3D Vorpal output data into SDDS format compatible with sddscontour.\n\n" \
  "Arguments:\n"                                                        \
  "  <inputFile>   Path to the input SDDS file containing 3D Vorpal data.\n" \
  "  <outputRoot>  (Optional) Root name for the output files. Defaults to <inputFile> name if not provided.\n\n" \
  "Link date: " __DATE__ " " __TIME__ ", SVN revision: " SVN_VERSION "\n"

Function Documentation

◆ free_data_memory()

static void free_data_memory	(	double ****	data,
		long	output_columns,
		long	pages,
		long	ydim )

static

Definition at line 257 of file sdds3dconvert.c.

                                                                                           {
  long i, j, k;
  if (!data)
    return;
  for (i = 0; i < output_columns; i++) {
    if (!data[i])
      continue;
    for (j = 0; j < z_dim; j++) {
      if (!data[i][j])
        continue;
      for (k = 0; k < y_dim; k++) {
        free(data[i][j][k]);
      }
      free(data[i][j]);
    }
    free(data[i]);
  }
  free(data);
}

◆ main()

int main	(	int	argc,
		char **	argv )

Definition at line 36 of file sdds3dconvert.c.

                                {
  SDDS_DATASET sdds_orig, sdds_out1, sdds_out2;
  int32_t i, j, k, row, str_len;
  SCANNED_ARG *s_arg;
  char *input_file, *output_root, output1[1024], output2[1024], tmp_col[256];
  double xmin, xmax, ymin, ymax, zmin, zmax, x_interval, y_interval, z_interval;
  int32_t x_dim, y_dim, z_dim, column_names, output_columns, page = 0;
  char **column_name, **output_column;
  double ****data;
 
  input_file = output_root = NULL;
  SDDS_RegisterProgramName(argv[0]);
  argc = scanargs(&s_arg, argc, argv);
 
  if (argc < 2) {
    fprintf(stderr, "%s", USAGE_MESSAGE);
    exit(EXIT_FAILURE);
  }
 
  column_names = output_columns = 0;
  column_name = output_column = NULL;
  input_file = s_arg[1].list[0];
  output_root = (argc == 3) ? s_arg[2].list[0] : input_file;
 
  snprintf(output1, sizeof(output1), "%s.yz", output_root);
  snprintf(output2, sizeof(output2), "%s.xz", output_root);
 
  data = NULL;
  if (!SDDS_InitializeInput(&sdds_orig, input_file)) {
    SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
    exit(EXIT_FAILURE);
  }
 
  column_name = (char **)SDDS_GetColumnNames(&sdds_orig, &column_names);
  for (i = 0; i < column_names; i++) {
    if (wild_match(column_name[i], "*_1")) {
      output_column = SDDS_Realloc(output_column, (output_columns + 1) * sizeof(*output_column));
      if (!output_column) {
        fprintf(stderr, "Memory allocation failed for output_column.\n");
        exit(EXIT_FAILURE);
      }
      str_len = strlen(column_name[i]);
      output_column[output_columns] = malloc(str_len - 1); // Allocate enough space
      if (!output_column[output_columns]) {
        fprintf(stderr, "Memory allocation failed for output_column[%d].\n", output_columns);
        exit(EXIT_FAILURE);
      }
      strncpy(output_column[output_columns], column_name[i], str_len - 2);
      output_column[output_columns][str_len - 2] = '\0';
      output_columns++;
    }
  }
 
  data = malloc(sizeof(*data) * output_columns);
  if (!data) {
    fprintf(stderr, "Memory allocation failed for data.\n");
    exit(EXIT_FAILURE);
  }
 
  while (SDDS_ReadPage(&sdds_orig) > 0) {
    if (page == 0) {
      if (!SDDS_GetParameterAsDouble(&sdds_orig, "origin1", &xmin) ||
          !SDDS_GetParameterAsDouble(&sdds_orig, "max_ext1", &xmax) ||
          !SDDS_GetParameterAsDouble(&sdds_orig, "delta1", &x_interval) ||
          !SDDS_GetParameterAsLong(&sdds_orig, "numPhysCells1", &x_dim) ||
          !SDDS_GetParameterAsDouble(&sdds_orig, "origin2", &ymin) ||
          !SDDS_GetParameterAsDouble(&sdds_orig, "max_ext2", &ymax) ||
          !SDDS_GetParameterAsDouble(&sdds_orig, "delta2", &y_interval) ||
          !SDDS_GetParameterAsLong(&sdds_orig, "numPhysCells2", &y_dim) ||
          !SDDS_GetParameterAsDouble(&sdds_orig, "origin3", &zmin) ||
          !SDDS_GetParameterAsDouble(&sdds_orig, "max_ext3", &zmax) ||
          !SDDS_GetParameterAsDouble(&sdds_orig, "delta3", &z_interval) ||
          !SDDS_GetParameterAsLong(&sdds_orig, "numPhysCells3", &z_dim)) {
        SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
        exit(EXIT_FAILURE);
      }
      setup_output_file(&sdds_out1, output1, 1, output_columns, output_column);
      setup_output_file(&sdds_out2, output2, 0, output_columns, output_column);
 
      for (i = 0; i < output_columns; i++) {
        data[i] = malloc(z_dim * sizeof(**data));
        if (!data[i]) {
          fprintf(stderr, "Memory allocation failed for data[%d].\n", i);
          free_data_memory(data, output_columns, z_dim, y_dim);
          exit(EXIT_FAILURE);
        }
        for (j = 0; j < z_dim; j++) {
          data[i][j] = malloc(y_dim * sizeof(***data));
          if (!data[i][j]) {
            fprintf(stderr, "Memory allocation failed for data[%d][%d].\n", i, j);
            free_data_memory(data, output_columns, z_dim, y_dim);
            exit(EXIT_FAILURE);
          }
        }
      }
    }
 
    for (i = 0; i < output_columns; i++) {
      for (j = 1; j <= y_dim; j++) {
        snprintf(tmp_col, sizeof(tmp_col), "%s_%d", output_column[i], j);
        data[i][page][j - 1] = SDDS_GetColumnInDoubles(&sdds_orig, tmp_col);
        if (!data[i][page][j - 1]) {
          SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
          free_data_memory(data, output_columns, z_dim, y_dim);
          exit(EXIT_FAILURE);
        }
      }
    }
    page++;
  }
 
  if (!SDDS_Terminate(&sdds_orig)) {
    SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
    free_data_memory(data, output_columns, z_dim, y_dim);
    exit(EXIT_FAILURE);
  }
 
  if (page != z_dim) {
    free_data_memory(data, output_columns, z_dim, y_dim);
    fprintf(stderr, "Error: Page count (%d) does not match z-dimension size (%d).\n", page, z_dim);
    exit(EXIT_FAILURE);
  }
 
  /* Write yz output */
  for (page = 0; page < x_dim; page++) {
    if (!SDDS_StartPage(&sdds_out1, y_dim * z_dim) ||
        !SDDS_SetParameters(&sdds_out1, SDDS_SET_BY_NAME | SDDS_PASS_BY_VALUE,
                            "origin1", xmin, "origin2", ymin, "origin3", zmin,
                            "max_ext1", xmax, "max_ext2", ymax, "max_ext3", zmax,
                            "delta1", x_interval, "delta2", y_interval, "delta3", z_interval,
                            "numPhysCells1", x_dim, "numPhysCells2", y_dim, "numPhysCells3", z_dim,
                            "Variable1Name", "Y", "Variable2Name", "Z",
                            "ZMinimum", zmin, "ZMaximum", zmax, "ZInterval", z_interval, "ZDimension", z_dim,
                            "YMinimum", ymin, "YMaximum", ymax, "YInterval", y_interval, "YDimension", y_dim,
                            NULL)) {
      SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
      free_data_memory(data, output_columns, z_dim, y_dim);
      exit(EXIT_FAILURE);
    }
 
    for (i = 0; i < output_columns; i++) {
      row = 0;
      for (j = 0; j < y_dim; j++) {
        for (k = 0; k < z_dim; k++) {
          if (!SDDS_SetRowValues(&sdds_out1, SDDS_SET_BY_NAME | SDDS_PASS_BY_VALUE, row,
                                 output_column[i], data[i][k][j][page],
                                 "z", k * z_interval + zmin,
                                 "y", j * y_interval + ymin, NULL)) {
            SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
            free_data_memory(data, output_columns, z_dim, y_dim);
            exit(EXIT_FAILURE);
          }
          row++;
        }
      }
    }
 
    if (!SDDS_WritePage(&sdds_out1)) {
      SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
      free_data_memory(data, output_columns, z_dim, y_dim);
      exit(EXIT_FAILURE);
    }
  }
 
  if (!SDDS_Terminate(&sdds_out1)) {
    SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
    free_data_memory(data, output_columns, z_dim, y_dim);
    exit(EXIT_FAILURE);
  }
 
  /* Write xz output */
  for (page = 0; page < y_dim; page++) {
    if (!SDDS_StartPage(&sdds_out2, x_dim * z_dim) ||
        !SDDS_SetParameters(&sdds_out2, SDDS_SET_BY_NAME | SDDS_PASS_BY_VALUE,
                            "origin1", xmin, "origin2", ymin, "origin3", zmin,
                            "max_ext1", xmax, "max_ext2", ymax, "max_ext3", zmax,
                            "delta1", x_interval, "delta2", y_interval, "delta3", z_interval,
                            "numPhysCells1", x_dim, "numPhysCells2", y_dim, "numPhysCells3", z_dim,
                            "Variable1Name", "X", "Variable2Name", "Z",
                            "ZMinimum", zmin, "ZMaximum", zmax, "ZInterval", z_interval, "ZDimension", z_dim,
                            "XMinimum", xmin, "XMaximum", xmax, "XInterval", x_interval, "XDimension", x_dim,
                            NULL)) {
      SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
      free_data_memory(data, output_columns, z_dim, y_dim);
      exit(EXIT_FAILURE);
    }
 
    for (i = 0; i < output_columns; i++) {
      row = 0;
      for (j = 0; j < x_dim; j++) {
        for (k = 0; k < z_dim; k++) {
          if (!SDDS_SetRowValues(&sdds_out2, SDDS_SET_BY_NAME | SDDS_PASS_BY_VALUE, row,
                                 output_column[i], data[i][k][page][j],
                                 "z", k * z_interval + zmin,
                                 "x", j * x_interval + xmin, NULL)) {
            SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
            free_data_memory(data, output_columns, z_dim, y_dim);
            exit(EXIT_FAILURE);
          }
          row++;
        }
      }
    }
 
    if (!SDDS_WritePage(&sdds_out2)) {
      SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
      free_data_memory(data, output_columns, z_dim, y_dim);
      exit(EXIT_FAILURE);
    }
  }
 
  free_data_memory(data, output_columns, z_dim, y_dim);
 
  if (!SDDS_Terminate(&sdds_out2)) {
    SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
    exit(EXIT_FAILURE);
  }
 
  return EXIT_SUCCESS;
}

◆ setup_output_file()

static void setup_output_file	(	SDDS_DATASET *	sdds_out,
		const char *	output,
		long	yz,
		long	output_columns,
		char **	output_column )