SDDSlib
Loading...
Searching...
No Matches
Functions
sdds_read_demo.c File Reference

A program to read and process SDDS files, displaying parameters, columns, and arrays. More...

#include "SDDS.h"
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <float.h>

Go to the source code of this file.

Functions

int main (int argc, char **argv)
 Main function that processes the SDDS file.
 

Detailed Description

A program to read and process SDDS files, displaying parameters, columns, and arrays.

This program reads an SDDS (Self Describing Data Set) file specified as a command-line argument, and processes its pages, parameters, columns, and arrays, printing their values to the console.

It demonstrates how to use the SDDS library to access different types of data within an SDDS file.

Definition in file sdds_read_demo.c.

Function Documentation

◆ main()

int main ( int argc,
char ** argv )

Main function that processes the SDDS file.

Parameters
argcThe number of command-line arguments.
argvThe array of command-line argument strings.
Returns
Returns 0 on successful execution, non-zero otherwise.

The main function checks the command-line arguments, initializes the SDDS dataset, and iterates over the pages in the SDDS file. For each page, it processes the parameters, columns, and arrays, printing their names and values to the console.

< SDDS dataset structure

< Current page number

< Number of parameters

< Number of columns

< Number of arrays

< Number of rows in the current page

< Array of parameter names

< Array of column names

< Array of array names

< Data type identifier

< Generic data pointer

Check command-line arguments

Initialize SDDS input

Get parameter, column, and array names

Iterate over pages in the SDDS file

Process parameters

Get parameter value

< Free the allocated string

Process columns

< Free each string

Free data

Process arrays

Free array data

Free parameter names

Free column names

Free array names

Terminate SDDS

Definition at line 28 of file sdds_read_demo.c.

28 {
29 SDDS_DATASET SDDS_dataset; /**< SDDS dataset structure */
30 int32_t page; /**< Current page number */
31 int32_t n_params; /**< Number of parameters */
32 int32_t n_columns; /**< Number of columns */
33 int32_t n_arrays; /**< Number of arrays */
34 int64_t n_rows; /**< Number of rows in the current page */
35 char **parameter_names; /**< Array of parameter names */
36 char **column_names; /**< Array of column names */
37 char **array_names; /**< Array of array names */
38 int32_t type; /**< Data type identifier */
39 void *data; /**< Generic data pointer */
40
41 /** Check command-line arguments */
42 if (argc != 2) {
43 fprintf(stderr, "Usage: %s filename.sdds\n", argv[0]);
44 exit(1);
45 }
46
47 /** Initialize SDDS input */
48 if (!SDDS_InitializeInput(&SDDS_dataset, argv[1])) {
49 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
50 exit(1);
51 }
52
53 /** Get parameter, column, and array names */
54 parameter_names = SDDS_GetParameterNames(&SDDS_dataset, &n_params);
55 column_names = SDDS_GetColumnNames(&SDDS_dataset, &n_columns);
56 array_names = SDDS_GetArrayNames(&SDDS_dataset, &n_arrays);
57
58 page = 0;
59 /** Iterate over pages in the SDDS file */
60 while ((page = SDDS_ReadPage(&SDDS_dataset)) > 0) {
61 printf("Page %d\n", page);
62
63 n_rows = SDDS_CountRowsOfInterest(&SDDS_dataset);
64
65 /** Process parameters */
66 printf("Parameters:\n");
67 for (int32_t i = 0; i < n_params; i++) {
68 type = SDDS_GetParameterType(&SDDS_dataset, i);
69 printf(" %s = ", parameter_names[i]);
70 switch (type) {
71 case SDDS_SHORT: {
72 short value;
73 /** Get parameter value */
74 if (SDDS_GetParameter(&SDDS_dataset, parameter_names[i], &value) == NULL) {
75 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
76 continue;
77 }
78 printf("%hd\n", value);
79 break;
80 }
81 case SDDS_USHORT: {
82 unsigned short value;
83 if (SDDS_GetParameter(&SDDS_dataset, parameter_names[i], &value) == NULL) {
84 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
85 continue;
86 }
87 printf("%hu\n", value);
88 break;
89 }
90 case SDDS_LONG: {
91 int32_t value;
92 if (SDDS_GetParameter(&SDDS_dataset, parameter_names[i], &value) == NULL) {
93 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
94 continue;
95 }
96 printf("%" PRId32 "\n", value);
97 break;
98 }
99 case SDDS_ULONG: {
100 uint32_t value;
101 if (SDDS_GetParameter(&SDDS_dataset, parameter_names[i], &value) == NULL) {
102 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
103 continue;
104 }
105 printf("%" PRIu32 "\n", value);
106 break;
107 }
108 case SDDS_LONG64: {
109 int64_t value;
110 if (SDDS_GetParameter(&SDDS_dataset, parameter_names[i], &value) == NULL) {
111 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
112 continue;
113 }
114 printf("%" PRId64 "\n", value);
115 break;
116 }
117 case SDDS_ULONG64: {
118 uint64_t value;
119 if (SDDS_GetParameter(&SDDS_dataset, parameter_names[i], &value) == NULL) {
120 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
121 continue;
122 }
123 printf("%" PRIu64 "\n", value);
124 break;
125 }
126 case SDDS_FLOAT: {
127 float value;
128 if (SDDS_GetParameter(&SDDS_dataset, parameter_names[i], &value) == NULL) {
129 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
130 continue;
131 }
132 printf("%15.6e\n", value);
133 break;
134 }
135 case SDDS_DOUBLE: {
136 double value;
137 if (SDDS_GetParameter(&SDDS_dataset, parameter_names[i], &value) == NULL) {
138 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
139 continue;
140 }
141 printf("%21.14e\n", value);
142 break;
143 }
144 case SDDS_LONGDOUBLE: {
145 long double value;
146 if (SDDS_GetParameter(&SDDS_dataset, parameter_names[i], &value) == NULL) {
147 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
148 continue;
149 }
150 if (LDBL_DIG == 18) {
151 printf("%21.18Le\n", value);
152 } else {
153 printf("%21.14Le\n", value);
154 }
155 break;
156 }
157 case SDDS_STRING: {
158 char *value;
159 if (SDDS_GetParameter(&SDDS_dataset, parameter_names[i], &value) == NULL) {
160 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
161 continue;
162 }
163 printf("%s\n", value);
164 free(value); /**< Free the allocated string */
165 break;
166 }
167 case SDDS_CHARACTER: {
168 char value;
169 if (SDDS_GetParameter(&SDDS_dataset, parameter_names[i], &value) == NULL) {
170 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
171 continue;
172 }
173 printf("%c\n", value);
174 break;
175 }
176 default:
177 printf("Unknown type\n");
178 break;
179 }
180 }
181
182 /** Process columns */
183 printf("Columns (%" PRId64 " rows):\n", n_rows);
184 for (int32_t i = 0; i < n_columns; i++) {
185 type = SDDS_GetColumnType(&SDDS_dataset, i);
186 printf(" Column: %s\n", column_names[i]);
187 data = SDDS_GetColumn(&SDDS_dataset, column_names[i]);
188 if (data == NULL) {
189 fprintf(stderr, "Error getting column %s\n", column_names[i]);
190 continue;
191 }
192 switch (type) {
193 case SDDS_SHORT: {
194 short *values = (short *)data;
195 for (int64_t row = 0; row < n_rows; row++) {
196 printf(" %hd\n", values[row]);
197 }
198 break;
199 }
200 case SDDS_USHORT: {
201 unsigned short *values = (unsigned short *)data;
202 for (int64_t row = 0; row < n_rows; row++) {
203 printf(" %hu\n", values[row]);
204 }
205 break;
206 }
207 case SDDS_LONG: {
208 int32_t *values = (int32_t *)data;
209 for (int64_t row = 0; row < n_rows; row++) {
210 printf(" %" PRId32 "\n", values[row]);
211 }
212 break;
213 }
214 case SDDS_ULONG: {
215 uint32_t *values = (uint32_t *)data;
216 for (int64_t row = 0; row < n_rows; row++) {
217 printf(" %" PRIu32 "\n", values[row]);
218 }
219 break;
220 }
221 case SDDS_LONG64: {
222 int64_t *values = (int64_t *)data;
223 for (int64_t row = 0; row < n_rows; row++) {
224 printf(" %" PRId64 "\n", values[row]);
225 }
226 break;
227 }
228 case SDDS_ULONG64: {
229 uint64_t *values = (uint64_t *)data;
230 for (int64_t row = 0; row < n_rows; row++) {
231 printf(" %" PRIu64 "\n", values[row]);
232 }
233 break;
234 }
235 case SDDS_FLOAT: {
236 float *values = (float *)data;
237 for (int64_t row = 0; row < n_rows; row++) {
238 printf(" %15.6e\n", values[row]);
239 }
240 break;
241 }
242 case SDDS_DOUBLE: {
243 double *values = (double *)data;
244 for (int64_t row = 0; row < n_rows; row++) {
245 printf(" %21.14e\n", values[row]);
246 }
247 break;
248 }
249 case SDDS_LONGDOUBLE: {
250 long double *values = (long double *)data;
251 if (LDBL_DIG == 18) {
252 for (int64_t row = 0; row < n_rows; row++) {
253 printf(" %21.18Le\n", values[row]);
254 }
255 } else {
256 for (int64_t row = 0; row < n_rows; row++) {
257 printf(" %21.14Le\n", values[row]);
258 }
259 }
260 break;
261 }
262 case SDDS_STRING: {
263 char **values = (char **)data;
264 for (int64_t row = 0; row < n_rows; row++) {
265 printf(" %s\n", values[row]);
266 free(values[row]); /**< Free each string */
267 }
268 break;
269 }
270 case SDDS_CHARACTER: {
271 char *values = (char *)data;
272 for (int64_t row = 0; row < n_rows; row++) {
273 printf(" %c\n", values[row]);
274 }
275 break;
276 }
277 default:
278 printf("Unknown type\n");
279 break;
280 }
281 /** Free data */
282 SDDS_Free(data);
283 data = NULL;
284 }
285
286 /** Process arrays */
287 printf("Arrays:\n");
288 for (int32_t i = 0; i < n_arrays; i++) {
289 type = SDDS_GetArrayType(&SDDS_dataset, i);
290 data = SDDS_GetArray(&SDDS_dataset, array_names[i], NULL);
291 if (!data) {
292 fprintf(stderr, "Error getting array %s\n", array_names[i]);
293 continue;
294 }
295 printf(" Array: %s (dimensions: ", array_names[i]);
296
297 SDDS_ARRAY *array = (SDDS_ARRAY *)data;
298 for (int32_t d = 0; d < array->definition->dimensions; d++) {
299 printf("%d", array->dimension[d]);
300 if (d < array->definition->dimensions - 1)
301 printf(" x ");
302 }
303 printf(")\n");
304
305 switch (type) {
306 case SDDS_SHORT: {
307 short *values = (short *)array->data;
308 for (int32_t idx = 0; idx < array->elements; idx++) {
309 printf(" %hd\n", values[idx]);
310 }
311 break;
312 }
313 case SDDS_USHORT: {
314 unsigned short *values = (unsigned short *)array->data;
315 for (int32_t idx = 0; idx < array->elements; idx++) {
316 printf(" %hu\n", values[idx]);
317 }
318 break;
319 }
320 case SDDS_LONG: {
321 int32_t *values = (int32_t *)array->data;
322 for (int32_t idx = 0; idx < array->elements; idx++) {
323 printf(" %" PRId32 "\n", values[idx]);
324 }
325 break;
326 }
327 case SDDS_ULONG: {
328 uint32_t *values = (uint32_t *)array->data;
329 for (int32_t idx = 0; idx < array->elements; idx++) {
330 printf(" %" PRIu32 "\n", values[idx]);
331 }
332 break;
333 }
334 case SDDS_LONG64: {
335 int64_t *values = (int64_t *)array->data;
336 for (int32_t idx = 0; idx < array->elements; idx++) {
337 printf(" %" PRId64 "\n", values[idx]);
338 }
339 break;
340 }
341 case SDDS_ULONG64: {
342 uint64_t *values = (uint64_t *)array->data;
343 for (int32_t idx = 0; idx < array->elements; idx++) {
344 printf(" %" PRIu64 "\n", values[idx]);
345 }
346 break;
347 }
348 case SDDS_FLOAT: {
349 float *values = (float *)array->data;
350 for (int32_t idx = 0; idx < array->elements; idx++) {
351 printf(" %15.6e\n", values[idx]);
352 }
353 break;
354 }
355 case SDDS_DOUBLE: {
356 double *values = (double *)array->data;
357 for (int32_t idx = 0; idx < array->elements; idx++) {
358 printf(" %21.14e\n", values[idx]);
359 }
360 break;
361 }
362 case SDDS_LONGDOUBLE: {
363 long double *values = (long double *)array->data;
364 if (LDBL_DIG == 18) {
365 for (int32_t idx = 0; idx < array->elements; idx++) {
366 printf(" %21.18Le\n", values[idx]);
367 }
368 } else {
369 for (int32_t idx = 0; idx < array->elements; idx++) {
370 printf(" %21.14Le\n", values[idx]);
371 }
372 }
373 break;
374 }
375 case SDDS_STRING: {
376 char **values = (char **)array->data;
377 for (int32_t idx = 0; idx < array->elements; idx++) {
378 printf(" %s\n", values[idx]);
379 }
380 break;
381 }
382 case SDDS_CHARACTER: {
383 char *values = (char *)array->data;
384 for (int32_t idx = 0; idx < array->elements; idx++) {
385 printf(" %c\n", values[idx]);
386 }
387 break;
388 }
389 default:
390 printf("Unknown type\n");
391 break;
392 }
393 /** Free array data */
394 SDDS_FreeArray(data);
395 }
396 }
397
398 /** Free parameter names */
399 SDDS_FreeStringArray(parameter_names, n_params);
400 SDDS_Free(parameter_names);
401
402 /** Free column names */
403 SDDS_FreeStringArray(column_names, n_columns);
404 SDDS_Free(column_names);
405
406 /** Free array names */
407 SDDS_FreeStringArray(array_names, n_arrays);
408 SDDS_Free(array_names);
409
410 /** Terminate SDDS */
411 SDDS_Terminate(&SDDS_dataset);
412 return 0;
413}
SDDS_GetColumn
void * SDDS_GetColumn(SDDS_DATASET *SDDS_dataset, char *column_name)
Retrieves a copy of the data for a specified column, including only rows marked as "of interest".
Definition SDDS_extract.c:611
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_GetArray
SDDS_ARRAY * SDDS_GetArray(SDDS_DATASET *SDDS_dataset, char *array_name, SDDS_ARRAY *memory)
Retrieves an array from the current data table of an SDDS dataset.
Definition SDDS_extract.c:4209
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_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_ReadPage
int32_t SDDS_ReadPage(SDDS_DATASET *SDDS_dataset)
Definition SDDS_input.c:1006
SDDS_FreeArray
void SDDS_FreeArray(SDDS_ARRAY *array)
Frees memory allocated for an SDDS array structure.
Definition SDDS_utils.c:2766
SDDS_FreeStringArray
int32_t SDDS_FreeStringArray(char **string, int64_t strings)
Frees an array of strings by deallocating each individual string.
Definition SDDS_utils.c:2865
SDDS_GetParameterType
int32_t SDDS_GetParameterType(SDDS_DATASET *SDDS_dataset, int32_t index)
Retrieves the data type of a parameter in the SDDS dataset by its index.
Definition SDDS_utils.c:2251
SDDS_GetParameterNames
char ** SDDS_GetParameterNames(SDDS_DATASET *SDDS_dataset, int32_t *number)
Retrieves the names of all parameters in the SDDS dataset.
Definition SDDS_utils.c:2501
SDDS_GetColumnNames
char ** SDDS_GetColumnNames(SDDS_DATASET *SDDS_dataset, int32_t *number)
Retrieves the names of all columns in the SDDS dataset.
Definition SDDS_utils.c:2460
SDDS_GetArrayType
int32_t SDDS_GetArrayType(SDDS_DATASET *SDDS_dataset, int32_t index)
Retrieves the data type of an array in the SDDS dataset by its index.
Definition SDDS_utils.c:2202
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_GetColumnType
int32_t SDDS_GetColumnType(SDDS_DATASET *SDDS_dataset, int32_t index)
Retrieves the data type of a column in the SDDS dataset by its index.
Definition SDDS_utils.c:2153
SDDS_GetArrayNames
char ** SDDS_GetArrayNames(SDDS_DATASET *SDDS_dataset, int32_t *number)
Retrieves the names of all arrays in the SDDS dataset.
Definition SDDS_utils.c:2539
SDDS_Free
void SDDS_Free(void *mem)
Free memory previously allocated by SDDS_Malloc.
Definition SDDS_utils.c:655
SDDS_ULONG
#define SDDS_ULONG
Identifier for the unsigned 32-bit integer data type.
Definition SDDStypes.h:67
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_ULONG64
#define SDDS_ULONG64
Identifier for the unsigned 64-bit integer data type.
Definition SDDStypes.h:55
SDDS_LONG
#define SDDS_LONG
Identifier for the signed 32-bit integer data type.
Definition SDDStypes.h:61
SDDS_SHORT
#define SDDS_SHORT
Identifier for the signed short integer data type.
Definition SDDStypes.h:73
SDDS_CHARACTER
#define SDDS_CHARACTER
Identifier for the character data type.
Definition SDDStypes.h:91
SDDS_USHORT
#define SDDS_USHORT
Identifier for the unsigned short integer data type.
Definition SDDStypes.h:79
SDDS_DOUBLE
#define SDDS_DOUBLE
Identifier for the double data type.
Definition SDDStypes.h:37
SDDS_LONGDOUBLE
#define SDDS_LONGDOUBLE
Identifier for the long double data type.
Definition SDDStypes.h:31
SDDS_LONG64
#define SDDS_LONG64
Identifier for the signed 64-bit integer data type.
Definition SDDStypes.h:49
SDDS_ARRAY
Definition SDDS.h:285
SDDS_DATASET
Definition SDDS.h:303
Generated by doxygen 1.12.0