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;
}
