char *test_read_complex_dataset() { int i,rank = 1; hsize_t dims[1]; hid_t dataspace_id, dset_id, dtr_id, dti_id, file_id; size_t type_size; hid_t type_id; herr_t status, status_2; float *real_part, *imag_part; const char* path = "dataset_name"; AH5_complex_t cplx[2]; AH5_complex_t * rdata; file_id = AH5_auto_test_file(); cplx[0].re=10.; cplx[0].im=20.; cplx[1].re=10.5; cplx[1].im=20.5; //first write complex array set with hdf5 lib real_part = (float *)malloc(2 * sizeof(float)); imag_part = (float *)malloc(2 * sizeof(float)); for( i=0;i<2;i++) { real_part[i] = cplx[i].re; imag_part[i] = cplx[i].im; } type_id = create_type_id(H5T_NATIVE_FLOAT); dims[0] = 2; dataspace_id = H5Screate_simple(rank, dims, NULL); dset_id = H5Dcreate(file_id,path,type_id,dataspace_id, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT); type_size = H5Tget_size(H5T_NATIVE_FLOAT); dtr_id = H5Tcreate(H5T_COMPOUND,type_size); status = H5Tinsert(dtr_id,"r",0, H5T_NATIVE_FLOAT); dti_id = H5Tcreate(H5T_COMPOUND,type_size); status = H5Tinsert(dti_id,"i",0, H5T_NATIVE_FLOAT); status = H5Dwrite(dset_id,dtr_id,H5S_ALL,H5S_ALL,H5P_DEFAULT,real_part); status = H5Dwrite(dset_id,dti_id,H5S_ALL,H5S_ALL,H5P_DEFAULT,imag_part); status = H5Tclose(dtr_id); status = H5Tclose(dti_id); free(real_part); free(imag_part); mu_assert("Read complex dataset.", AH5_read_cpx_dataset(file_id,"dataset_name", 2, &rdata)); for (i = 0; i < 2; i++) { printf("Real parts : %f %f\n", cplx[i].re, rdata[i].re); printf("Imaginary parts : %f %f\n", cplx[i].im, rdata[i].im); mu_assert_equal("Check the real values.", cplx[i].re, rdata[i].re); mu_assert_equal("Check the imaginary value.", cplx[i].im, rdata[i].im); } return MU_FINISHED_WITHOUT_ERRORS; }
//! Test write dataset. // Data extracted from http://www.hdfgroup.org/ftp/HDF5/examples/examples-by-api/hdf5-examples/1_8/C/H5T/h5ex_t_string.c char *test_write_complex_dataset() { hid_t file_id, filetype, memtype, space, dset; size_t sdim; hsize_t dims[1] = {2}; int ndims, i, j; int rank; int length; size_t type_size; float * buf; hid_t real_id_type; herr_t status; hsize_t *newdims; AH5_complex_t cplx[2]; file_id = AH5_auto_test_file(); cplx[0].re=10.; cplx[0].im=20.; cplx[1].re=10.5; cplx[1].im=20.5; mu_assert("Write complex dataset.", AH5_write_cpx_dataset(file_id,"dataset_name", 2, cplx)); // Test the written data using hdf5 API. real_id_type = create_type_id(H5T_NATIVE_FLOAT); status = H5LTget_dataset_ndims(file_id, "dataset_name", &rank); newdims = (hsize_t *) malloc(rank * sizeof(hsize_t)); status = H5LTget_dataset_info(file_id,"dataset_name" , newdims, NULL, NULL); length = newdims[0]; for (i = 1; i < rank; i++) length = length * newdims[i]; buf = (float *) malloc(2 * length * sizeof(float)); status = H5LTread_dataset(file_id, "dataset_name", real_id_type, buf); j = 0; for (i = 0; i < length; i++) { printf("Real parts : %f %f\n", cplx[i].re, buf[j]); printf("Imaginary parts : %f %f\n", cplx[i].im, buf[j+1]); mu_assert_equal("Check the real values.", cplx[i].re, buf[j]); mu_assert_equal("Check the imaginary value.", cplx[i].im, buf[j+1]); j = j + 2; } free(buf); return MU_FINISHED_WITHOUT_ERRORS; }
char *test_write_single_flotingtype() { hid_t file_id; AH5_singleinteger_t flti; AH5_singlereal_t fltr; int idata; float rdata; // Write a simple mesh test. file_id = AH5_auto_test_file(); // single integer flti.path = (char *)"/floatingType/flti"; flti.value = 10; flti.opt_attrs.nb_instances = 0; mu_assert("Write single integer.", AH5_write_ft_singleinteger(file_id, &flti)); AH5_read_int_attr(file_id, "/floatingType/flti", "value", &idata); mu_assert_eq("Test the written int value.", idata, 10); // single real fltr.path = (char *)"/floatingType/fltr"; fltr.value = 0.5; fltr.opt_attrs.nb_instances = 0; mu_assert("Write single real.", AH5_write_ft_singlereal(file_id, &fltr)); AH5_read_flt_attr(file_id, "/floatingType/fltr", "value", &rdata); mu_assert_eq("Test the written real value.", rdata, 0.5); // Close file. AH5_close_test_file(file_id); return MU_FINISHED_WITHOUT_ERRORS; }
char *test_write_ft_dataset() { hid_t file_id; hsize_t i; float *fvalues; AH5_dataset_t ds; // Write a simple mesh test. file_id = AH5_auto_test_file(); ds.path = "/floatingType/dataset"; ds.opt_attrs.nb_instances = 0; ds.type_class = H5T_FLOAT; ds.nb_dims = 2; ds.dims = (hsize_t *)malloc(ds.nb_dims*sizeof(hsize_t)); ds.dims[0] = 10; ds.dims[1] = 2; ds.values.f = (float *)malloc(ds.dims[0]*ds.dims[1]*sizeof(float)); for (i = 0; i < ds.dims[0]*ds.dims[1]; ++i) ds.values.f[i] = (float)0.3 * i; mu_assert("Write ds.", AH5_write_ft_dataset(file_id, &ds)); AH5_read_flt_dataset(file_id, "/floatingType/dataset", ds.dims[0]*ds.dims[1], &fvalues); for (i = 0; i < ds.dims[0]*ds.dims[1]; ++i) mu_assert_close("Test the written real values.", fvalues[i], 0.3 * (float)i, 1.e-4); free(fvalues); // Close file. AH5_close_test_file(file_id); return MU_FINISHED_WITHOUT_ERRORS; }
char *test_write_ft_vector() { hid_t file_id; hsize_t i; const hsize_t nb_values = 10; float *fvalues; AH5_vector_t vector; // Write a simple mesh test. file_id = AH5_auto_test_file(); vector.path = "/floatingType/vector"; vector.opt_attrs.nb_instances = 0; vector.type_class = H5T_FLOAT; vector.nb_values = nb_values; vector.values.f = (float *)malloc(vector.nb_values*sizeof(float)); for (i = 0; i < vector.nb_values; ++i) vector.values.f[i] = 0.3 * i; mu_assert("Write vector.", AH5_write_ft_vector(file_id, &vector)); mu_assert("Read float dataset for check.", AH5_read_flt_dataset(file_id, "/floatingType/vector", nb_values, &fvalues)); for (i = 0; i < nb_values; ++i) mu_assert_close("Test the written real values.", fvalues[i], 0.3 * i, 1.e-4); free(fvalues); // Close file. AH5_close_test_file(file_id); return MU_FINISHED_WITHOUT_ERRORS; }
char *test_write_string_dataset() { #define DIM0 4 #define SDIM 8 hid_t file_id, filetype, memtype, space, dset; size_t sdim; hsize_t dims[1] = {DIM0}; int ndims, i, j; /*char wdata[DIM0][SDIM] =*/ char *wdata[] = {"Parting", "is such", "sweet ", "sorrow."}; char **rdata; // Write a simple mesh test. file_id = AH5_auto_test_file(); mu_assert("Write string dataset.", AH5_write_str_dataset(file_id, "dataset_name", DIM0, SDIM, wdata)); // Test the written data using hdf5 API. dset = H5Dopen(file_id, "/dataset_name", H5P_DEFAULT); filetype = H5Dget_type(dset); sdim = H5Tget_size(filetype); space = H5Dget_space(dset); ndims = H5Sget_simple_extent_dims(space, dims, NULL); rdata = (char **) malloc(dims[0] * sizeof (char *)); rdata[0] = (char *) malloc(dims[0] * sdim * sizeof (char)); for (i=1; i<dims[0]; i++) rdata[i] = rdata[0] + i * sdim; memtype = H5Tcopy(H5T_C_S1); mu_assert("HDF5 error in H5Tset_size.", H5Tset_size(memtype, sdim) >= 0); mu_assert("HDF5 error in H5Dread.", H5Dread(dset, memtype, H5S_ALL, H5S_ALL, H5P_DEFAULT, rdata[0]) >= 0); for (i = 0; i < dims[0]; i++) { printf("%s %s\n", wdata[i], rdata[i]); /*mu_assert_str_equal("Check the first str dataset values.", wdata[i], rdata[i]);*/ j = 0; while (wdata[i][j] != ' ' && wdata[i][j] != '\0') { mu_assert_equal("Check the first str dataset values.", wdata[i][j], rdata[i][j]); ++j; } } // Release resources. free(rdata[0]); free(rdata); mu_assert("HDF5 error in H5Dclose.", H5Dclose(dset) >= 0); mu_assert("HDF5 error in H5Sclose.", H5Sclose(space) >= 0); mu_assert("HDF5 error in H5Tclose.", H5Tclose(filetype) >= 0); mu_assert("HDF5 error in H5Tclose.", H5Tclose(memtype) >= 0); // Write a string dataset using strlen. mu_assert("Write string dataset using strlen.", AH5_write_str_dataset(file_id, "dataset_name_2", DIM0, strlen(wdata[0]) + 1, wdata)); // Test the written data using hdf5 API. dset = H5Dopen(file_id, "/dataset_name", H5P_DEFAULT); filetype = H5Dget_type(dset); sdim = H5Tget_size(filetype); space = H5Dget_space(dset); ndims = H5Sget_simple_extent_dims(space, dims, NULL); rdata = (char **) malloc(dims[0] * sizeof (char *)); rdata[0] = (char *) malloc(dims[0] * sdim * sizeof (char)); for (i=1; i<dims[0]; i++) rdata[i] = rdata[0] + i * sdim; memtype = H5Tcopy(H5T_C_S1); mu_assert("HDF5 error in H5Tset_size.", H5Tset_size(memtype, sdim) >= 0); mu_assert("HDF5 error in H5Dread.", H5Dread(dset, memtype, H5S_ALL, H5S_ALL, H5P_DEFAULT, rdata[0]) >= 0); for (i = 0; i < dims[0]; i++) { /*mu_assert_str_equal("Check the first str dataset values.", wdata[i], rdata[i]);*/ j = 0; while (wdata[i][j] != ' ' && wdata[i][j] != '\0') { mu_assert_equal("Check the first str dataset values.", wdata[i][j], rdata[i][j]); ++j; } } // Release resources. free(rdata[0]); free(rdata); mu_assert("HDF5 error in H5Dclose.", H5Dclose(dset) >= 0); mu_assert("HDF5 error in H5Sclose.", H5Sclose(space) >= 0); mu_assert("HDF5 error in H5Tclose.", H5Tclose(filetype) >= 0); mu_assert("HDF5 error in H5Tclose.", H5Tclose(memtype) >= 0); // Close file. AH5_close_test_file(file_id); return MU_FINISHED_WITHOUT_ERRORS; }
char *test_write_ft_arrayset() { hid_t file_id; hsize_t i; int dim = 0; hsize_t nb_values = 1; float *fvalues; char **svalues; AH5_arrayset_t array, dataonmesh; char *meshpath = "/mesh/gmesh/umesh/group/groupname"; // Write a simple mesh test. file_id = AH5_auto_test_file(); /* simple array set*/ array.path = "/floatingType/array"; array.opt_attrs.nb_instances = 0; array.nb_dims = 2; array.dims = (AH5_vector_t *)malloc(array.nb_dims*sizeof(AH5_vector_t)); array.dims[0].nb_values = 10; array.dims[0].opt_attrs.nb_instances = 0; array.dims[0].type_class = H5T_FLOAT; array.dims[0].values.f = (float *)malloc(array.dims[0].nb_values*sizeof(float)); for (i = 0; i < array.dims[0].nb_values; ++i) array.dims[0].values.f[i] = 0.3 * i; array.dims[1].nb_values = 2; array.dims[1].opt_attrs.nb_instances = 0; array.dims[1].type_class = H5T_INTEGER; array.dims[1].values.i = (int *)malloc(array.dims[1].nb_values*sizeof(int)); for (i = 0; i < array.dims[1].nb_values; ++i) array.dims[1].values.i[i] = i * 3; array.data.type_class = H5T_FLOAT; array.data.opt_attrs.nb_instances = 0; array.data.nb_dims = array.nb_dims; array.data.dims = (hsize_t *)malloc(array.data.nb_dims*sizeof(hsize_t)); for (dim = 0; dim < array.data.nb_dims; ++dim) { array.data.dims[dim] = array.dims[dim].nb_values; nb_values *= array.dims[dim].nb_values; } array.data.values.f = (float *)malloc(nb_values*sizeof(float)); for (i = 0; i < nb_values; ++i) array.data.values.f[i] = 0.3 * i; mu_assert("Write array set.", AH5_write_ft_arrayset(file_id, &array)); AH5_read_flt_dataset(file_id, "/floatingType/array/data", nb_values, &fvalues); for (i = 0; i < nb_values; ++i) mu_assert_close("Test the written real values.", fvalues[i], 0.3 * i, 1.e-4); free(fvalues); /* a data on mesh */ dataonmesh.path = "/floatingType/dataonmesh"; dataonmesh.opt_attrs.nb_instances = 0; dataonmesh.nb_dims = 2; dataonmesh.dims = (AH5_vector_t *)malloc(dataonmesh.nb_dims*sizeof(AH5_vector_t)); dataonmesh.dims[0].nb_values = 1; dataonmesh.dims[0].opt_attrs.nb_instances = 0; dataonmesh.dims[0].type_class = H5T_STRING; dataonmesh.dims[0].values.s = &meshpath; dataonmesh.dims[1].nb_values = 2; dataonmesh.dims[1].opt_attrs.nb_instances = 0; dataonmesh.dims[1].type_class = H5T_INTEGER; dataonmesh.dims[1].values.i = (int *)malloc(dataonmesh.dims[1].nb_values*sizeof(int)); for (i = 0; i < dataonmesh.dims[1].nb_values; ++i) dataonmesh.dims[1].values.i[i] = i * 3; dataonmesh.data.type_class = H5T_FLOAT; dataonmesh.data.opt_attrs.nb_instances = 0; dataonmesh.data.nb_dims = dataonmesh.nb_dims; dataonmesh.data.dims = (hsize_t *)malloc(dataonmesh.data.nb_dims*sizeof(hsize_t)); dataonmesh.data.dims[0] = 10; dataonmesh.data.dims[1] = dataonmesh.dims[1].nb_values; nb_values = 1; for (dim = 0; dim < dataonmesh.data.nb_dims; ++dim) nb_values *= dataonmesh.data.dims[dim]; dataonmesh.data.values.f = (float *)malloc(nb_values*sizeof(float)); for (i = 0; i < nb_values; ++i) dataonmesh.data.values.f[i] = 0.3 * i; mu_assert("Write dataonmesh.", AH5_write_ft_arrayset(file_id, &dataonmesh)); AH5_read_flt_dataset(file_id, "/floatingType/dataonmesh/data", nb_values, &fvalues); for (i = 0; i < nb_values; ++i) mu_assert_close("Test the written real values.", fvalues[i], 0.3 * i, 1.e-4); AH5_read_str_dataset(file_id, "/floatingType/dataonmesh/ds/dim1", 1, strlen(meshpath), &svalues); mu_assert_str_equal("Test the written string dims.", *svalues, meshpath); free(fvalues); // Close file. AH5_close_test_file(file_id); return MU_FINISHED_WITHOUT_ERRORS; }