// Read label dataset
char AH5_read_lbl_dataset(hid_t file_id, const char *path, AH5_lbl_dataset_t *lbl_dataset)
{
H5T_class_t type_class;
char rdata = AH5_FALSE;
size_t length;
int nb_dims;
AH5_init_lbl_dataset(lbl_dataset);
lbl_dataset->path = strdup(path);
lbl_dataset->nb_items = 1; // in case of single value
if (AH5_path_valid(file_id, path))
if (H5LTget_dataset_ndims(file_id, path, &nb_dims) >= 0)
if (nb_dims <= 1)
if (H5LTget_dataset_info(file_id, path, &(lbl_dataset->nb_items), &type_class, &length) >= 0)
if (type_class == H5T_STRING)
if(AH5_read_str_dataset(file_id, path, lbl_dataset->nb_items, length, &(lbl_dataset->items)))
rdata = AH5_TRUE;
if (!rdata)
{
AH5_print_err_dset(AH5_C_LABEL, path);
lbl_dataset->nb_items = 0;
}
return rdata;
}
// Read dataset in externalElement and open external files
char AH5_read_eet_dataset (hid_t file_id, const char *path, AH5_eet_dataset_t *eet_dataset)
{
H5T_class_t type_class;
char rdata = AH5_FALSE;
hsize_t dims[2], i;
size_t length;
int nb_dims;
eet_dataset->path = strdup(path);
if (AH5_path_valid(file_id, path))
if (H5LTget_dataset_ndims(file_id, path, &nb_dims) >= 0)
if (nb_dims == 2)
if (H5LTget_dataset_info(file_id, path, dims, &type_class, &length) >= 0)
if (dims[0] > 0 && dims[1] == 3 && type_class == H5T_STRING)
if(AH5_read_str_dataset(file_id, path, dims[0] * dims[1], length, &(eet_dataset->eed_items)))
{
eet_dataset->nb_eed_items = dims[0];
rdata = AH5_TRUE;
eet_dataset->file_id = (hid_t *) malloc(eet_dataset->nb_eed_items * sizeof(hid_t));
for (i = 0; i < eet_dataset->nb_eed_items; i++)
eet_dataset->file_id[i] = -1;
}
if (!rdata)
{
AH5_print_err_dset(AH5_C_EXTERNAL_ELEMENT, path);
eet_dataset->nb_eed_items = 0;
eet_dataset->file_id = NULL;
eet_dataset->eed_items = NULL;
}
else
if (!AH5_open_external_files(eet_dataset))
rdata = AH5_FALSE;
return rdata;
}
char* test_utf_8() {
hid_t file, node, unode, dset;
size_t len;
char res, *path, *attr, **dset_val;
file = H5Fopen(FILE, H5F_ACC_RDONLY, H5P_DEFAULT);
mu_assert("H5Fopen() open file...", file >= 0);
mu_assert("Valid node path...", AH5_path_valid(file, NODE_PATH));
node = H5Oopen(file, NODE_PATH, H5P_DEFAULT);
mu_assert("H5Oopen() open node...", node >= 0);
mu_assert("Valid unode path...", AH5_path_valid(node, UNODE_PATH));
unode = H5Oopen(node, UNODE_PATH, H5P_DEFAULT);
mu_assert("H5Oopen() open unode...", unode >= 0);
H5Oclose(unode);
path = (char*) malloc(sizeof(char) * (1 + strlen(NODE_PATH) + 1 + strlen(UNODE_PATH) + 1));
path[0] = '/';
path[1] = '\0';
strcat(path, NODE_PATH);
strcat(path, "/");
strcat(path, UNODE_PATH);
mu_assert("Valid unode absolute path...", AH5_path_valid(file, path));
unode = H5Oopen(file, path, H5P_DEFAULT);
mu_assert("H5Oopen() open unode...", unode >= 0);
free(path);
len = AH5_read_str_attr_len(unode, ".", "attribut du sous-nœud accentué");
mu_assert("AH5_read_str_attr_len() read utf-8 attr len...", len > 0);
attr = (char*) malloc(sizeof(char) * (len + 1));
res = AH5_read_str_attr(unode, ".", "attribut du sous-nœud accentué", &attr);
mu_assert("AH5_read_str_attr() status...", res == AH5_TRUE);
mu_assert("AH5_read_str_attr() str length...", strlen(attr) == strlen("é è à œ"));
mu_assert("AH5_read_str_attr() str value...", strcmp(attr, "é è à œ") == 0);
free(attr);
mu_assert("Valid dset path...", AH5_path_valid(unode, DSET_PATH));
dset = H5Oopen(unode, DSET_PATH, H5P_DEFAULT);
mu_assert("H5Oopen() open dset...", dset >= 0);
len = 11;
dset_val = (char**) malloc(sizeof(char*));
dset_val[0] = (char*) malloc(sizeof(char) * (len + 1));
res = AH5_read_str_dataset(dset, ".", 1, len, &dset_val);
mu_assert("AH5_read_str_dataset() status...", res == AH5_TRUE);
mu_assert("AH5_read_str_dataset() str length...", strlen(dset_val[0]) == strlen("é è à œ"));
mu_assert("AH5_read_str_dataset() str value...", strcmp(dset_val[0], "é è à œ") == 0);
free(dset_val[0]);
free(dset_val);
H5Oclose(dset);
H5Oclose(unode);
H5Oclose(node);
H5Fclose(file);
return MU_FINISHED_WITHOUT_ERRORS;
}
// Read dataset in externalElement and open external files
char AH5_read_eet_dataset (hid_t file_id, const char *path, AH5_eet_dataset_t *eet_dataset)
{
H5T_class_t type_class;
char rdata = AH5_FALSE;
hsize_t dims[2], i;
size_t length;
int nb_dims;
ssize_t fpath_size;
eet_dataset->path = strdup(path);
fpath_size = H5Fget_name(file_id, NULL, 0);
// Strange behavior of H5Fget_name: it seems to return to small length.
eet_dataset->principle_file_path = malloc(fpath_size + 2);
eet_dataset->principle_file_path[fpath_size + 1] = '\0';
eet_dataset->principle_file_path[fpath_size] = '\0';
H5Fget_name(file_id, eet_dataset->principle_file_path, fpath_size + 1);
if (AH5_path_valid(file_id, path))
if (H5LTget_dataset_ndims(file_id, path, &nb_dims) >= 0)
if (nb_dims == 2)
if (H5LTget_dataset_info(file_id, path, dims, &type_class, &length) >= 0)
if (dims[0] > 0 && dims[1] == 3 && type_class == H5T_STRING)
if(AH5_read_str_dataset(file_id, path, dims[0] * dims[1], length, &(eet_dataset->eed_items)))
{
eet_dataset->nb_eed_items = dims[0];
rdata = AH5_TRUE;
eet_dataset->file_id = (hid_t *) malloc((size_t) eet_dataset->nb_eed_items * sizeof(hid_t));
for (i = 0; i < eet_dataset->nb_eed_items; i++)
eet_dataset->file_id[i] = -1;
}
if (!rdata)
{
AH5_print_err_dset(AH5_C_EXTERNAL_ELEMENT, path);
eet_dataset->nb_eed_items = 0;
eet_dataset->file_id = NULL;
eet_dataset->eed_items = NULL;
}
else if (!AH5_open_external_files(eet_dataset))
rdata = AH5_FALSE;
return rdata;
}
// Read simulation instance
char AH5_read_sim_instance (hid_t file_id, const char *path, AH5_sim_instance_t *sim_instance)
{
char mandatory[][AH5_ATTR_LENGTH] = {AH5_A_MODULE, AH5_A_VERSION};
/* char mandatory2[][AH5_ATTR_LENGTH] = {}; */
char *path1;
char rdata = AH5_TRUE;
H5T_class_t type_class;
char success1 = AH5_FALSE, success2 = AH5_FALSE;
size_t length;
int nb_dims;
sim_instance->path = strdup(path);
sim_instance->opt_attrs.instances = NULL;
sim_instance->module = NULL;
sim_instance->version = NULL;
sim_instance->inputs = NULL;
sim_instance->outputs = NULL;
if (AH5_path_valid(file_id, path))
{
AH5_read_opt_attrs(file_id, path, &(sim_instance->opt_attrs), mandatory,
sizeof(mandatory)/AH5_ATTR_LENGTH);
if (!AH5_read_str_attr(file_id, path, AH5_A_MODULE, &(sim_instance->module)))
AH5_print_err_attr(AH5_C_SIMULATION, path, AH5_A_MODULE);
if (!AH5_read_str_attr(file_id, path, AH5_A_VERSION, &(sim_instance->version)))
AH5_print_err_attr(AH5_C_SIMULATION, path, AH5_A_VERSION);
path1 = malloc((strlen(path) + strlen(AH5_G_PARAMETER) + 1) * sizeof(*path1));
if (!path1)
{
AH5_print_err_dset(AH5_C_SIMULATION, path);
return AH5_FALSE;
}
strncpy(path1, path, strlen(path) + 1);
strncat(path1, AH5_G_PARAMETER, strlen(AH5_G_PARAMETER));
AH5_read_opt_attrs(file_id, path1, &(sim_instance->parameter), NULL, 0);
// inputs
sim_instance->nb_inputs = 1; // in case of single value
path1 = realloc(path1, (strlen(path) + strlen(AH5_G_INPUTS) + 1) * sizeof(*path1));
if (!path1)
{
AH5_print_err_dset(AH5_C_SIMULATION, path);
return AH5_FALSE;
}
strncpy(path1, path, strlen(path) + 1);
strncat(path1, AH5_G_INPUTS, strlen(AH5_G_INPUTS));
if (AH5_path_valid(file_id, path1))
if (H5LTget_dataset_ndims(file_id, path1, &nb_dims) >= 0)
if (nb_dims <= 1)
if (H5LTget_dataset_info(file_id, path1, &(sim_instance->nb_inputs), &type_class, &length) >= 0)
if (type_class == H5T_STRING)
if(AH5_read_str_dataset(file_id, path1, sim_instance->nb_inputs, length, &(sim_instance->inputs)))
success1 = AH5_TRUE;
if (!success1)
{
AH5_print_err_dset(AH5_C_SIMULATION, path1);
sim_instance->nb_inputs = 0;
rdata = AH5_FALSE;
}
// outputs
sim_instance->nb_outputs = 1; // in case of single value
path1 = realloc(path1, (strlen(path) + strlen(AH5_G_OUTPUTS) + 1) * sizeof(*path1));
if (!path1)
{
AH5_print_err_dset(AH5_C_SIMULATION, path);
return AH5_FALSE;
}
strncpy(path1, path, strlen(path) + 1);
strncat(path1, AH5_G_OUTPUTS, strlen(AH5_G_OUTPUTS));
if (AH5_path_valid(file_id, path1))
if (H5LTget_dataset_ndims(file_id, path1, &nb_dims) >= 0)
if (nb_dims <= 1)
if (H5LTget_dataset_info(file_id, path1, &(sim_instance->nb_outputs), &type_class, &length) >= 0)
if (type_class == H5T_STRING)
if(AH5_read_str_dataset(file_id, path1, sim_instance->nb_outputs, length, &(sim_instance->outputs)))
success2 = AH5_TRUE;
if (!success2)
{
AH5_print_wrn_outputs(path);
sim_instance->nb_outputs = 0;
}
free(path1);
}
else
{
rdata = AH5_FALSE;
}
return rdata;
}
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;
}
