diff options
Diffstat (limited to 'examples')
| -rw-r--r-- | examples/Makefile.in | 24 | ||||
| -rw-r--r-- | examples/h5_attribute.c | 259 | ||||
| -rw-r--r-- | examples/h5_select.c | 204 |
3 files changed, 482 insertions, 5 deletions
diff --git a/examples/Makefile.in b/examples/Makefile.in index 0a3d851..2d476db 100644 --- a/examples/Makefile.in +++ b/examples/Makefile.in @@ -12,20 +12,21 @@ CPPFLAGS=-I. -I../src @CPPFLAGS@ # These are the programs that `make all' will build, `make install' # will copy to the binaries directory, and `make uninstall' will # remove from that directory. -PROGS=h5_chunk_read h5_compound h5_extend_write h5_group h5_read h5_write +PROGS=h5_chunk_read h5_compound h5_extend_write h5_group h5_read h5_write \ + h5_select h5_attribute # These are the programs that `make test' will run TESTS= # These are the files that `make clean' (and derivatives) will remove from # this directory. -CLEAN= +CLEAN=*.h5 # List all source files here. The list of object files will be # created by replacing the `.c' with a `.o'. This list is necessary # for building automatic dependencies. PROG_SRC=h5_chunk_read.c h5_compound.c h5_extend_write.c h5_group.c \ - h5_read.c h5_write.c + h5_read.c h5_write.c h5_select.c h5_attribute.c PROG_OBJ=$(PROG_SRC:.c=.o) # List the source files for each individual program. Most programs @@ -51,6 +52,13 @@ READ_OBJ=$(READ_SRC:.c=.o) WRITE_SRC=h5_write.c WRITE_OBJ=$(WRITE_SRC:.c=.o) +SELECT_SRC=h5_select.c +SELECT_OBJ=$(SELECT_SRC:.c=.o) + + +ATTRIBUTE_SRC=h5_attribute.c +ATTRIBUTE_OBJ=$(ATTRIBUTE_SRC:.c=.o) + # How to build the programs... h5_chunk_read: $(CHUNK_READ_OBJ) ../src/libhdf5.a $(CC) $(CFLAGS) -o $@ $(CHUNK_READ_OBJ) ../src/libhdf5.a $(LIBS) @@ -64,10 +72,16 @@ h5_extend_write: $(EXTEND_WRITE_OBJ) ../src/libhdf5.a h5_group: $(GROUP_OBJ) ../src/libhdf5.a $(CC) $(CFLAGS) -o $@ $(GROUP_OBJ) ../src/libhdf5.a $(LIBS) +h5_write: $(WRITE_OBJ) ../src/libhdf5.a + $(CC) $(CFLAGS) -o $@ $(WRITE_OBJ) ../src/libhdf5.a $(LIBS) + h5_read: $(READ_OBJ) ../src/libhdf5.a $(CC) $(CFLAGS) -o $@ $(READ_OBJ) ../src/libhdf5.a $(LIBS) -h5_write: $(WRITE_OBJ) ../src/libhdf5.a - $(CC) $(CFLAGS) -o $@ $(WRITE_OBJ) ../src/libhdf5.a $(LIBS) +h5_select: $(SELECT_OBJ) ../src/libhdf5.a + $(CC) $(CFLAGS) -o $@ $(SELECT_OBJ) ../src/libhdf5.a $(LIBS) + +h5_attribute: $(ATTRIBUTE_OBJ) ../src/libhdf5.a + $(CC) $(CFLAGS) -o $@ $(ATTRIBUTE_OBJ) ../src/libhdf5.a $(LIBS) @CONCLUDE@ diff --git a/examples/h5_attribute.c b/examples/h5_attribute.c new file mode 100644 index 0000000..661f72d --- /dev/null +++ b/examples/h5_attribute.c @@ -0,0 +1,259 @@ +/* + * This program illustrates the usage of the H5A Interface functions. + * It creates and writes a dataset, and then creates and writes array, + * scalar, and string attributes of the dataset. + * Program reopens the file, attaches to the scalar attribute using + * attribute name and reads and displays its value. Then index of the + * third attribute is used to read and display attribute values. + * The H5Aiterate function is used to iterate through the dataset attributes, + * and display their names. The function is also reads and displays the values + * of the array attribute. + */ + +#include <hdf5.h> + +#define FILE "Attributes.h5" + +#define RANK 1 /* Rank and size of the dataset */ +#define SIZE 7 + +#define ARANK 2 /* Rank and dimension sizes of the first dataset attribute */ +#define ADIM1 2 +#define ADIM2 3 +#define ANAME "Float attribute" /* Name of the array attribute */ +#define ANAMES "Character attribute" /* Name of the string attribute */ + +herr_t attr_info(hid_t loc_id, const char *name, void *opdata); + /* Operator function */ + +int main (void) +{ + + hid_t file, dataset; /* File and dataset identifiers */ + + hid_t fid; /* Dataspace identifier */ + hid_t attr1, attr2, attr3; /* Attribute identifiers */ + hid_t attr; + hid_t aid1, aid2, aid3; /* Attribute dataspace identifiers */ + hid_t atype; /* Attribute type */ + + hsize_t fdim[] = {SIZE}; + hsize_t adim[] = {ADIM1, ADIM2}; /* Dimensions of the first attribute */ + + float matrix[ADIM1][ADIM2]; /* Attribute data */ + + herr_t ret; /* Return value */ + uint i,j; /* Counters */ + int idx; /* Attribute index */ + char string_out[80]; /* Buffer to read string attribute back */ + int point_out; /* Buffer to read scalar attribute back */ + +/* + * Data initialization. + */ +int vector[] = {1, 2, 3, 4, 5, 6, 7}; /* Dataset data */ +int point = 1; /* Value of the scalar attribute */ +char string[] = "ABCD"; /* Value of the string attribute */ + + +for (i=0; i < ADIM1; i++) { /* Values of the array attribute */ + for (j=0; j < ADIM2; j++) + matrix[i][j] = -1.; +} + +/* + * Create a file. + */ +file = H5Fcreate(FILE, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT); + +/* + * Create the dataspace for the dataset in the file. + */ +fid = H5Screate(H5S_SIMPLE); +ret = H5Sset_extent_simple(fid, RANK, fdim, NULL); + +/* + * Create the dataset in the file. + */ +dataset = H5Dcreate(file, "Dataset", H5T_NATIVE_INT, fid, H5P_DEFAULT); + +/* + * Write data to the dataset. + */ +ret = H5Dwrite(dataset, H5T_NATIVE_INT, H5S_ALL , H5S_ALL, H5P_DEFAULT, vector); + +/* + * Create dataspace for the first attribute. + */ +aid1 = H5Screate(H5S_SIMPLE); +ret = H5Sset_extent_simple(aid1, ARANK, adim, NULL); + +/* + * Create array attribute. + */ +attr1 = H5Acreate(dataset, ANAME, H5T_NATIVE_FLOAT, aid1, H5P_DEFAULT); + +/* + * Write array attribute. + */ +ret = H5Awrite(attr1, H5T_NATIVE_FLOAT, matrix); + +/* + * Create scalar attribute. + */ +aid2 = H5Screate(H5S_SCALAR); +attr2 = H5Acreate(dataset, "Integer attribute", H5T_NATIVE_INT, aid2, + H5P_DEFAULT); + +/* + * Write scalar attribute. + */ +ret = H5Awrite(attr2, H5T_NATIVE_INT, &point); + +/* + * Create string attribute. + */ +aid3 = H5Screate(H5S_SCALAR); +atype = H5Tcopy(H5T_C_S1); + H5Tset_size(atype, 4); +attr3 = H5Acreate(dataset, ANAMES, atype, aid3, H5P_DEFAULT); + +/* + * Write string attribute. + */ +ret = H5Awrite(attr3, atype, string); + +/* + * Close attribute and file datapsaces. + */ +ret = H5Sclose(aid1); +ret = H5Sclose(aid2); +ret = H5Sclose(aid3); +ret = H5Sclose(fid); + +/* + * Close the attributes. + */ +ret = H5Aclose(attr1); +ret = H5Aclose(attr2); +ret = H5Aclose(attr3); + +/* + * Close the dataset. + */ +ret = H5Dclose(dataset); + +/* + * Close the file. + */ +ret = H5Fclose(file); + +/* + * Reopen the file. + */ +file = H5Fopen(FILE, H5F_ACC_RDONLY, H5P_DEFAULT); + +/* + * Open the dataset. + */ +dataset = H5Dopen(file,"Dataset"); + +/* + * Attach to the scalar attribute using attribute name, then read and + * display its value. + */ +attr = H5Aopen_name(dataset,"Integer attribute"); +ret = H5Aread(attr, H5T_NATIVE_INT, &point_out); +printf("The value of the attribute \"Integer attribute\" is %d \n", point_out); +ret = H5Aclose(attr); + +/* + * Attach to the string attribute using its index, then read and display the value. + */ +attr = H5Aopen_idx(dataset, 2); +atype = H5Tcopy(H5T_C_S1); + H5Tset_size(atype, 4); +ret = H5Aread(attr, atype, string_out); +printf("The value of the attribute with the index 2 is %s \n", string_out); +ret = H5Aclose(attr); +ret = H5Tclose(atype); + +/* + * Get attribute info using iteration function. + */ +idx = H5Aiterate(dataset, NULL, attr_info, NULL); + +/* + * Close the dataset and the file. + */ +H5Dclose(dataset); +H5Fclose(file); +return 0; +} + +/* + * Operator function. + */ +herr_t attr_info(hid_t loc_id, const char *name, void *opdata) +{ + hid_t attr, atype, aspace; /* Attribute, datatype and dataspace identifiers */ + int rank; + hsize_t sdim[64]; + herr_t ret; + int i; + size_t npoints; /* Number of elements in the array attribute. */ + float *float_array; /* Pointer to the array attribute. */ +/* + * Open the attribute using its name. + */ + attr = H5Aopen_name(loc_id, name); + +/* + * Display attribute name. + */ + printf("\n"); + printf("Name : "); + puts(name); + +/* + * Get attribute datatype, dataspace, rank, and dimensions. + */ + atype = H5Aget_type(attr); + aspace = H5Aget_space(attr); + rank = H5Sextent_ndims(aspace); + ret = H5Sextent_dims(aspace, sdim, NULL); +/* + * Display rank and dimension sizes for the array attribute. + */ + + if(rank > 0) { + printf("Rank : %d \n", rank); + printf("Dimension sizes : "); + for (i=0; i< rank; i++) printf("%d ", (int)sdim[i]); + printf("\n"); + } + +/* + * Read array attribute and display its type and values. + */ + + if (H5T_FLOAT == H5Tget_class(atype)) { + printf("Type : FLOAT \n"); + npoints = H5Sextent_npoints(aspace); + float_array = (float *)malloc(sizeof(float)*(int)npoints); + ret = H5Aread(attr, atype, float_array); + printf("Values : "); + for( i = 0; i < npoints; i++) printf("%f ", float_array[i]); + printf("\n"); + free(float_array); + } + + +/* + * Release all identifiers. + */ + H5Tclose(atype); + H5Sclose(aspace); + H5Aclose(attr); + return 0; +} diff --git a/examples/h5_select.c b/examples/h5_select.c new file mode 100644 index 0000000..4de93e0 --- /dev/null +++ b/examples/h5_select.c @@ -0,0 +1,204 @@ +/* + * This program shows how the H5Sselect_hyperslab and H5Sselect_elements + * functions are used to write selected data from memory to the file. + * Program takes 48 elements from the linear buffer and writes them into + * the matrix using 3x2 blocks, (4,3) stride and (2,4) count. + * Then four elements of the matrix are overwritten with the new values and + * file is closed. Program reopens the file and reads and displays the result. + */ + +#include <hdf5.h> + +#define FILE "Select.h5" + +#define MSPACE1_RANK 1 /* Rank of the first dataset in memory */ +#define MSPACE1_DIM 50 /* Dataset size in memory */ + +#define MSPACE2_RANK 1 /* Rank of the second dataset in memory */ +#define MSPACE2_DIM 4 /* Dataset size in memory */ + +#define FSPACE_RANK 2 /* Dataset rank as it is stored in the file */ +#define FSPACE_DIM1 8 /* Dimension sizes of the dataset as it is + stored in the file */ +#define FSPACE_DIM2 12 + + /* We will read dataset back from the file + to the dataset in memory with these + dataspace parameters. */ +#define MSPACE_RANK 2 +#define MSPACE_DIM1 8 +#define MSPACE_DIM2 12 + +#define NPOINTS 4 /* Number of points that will be selected + and overwritten */ +int main (void) +{ + + hid_t file, dataset; /* File and dataset identifiers */ + hid_t mid1, mid2, fid; /* Dataspace identifiers */ + hsize_t dim1[] = {MSPACE1_DIM}; /* Dimension size of the first dataset + (in memory) */ + hsize_t dim2[] = {MSPACE2_DIM}; /* Dimension size of the second dataset + (in memory */ + hsize_t fdim[] = {FSPACE_DIM1, FSPACE_DIM2}; + /* Dimension sizes of the dataset (on disk) */ + + hssize_t start[2]; /* Start of hyperslab */ + hsize_t stride[2]; /* Stride of hyperslab */ + hsize_t count[2]; /* Block count */ + hsize_t block[2]; /* Block sizes */ + + hssize_t coord[NPOINTS][FSPACE_RANK]; /* Array to store selected points + from the file dataspace */ + herr_t ret; + uint i,j; + int matrix[MSPACE_DIM1][MSPACE_DIM2]; + int vector[MSPACE1_DIM]; + int values[] = {53, 59, 61, 67}; /* New values to be written */ +/* + * Buffers' initialization. + */ +vector[0] = vector[MSPACE1_DIM - 1] = -1; +for (i = 1; i < MSPACE1_DIM - 1; i++) vector[i] = i; + +for (i = 0; i < MSPACE_DIM1; i++) { + for (j = 0; j < MSPACE_DIM2; j++) + matrix[i][j] = 0; +} +/* + * Create a file. + */ +file = H5Fcreate(FILE, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT); + +/* + * Create dataspace for the dataset in the file. + */ +fid = H5Screate_simple(FSPACE_RANK, fdim, NULL); + +/* + * Create dataset and write it into the file. + */ +dataset = H5Dcreate(file, "Matrix in file", H5T_NATIVE_INT, fid, H5P_DEFAULT); +ret = H5Dwrite(dataset, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, matrix); + +/* + * Select hyperslab for the dataset in the file, using 3x2 blocks, (4,3) stride + * (2,4) count starting at the position (0,1). + */ +start[0] = 0; start[1] = 1; +stride[0] = 4; stride[1] = 3; +count[0] = 2; count[1] = 4; +block[0] = 3; block[1] = 2; +ret = H5Sselect_hyperslab(fid, H5S_SELECT_SET, start, stride, count, block); + +/* + * Create dataspace for the first dataset. + */ +mid1 = H5Screate_simple(MSPACE1_RANK, dim1, NULL); + +/* + * Select hyperslab. + * We will use 48 elements of the vector buffer starting at the second element. + * Selected elements are 1 2 3 . . . 48 + */ +start[0] = 1; +stride[0] = 1; +count[0] = 48; +block[0] = 1; +ret = H5Sselect_hyperslab(mid1, H5S_SELECT_SET, start, stride, count, block); + +/* + * Write selection from the vector buffer to the dataset in the file. + * + * File dataset should look like this: + * 0 1 2 0 3 4 0 5 6 0 7 8 + * 0 9 10 0 11 12 0 13 14 0 15 16 + * 0 17 18 0 19 20 0 21 22 0 23 24 + * 0 0 0 0 0 0 0 0 0 0 0 0 + * 0 25 26 0 27 28 0 29 30 0 31 32 + * 0 33 34 0 35 36 0 37 38 0 39 40 + * 0 41 42 0 43 44 0 45 46 0 47 48 + * 0 0 0 0 0 0 0 0 0 0 0 0 + */ +ret = H5Dwrite(dataset, H5T_NATIVE_INT, mid1, fid, H5P_DEFAULT, vector); + +/* + * Reset the selection for the file dataspace fid. + */ +ret = H5Sselect_none(fid); + +/* + * Create dataspace for the second dataset. + */ +mid2 = H5Screate_simple(MSPACE2_RANK, dim2, NULL); + +/* + * Select sequence of NPOINTS points in the file dataspace. + */ +coord[0][0] = 0; coord[0][1] = 0; +coord[1][0] = 3; coord[1][1] = 3; +coord[2][0] = 3; coord[2][1] = 5; +coord[3][0] = 5; coord[3][1] = 6; + +ret = H5Sselect_elements(fid, H5S_SELECT_SET, NPOINTS, + (const hssize_t **)coord); + +/* + * Write new selection of points to the dataset. + */ +ret = H5Dwrite(dataset, H5T_NATIVE_INT, mid2, fid, H5P_DEFAULT, values); + +/* + * File dataset should look like this: + * 53 1 2 0 3 4 0 5 6 0 7 8 + * 0 9 10 0 11 12 0 13 14 0 15 16 + * 0 17 18 0 19 20 0 21 22 0 23 24 + * 0 0 0 59 0 61 0 0 0 0 0 0 + * 0 25 26 0 27 28 0 29 30 0 31 32 + * 0 33 34 0 35 36 67 37 38 0 39 40 + * 0 41 42 0 43 44 0 45 46 0 47 48 + * 0 0 0 0 0 0 0 0 0 0 0 0 + * + */ + +/* + * Close memory file and memory dataspaces. + */ +ret = H5Sclose(mid1); +ret = H5Sclose(mid2); +ret = H5Sclose(fid); + +/* + * Close dataset. + */ +ret = H5Dclose(dataset); + +/* + * Close the file. + */ +ret = H5Fclose(file); +/* + * Open the file. + */ +file = H5Fopen(FILE, H5F_ACC_RDONLY, H5P_DEFAULT); + +/* + * Open the dataset. + */ +dataset = dataset = H5Dopen(file,"Matrix in file"); + +/* + * Read data back to the buffer matrix. + */ +ret = H5Dread(dataset, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, + H5P_DEFAULT, matrix); + +/* + * Display the result. + */ +for (i=0; i < MSPACE_DIM1; i++) { + for(j=0; j < MSPACE_DIM2; j++) printf("%3d ", matrix[i][j]); + printf("\n"); +} +return 0; +} |