本文整理汇总了C++中H5Tclose函数的典型用法代码示例。如果您正苦于以下问题：C++ H5Tclose函数的具体用法？C++ H5Tclose怎么用？C++ H5Tclose使用的例子？那么恭喜您, 这里精选的函数代码示例或许可以为您提供帮助。
在下文中一共展示了H5Tclose函数的15个代码示例，这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞，您的评价将有助于系统推荐出更棒的C++代码示例。
示例1: H5Dopen2
void pyne::Material::_load_comp_protocol1(hid_t db, std::string datapath, int row) {
std::string nucpath;
hid_t data_set = H5Dopen2(db, datapath.c_str(), H5P_DEFAULT);
hsize_t data_offset[1] = {row};
if (row < 0) {
// Handle negative row indices
hid_t data_space = H5Dget_space(data_set);
hsize_t data_dims[1];
H5Sget_simple_extent_dims(data_space, data_dims, NULL);
data_offset[0] += data_dims[0];
};
// Grab the nucpath
hid_t nuc_attr = H5Aopen(data_set, "nucpath", H5P_DEFAULT);
H5A_info_t nuc_info;
H5Aget_info(nuc_attr, &nuc_info);
hsize_t nuc_attr_len = nuc_info.data_size;
hid_t str_attr = H5Tcopy(H5T_C_S1);
H5Tset_size(str_attr, nuc_attr_len);
char * nucpathbuf = new char [nuc_attr_len];
H5Aread(nuc_attr, str_attr, nucpathbuf);
nucpath = std::string(nucpathbuf, nuc_attr_len);
delete[] nucpathbuf;
// Grab the nuclides
std::vector<int> nuclides = h5wrap::h5_array_to_cpp_vector_1d<int>(db, nucpath, H5T_NATIVE_INT);
int nuc_size = nuclides.size();
hsize_t nuc_dims[1] = {nuc_size};
// Get the data hyperslab
hid_t data_hyperslab = H5Dget_space(data_set);
hsize_t data_count[1] = {1};
H5Sselect_hyperslab(data_hyperslab, H5S_SELECT_SET, data_offset, NULL, data_count, NULL);
// Get memory space for writing
hid_t mem_space = H5Screate_simple(1, data_count, NULL);
// Get material type
size_t material_struct_size = sizeof(pyne::material_struct) + sizeof(double)*nuc_size;
hid_t desc = H5Tcreate(H5T_COMPOUND, material_struct_size);
hid_t comp_values_array_type = H5Tarray_create2(H5T_NATIVE_DOUBLE, 1, nuc_dims);
// make the data table type
H5Tinsert(desc, "mass", HOFFSET(pyne::material_struct, mass), H5T_NATIVE_DOUBLE);
H5Tinsert(desc, "density", HOFFSET(pyne::material_struct, density),
H5T_NATIVE_DOUBLE);
H5Tinsert(desc, "atoms_per_molecule", HOFFSET(pyne::material_struct, atoms_per_mol),
H5T_NATIVE_DOUBLE);
H5Tinsert(desc, "comp", HOFFSET(pyne::material_struct, comp), comp_values_array_type);
// make the data array, have to over-allocate
material_struct * mat_data = new material_struct [material_struct_size];
// Finally, get data and put in on this instance
H5Dread(data_set, desc, mem_space, data_hyperslab, H5P_DEFAULT, mat_data);
mass = (*mat_data).mass;
density = (*mat_data).density;
atoms_per_molecule = (*mat_data).atoms_per_mol;
for (int i = 0; i < nuc_size; i++)
comp[nuclides[i]] = (double) (*mat_data).comp[i];
delete[] mat_data;
H5Tclose(str_attr);
//
// Get metadata from associated dataset, if available
//
std::string attrpath = datapath + "_metadata";
bool attrpath_exists = h5wrap::path_exists(db, attrpath);
if (!attrpath_exists)
return;
hid_t metadatapace, attrtype, metadataet, metadatalab, attrmemspace;
int attrrank;
hvl_t attrdata [1];
attrtype = H5Tvlen_create(H5T_NATIVE_CHAR);
// Get the metadata from the file
metadataet = H5Dopen2(db, attrpath.c_str(), H5P_DEFAULT);
metadatalab = H5Dget_space(metadataet);
H5Sselect_hyperslab(metadatalab, H5S_SELECT_SET, data_offset, NULL, data_count, NULL);
attrmemspace = H5Screate_simple(1, data_count, NULL);
H5Dread(metadataet, attrtype, attrmemspace, metadatalab, H5P_DEFAULT, attrdata);
// convert to in-memory JSON
Json::Reader reader;
reader.parse((char *) attrdata[0].p, (char *) attrdata[0].p+attrdata[0].len, metadata, false);
// close attr data objects
H5Fflush(db, H5F_SCOPE_GLOBAL);
H5Dclose(metadataet);
H5Sclose(metadatapace);
H5Tclose(attrtype);
// Close out the HDF5 file
H5Fclose(db);
};示例2: e5_merge_flash_scalars
//.........这里部分代码省略.........
f5_memspace = H5Screate_simple(1, &dimens_1d, NULL);
hstatus = H5Dread(f5_dataset, f5_real_list_type, f5_memspace, f5_dataspace, H5P_DEFAULT, f5_real_list);
if (hstatus < 0)
{
estatus = E5_READ_FAILURE;
e5_error(f5_file_id, estatus, "Failed to read '%s' from F5 data file\n", f5_list_name);
break;
}
f5_data = f5_real_list;
f5_type = f5_real_list_type;
if(f5_data)
{
// Add the scalar list as attributes for the top-level Emissivity group
e5_scalar_bytes = (dimens_1d + 1) * sizeof(e5_mutable_attr_double);
e5_mutable_attr_double* e5_double_scalars = (e5_mutable_attr_double*) e5_malloc(e5_scalar_bytes);
memset(e5_double_scalars, 0, e5_scalar_bytes);
for(s = 0; s < dimens_1d; s++)
{
e5_double_scalars[s].value = f5_real_list[s].value;
e5_double_scalars[s].name = f5_real_list[s].name;
e5_double_scalars[s].name = e5_trim(f5_real_list[s].name, E5_TRUE, E5_TRUE, F5_MAX_STRING_LENGTH);
}
e5_write_attr_list_double(e5_em_group_id, (e5_attr_double*)e5_double_scalars);
e5_free(e5_double_scalars);
}
break;
}
case F5_SCALAR_LIST_STRING:
{
hid_t f5_str_list_type;
f5_str_list_t *f5_str_list;
f5_scalar_bytes = dimens_1d * sizeof(f5_str_list_t);
f5_str_list = (f5_str_list_t *) e5_malloc(f5_scalar_bytes);
if(!f5_str_list)
{
estatus = E5_OUT_OF_MEMORY;
e5_error(f5_file_id, estatus, "Failed to allocate memory for reading '%s' from F5 data file\n", f5_list_name);
break;
}
memset(f5_str_list, 0, f5_scalar_bytes);
f5_str_list_type = H5Tcreate(H5T_COMPOUND, sizeof(f5_str_list_t));
H5Tinsert(f5_str_list_type, "name", HOFFSET(f5_str_list_t, name), string_type);
H5Tinsert(f5_str_list_type, "value", HOFFSET(f5_str_list_t, value), string_type);
f5_memspace = H5Screate_simple(1, &dimens_1d, NULL);
hstatus = H5Dread(f5_dataset, f5_str_list_type, f5_memspace, f5_dataspace, H5P_DEFAULT, f5_str_list);
if (hstatus < 0)
{
estatus = E5_READ_FAILURE;
e5_error(f5_file_id, estatus, "Failed to read '%s' from F5 data file\n", f5_list_name);
break;
}
f5_data = f5_str_list;
f5_type = f5_str_list_type;
if(f5_data)
{
// Add the scalar list as attributes for the top-level Emissivity group
e5_scalar_bytes = (dimens_1d + 1) * sizeof(e5_mutable_attr_str);
e5_mutable_attr_str* e5_str_scalars = (e5_mutable_attr_str*) e5_malloc(e5_scalar_bytes);
memset(e5_str_scalars, 0, e5_scalar_bytes);
for(s = 0; s < dimens_1d; s++)
{
char* trimmed = e5_trim(f5_str_list[s].value, E5_TRUE, E5_TRUE, E5_MAX_ATTR_STRING_LENGTH);
strncpy( e5_str_scalars[s].value, trimmed, E5_MAX_ATTR_STRING_LENGTH);
e5_str_scalars[s].name = e5_trim(f5_str_list[s].name, E5_TRUE, E5_TRUE, F5_MAX_STRING_LENGTH);
}
e5_write_attr_list_str(e5_em_group_id, (e5_attr_str*)e5_str_scalars);
e5_free(e5_str_scalars);
}
break;
}
default:
{
estatus = E5_INVALID_DATASET;
e5_error(f5_file_id, estatus, "Unknown scalar list requested '%s' from F5 data file\n", f5_list_name);
break;
}
};
H5Tclose(f5_type);
H5Sclose(f5_memspace);
H5Sclose(f5_dataspace);
H5Dclose(f5_dataset);
e5_free(f5_data);
e5_close_group(e5_em_group_id);
return estatus;
}示例3: main
int
main()
{
printf("\n*** Checking HDF5 attribute functions some more.\n");
printf("*** Creating tst_xplatform2_3.nc with HDF only...");
{
hid_t fapl_id, fcpl_id;
size_t chunk_cache_size = MY_CHUNK_CACHE_SIZE;
size_t chunk_cache_nelems = CHUNK_CACHE_NELEMS;
float chunk_cache_preemption = CHUNK_CACHE_PREEMPTION;
hid_t fileid, grpid, attid, spaceid;
hid_t s1_typeid, vlen_typeid, s3_typeid;
hid_t file_typeid1[NUM_OBJ], native_typeid1[NUM_OBJ];
hid_t file_typeid2, native_typeid2;
hsize_t num_obj;
H5O_info_t obj_info;
char obj_name[STR_LEN + 1];
hsize_t dims[1] = {ATT_LEN}; /* netcdf attributes always 1-D. */
struct s1
{
float x;
double y;
};
struct s3
{
hvl_t data[NUM_VL];
};
/* cvc stands for "Compound with Vlen of Compound." */
struct s3 cvc_out[ATT_LEN];
int i, j, k;
/* Create some output data: a struct s3 array (length ATT_LEN)
* which holds an array of vlen (length NUM_VL) of struct s1. */
for (i = 0; i < ATT_LEN; i++)
for (j = 0; j < NUM_VL; j++)
{
cvc_out[i].data[j].len = i + 1;
if (!(cvc_out[i].data[j].p = calloc(sizeof(struct s1), cvc_out[i].data[j].len))) ERR;
for (k = 0; k < cvc_out[i].data[j].len; k++)
{
((struct s1 *)cvc_out[i].data[j].p)[k].x = 42.42;
((struct s1 *)cvc_out[i].data[j].p)[k].y = 2.0;
}
}
/* Create the HDF5 file, with cache control, creation order, and
* all the timmings. */
if ((fapl_id = H5Pcreate(H5P_FILE_ACCESS)) < 0) ERR;
if (H5Pset_fclose_degree(fapl_id, H5F_CLOSE_STRONG)) ERR;
if (H5Pset_cache(fapl_id, 0, chunk_cache_nelems, chunk_cache_size,
chunk_cache_preemption) < 0) ERR;
if (H5Pset_libver_bounds(fapl_id, H5F_LIBVER_LATEST,
H5F_LIBVER_LATEST) < 0) ERR;
if ((fcpl_id = H5Pcreate(H5P_FILE_CREATE)) < 0) ERR;
if (H5Pset_link_creation_order(fcpl_id, (H5P_CRT_ORDER_TRACKED |
H5P_CRT_ORDER_INDEXED)) < 0) ERR;
if (H5Pset_attr_creation_order(fcpl_id, (H5P_CRT_ORDER_TRACKED |
H5P_CRT_ORDER_INDEXED)) < 0) ERR;
if ((fileid = H5Fcreate(FILE_NAME, H5F_ACC_TRUNC, fcpl_id, fapl_id)) < 0) ERR;
if (H5Pclose(fapl_id) < 0) ERR;
if (H5Pclose(fcpl_id) < 0) ERR;
/* Open the root group. */
if ((grpid = H5Gopen2(fileid, "/", H5P_DEFAULT)) < 0) ERR;
/* Create the compound type for struct s1. */
if ((s1_typeid = H5Tcreate(H5T_COMPOUND, sizeof(struct s1))) < 0) ERR;
if (H5Tinsert(s1_typeid, X_NAME, offsetof(struct s1, x),
H5T_NATIVE_FLOAT) < 0) ERR;
if (H5Tinsert(s1_typeid, Y_NAME, offsetof(struct s1, y),
H5T_NATIVE_DOUBLE) < 0) ERR;
if (H5Tcommit(grpid, S1_TYPE_NAME, s1_typeid) < 0) ERR;
/* Create a vlen type. Its a vlen of struct s1. */
if ((vlen_typeid = H5Tvlen_create(s1_typeid)) < 0) ERR;
if (H5Tcommit(grpid, VLEN_TYPE_NAME, vlen_typeid) < 0) ERR;
/* Create the struct s3 type, which contains the vlen. */
if ((s3_typeid = H5Tcreate(H5T_COMPOUND, sizeof(struct s3))) < 0) ERR;
if (H5Tinsert(s3_typeid, VL_NAME, offsetof(struct s3, data),
vlen_typeid) < 0) ERR;
if (H5Tcommit(grpid, S3_TYPE_NAME, s3_typeid) < 0) ERR;
/* Create an attribute of this new type. */
if ((spaceid = H5Screate_simple(1, dims, NULL)) < 0) ERR;
if ((attid = H5Acreate(grpid, S3_ATT_NAME, s3_typeid, spaceid,
H5P_DEFAULT)) < 0) ERR;
if (H5Awrite(attid, s3_typeid, cvc_out) < 0) ERR;
/* Close the types. */
if (H5Tclose(s1_typeid) < 0 ||
H5Tclose(vlen_typeid) < 0 ||
H5Tclose(s3_typeid) < 0) ERR;
/* Close the att. */
if (H5Aclose(attid) < 0) ERR;
/* Close the space. */
if (H5Sclose(spaceid) < 0) ERR;
//.........这里部分代码省略.........
示例4: test_objnames
/*
* test_objnames
* Tests that UTF-8 can be used for object names in the file.
* Tests groups, datasets, named datatypes, and soft links.
* Note that this test doesn't actually mark the names as being
* in UTF-8. At the time this test was written, that feature
* didn't exist in HDF5, and when the character encoding property
* was added to links it didn't change how they were stored in the file,
* -JML 2/2/2006
*/
void test_objnames(hid_t fid, const char* string)
{
hid_t grp_id, grp1_id, grp2_id, grp3_id;
hid_t type_id, dset_id, space_id;
char read_buf[MAX_STRING_LENGTH];
char path_buf[MAX_PATH_LENGTH];
hsize_t dims=1;
hobj_ref_t obj_ref;
herr_t ret;
/* Create a group with a UTF-8 name */
grp_id = H5Gcreate2(fid, string, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
CHECK(grp_id, FAIL, "H5Gcreate2");
/* Set a comment on the group to test that we can access the group
* Also test that UTF-8 comments can be read.
*/
ret = H5Oset_comment_by_name(fid, string, string, H5P_DEFAULT);
CHECK(ret, FAIL, "H5Oset_comment_by_name");
ret = H5Oget_comment_by_name(fid, string, read_buf, (size_t)MAX_STRING_LENGTH, H5P_DEFAULT);
CHECK(ret, FAIL, "H5Oget_comment_by_name");
ret = H5Gclose(grp_id);
CHECK(ret, FAIL, "H5Gclose");
VERIFY(HDstrcmp(string, read_buf), 0, "strcmp");
/* Create a new dataset with a UTF-8 name */
grp1_id = H5Gcreate2(fid, GROUP1_NAME, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
CHECK(grp1_id, FAIL, "H5Gcreate2");
space_id = H5Screate_simple(RANK, &dims, NULL);
CHECK(space_id, FAIL, "H5Screate_simple");
dset_id = H5Dcreate2(grp1_id, string, H5T_NATIVE_INT, space_id, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
CHECK(dset_id, FAIL, "H5Dcreate2");
/* Make sure that dataset can be opened again */
ret = H5Dclose(dset_id);
CHECK(ret, FAIL, "H5Dclose");
ret = H5Sclose(space_id);
CHECK(ret, FAIL, "H5Sclose");
dset_id = H5Dopen2(grp1_id, string, H5P_DEFAULT);
CHECK(ret, FAIL, "H5Dopen2");
ret = H5Dclose(dset_id);
CHECK(ret, FAIL, "H5Dclose");
ret = H5Gclose(grp1_id);
CHECK(ret, FAIL, "H5Gclose");
/* Do the same for a named datatype */
grp2_id = H5Gcreate2(fid, GROUP2_NAME, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
CHECK(grp2_id, FAIL, "H5Gcreate2");
type_id = H5Tcreate(H5T_OPAQUE, (size_t)1);
CHECK(type_id, FAIL, "H5Tcreate");
ret = H5Tcommit2(grp2_id, string, type_id, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
CHECK(type_id, FAIL, "H5Tcommit2");
ret = H5Tclose(type_id);
CHECK(type_id, FAIL, "H5Tclose");
type_id = H5Topen2(grp2_id, string, H5P_DEFAULT);
CHECK(type_id, FAIL, "H5Topen2");
ret = H5Tclose(type_id);
CHECK(type_id, FAIL, "H5Tclose");
/* Don't close the group -- use it to test that object references
* can refer to objects named in UTF-8 */
space_id = H5Screate_simple(RANK, &dims, NULL);
CHECK(space_id, FAIL, "H5Screate_simple");
dset_id = H5Dcreate2(grp2_id, DSET3_NAME, H5T_STD_REF_OBJ, space_id, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
CHECK(ret, FAIL, "H5Dcreate2");
/* Create reference to named datatype */
ret = H5Rcreate(&obj_ref, grp2_id, string, H5R_OBJECT, (hid_t)-1);
CHECK(ret, FAIL, "H5Rcreate");
/* Write selection and read it back*/
ret = H5Dwrite(dset_id, H5T_STD_REF_OBJ, H5S_ALL, H5S_ALL, H5P_DEFAULT, &obj_ref);
CHECK(ret, FAIL, "H5Dwrite");
ret = H5Dread(dset_id, H5T_STD_REF_OBJ, H5S_ALL, H5S_ALL, H5P_DEFAULT, &obj_ref);
CHECK(ret, FAIL, "H5Dread");
/* Ensure that we can open named datatype using object reference */
type_id = H5Rdereference2(dset_id, H5P_DEFAULT, H5R_OBJECT, &obj_ref);
CHECK(type_id, FAIL, "H5Rdereference2");
ret = H5Tcommitted(type_id);
VERIFY(ret, 1, "H5Tcommitted");
ret = H5Tclose(type_id);
CHECK(type_id, FAIL, "H5Tclose");
//.........这里部分代码省略.........
示例5: e5_read_grid_list
//.........这里部分代码省略.........
if(list_name && strlen(list_name))
{
e5_list_group_id = e5_create_group(e5_group_id, list_name);
close_group = 1;
}
else
{
e5_list_group_id = e5_group_id;
close_group = 0;
}
for(i = 0; grid_list && grid_list[i].name != 0; i++)
{
e5_grid_dataset* grid = &grid_list[i];
if(grid->name == 0 || strlen(grid->name) < 1)
continue;
e5_dataset_id = H5Dopen(e5_list_group_id, grid->name);
if (e5_dataset_id < 0)
{
e5_status = E5_INVALID_DATASET;
e5_error(e5_list_group_id, e5_status, "Failed to open grid dataset '%s'\n", grid->name);
return e5_status;
}
if(!grid->data)
{
e5_status = E5_INVALID_POINTER;
e5_error(e5_dataspace_id, e5_status, "Failed to provide pointer for reading '%s' from E5 data file\n", grid->name);
break;
}
e5_dataspace_id = H5Dget_space(e5_dataset_id);
e5_type_id = H5Dget_type(e5_dataset_id);
H5Sget_simple_extent_dims(e5_dataspace_id, h5_min_dim, h5_max_dim);
for(d = 0; d < 3; d++)
{
grid->dim[d] = h5_min_dim[d] >= h5_max_dim[d] ? h5_min_dim[d] : h5_max_dim[d];
grid->dim[d] = grid->dim[d] < 1 ? 1 : grid->dim[d];
}
grid->type = e5_convert_hdf_type(e5_type_id);
switch(grid->type)
{
case E5_TYPE_FLOAT:
{
e5_info(e5_group_id, "Reading grid [type='float', name='%s', dim='%u %u %u']\n",
grid->name, grid->dim[0], grid->dim[1], grid->dim[2]);
e5_memspace_id = H5Screate_simple(3, h5_min_dim, h5_max_dim);
h5_status = H5Dread(e5_dataset_id, H5T_NATIVE_FLOAT, e5_memspace_id, e5_dataspace_id, H5P_DEFAULT, (grid->data));
if (h5_status < 0)
{
e5_status = E5_READ_FAILURE;
e5_error(e5_dataset_id, e5_status, "Failed to read '%s' from F5 data file\n", grid->name);
}
H5Sclose(e5_memspace_id);
break;
}
case E5_TYPE_DOUBLE:
{
e5_info(e5_group_id, "Reading grid [type='double', name='%s', dim='%u %u %u']\n",
grid->name, grid->dim[0], grid->dim[1], grid->dim[2]);
e5_memspace_id = H5Screate_simple(3, h5_min_dim, h5_max_dim);
h5_status = H5Dread(e5_dataset_id, H5T_NATIVE_DOUBLE, e5_memspace_id, e5_dataspace_id, H5P_DEFAULT, (grid->data));
if (h5_status < 0)
{
e5_status = E5_READ_FAILURE;
e5_error(e5_dataset_id, e5_status, "Failed to read '%s' from F5 data file\n", grid->name);
}
H5Sclose(e5_memspace_id);
break;
}
case E5_TYPE_INVALID:
default:
{
e5_status = E5_INVALID_TYPE;
e5_error(e5_dataset_id, e5_status, "Invalid type for grid '%s' data\n", grid->name);
break;
}
};
log_scale = 0;
if(e5_is_valid_attr(e5_dataset_id, "log10"))
e5_read_attr_int(e5_dataset_id, "log10", &log_scale);
grid->scale = log_scale ? E5_VALUE_SCALE_LOG10 : E5_VALUE_SCALE_LINEAR;
H5Sclose(e5_dataspace_id);
H5Dclose(e5_dataset_id);
H5Tclose(e5_type_id);
}
if(list_name)
e5_close_group(e5_list_group_id);
return e5_status;
}示例6: cow_histogram_dumphdf5
void cow_histogram_dumphdf5(cow_histogram *h, char *fn, char *gn)
// -----------------------------------------------------------------------------
// Dumps the histogram to the HDF5 file named `fn`, under the group
// `gn`/h->fullname. The function uses rank 0 to do the write.
// -----------------------------------------------------------------------------
{
#if (COW_HDF5)
if (!(h->committed && h->sealed)) {
return;
}
char gname[1024];
int rank = 0;
snprintf(gname, 1024, "%s/%s", gn, h->nickname);
#if (COW_MPI)
if (cow_mpirunning()) {
MPI_Comm_rank(h->comm, &rank);
}
#endif
if (rank == 0) {
// -------------------------------------------------------------------------
// The write functions assume the file is already created. Have master
// create the file if it's not there already.
// -------------------------------------------------------------------------
FILE *testf = fopen(fn, "r");
hid_t fid;
if (testf == NULL) {
fid = H5Fcreate(fn, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);
}
else {
fclose(testf);
fid = H5Fopen(fn, H5F_ACC_RDWR, H5P_DEFAULT);
}
if (H5Lexists_safe(fid, gname)) {
printf("[%s] writing histogram as HDF5 to %s/%s (clobber existing)\n",
MODULE, fn, gname);
H5Gunlink(fid, gname);
}
else {
printf("[%s] writing histogram as HDF5 to %s/%s\n", MODULE, fn, gname);
}
hid_t gcpl = H5Pcreate(H5P_LINK_CREATE);
H5Pset_create_intermediate_group(gcpl, 1);
hid_t memb = H5Gcreate(fid, gname, gcpl, H5P_DEFAULT, H5P_DEFAULT);
H5Pclose(gcpl);
H5Gclose(memb);
H5Fclose(fid);
}
else {
return;
}
// Create a group to represent this histogram, and an attribute to name it
// ---------------------------------------------------------------------------
hid_t fid = H5Fopen(fn, H5F_ACC_RDWR, H5P_DEFAULT);
hid_t grp = H5Gopen(fid, gname, H5P_DEFAULT);
if (h->fullname != NULL) {
hid_t aspc = H5Screate(H5S_SCALAR);
hid_t strn = H5Tcopy(H5T_C_S1);
H5Tset_size(strn, strlen(h->fullname));
hid_t attr = H5Acreate(grp, "fullname", strn, aspc, H5P_DEFAULT, H5P_DEFAULT);
H5Awrite(attr, strn, h->fullname); // write the full name
H5Aclose(attr);
H5Tclose(strn);
H5Sclose(aspc);
}
// Create the data sets in the group: binloc (bin centers) and binval (values)
// ---------------------------------------------------------------------------
double *binlocX = h->binlocx;
double *binlocY = h->binlocy;
double *binvalV = h->binvalv;
hsize_t sizeX[2] = { h->nbinsx };
hsize_t sizeY[2] = { h->nbinsy };
hsize_t sizeZ[2] = { h->nbinsx, h->nbinsy };
hid_t fspcZ = H5Screate_simple(h->n_dims, sizeZ, NULL);
if (h->n_dims >= 1) {
hid_t fspcX = H5Screate_simple(1, sizeX, NULL);
hid_t dsetbinX = H5Dcreate(grp, "binlocX", H5T_NATIVE_DOUBLE, fspcX,
H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
H5Dwrite(dsetbinX, H5T_NATIVE_DOUBLE, fspcX, fspcX, H5P_DEFAULT, binlocX);
H5Dclose(dsetbinX);
H5Sclose(fspcX);
}
if (h->n_dims >= 2) {
hid_t fspcY = H5Screate_simple(1, sizeY, NULL);
hid_t dsetbinY = H5Dcreate(grp, "binlocY", H5T_NATIVE_DOUBLE, fspcY,
H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
H5Dwrite(dsetbinY, H5T_NATIVE_DOUBLE, fspcY, fspcY, H5P_DEFAULT, binlocY);
H5Dclose(dsetbinY);
H5Sclose(fspcY);
}
hid_t dsetvalV = H5Dcreate(grp, "binval", H5T_NATIVE_DOUBLE, fspcZ,
H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
H5Dwrite(dsetvalV, H5T_NATIVE_DOUBLE, fspcZ, fspcZ, H5P_DEFAULT, binvalV);
H5Dclose(dsetvalV);
H5Sclose(fspcZ);
H5Gclose(grp);
H5Fclose(fid);
#endif
}示例7: main
int
main(void) {
hid_t fid; /* File, group, datasets, datatypes */
hid_t gid_a; /* and dataspaces identifiers */
hid_t did_b, sid_b, tid_b;
hid_t did_r, tid_r, sid_r;
H5O_type_t obj_type;
herr_t status;
hobj_ref_t *wbuf; /* buffer to write to disk */
hobj_ref_t *rbuf; /* buffer to read from disk */
hsize_t dim_r[1];
hsize_t dim_b[2];
/*
* Create a file using default properties.
*/
fid = H5Fcreate(H5FILE_NAME, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);
/*
* Create group "A" in the file.
*/
gid_a = H5Gcreate2(fid, "A", H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
/*
* Create dataset "B" in the file.
*/
dim_b[0] = 2;
dim_b[1] = 6;
sid_b = H5Screate_simple(2, dim_b, NULL);
did_b = H5Dcreate2(fid, "B", H5T_NATIVE_FLOAT, sid_b, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
/*
* Create dataset "R" to store references to the objects "A" and "B".
*/
dim_r[0] = 2;
sid_r = H5Screate_simple(1, dim_r, NULL);
tid_r = H5Tcopy(H5T_STD_REF_OBJ);
did_r = H5Dcreate2(fid, "R", tid_r, sid_r, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
/*
* Allocate write and read buffers.
*/
wbuf = (hobj_ref_t *)malloc(sizeof(hobj_ref_t) * 2);
rbuf = (hobj_ref_t *)malloc(sizeof(hobj_ref_t) * 2);
/*
* Create references to the group "A" and dataset "B"
* and store them in the wbuf.
*/
H5Rcreate(&wbuf[0], fid, "A", H5R_OBJECT, (hid_t)-1);
H5Rcreate(&wbuf[1], fid, "B", H5R_OBJECT, (hid_t)-1);
/*
* Write dataset R using default transfer properties.
*/
status = H5Dwrite(did_r, H5T_STD_REF_OBJ, H5S_ALL, H5S_ALL, H5P_DEFAULT, wbuf);
/*
* Close all objects.
*/
H5Gclose(gid_a);
H5Sclose(sid_b);
H5Dclose(did_b);
H5Tclose(tid_r);
H5Sclose(sid_r);
H5Dclose(did_r);
H5Fclose(fid);
/*
* Reopen the file.
*/
fid = H5Fopen(H5FILE_NAME, H5F_ACC_RDWR, H5P_DEFAULT);
/*
* Open and read dataset "R".
*/
did_r = H5Dopen2(fid, "R", H5P_DEFAULT);
status = H5Dread(did_r, H5T_STD_REF_OBJ, H5S_ALL, H5S_ALL, H5P_DEFAULT, rbuf);
/*
* Find the type of referenced objects.
*/
status = H5Rget_obj_type2(did_r, H5R_OBJECT, &rbuf[0], &obj_type);
if(obj_type == H5O_TYPE_GROUP)
printf("First dereferenced object is a group. \n");
status = H5Rget_obj_type2(did_r, H5R_OBJECT, &rbuf[1], &obj_type);
if(obj_type == H5O_TYPE_DATASET)
printf("Second dereferenced object is a dataset. \n");
/*
* Get datatype of the dataset "B"
*/
did_b = H5Rdereference2(did_r, H5P_DEFAULT, H5R_OBJECT, &rbuf[1]);
//.........这里部分代码省略.........
示例8: diff_datasetid
//.........这里部分代码省略.........
hs_offset[i - 1] += hs_size[i - 1];
if(hs_offset[i - 1] == dims1[i - 1])
hs_offset[i - 1] = 0;
else
carry = 0;
} /* i */
} /* elmtno */
H5Sclose(sm_space);
} /* hyperslab read */
} /*can_compare*/
/*-------------------------------------------------------------------------
* close
*-------------------------------------------------------------------------
*/
h5difftrace("compare attributes?\n");
/* free */
if(buf1 != NULL) {
HDfree(buf1);
buf1 = NULL;
} /* end if */
if(buf2 != NULL) {
HDfree(buf2);
buf2 = NULL;
} /* end if */
if(sm_buf1 != NULL) {
HDfree(sm_buf1);
sm_buf1 = NULL;
} /* end if */
if(sm_buf2 != NULL) {
HDfree(sm_buf2);
sm_buf2 = NULL;
} /* end if */
H5E_BEGIN_TRY {
H5Sclose(sid1);
H5Sclose(sid2);
H5Tclose(f_tid1);
H5Tclose(f_tid2);
H5Tclose(m_tid1);
H5Tclose(m_tid2);
} H5E_END_TRY;
h5difftrace("diff_datasetid finish\n");
return nfound;
error:
options->err_stat=1;
/* free */
if (buf1!=NULL)
{
/* reclaim any VL memory, if necessary */
if(vl_data)
H5Dvlen_reclaim(m_tid1, sid1, H5P_DEFAULT, buf1);
HDfree(buf1);
buf1=NULL;
}
if (buf2!=NULL)
{
/* reclaim any VL memory, if necessary */
if(vl_data)
H5Dvlen_reclaim(m_tid2, sid2, H5P_DEFAULT, buf2);
HDfree(buf2);
buf2=NULL;
}
if (sm_buf1!=NULL)
{
/* reclaim any VL memory, if necessary */
if(vl_data)
H5Dvlen_reclaim(m_tid1, sm_space, H5P_DEFAULT, sm_buf1);
HDfree(sm_buf1);
sm_buf1=NULL;
}
if (sm_buf2!=NULL)
{
/* reclaim any VL memory, if necessary */
if(vl_data)
H5Dvlen_reclaim(m_tid1, sm_space, H5P_DEFAULT, sm_buf2);
HDfree(sm_buf2);
sm_buf2=NULL;
}
/* disable error reporting */
H5E_BEGIN_TRY {
H5Sclose(sid1);
H5Sclose(sid2);
H5Tclose(f_tid1);
H5Tclose(f_tid2);
H5Tclose(m_tid1);
H5Tclose(m_tid2);
/* enable error reporting */
} H5E_END_TRY;
h5difftrace("diff_datasetid errored\n");
return nfound;
}示例9: diff_can_type
//.........这里部分代码省略.........
parallel_print("\n");
}
}
can_compare = 0;
options->not_cmp = 1;
return can_compare;
}
/*-------------------------------------------------------------------------
* maximum dimensions; just give a warning
*-------------------------------------------------------------------------
*/
if (maxdim1 && maxdim2 && maxdim_diff==1 && obj1_name )
{
if (options->m_verbose) {
parallel_print( "Warning: different maximum dimensions\n");
parallel_print("<%s> has max dimensions ", obj1_name);
print_dimensions(rank1,maxdim1);
parallel_print("\n");
parallel_print("<%s> has max dimensions ", obj2_name);
print_dimensions(rank2,maxdim2);
parallel_print("\n");
}
}
if ( tclass1 == H5T_COMPOUND )
{
int nmembs1;
int nmembs2;
int j;
hid_t memb_type1;
hid_t memb_type2;
nmembs1 = H5Tget_nmembers(f_tid1);
nmembs2 = H5Tget_nmembers(f_tid2);
if ( nmembs1 != nmembs2 )
{
if ( (options->m_verbose||options->m_list_not_cmp) && obj1_name && obj2_name)
{
parallel_print("Not comparable: <%s> has %d members ", obj1_name, nmembs1);
parallel_print("<%s> has %d members ", obj2_name, nmembs2);
parallel_print("\n");
}
can_compare = 0;
options->not_cmp = 1;
return can_compare;
}
for (j = 0; j < nmembs1; j++)
{
memb_type1 = H5Tget_member_type(f_tid1, (unsigned)j);
memb_type2 = H5Tget_member_type(f_tid2, (unsigned)j);
if (diff_can_type(memb_type1,
memb_type2,
rank1,
rank2,
dims1,
dims2,
maxdim1,
maxdim2,
obj1_name,
obj2_name,
options,
1)!=1)
{
can_compare = 0;
options->not_cmp = 1;
H5Tclose(memb_type1);
H5Tclose(memb_type2);
return can_compare;
}
H5Tclose(memb_type1);
H5Tclose(memb_type2);
}
}
return can_compare;
}示例10: add_attrs
int
add_attrs(hid_t objid)
{
hid_t scalar_spaceid = -1;
hid_t vlstr_typeid = -1, fixstr_typeid = -1;
char *vlstr;
hid_t attid = -1;
/* Create scalar dataspace */
if ((scalar_spaceid = H5Screate(H5S_SCALAR)) < 0) ERR_GOTO;
/* Create string datatypes */
if ((vlstr_typeid = H5Tcreate(H5T_STRING, (size_t)H5T_VARIABLE)) < 0) ERR_GOTO;
if ((fixstr_typeid = H5Tcreate(H5T_STRING, (size_t)10)) < 0) ERR_GOTO;
/* Create attribute with VL string datatype on object */
if ((attid = H5Acreate2(objid, VSTR_ATT1_NAME, vlstr_typeid, scalar_spaceid, H5P_DEFAULT, H5P_DEFAULT)) < 0) ERR_GOTO;
/* No write, use fill value */
if (H5Aclose(attid) < 0) ERR_GOTO;
/* Create attribute with VL string datatype on object */
if ((attid = H5Acreate2(objid, VSTR_ATT2_NAME, vlstr_typeid, scalar_spaceid, H5P_DEFAULT, H5P_DEFAULT)) < 0) ERR_GOTO;
vlstr = NULL;
if (H5Awrite(attid, vlstr_typeid, &vlstr) < 0) ERR_GOTO;
if (H5Aclose(attid) < 0) ERR_GOTO;
/* Create attribute with VL string datatype on object */
if ((attid = H5Acreate2(objid, VSTR_ATT3_NAME, vlstr_typeid, scalar_spaceid, H5P_DEFAULT, H5P_DEFAULT)) < 0) ERR_GOTO;
vlstr = malloc(10);
*vlstr = '\0';
if (H5Awrite(attid, vlstr_typeid, &vlstr) < 0) ERR_GOTO;
if (H5Aclose(attid) < 0) ERR_GOTO;
/* Create attribute with VL string datatype on object */
if ((attid = H5Acreate2(objid, VSTR_ATT4_NAME, vlstr_typeid, scalar_spaceid, H5P_DEFAULT, H5P_DEFAULT)) < 0) ERR_GOTO;
strcpy(vlstr, "foo");
if (H5Awrite(attid, vlstr_typeid, &vlstr) < 0) ERR_GOTO;
free(vlstr);
if (H5Aclose(attid) < 0) ERR_GOTO;
/* Create attribute with fixed-length string datatype on object */
if ((attid = H5Acreate2(objid, FSTR_ATT_NAME, fixstr_typeid, scalar_spaceid, H5P_DEFAULT, H5P_DEFAULT)) < 0) ERR_GOTO;
if (H5Aclose(attid) < 0) ERR_GOTO;
/* Create attribute with native integer datatype on object */
if ((attid = H5Acreate2(objid, INT_ATT_NAME, H5T_NATIVE_INT, scalar_spaceid, H5P_DEFAULT, H5P_DEFAULT)) < 0) ERR_GOTO;
if (H5Aclose(attid) < 0) ERR_GOTO;
/* Clean up objects created */
if (H5Sclose(scalar_spaceid) < 0) ERR_GOTO;
if (H5Tclose(vlstr_typeid) < 0) ERR_GOTO;
if (H5Tclose(fixstr_typeid) < 0) ERR_GOTO;
return(0);
error:
H5E_BEGIN_TRY {
H5Aclose(attid);
H5Sclose(scalar_spaceid);
H5Tclose(vlstr_typeid);
H5Tclose(fixstr_typeid);
} H5E_END_TRY;
return(-1);
}示例11: process_cmpd_fields
/*-------------------------------------------------------------------------
* Function: process_cmpd_fields
*
* Purpose: To check whether the fields selected in "g_list_of_fields"
* are valid fields associated with the dataset.
*
* Return: 0 on success; negative on failure
*
* Programmer: Vailin Choi; August 2010
*
*-------------------------------------------------------------------------
*/
static herr_t
process_cmpd_fields(hid_t fid, char *dsetname)
{
hid_t did=-1; /* dataset id */
hid_t dtid=-1, tid=-1; /* dataset's data type id */
size_t len; /* number of comma-separated fields in "g_list_of_fields" */
herr_t ret_value = SUCCEED; /* Return value */
HDassert(g_list_of_fields && *g_list_of_fields);
/* Open the dataset */
if((did = H5Dopen2(fid, dsetname, H5P_DEFAULT)) < 0) {
error_msg("error in opening dataset \"%s\"\n", dsetname);
ret_value = FAIL;
goto done;
}
/* Get the dataset's datatype */
if(((dtid = H5Dget_type(did)) < 0) || (tid = H5Tget_native_type(dtid, H5T_DIR_DEFAULT)) < 0) {
error_msg("error in getting dataset's datatype\n");
ret_value = FAIL;
goto done;
}
/* Check to make sure that the dataset's datatype is compound type */
if(H5Tget_class(dtid) != H5T_COMPOUND) {
error_msg("dataset should be compound type for <list_of_fields>\n");
ret_value = FAIL;
goto done;
}
/* Make a copy of "g_list_of_fields" */
if((g_dup_fields = HDstrdup(g_list_of_fields)) == NULL) {
error_msg("error in duplicating g_list_of_fields\n");
ret_value = FAIL;
goto done;
}
/* Estimate the number of comma-separated fields in "g_list of_fields" */
len = HDstrlen(g_list_of_fields)/2 + 2;
/* Allocate memory for a list vector of H5LD_memb_t structures to store "g_list_of_fields" info */
if((g_listv = (H5LD_memb_t **)HDcalloc(len, sizeof(H5LD_memb_t *))) == NULL) {
error_msg("error in allocating memory for H5LD_memb_t\n");
ret_value = FAIL;
goto done;
}
/* Process and store info for "g_listv" */
if(H5LD_construct_vector(g_dup_fields, g_listv, tid) < 0) {
error_msg("error in processing <list_of_fields>\n");
ret_value = FAIL;
goto done;
}
/* Will free memory for g_listv and g_dup_fields when exiting from h5watch */
done:
/* Closing */
H5E_BEGIN_TRY
H5Tclose(dtid);
H5Tclose(tid);
H5Dclose(did);
H5E_END_TRY
return(ret_value);
} /* process_cmpd_fields() */示例12: main
int
main()
{
printf("\n*** Creating file with datasets & attributes that have scalar dataspaces...");
{
hid_t fileid;
hid_t fcplid;
hid_t dsetid;
hid_t dcplid;
hid_t scalar_spaceid;
hid_t vlstr_typeid, fixstr_typeid;
hid_t attid;
/* Create scalar dataspace */
if ((scalar_spaceid = H5Screate(H5S_SCALAR)) < 0) ERR;
/* Set creation ordering for file, so we can revise its contents later */
if ((fcplid = H5Pcreate(H5P_FILE_CREATE)) < 0) ERR;
if (H5Pset_link_creation_order(fcplid, H5P_CRT_ORDER_TRACKED) < 0) ERR;
if (H5Pset_attr_creation_order(fcplid, H5P_CRT_ORDER_TRACKED) < 0) ERR;
/* Create new file, using default properties */
if ((fileid = H5Fcreate(FILE_NAME, H5F_ACC_TRUNC, fcplid, H5P_DEFAULT)) < 0) ERR;
/* Close file creation property list */
if (H5Pclose(fcplid) < 0) ERR;
/* Create variable-length string datatype */
if ((vlstr_typeid = H5Tcreate(H5T_STRING, (size_t)H5T_VARIABLE)) < 0) ERR;
/* Create fixed-length string datatype */
if ((fixstr_typeid = H5Tcreate(H5T_STRING, (size_t)10)) < 0) ERR;
/* Set creation ordering for dataset, so we can revise its contents later */
if ((dcplid = H5Pcreate(H5P_DATASET_CREATE)) < 0) ERR;
if (H5Pset_attr_creation_order(dcplid, H5P_CRT_ORDER_TRACKED) < 0) ERR;
/* Create scalar dataset with VL string datatype */
if ((dsetid = H5Dcreate2(fileid, VSTR_VAR1_NAME, vlstr_typeid, scalar_spaceid, H5P_DEFAULT, dcplid, H5P_DEFAULT)) < 0) ERR;
/* Add attributes to dataset */
if (add_attrs(dsetid) < 0) ERR;
/* Close VL string dataset */
if (H5Dclose(dsetid) < 0) ERR;
/* Create scalar dataset with fixed-length string datatype */
if ((dsetid = H5Dcreate2(fileid, FSTR_VAR_NAME, fixstr_typeid, scalar_spaceid, H5P_DEFAULT, dcplid, H5P_DEFAULT)) < 0) ERR;
/* Add attributes to dataset */
if (add_attrs(dsetid) < 0) ERR;
/* Close fixed-length string dataset */
if (H5Dclose(dsetid) < 0) ERR;
/* Create scalar dataset with native integer datatype */
if ((dsetid = H5Dcreate2(fileid, INT_VAR_NAME, H5T_NATIVE_INT, scalar_spaceid, H5P_DEFAULT, dcplid, H5P_DEFAULT)) < 0) ERR;
/* Add attributes to dataset */
if (add_attrs(dsetid) < 0) ERR;
/* Close native integer dataset */
if (H5Dclose(dsetid) < 0) ERR;
/* Add attributes to root group */
if (add_attrs(fileid) < 0) ERR;
/* Close dataset creation property list */
if (H5Pclose(dcplid) < 0) ERR;
/* Close string datatypes */
if (H5Tclose(vlstr_typeid) < 0) ERR;
if (H5Tclose(fixstr_typeid) < 0) ERR;
/* Close rest */
if (H5Sclose(scalar_spaceid) < 0) ERR;
if (H5Fclose(fileid) < 0) ERR;
}
SUMMARIZE_ERR;
printf("*** Checking accessing file through netCDF-4 API...");
{
int ncid, varid;
size_t len;
nc_type type;
int ndims;
char *vlstr;
int x;
if (nc_open(FILE_NAME, NC_NOWRITE, &ncid)) ERR;
/* Check the global attributes are OK */
//.........这里部分代码省略.........
示例13: _get_all_samples
static void* _get_all_samples(hid_t gid_series, char* nam_series, uint32_t type,
int nsamples)
{
void* data = NULL;
hid_t id_data_set, dtyp_memory, g_sample, sz_dest;
herr_t ec;
int smpx ,len;
void *data_prior = NULL, *data_cur = NULL;
char name_sample[MAX_GROUP_NAME+1];
hdf5_api_ops_t* ops;
ops = profile_factory(type);
if (ops == NULL) {
error("Failed to create operations for %s",
acct_gather_profile_type_to_string(type));
return NULL;
}
data = (*(ops->init_job_series))(nsamples);
if (data == NULL) {
xfree(ops);
error("Failed to get memory for combined data");
return NULL;
}
dtyp_memory = (*(ops->create_memory_datatype))();
if (dtyp_memory < 0) {
xfree(ops);
xfree(data);
error("Failed to create %s memory datatype",
acct_gather_profile_type_to_string(type));
return NULL;
}
for (smpx=0; smpx<nsamples; smpx++) {
len = H5Lget_name_by_idx(gid_series, ".", H5_INDEX_NAME,
H5_ITER_INC, smpx, name_sample,
MAX_GROUP_NAME, H5P_DEFAULT);
if (len<1 || len>MAX_GROUP_NAME) {
error("Invalid group name %s", name_sample);
continue;
}
g_sample = H5Gopen(gid_series, name_sample, H5P_DEFAULT);
if (g_sample < 0) {
info("Failed to open %s", name_sample);
}
id_data_set = H5Dopen(g_sample, get_data_set_name(name_sample),
H5P_DEFAULT);
if (id_data_set < 0) {
H5Gclose(g_sample);
error("Failed to open %s dataset",
acct_gather_profile_type_to_string(type));
continue;
}
sz_dest = (*(ops->dataset_size))();
data_cur = xmalloc(sz_dest);
if (data_cur == NULL) {
H5Dclose(id_data_set);
H5Gclose(g_sample);
error("Failed to get memory for prior data");
continue;
}
ec = H5Dread(id_data_set, dtyp_memory, H5S_ALL, H5S_ALL,
H5P_DEFAULT, data_cur);
if (ec < 0) {
xfree(data_cur);
H5Dclose(id_data_set);
H5Gclose(g_sample);
error("Failed to read %s data",
acct_gather_profile_type_to_string(type));
continue;
}
(*(ops->merge_step_series))(g_sample, data_prior, data_cur,
data+(smpx)*sz_dest);
xfree(data_prior);
data_prior = data_cur;
H5Dclose(id_data_set);
H5Gclose(g_sample);
}
xfree(data_cur);
H5Tclose(dtyp_memory);
xfree(ops);
return data;
}示例14: H5Aget_space
void H5Attribute::copy(const hid_t src, const hid_t dest, const std::string & name)
{
hid_t type, stype;
hid_t space, sspace;
char * data = 0;
hsize_t size;
hsize_t * dims = 0;
hsize_t ndims;
sspace = H5Aget_space(src);
if (sspace < 0)
{
throw H5Exception(__LINE__, __FILE__, _("Cannot copy the attribute"));
}
space = H5Scopy(sspace);
H5Sclose(sspace);
stype = H5Aget_type(src);
if (stype < 0)
{
H5Sclose(space);
throw H5Exception(__LINE__, __FILE__, _("Cannot copy the attribute"));
}
type = H5Tcopy(stype);
H5Tclose(stype);
size = H5Tget_size(type);
dims = new hsize_t[__SCILAB_HDF5_MAX_DIMS__];
ndims = H5Sget_simple_extent_dims(space, dims, 0);
for (unsigned int i = 0; i < ndims; i++)
{
size *= dims[i];
}
data = new char[size];
if (H5Aread(src, type, data) < 0)
{
H5Sclose(space);
H5Tclose(type);
delete[] dims;
delete[] data;
throw H5Exception(__LINE__, __FILE__, _("Cannot read attribute data."));
}
try
{
hid_t attr = create(dest, name, type, type, space, space, data);
H5Aclose(attr);
H5Sclose(space);
H5Tclose(type);
delete[] dims;
delete[] data;
}
catch (const H5Exception & /*e*/)
{
H5Sclose(space);
H5Tclose(type);
delete[] dims;
delete[] data;
throw;
}
}示例15: Py_INCREF
PyObject *H5UIget_info( hid_t loc_id,
const char *dset_name,
char *byteorder)
{
hid_t dataset_id;
int rank;
hsize_t *dims;
hid_t space_id;
H5T_class_t class_id;
H5T_order_t order;
hid_t type_id;
PyObject *t;
int i;
/* Open the dataset. */
if ( (dataset_id = H5Dopen( loc_id, dset_name, H5P_DEFAULT )) < 0 ) {
Py_INCREF(Py_None);
return Py_None; /* Not chunked, so return None */
}
/* Get an identifier for the datatype. */
type_id = H5Dget_type( dataset_id );
/* Get the class. */
class_id = H5Tget_class( type_id );
/* Get the dataspace handle */
if ( (space_id = H5Dget_space( dataset_id )) < 0 )
goto out;
/* Get rank */
if ( (rank = H5Sget_simple_extent_ndims( space_id )) < 0 )
goto out;
/* Book resources for dims */
dims = (hsize_t *)malloc(rank * sizeof(hsize_t));
/* Get dimensions */
if ( H5Sget_simple_extent_dims( space_id, dims, NULL) < 0 )
goto out;
/* Assign the dimensions to a tuple */
t = PyTuple_New(rank);
for(i=0;i<rank;i++) {
/* I don't know if I should increase the reference count for dims[i]! */
PyTuple_SetItem(t, i, PyLong_FromLong((long)dims[i]));
}
/* Release resources */
free(dims);
/* Terminate access to the dataspace */
if ( H5Sclose( space_id ) < 0 )
goto out;
/* Get the byteorder */
/* Only integer, float, time and enum classes can be byteordered */
if ((class_id == H5T_INTEGER) || (class_id == H5T_FLOAT)
|| (class_id == H5T_BITFIELD) || (class_id == H5T_TIME)
|| (class_id == H5T_ENUM)) {
order = H5Tget_order( type_id );
if (order == H5T_ORDER_LE)
strcpy(byteorder, "little");
else if (order == H5T_ORDER_BE)
strcpy(byteorder, "big");
else {
fprintf(stderr, "Error: unsupported byteorder: %d\n", order);
goto out;
}
}
else {
strcpy(byteorder, "irrelevant");
}
/* End access to the dataset */
H5Dclose( dataset_id );
/* Return the dimensions tuple */
return t;
out:
H5Tclose( type_id );
H5Dclose( dataset_id );
Py_INCREF(Py_None);
return Py_None; /* Not chunked, so return None */
}