SDDSlib
Loading...
Searching...
No Matches
Macros | Enumerations | Functions | Variables
sdds2math.c File Reference

Converts SDDS files to a Mathematica-compatible format. More...

#include <stdio.h>
#include <string.h>
#include <math.h>
#include "mdb.h"
#include "SDDS.h"
#include "scan.h"

Go to the source code of this file.

Macros

#define FORMAT   "%g"
 

Enumerations

enum  option_type {
  SET_COMMENTS , SET_FORMAT , SET_VERBOSE , SET_PIPE ,
  N_OPTIONS
}
 

Functions

int main (int argc, char **argv)
 

Variables

static char * option [N_OPTIONS]
 
static char * USAGE
 

Detailed Description

Converts SDDS files to a Mathematica-compatible format.

This program reads an SDDS (Self Describing Data Sets) file and converts it into a format that can be easily imported and used within Mathematica. The output is structured as a single Mathematica variable containing descriptions, column definitions, parameter definitions, array definitions, associations, and tables of data.

Usage:

sdds2math [<SDDSfilename>] [<outputname>] [OPTIONS]

Options:

  • -pipe[=in][,out] : Standard SDDS Toolkit pipe option.
  • -comments : Include helpful Mathematica comments in the output file.
  • -format=<format-string> : Specify the format for double precision numbers (Default: "%g").
  • -verbose : Display header information to the terminal similar to sddsquery.

The output Mathematica variable has the following structure:

sdds = {description, coldef, pardef, arraydef, associates, tables}
  • description: Contains text and contents descriptions.
  • coldef: Defines columns with name, units, symbol, format, type, field length, and description.
  • pardef: Defines parameters with name, fixed value, units, symbol, type, and description.
  • arraydef: Defines arrays with name, units, symbol, format, type, field length, group, and description.
  • associates: Lists associations with SDDS flag, filename, path, contents, and description.
  • tables: Contains data tables with parameters and row data.

Example:

sdds = {
{ "Description Text", "Contents Description" },
{ { "Col1", "Units1", "Symbol1", "Format1", "Type1", 10, "Description1" }, ... },
{ { "Param1", "FixedValue1", "Units1", "Symbol1", "Type1", "Description1" }, ... },
{ { "Array1", "Units1", "Symbol1", "Format1", "Type1*^2", 10, "Group1", "Description1" }, ... },
{ { "True", "Filename1", "Path1", "Contents1", "Description1" }, ... },
{
{
{ "ParamValue1", ... },
{ { "Row1Col1", "Row1Col2", ... }, ... }
},
...
}
}
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
K. Evans, C. Saunders, M. Borland, R. Soliday

Definition in file sdds2math.c.

Macro Definition Documentation

◆ FORMAT

#define FORMAT   "%g"

Definition at line 78 of file sdds2math.c.

Enumeration Type Documentation

◆ option_type

enum option_type

Definition at line 70 of file sdds2math.c.

70 {
71 SET_COMMENTS,
72 SET_FORMAT,
73 SET_VERBOSE,
74 SET_PIPE,
75 N_OPTIONS
76};

Function Documentation

◆ main()

int main ( int argc,
char ** argv )

Definition at line 109 of file sdds2math.c.

109 {
110 FILE *outfile;
111 SDDS_TABLE SDDS_table;
112 SDDS_LAYOUT *layout;
113 COLUMN_DEFINITION *coldef;
114 PARAMETER_DEFINITION *pardef;
115 ARRAY_DEFINITION *arraydef;
116 char s[256];
117 char *input, *output;
118 long i, i_arg, ntable;
119 int64_t nrows, j;
120 SCANNED_ARG *s_arg;
121 char *text, *contents, *ss, *ptr, *iformat = FORMAT, *format, *rformat;
122 long verbose = 0, comments = 0, addquotes = 1;
123 short nexp;
124 double dd, ddred;
125 float ff, ffred;
126 void *data;
127 unsigned long pipeFlags;
128
129 SDDS_RegisterProgramName(argv[0]);
130
131 input = output = NULL;
132 pipeFlags = 0;
133
134 argc = scanargs(&s_arg, argc, argv);
135 if (argc == 1) {
136 fprintf(stderr, "%s", USAGE);
137 exit(EXIT_FAILURE);
138 }
139
140 for (i_arg = 1; i_arg < argc; i_arg++) {
141 if (s_arg[i_arg].arg_type == OPTION) {
142 switch (match_string(s_arg[i_arg].list[0], option, N_OPTIONS, 0)) {
143 case SET_COMMENTS:
144 comments = 1;
145 break;
146 case SET_FORMAT:
147 if (s_arg[i_arg].n_items < 2)
148 SDDS_Bomb("Invalid -format syntax");
149 iformat = s_arg[i_arg].list[1]; /* Input format */
150 break;
151 case SET_VERBOSE:
152 verbose = 1;
153 break;
154 case SET_PIPE:
155 if (!processPipeOption(s_arg[i_arg].list + 1, s_arg[i_arg].n_items - 1, &pipeFlags))
156 SDDS_Bomb("Invalid -pipe syntax");
157 break;
158 default:
159 fprintf(stderr, "Unknown option: %s\n", s_arg[i_arg].list[0]);
160 fprintf(stderr, "%s", USAGE);
161 exit(EXIT_FAILURE);
162 }
163 } else {
164 if (input == NULL)
165 input = s_arg[i_arg].list[0];
166 else if (output == NULL)
167 output = s_arg[i_arg].list[0];
168 else
169 SDDS_Bomb("Too many filenames provided.");
170 }
171 }
172
173 processFilenames("sdds2math", &input, &output, pipeFlags, 0, NULL);
174
175 if (output) {
176 outfile = fopen(output, "w");
177 if (!outfile) {
178 fprintf(stderr, "Error: Cannot open output file '%s'\n", output);
179 exit(EXIT_FAILURE);
180 }
181 } else {
182 outfile = stdout;
183 }
184
185 /* Calculate formats for converting to Mathematica convention */
186 format = (char *)calloc(256, sizeof(char)); /* Whole format */
187 if (!format) {
188 fprintf(stderr, "Memory allocation error for format.\n");
189 exit(EXIT_FAILURE);
190 }
191
192 rformat = (char *)calloc(256, sizeof(char)); /* Part before e */
193 if (!rformat) {
194 fprintf(stderr, "Memory allocation error for rformat.\n");
195 free(format);
196 exit(EXIT_FAILURE);
197 }
198
199 strcpy(format, iformat);
200 if ((ptr = strchr(format, 'E')))
201 *ptr = 'e'; /* Convert 'E' to 'e' */
202 if ((ptr = strchr(format, 'G')))
203 *ptr = 'g'; /* Convert 'G' to 'g' */
204 strcpy(rformat, format);
205 if ((ptr = strpbrk(rformat, "eg")))
206 *ptr = 'f';
207
208 /* Initialize SDDS input */
209 if (!SDDS_InitializeInput(&SDDS_table, input)) {
210 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
211 exit(EXIT_FAILURE);
212 }
213
214 layout = &SDDS_table.layout;
215
216 /* Start top level */
217 fprintf(outfile, "{");
218
219 /* Description */
220 fprintf(outfile, "{");
221 if (verbose)
222 printf("\nFile '%s' is in SDDS protocol version %" PRId32 "\n", input, layout->version);
223
224 if (!SDDS_GetDescription(&SDDS_table, &text, &contents))
225 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
226
227 if (text) {
228 if (verbose)
229 printf("Description: %s\n", text);
230 fprintf(outfile, "\"%s\",", text);
231 }
232
233 if (contents) {
234 if (verbose)
235 printf("Contents: %s\n", contents);
236 fprintf(outfile, "\"%s\"", contents);
237 } else {
238 fprintf(outfile, "\"No contents\"");
239 }
240
241 if (layout->data_mode.mode == SDDS_ASCII) {
242 if (verbose)
243 printf("\nData is ASCII with %" PRId32 " lines per row and %" PRId32 " additional header lines expected.\n",
244 layout->data_mode.lines_per_row, layout->data_mode.additional_header_lines);
245 if (verbose)
246 printf("Row counts: %s\n", layout->data_mode.no_row_counts ? "No" : "Yes");
247 } else if (verbose) {
248 printf("\nData is binary\n");
249 }
250
251 fprintf(outfile, "},\n");
252
253 /* Columns */
254 fprintf(outfile, " {");
255 if (layout->n_columns) {
256 if (verbose)
257 printf("\n%" PRId32 " columns of data:\n", layout->n_columns);
258 if (verbose)
259 printf("NAME UNITS SYMBOL FORMAT TYPE FIELD DESCRIPTION\n");
260 if (verbose)
261 printf(" LENGTH\n");
262 for (i = 0; i < layout->n_columns; i++) {
263 if (i > 0)
264 fprintf(outfile, ",\n ");
265 coldef = layout->column_definition + i;
266 if (verbose)
267 printf("%-15s %-15s %-15s %-15s %-7s %-7" PRId32 " %s\n",
268 coldef->name ? coldef->name : "No name",
269 coldef->units ? coldef->units : "",
270 coldef->symbol ? coldef->symbol : "",
271 coldef->format_string ? coldef->format_string : "",
272 SDDS_type_name[coldef->type - 1],
273 coldef->field_length,
274 coldef->description ? coldef->description : "No description");
275 fprintf(outfile, "{\"%s\",\"%s\",\"%s\",\"%s\",\"%s\",%" PRId32 ",\"%s\"}",
276 coldef->name ? coldef->name : "No name",
277 coldef->units ? coldef->units : "",
278 coldef->symbol ? coldef->symbol : "",
279 coldef->format_string ? coldef->format_string : "",
280 SDDS_type_name[coldef->type - 1],
281 coldef->field_length,
282 coldef->description ? coldef->description : "No description");
283 }
284 }
285 fprintf(outfile, "},\n");
286
287 /* Parameters */
288 fprintf(outfile, " {");
289 if (layout->n_parameters) {
290 if (verbose)
291 printf("\n%" PRId32 " parameters:\n", layout->n_parameters);
292 if (verbose)
293 printf("NAME UNITS SYMBOL TYPE DESCRIPTION\n");
294 for (i = 0; i < layout->n_parameters; i++) {
295 if (i > 0)
296 fprintf(outfile, ",\n ");
297 pardef = layout->parameter_definition + i;
298 if (verbose)
299 printf("%-19s %-19s %-19s %-19s %s\n",
300 pardef->name ? pardef->name : "No name",
301 pardef->units ? pardef->units : "",
302 pardef->symbol ? pardef->symbol : "",
303 SDDS_type_name[pardef->type - 1],
304 pardef->description ? pardef->description : "No description");
305 fprintf(outfile, "{\"%s\",\"%s\",\"%s\",\"%s\",\"%s\",\"%s\"}",
306 pardef->name ? pardef->name : "No name",
307 pardef->fixed_value ? pardef->fixed_value : "",
308 pardef->units ? pardef->units : "",
309 pardef->symbol ? pardef->symbol : "",
310 SDDS_type_name[pardef->type - 1],
311 pardef->description ? pardef->description : "No description");
312 }
313 }
314 fprintf(outfile, "},\n");
315
316 /* Arrays */
317 fprintf(outfile, " {");
318 if (layout->n_arrays) {
319 if (verbose)
320 printf("\n%" PRId32 " arrays of data:\n", layout->n_arrays);
321 if (verbose)
322 printf("NAME UNITS SYMBOL FORMAT TYPE FIELD GROUP DESCRIPTION\n");
323 if (verbose)
324 printf(" LENGTH NAME\n");
325 for (i = 0; i < layout->n_arrays; i++) {
326 if (i > 0)
327 fprintf(outfile, ",\n ");
328 arraydef = layout->array_definition + i;
329 if (verbose)
330 printf("%-15s %-15s %-15s %-7s %-8s*^%-5" PRId32 " %-7" PRId32 " %-15s %s\n",
331 arraydef->name ? arraydef->name : "No name",
332 arraydef->units ? arraydef->units : "",
333 arraydef->symbol ? arraydef->symbol : "",
334 arraydef->format_string ? arraydef->format_string : "",
335 SDDS_type_name[arraydef->type - 1],
336 arraydef->dimensions,
337 arraydef->field_length,
338 arraydef->group_name ? arraydef->group_name : "",
339 arraydef->description ? arraydef->description : "No description");
340 fprintf(outfile, "{\"%s\",\"%s\",\"%s\",\"%s\",\"%s*^%" PRId32 "\",%" PRId32 ",\"%s\",\"%s\"}",
341 arraydef->name ? arraydef->name : "No name",
342 arraydef->units ? arraydef->units : "",
343 arraydef->symbol ? arraydef->symbol : "",
344 arraydef->format_string ? arraydef->format_string : "",
345 SDDS_type_name[arraydef->type - 1],
346 arraydef->dimensions,
347 arraydef->field_length,
348 arraydef->group_name ? arraydef->group_name : "",
349 arraydef->description ? arraydef->description : "No description");
350 }
351 }
352 fprintf(outfile, "},\n");
353
354 /* Associates */
355 fprintf(outfile, " {");
356 if (layout->n_associates) {
357 if (verbose)
358 printf("\n%" PRId32 " associates:\n", layout->n_associates);
359 if (verbose)
360 printf("SDDS FILENAME PATH CONTENTS DESCRIPTION\n");
361 for (i = 0; i < layout->n_associates; i++) {
362 if (i > 0)
363 fprintf(outfile, ",\n ");
364 if (verbose)
365 printf("%-5s %-19s %-29s %-19s %s\n",
366 layout->associate_definition[i].sdds ? "True" : "False",
367 layout->associate_definition[i].filename ? layout->associate_definition[i].filename : "",
368 layout->associate_definition[i].path ? layout->associate_definition[i].path : "",
369 layout->associate_definition[i].contents ? layout->associate_definition[i].contents : "",
370 layout->associate_definition[i].description ? layout->associate_definition[i].description : "No description");
371 fprintf(outfile, "{\"%s\",\"%s\",\"%s\",\"%s\",\"%s\"}",
372 layout->associate_definition[i].sdds ? "True" : "False",
373 layout->associate_definition[i].filename ? layout->associate_definition[i].filename : "",
374 layout->associate_definition[i].path ? layout->associate_definition[i].path : "",
375 layout->associate_definition[i].contents ? layout->associate_definition[i].contents : "",
376 layout->associate_definition[i].description ? layout->associate_definition[i].description : "No description");
377 }
378 }
379 fprintf(outfile, "},\n");
380
381 /* Process tables */
382 fprintf(outfile, " {"); /* Start of array of tables */
383 while ((ntable = SDDS_ReadTable(&SDDS_table)) > 0) {
384 if (ntable > 1)
385 fprintf(outfile, ",\n ");
386 if (comments)
387 fprintf(outfile, "(*Table %ld*)", ntable);
388 fprintf(outfile, "{\n"); /* Start of this table */
389
390 /* Variable parameters */
391 fprintf(outfile, " {"); /* Start of parameters */
392 for (i = 0; i < layout->n_parameters; i++) {
393 if (i > 0)
394 fprintf(outfile, ",\n ");
395 pardef = layout->parameter_definition + i;
396 if (!(data = SDDS_GetParameter(&SDDS_table, pardef->name, NULL))) {
397 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
398 exit(EXIT_FAILURE);
399 }
400
401 /* This parameter */
402 if (comments)
403 fprintf(outfile, "(* %s *)", pardef->name);
404
405 addquotes = 1;
406 switch (pardef->type) {
407 case SDDS_DOUBLE:
408 dd = *(double *)data;
409 sprintf(s, format, dd);
410 if ((ptr = strchr(s, 'e'))) {
411 *ptr = ' ';
412 sscanf(s, "%lf %hd", &ddred, &nexp);
413 fprintf(outfile, rformat, ddred);
414 fprintf(outfile, "*10^%d", nexp);
415 } else {
416 fprintf(outfile, "%s", s);
417 }
418 break;
419 case SDDS_FLOAT:
420 ff = *(float *)data;
421 sprintf(s, format, ff);
422 if ((ptr = strchr(s, 'e'))) {
423 *ptr = ' ';
424 sscanf(s, "%f %hd", &ffred, &nexp);
425 fprintf(outfile, rformat, ffred);
426 fprintf(outfile, "*10^%d", nexp);
427 } else {
428 fprintf(outfile, "%s", s);
429 }
430 break;
431 case SDDS_STRING:
432 ss = *(char **)data;
433 if (*ss == '"')
434 addquotes = 0;
435 else if (SDDS_StringIsBlank(ss) || SDDS_HasWhitespace(ss))
436 addquotes = 0;
437 case SDDS_CHARACTER:
438 if (addquotes)
439 fprintf(outfile, "\"");
440 SDDS_PrintTypedValue(data, 0, pardef->type, NULL, outfile, 0);
441 if (addquotes)
442 fprintf(outfile, "\"");
443 break;
444 default:
445 SDDS_PrintTypedValue(data, 0, pardef->type, NULL, outfile, 0);
446 break;
447 }
448 }
449 fprintf(outfile, "},\n"); /* End of parameters */
450
451 /* Columns */
452 fprintf(outfile, " {"); /* Start of data array */
453 if (layout->n_columns) {
454 SDDS_SetColumnFlags(&SDDS_table, 1);
455 SDDS_SetRowFlags(&SDDS_table, 1);
456 if ((nrows = SDDS_CountRowsOfInterest(&SDDS_table)) < 0) {
457 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
458 exit(EXIT_FAILURE);
459 }
460
461 if (nrows) {
462 for (j = 0; j < nrows; j++) {
463 if (j > 0)
464 fprintf(outfile, ",\n ");
465 fprintf(outfile, "{"); /* Start of row */
466 for (i = 0; i < layout->n_columns; i++) {
467 if (i > 0)
468 fprintf(outfile, ",");
469 coldef = layout->column_definition + i;
470 if (!(data = SDDS_GetValue(&SDDS_table, coldef->name, j, NULL))) {
471 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
472 exit(EXIT_FAILURE);
473 }
474
475 addquotes = 1;
476 switch (coldef->type) {
477 case SDDS_DOUBLE:
478 dd = *(double *)data;
479 sprintf(s, format, dd);
480 if ((ptr = strchr(s, 'e'))) {
481 *ptr = ' ';
482 sscanf(s, "%lf %hd", &ddred, &nexp);
483 fprintf(outfile, rformat, ddred);
484 fprintf(outfile, "*10^%d", nexp);
485 } else {
486 fprintf(outfile, "%s", s);
487 }
488 break;
489 case SDDS_FLOAT:
490 ff = *(float *)data;
491 sprintf(s, format, ff);
492 if ((ptr = strchr(s, 'e'))) {
493 *ptr = ' ';
494 sscanf(s, "%f %hd", &ffred, &nexp);
495 fprintf(outfile, rformat, ffred);
496 fprintf(outfile, "*10^%d", nexp);
497 } else {
498 fprintf(outfile, "%s", s);
499 }
500 break;
501 case SDDS_STRING:
502 ss = *(char **)data;
503 if (*ss == '"')
504 addquotes = 0;
505 else if (SDDS_StringIsBlank(ss) || SDDS_HasWhitespace(ss))
506 addquotes = 0;
507 case SDDS_CHARACTER:
508 if (addquotes)
509 fprintf(outfile, "\"");
510 SDDS_PrintTypedValue(data, 0, coldef->type, NULL, outfile, 0);
511 if (addquotes)
512 fprintf(outfile, "\"");
513 break;
514 default:
515 SDDS_PrintTypedValue(data, 0, coldef->type, NULL, outfile, 0);
516 break;
517 }
518 }
519 fprintf(outfile, "}"); /* End of row */
520 }
521 }
522 }
523 fprintf(outfile, "}"); /* End of data array */
524 fprintf(outfile, "}"); /* End of this table */
525 }
526 fprintf(outfile, "\n }\n"); /* End of array of tables, last major component */
527
528 /* End top level */
529 fprintf(outfile, "}\n"); /* End of top level */
530
531 /* Clean up and exit */
532 fflush(stdout);
533 if (!SDDS_Terminate(&SDDS_table)) {
534 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
535 exit(EXIT_FAILURE);
536 }
537
538 free(format);
539 free(rformat);
540
541 return EXIT_SUCCESS;
542}
SDDS_type_name
char * SDDS_type_name[SDDS_NUM_TYPES]
Array of supported data type names.
Definition SDDS_data.c:43
SDDS_CountRowsOfInterest
int64_t SDDS_CountRowsOfInterest(SDDS_DATASET *SDDS_dataset)
Counts the number of rows marked as "of interest" in the current data table.
Definition SDDS_extract.c:364
SDDS_SetRowFlags
int32_t SDDS_SetRowFlags(SDDS_DATASET *SDDS_dataset, int32_t row_flag_value)
Sets the acceptance flags for all rows in the current data table of a data set.
Definition SDDS_extract.c:46
SDDS_GetParameter
void * SDDS_GetParameter(SDDS_DATASET *SDDS_dataset, char *parameter_name, void *memory)
Retrieves the value of a specified parameter from the current data table of a data set.
Definition SDDS_extract.c:2481
SDDS_SetColumnFlags
int32_t SDDS_SetColumnFlags(SDDS_DATASET *SDDS_dataset, int32_t column_flag_value)
Sets the acceptance flags for all columns in the current data table of a data set.
Definition SDDS_extract.c:218
SDDS_GetDescription
int32_t SDDS_GetDescription(SDDS_DATASET *SDDS_dataset, char **text, char **contents)
Retrieves the text and contents descriptions from an SDDS dataset.
Definition SDDS_extract.c:4626
SDDS_GetValue
void * SDDS_GetValue(SDDS_DATASET *SDDS_dataset, char *column_name, int64_t srow_index, void *memory)
Retrieves the value from a specified column and selected row, optionally storing it in provided memor...
Definition SDDS_extract.c:1754
SDDS_InitializeInput
int32_t SDDS_InitializeInput(SDDS_DATASET *SDDS_dataset, char *filename)
Definition SDDS_input.c:49
SDDS_Terminate
int32_t SDDS_Terminate(SDDS_DATASET *SDDS_dataset)
Definition SDDS_input.c:1448
SDDS_PrintErrors
void SDDS_PrintErrors(FILE *fp, int32_t mode)
Prints recorded error messages to a specified file stream.
Definition SDDS_utils.c:432
SDDS_RegisterProgramName
void SDDS_RegisterProgramName(const char *name)
Registers the executable program name for use in error messages.
Definition SDDS_utils.c:288
SDDS_StringIsBlank
int32_t SDDS_StringIsBlank(char *s)
Checks if a string is blank (contains only whitespace characters).
Definition SDDS_utils.c:2404
SDDS_Bomb
void SDDS_Bomb(char *message)
Terminates the program after printing an error message and recorded errors.
Definition SDDS_utils.c:342
SDDS_PrintTypedValue
int32_t SDDS_PrintTypedValue(void *data, int64_t index, int32_t type, char *format, FILE *fp, uint32_t mode)
Prints a data value of a specified type using an optional printf format string.
Definition SDDS_utils.c:59
SDDS_HasWhitespace
int32_t SDDS_HasWhitespace(char *string)
Checks if a string contains any whitespace characters.
Definition SDDS_utils.c:1422
SDDS_FLOAT
#define SDDS_FLOAT
Identifier for the float data type.
Definition SDDStypes.h:43
SDDS_STRING
#define SDDS_STRING
Identifier for the string data type.
Definition SDDStypes.h:85
SDDS_CHARACTER
#define SDDS_CHARACTER
Identifier for the character data type.
Definition SDDStypes.h:91
SDDS_DOUBLE
#define SDDS_DOUBLE
Identifier for the double data type.
Definition SDDStypes.h:37
match_string
long match_string(char *string, char **option, long n_options, long mode)
Matches a given string against an array of option strings based on specified modes.
Definition match_string.c:34
scanargs
int scanargs(SCANNED_ARG **scanned, int argc, char **argv)
Definition scanargs.c:36
processPipeOption
long processPipeOption(char **item, long items, unsigned long *flags)
Definition scanargs.c:356
processFilenames
void processFilenames(char *programName, char **input, char **output, unsigned long pipeFlags, long noWarnings, long *tmpOutputUsed)
Definition scanargs.c:390
ARRAY_DEFINITION
Definition SDDS.h:186
COLUMN_DEFINITION
Definition SDDS.h:178
PARAMETER_DEFINITION
Definition SDDS.h:169
SDDS_DATASET
Definition SDDS.h:303
SDDS_LAYOUT
Definition SDDS.h:252

Variable Documentation

◆ option

char* option[N_OPTIONS]
static
Initial value:
= {
"comments",
"format",
"verbose",
"pipe"
}

Definition at line 81 of file sdds2math.c.

81 {
82 "comments",
83 "format",
84 "verbose",
85 "pipe"
86};

◆ USAGE

char* USAGE
static
Initial value:
=
"\nUsage:\n"
" sdds2math [<SDDSfilename>] [<outputname>] [OPTIONS]\n"
"\n"
"Options:\n"
" -pipe[=in][,out] Standard SDDS Toolkit pipe option.\n"
" -comments Include helpful Mathematica comments in the output file.\n"
" -format=<format-string> Specify the format for double precision numbers (Default: " FORMAT ").\n"
" -verbose Display header information to the terminal.\n"
"\n"
"Description:\n"
" sdds2math converts an SDDS file into a Mathematica-readable format.\n"
" The output is a single Mathematica variable with the structure:\n"
" sdds = {description, coldef, pardef, arraydef, associates, tables}\n"
" where each component contains detailed information about the SDDS data.\n"
"\n"
"Author:\n"
" Kenneth Evans (Original version: 1994)\n"
" Updated: " __DATE__ " " __TIME__ ", SVN revision: " SVN_VERSION "\n"

Definition at line 89 of file sdds2math.c.

Generated by doxygen 1.12.0