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