summaryrefslogtreecommitdiffstats
path: root/examples
diff options
context:
space:
mode:
Diffstat (limited to 'examples')
-rw-r--r--examples/Makefile.in24
-rw-r--r--examples/h5_attribute.c259
-rw-r--r--examples/h5_select.c204
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;
+}