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. It supports processing variables such as Ex, Ey, Ez, Rho, Jx, Jy, Jz, etc., contained in 3D data files with specific x, y, and z coordinates. The program generates output that can be plotted for yz and xz planes.

Usage

sdds3dconvert <inputFile> [<outputRoot>]

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: H. Shang, R. Soliday

Definition in file sdds3dconvert.c.

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

Go to the source code of this file.

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)

Function Documentation

◆ free_data_memory()

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

static

Definition at line 263 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 42 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 )