SDDS ToolKit Programs and Libraries for C and Python
All Classes Files Functions Variables Macros Pages
sdds3dconvert.c
Go to the documentation of this file.
1/**
2 * @file sdds3dconvert.c
3 * @brief Converts 3D Vorpal output data into SDDS format compatible with sddscontour for plotting.
4 *
5 * @details
6 * This program converts 3D Vorpal output data into a format compatible with `sddscontour`.
7 * It supports processing variables such as Ex, Ey, Ez, Rho, Jx, Jy, Jz, etc., contained
8 * in 3D data files with specific x, y, and z coordinates. The program generates output
9 * that can be plotted for yz and xz planes.
10 *
11 * @section Usage
12 * ```
13 * sdds3dconvert <inputFile> [<outputRoot>]
14 * ```
15 *
16 * @copyright
17 * - (c) 2002 The University of Chicago, as Operator of Argonne National Laboratory.
18 * - (c) 2002 The Regents of the University of California, as Operator of Los Alamos National Laboratory.
19 *
20 * @license
21 * This file is distributed under the terms of the Software License Agreement
22 * found in the file LICENSE included with this distribution.
23 *
24 * @author
25 * H. Shang, R. Soliday
26 */
27
28#include "mdb.h"
29#include "SDDS.h"
30#include "scan.h"
31
32#define USAGE_MESSAGE "Usage: sdds3dconvert <inputFile> [<outputRoot>]\n" \
33 "Converts 3D Vorpal output data into SDDS format compatible with sddscontour.\n\n" \
34 "Arguments:\n" \
35 " <inputFile> Path to the input SDDS file containing 3D Vorpal data.\n" \
36 " <outputRoot> (Optional) Root name for the output files. Defaults to <inputFile> name if not provided.\n\n" \
37 "Link date: " __DATE__ " " __TIME__ ", SVN revision: " SVN_VERSION "\n"
38
39static void setup_output_file(SDDS_DATASET *sdds_out, const char *output, long yz, long output_columns, char **output_column);
40static void free_data_memory(double ****data, long output_columns, long pages, long ydim);
41
42int main(int argc, char **argv) {
43 SDDS_DATASET sdds_orig, sdds_out1, sdds_out2;
44 int32_t i, j, k, row, str_len;
45 SCANNED_ARG *s_arg;
46 char *input_file, *output_root, output1[1024], output2[1024], tmp_col[256];
47 double xmin, xmax, ymin, ymax, zmin, zmax, x_interval, y_interval, z_interval;
48 int32_t x_dim, y_dim, z_dim, column_names, output_columns, page = 0;
49 char **column_name, **output_column;
50 double ****data;
51
52 input_file = output_root = NULL;
54 argc = scanargs(&s_arg, argc, argv);
55
56 if (argc < 2) {
57 fprintf(stderr, "%s", USAGE_MESSAGE);
58 exit(EXIT_FAILURE);
59 }
60
61 column_names = output_columns = 0;
62 column_name = output_column = NULL;
63 input_file = s_arg[1].list[0];
64 output_root = (argc == 3) ? s_arg[2].list[0] : input_file;
65
66 snprintf(output1, sizeof(output1), "%s.yz", output_root);
67 snprintf(output2, sizeof(output2), "%s.xz", output_root);
68
69 data = NULL;
70 if (!SDDS_InitializeInput(&sdds_orig, input_file)) {
71 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
72 exit(EXIT_FAILURE);
73 }
74
75 column_name = (char **)SDDS_GetColumnNames(&sdds_orig, &column_names);
76 for (i = 0; i < column_names; i++) {
77 if (wild_match(column_name[i], "*_1")) {
78 output_column = SDDS_Realloc(output_column, (output_columns + 1) * sizeof(*output_column));
79 if (!output_column) {
80 fprintf(stderr, "Memory allocation failed for output_column.\n");
81 exit(EXIT_FAILURE);
82 }
83 str_len = strlen(column_name[i]);
84 output_column[output_columns] = malloc(str_len - 1); // Allocate enough space
85 if (!output_column[output_columns]) {
86 fprintf(stderr, "Memory allocation failed for output_column[%d].\n", output_columns);
87 exit(EXIT_FAILURE);
88 }
89 strncpy(output_column[output_columns], column_name[i], str_len - 2);
90 output_column[output_columns][str_len - 2] = '\0';
91 output_columns++;
92 }
93 }
94
95 data = malloc(sizeof(*data) * output_columns);
96 if (!data) {
97 fprintf(stderr, "Memory allocation failed for data.\n");
98 exit(EXIT_FAILURE);
99 }
100
101 while (SDDS_ReadPage(&sdds_orig) > 0) {
102 if (page == 0) {
103 if (!SDDS_GetParameterAsDouble(&sdds_orig, "origin1", &xmin) ||
104 !SDDS_GetParameterAsDouble(&sdds_orig, "max_ext1", &xmax) ||
105 !SDDS_GetParameterAsDouble(&sdds_orig, "delta1", &x_interval) ||
106 !SDDS_GetParameterAsLong(&sdds_orig, "numPhysCells1", &x_dim) ||
107 !SDDS_GetParameterAsDouble(&sdds_orig, "origin2", &ymin) ||
108 !SDDS_GetParameterAsDouble(&sdds_orig, "max_ext2", &ymax) ||
109 !SDDS_GetParameterAsDouble(&sdds_orig, "delta2", &y_interval) ||
110 !SDDS_GetParameterAsLong(&sdds_orig, "numPhysCells2", &y_dim) ||
111 !SDDS_GetParameterAsDouble(&sdds_orig, "origin3", &zmin) ||
112 !SDDS_GetParameterAsDouble(&sdds_orig, "max_ext3", &zmax) ||
113 !SDDS_GetParameterAsDouble(&sdds_orig, "delta3", &z_interval) ||
114 !SDDS_GetParameterAsLong(&sdds_orig, "numPhysCells3", &z_dim)) {
115 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
116 exit(EXIT_FAILURE);
117 }
118 setup_output_file(&sdds_out1, output1, 1, output_columns, output_column);
119 setup_output_file(&sdds_out2, output2, 0, output_columns, output_column);
120
121 for (i = 0; i < output_columns; i++) {
122 data[i] = malloc(z_dim * sizeof(**data));
123 if (!data[i]) {
124 fprintf(stderr, "Memory allocation failed for data[%d].\n", i);
125 free_data_memory(data, output_columns, z_dim, y_dim);
126 exit(EXIT_FAILURE);
127 }
128 for (j = 0; j < z_dim; j++) {
129 data[i][j] = malloc(y_dim * sizeof(***data));
130 if (!data[i][j]) {
131 fprintf(stderr, "Memory allocation failed for data[%d][%d].\n", i, j);
132 free_data_memory(data, output_columns, z_dim, y_dim);
133 exit(EXIT_FAILURE);
134 }
135 }
136 }
137 }
138
139 for (i = 0; i < output_columns; i++) {
140 for (j = 1; j <= y_dim; j++) {
141 snprintf(tmp_col, sizeof(tmp_col), "%s_%d", output_column[i], j);
142 data[i][page][j - 1] = SDDS_GetColumnInDoubles(&sdds_orig, tmp_col);
143 if (!data[i][page][j - 1]) {
144 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
145 free_data_memory(data, output_columns, z_dim, y_dim);
146 exit(EXIT_FAILURE);
147 }
148 }
149 }
150 page++;
151 }
152
153 if (!SDDS_Terminate(&sdds_orig)) {
154 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
155 free_data_memory(data, output_columns, z_dim, y_dim);
156 exit(EXIT_FAILURE);
157 }
158
159 if (page != z_dim) {
160 free_data_memory(data, output_columns, z_dim, y_dim);
161 fprintf(stderr, "Error: Page count (%d) does not match z-dimension size (%d).\n", page, z_dim);
162 exit(EXIT_FAILURE);
163 }
164
165 /* Write yz output */
166 for (page = 0; page < x_dim; page++) {
167 if (!SDDS_StartPage(&sdds_out1, y_dim * z_dim) ||
168 !SDDS_SetParameters(&sdds_out1, SDDS_SET_BY_NAME | SDDS_PASS_BY_VALUE,
169 "origin1", xmin, "origin2", ymin, "origin3", zmin,
170 "max_ext1", xmax, "max_ext2", ymax, "max_ext3", zmax,
171 "delta1", x_interval, "delta2", y_interval, "delta3", z_interval,
172 "numPhysCells1", x_dim, "numPhysCells2", y_dim, "numPhysCells3", z_dim,
173 "Variable1Name", "Y", "Variable2Name", "Z",
174 "ZMinimum", zmin, "ZMaximum", zmax, "ZInterval", z_interval, "ZDimension", z_dim,
175 "YMinimum", ymin, "YMaximum", ymax, "YInterval", y_interval, "YDimension", y_dim,
176 NULL)) {
177 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
178 free_data_memory(data, output_columns, z_dim, y_dim);
179 exit(EXIT_FAILURE);
180 }
181
182 for (i = 0; i < output_columns; i++) {
183 row = 0;
184 for (j = 0; j < y_dim; j++) {
185 for (k = 0; k < z_dim; k++) {
186 if (!SDDS_SetRowValues(&sdds_out1, SDDS_SET_BY_NAME | SDDS_PASS_BY_VALUE, row,
187 output_column[i], data[i][k][j][page],
188 "z", k * z_interval + zmin,
189 "y", j * y_interval + ymin, NULL)) {
190 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
191 free_data_memory(data, output_columns, z_dim, y_dim);
192 exit(EXIT_FAILURE);
193 }
194 row++;
195 }
196 }
197 }
198
199 if (!SDDS_WritePage(&sdds_out1)) {
200 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
201 free_data_memory(data, output_columns, z_dim, y_dim);
202 exit(EXIT_FAILURE);
203 }
204 }
205
206 if (!SDDS_Terminate(&sdds_out1)) {
207 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
208 free_data_memory(data, output_columns, z_dim, y_dim);
209 exit(EXIT_FAILURE);
210 }
211
212 /* Write xz output */
213 for (page = 0; page < y_dim; page++) {
214 if (!SDDS_StartPage(&sdds_out2, x_dim * z_dim) ||
215 !SDDS_SetParameters(&sdds_out2, SDDS_SET_BY_NAME | SDDS_PASS_BY_VALUE,
216 "origin1", xmin, "origin2", ymin, "origin3", zmin,
217 "max_ext1", xmax, "max_ext2", ymax, "max_ext3", zmax,
218 "delta1", x_interval, "delta2", y_interval, "delta3", z_interval,
219 "numPhysCells1", x_dim, "numPhysCells2", y_dim, "numPhysCells3", z_dim,
220 "Variable1Name", "X", "Variable2Name", "Z",
221 "ZMinimum", zmin, "ZMaximum", zmax, "ZInterval", z_interval, "ZDimension", z_dim,
222 "XMinimum", xmin, "XMaximum", xmax, "XInterval", x_interval, "XDimension", x_dim,
223 NULL)) {
224 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
225 free_data_memory(data, output_columns, z_dim, y_dim);
226 exit(EXIT_FAILURE);
227 }
228
229 for (i = 0; i < output_columns; i++) {
230 row = 0;
231 for (j = 0; j < x_dim; j++) {
232 for (k = 0; k < z_dim; k++) {
233 if (!SDDS_SetRowValues(&sdds_out2, SDDS_SET_BY_NAME | SDDS_PASS_BY_VALUE, row,
234 output_column[i], data[i][k][page][j],
235 "z", k * z_interval + zmin,
236 "x", j * x_interval + xmin, NULL)) {
237 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
238 free_data_memory(data, output_columns, z_dim, y_dim);
239 exit(EXIT_FAILURE);
240 }
241 row++;
242 }
243 }
244 }
245
246 if (!SDDS_WritePage(&sdds_out2)) {
247 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
248 free_data_memory(data, output_columns, z_dim, y_dim);
249 exit(EXIT_FAILURE);
250 }
251 }
252
253 free_data_memory(data, output_columns, z_dim, y_dim);
254
255 if (!SDDS_Terminate(&sdds_out2)) {
256 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
257 exit(EXIT_FAILURE);
258 }
259
260 return EXIT_SUCCESS;
261}
262
263static void free_data_memory(double ****data, long output_columns, long z_dim, long y_dim) {
264 long i, j, k;
265 if (!data)
266 return;
267 for (i = 0; i < output_columns; i++) {
268 if (!data[i])
269 continue;
270 for (j = 0; j < z_dim; j++) {
271 if (!data[i][j])
272 continue;
273 for (k = 0; k < y_dim; k++) {
274 free(data[i][j][k]);
275 }
276 free(data[i][j]);
277 }
278 free(data[i]);
279 }
280 free(data);
281}
282
283static void setup_output_file(SDDS_DATASET *sdds_out, const char *output, long yz, long output_columns, char **output_column) {
284 long i;
285 if (!SDDS_InitializeOutput(sdds_out, SDDS_BINARY, 0, NULL, NULL, output)) {
286 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
287 }
288
289 if (!SDDS_DefineSimpleParameter(sdds_out, "origin1", NULL, SDDS_DOUBLE) ||
290 !SDDS_DefineSimpleParameter(sdds_out, "origin2", NULL, SDDS_DOUBLE) ||
291 !SDDS_DefineSimpleParameter(sdds_out, "origin3", NULL, SDDS_DOUBLE) ||
292 !SDDS_DefineSimpleParameter(sdds_out, "max_ext1", NULL, SDDS_DOUBLE) ||
293 !SDDS_DefineSimpleParameter(sdds_out, "max_ext2", NULL, SDDS_DOUBLE) ||
294 !SDDS_DefineSimpleParameter(sdds_out, "max_ext3", NULL, SDDS_DOUBLE) ||
295 !SDDS_DefineSimpleParameter(sdds_out, "delta1", NULL, SDDS_DOUBLE) ||
296 !SDDS_DefineSimpleParameter(sdds_out, "delta2", NULL, SDDS_DOUBLE) ||
297 !SDDS_DefineSimpleParameter(sdds_out, "delta3", NULL, SDDS_DOUBLE) ||
298 !SDDS_DefineSimpleParameter(sdds_out, "numPhysCells1", NULL, SDDS_LONG) ||
299 !SDDS_DefineSimpleParameter(sdds_out, "numPhysCells2", NULL, SDDS_LONG) ||
300 !SDDS_DefineSimpleParameter(sdds_out, "numPhysCells3", NULL, SDDS_LONG) ||
301 !SDDS_DefineSimpleParameter(sdds_out, "Variable1Name", NULL, SDDS_STRING) ||
302 !SDDS_DefineSimpleParameter(sdds_out, "Variable2Name", NULL, SDDS_STRING) ||
303 !SDDS_DefineSimpleParameter(sdds_out, "ZMinimum", NULL, SDDS_DOUBLE) ||
304 !SDDS_DefineSimpleParameter(sdds_out, "ZMaximum", NULL, SDDS_DOUBLE) ||
305 !SDDS_DefineSimpleParameter(sdds_out, "ZInterval", NULL, SDDS_DOUBLE) ||
306 !SDDS_DefineSimpleParameter(sdds_out, "ZDimension", NULL, SDDS_LONG) ||
307 !SDDS_DefineSimpleColumn(sdds_out, "z", NULL, SDDS_DOUBLE)) {
308 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
309 }
310
311 if (yz) {
312 if (!SDDS_DefineSimpleParameter(sdds_out, "YMinimum", NULL, SDDS_DOUBLE) ||
313 !SDDS_DefineSimpleParameter(sdds_out, "YMaximum", NULL, SDDS_DOUBLE) ||
314 !SDDS_DefineSimpleParameter(sdds_out, "YInterval", NULL, SDDS_DOUBLE) ||
315 !SDDS_DefineSimpleParameter(sdds_out, "YDimension", NULL, SDDS_LONG) ||
316 !SDDS_DefineSimpleColumn(sdds_out, "y", NULL, SDDS_DOUBLE)) {
317 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
318 }
319 } else {
320 if (!SDDS_DefineSimpleParameter(sdds_out, "XMinimum", NULL, SDDS_DOUBLE) ||
321 !SDDS_DefineSimpleParameter(sdds_out, "XMaximum", NULL, SDDS_DOUBLE) ||
322 !SDDS_DefineSimpleParameter(sdds_out, "XInterval", NULL, SDDS_DOUBLE) ||
323 !SDDS_DefineSimpleParameter(sdds_out, "XDimension", NULL, SDDS_LONG) ||
324 !SDDS_DefineSimpleColumn(sdds_out, "x", NULL, SDDS_DOUBLE)) {
325 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
326 }
327 }
328
329 for (i = 0; i < output_columns; i++) {
330 if (!SDDS_DefineSimpleColumn(sdds_out, output_column[i], NULL, SDDS_DOUBLE)) {
331 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
332 }
333 }
334
335 if (!SDDS_WriteLayout(sdds_out)) {
336 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
337 }
338}
SDDS (Self Describing Data Set) Data Types Definitions and Function Prototypes.
int32_t SDDS_SetRowValues(SDDS_DATASET *SDDS_dataset, int32_t mode, int64_t row,...)
int32_t SDDS_StartPage(SDDS_DATASET *SDDS_dataset, int64_t expected_n_rows)
int32_t SDDS_SetParameters(SDDS_DATASET *SDDS_dataset, int32_t mode,...)
int32_t * SDDS_GetParameterAsLong(SDDS_DATASET *SDDS_dataset, char *parameter_name, int32_t *memory)
Retrieves the value of a specified parameter as a 32-bit integer from the current data table of a dat...
double * SDDS_GetParameterAsDouble(SDDS_DATASET *SDDS_dataset, char *parameter_name, double *memory)
Retrieves the value of a specified parameter as a double from the current data table of an SDDS datas...
double * SDDS_GetColumnInDoubles(SDDS_DATASET *SDDS_dataset, char *column_name)
Retrieves the data of a specified numerical column as an array of doubles, considering only rows mark...
int32_t SDDS_InitializeInput(SDDS_DATASET *SDDS_dataset, char *filename)
Definition SDDS_input.c:49
int32_t SDDS_Terminate(SDDS_DATASET *SDDS_dataset)
int32_t SDDS_ReadPage(SDDS_DATASET *SDDS_dataset)
int32_t SDDS_InitializeOutput(SDDS_DATASET *SDDS_dataset, int32_t data_mode, int32_t lines_per_row, const char *description, const char *contents, const char *filename)
Initializes the SDDS output dataset.
int32_t SDDS_DefineSimpleColumn(SDDS_DATASET *SDDS_dataset, const char *name, const char *unit, int32_t type)
Defines a simple data column within the SDDS dataset.
int32_t SDDS_DefineSimpleParameter(SDDS_DATASET *SDDS_dataset, const char *name, const char *unit, int32_t type)
Defines a simple data parameter within the SDDS dataset.
int32_t SDDS_WritePage(SDDS_DATASET *SDDS_dataset)
Writes the current data table to the output file.
int32_t SDDS_WriteLayout(SDDS_DATASET *SDDS_dataset)
Writes the SDDS layout header to the output file.
char ** SDDS_GetColumnNames(SDDS_DATASET *SDDS_dataset, int32_t *number)
Retrieves the names of all columns in the SDDS dataset.
void SDDS_PrintErrors(FILE *fp, int32_t mode)
Prints recorded error messages to a specified file stream.
Definition SDDS_utils.c:432
void SDDS_RegisterProgramName(const char *name)
Registers the executable program name for use in error messages.
Definition SDDS_utils.c:288
void * SDDS_Realloc(void *old_ptr, size_t new_size)
Reallocates memory to a new size.
Definition SDDS_utils.c:677
#define SDDS_STRING
Identifier for the string data type.
Definition SDDStypes.h:85
#define SDDS_LONG
Identifier for the signed 32-bit integer data type.
Definition SDDStypes.h:61
#define SDDS_DOUBLE
Identifier for the double data type.
Definition SDDStypes.h:37
int scanargs(SCANNED_ARG **scanned, int argc, char **argv)
Definition scanargs.c:36
int wild_match(char *string, char *template)
Determine whether one string is a wildcard match for another.
Definition wild_match.c:49