typename F::return_value iterate(F & functor, H5_index_t index_type=H5_INDEX_CRT_ORDER, H5_iter_order_t order=H5_ITER_INC, hsize_t *idx=0) const { h5e::check_error(H5Literate(_self, index_type, order, idx, &F::iterate, static_cast<void*>(&functor))); return functor.value; }
//-***************************************************************************** OrData::OrData( ObjectHeaderPtr iHeader, H5Node & iParentGroup, int32_t iArchiveVersion ) : m_children( NULL ) { ABCA_ASSERT( iHeader, "Invalid header" ); ABCA_ASSERT( iParentGroup.isValidObject(), "Invalid group" ); m_group = OpenGroup( iParentGroup, iHeader->getName().c_str() ); ABCA_ASSERT( m_group.isValidObject(), "Could not open object group: " << iHeader->getFullName() ); std::vector<std::string> objNames; herr_t status = H5Literate( m_group.getObject(), H5_INDEX_CRT_ORDER, H5_ITER_INC, NULL, VisitAllLinksCB, ( void * )&objNames ); ABCA_ASSERT( status >= 0, "OrData::OrData: H5Literate failed" ); std::vector < std::string >::iterator namesIt; uint32_t i = 0; if ( !objNames.empty() ) { m_children = new Child[ objNames.size() ]; } std::string parentFullName = iHeader->getFullName(); if ( parentFullName != "/" ) { parentFullName += "/"; } for ( namesIt = objNames.begin(); namesIt != objNames.end(); ++namesIt, ++i ) { m_childrenMap[ *namesIt ] = i; m_children[i].header.reset( new AbcA::ObjectHeader( *namesIt, parentFullName + *namesIt, AbcA::MetaData() ) ); m_children[i].loadedMetaData = false; } m_oldGroup = m_group; m_data = Alembic::Util::shared_ptr<CprData>( new CprData( m_group, iArchiveVersion, ".prop" ) ); }
static char* name(ndio_hdf5_t self) { static const char name_[]="data"; if(self->name) return self->name; if(!self->isr) { TRY(self->name=(char*)malloc(1+countof(name_))); strcpy(self->name,name_); } else { HTRY(H5Literate(self->file,H5_INDEX_NAME,H5_ITER_NATIVE,NULL,query_first_name,&self->name)); } return self->name; Error: return 0; }
int getDataSetId_v1(int _iFile) { herr_t status = 0; int iDatasetId = 0; hsize_t idx = 0; /* * Begin iteration. */ status = H5Literate(_iFile, H5_INDEX_NAME, H5_ITER_NATIVE, &idx, op_func_v1, &iDatasetId); if (status < 0) { return -1; } return iDatasetId; }
std::string H5Group::ls() const { std::ostringstream os; herr_t err; OpDataPrintLs opdata; opdata.parent = const_cast<H5Group *>(this); opdata.os = &os; hsize_t idx = 0; err = H5Literate(group, H5_INDEX_NAME, H5_ITER_INC, &idx, printLsInfo, &opdata); if (err < 0) { throw H5Exception(__LINE__, __FILE__, _("Cannot list group contents")); } return os.str(); }
int VsFilter::visitGroup(hid_t locId, const char* name, void* opdata) { RECURSION_DATA* data = static_cast< RECURSION_DATA* >(opdata); VsGroup* parent = static_cast< VsGroup*> (data->parent); VsRegistry* registry = data->registry; VsLog::debugLog() << "VsFilter::visitGroup: node '" << name << "' is a group." << std::endl; if (std::string(name) == "..") { VsLog::debugLog() << "VsFilter::visitGroup: skipping group '..'" << std::endl; return 0; } hid_t groupId = H5Gopen(locId, name, H5P_DEFAULT); //If unable to get a handle to the hdf5 object, we just drop the object //But return 0 to continue iterating over objects if (groupId < 0) { VsLog::errorLog() <<"VsFilter::visitGroup() - Unable to open group with name " <<name <<std::endl; VsLog::errorLog() <<"VsFilter::visitGroup() - This object and all children will be dropped." <<std::endl; return 0; } VsGroup* newGroup = new VsGroup(registry, parent, name, groupId); RECURSION_DATA nextLevelData; nextLevelData.registry = registry; nextLevelData.parent = newGroup; // Recurse over all attributes of the group VsLog::debugLog() <<"VsFilter::visitGroup(): Recursing on attributes of group " <<newGroup->getFullName() <<std::endl; H5Aiterate(groupId, H5_INDEX_NAME, H5_ITER_INC, NULL, visitAttrib, &nextLevelData); // Recurse to examine child groups VsLog::debugLog() <<"VsFilter::visitGroup(): Recursing on children of group " <<newGroup->getFullName() <<std::endl; H5Literate(groupId, H5_INDEX_NAME, H5_ITER_INC, NULL, visitLinks, &nextLevelData); // Not needed because the newly declared VsGroup takes ownership of the id // And will do the H5GClose when it is deleted // H5Gclose(groupId); VsLog::debugLog() <<"VsFilter::visitGroup(): Returning." <<std::endl; return 0; }
void AbstractHdf5Converter<ELEMENT_DIM,SPACE_DIM>::GenerateListOfDatasets(const FileFinder& rH5Folder, const std::string& rFileName) { /* * Open file. */ std::string file_name = rH5Folder.GetAbsolutePath() + rFileName + ".h5"; hid_t file = H5Fopen(file_name.c_str(), H5F_ACC_RDONLY, H5P_DEFAULT); /* * Begin HDF5 iteration, calls a method that populates mDatasetNames. */ #if H5_VERS_MAJOR >= 1 && H5_VERS_MINOR >=8 //std::cout << "HDF5 1.8.x or above detected.\n"; H5Literate(file, H5_INDEX_NAME, H5_ITER_NATIVE, NULL, op_func, &mDatasetNames); #else //std::cout << "HDF5 1.6.x detected.\n"; H5Giterate(file, "/", NULL, op_func, &mDatasetNames); #endif H5Fclose(file); // Remove datasets that end in "_Unlimited", as these are paired up with other ones! std::string ending = "_Unlimited"; // Strip off the independent variables from the list std::vector<std::string>::iterator iter; for (iter = mDatasetNames.begin(); iter != mDatasetNames.end(); ) { // If the dataset name is "Time" OR ... // it is longer than the ending we are looking for ("_Unlimited") ... // ... AND it ends with the string we are looking for, // then erase it. if ( (*(iter) == "Time") || ( ( iter->length() > ending.length() ) && ( 0 == iter->compare(iter->length() - ending.length(), ending.length(), ending) ) ) ) { iter = mDatasetNames.erase(iter); } else { ++iter; } } }
void H5Group::ls(std::vector<std::string> & name, std::vector<std::string> & type) const { herr_t err; OpDataGetLs opdata(const_cast<H5Group *>(this), &name, &type); hsize_t idx = 0; err = H5Literate(group, H5_INDEX_NAME, H5_ITER_INC, &idx, getLsInfo, &opdata); if (err < 0) { throw H5Exception(__LINE__, __FILE__, _("Cannot list group links.")); } idx = 0; err = H5Aiterate(group, H5_INDEX_NAME, H5_ITER_INC, &idx, H5Object::getLsAttributes, &opdata); if (err < 0) { throw H5Exception(__LINE__, __FILE__, _("Cannot list group attributes.")); } }
VsFile* VsFilter::readFile(VsRegistry* registry, std::string fileName) { hid_t fapl = H5Pcreate(H5P_FILE_ACCESS); H5Pset_fclose_degree(fapl, H5F_CLOSE_SEMI); hid_t fileId = H5Fopen(fileName.c_str(), H5F_ACC_RDONLY, fapl); H5Pclose(fapl); if (fileId < 0) { VsLog::errorLog() << "VsFile::readFile(): HDF5 error opening the file '" << fileName << "'." << std::endl; return NULL; } VsFile* file = new VsFile(registry, fileName, fileId); RECURSION_DATA data; data.registry = registry; data.parent = NULL; H5Literate(fileId, H5_INDEX_NAME, H5_ITER_INC, 0, visitLinks, &data); return file; }
HDF5Err HDF5Group::deleteSubtree(HDF5Id group_id, const char *group_name, const H5L_info_t *NK_UNUSED_PARAM(group_info), void *NK_UNUSED_PARAM(op_data)) { // open the child group HDF5Group child_group; child_group.open(group_id, String(group_name)); // iterate over the group's children HDF5Size iter_index = 0; H5Literate(child_group.id(), H5_INDEX_CRT_ORDER, H5_ITER_NATIVE, &iter_index, deleteSubtree, NULL); // close the child group child_group.close(); // delete the link H5Ldelete(group_id, group_name, H5P_DEFAULT); return 0; }
/* * Class: hdf_hdf5lib_H5 * Method: H5Literate * Signature: (JIIJLjava/lang/Object;Ljava/lang/Object;)I */ JNIEXPORT jint JNICALL Java_hdf_hdf5lib_H5_H5Literate (JNIEnv *env, jclass clss, jlong grp_id, jint idx_type, jint order, jlong idx, jobject callback_op, jobject op_data) { hsize_t start_idx = (hsize_t)idx; herr_t status = -1; cb_wrapper wrapper = {callback_op, op_data}; ENVPTR->GetJavaVM(ENVPAR &jvm); if ((op_data == NULL) || (callback_op == NULL)) { h5nullArgument(env, "H5Literate: op_data or callback_op is NULL"); } /* end if */ else { status = H5Literate((hid_t)grp_id, (H5_index_t)idx_type, (H5_iter_order_t)order, (hsize_t*)&start_idx, (H5L_iterate_t)H5L_iterate_cb, (void*)&wrapper); if (status < 0) h5libraryError(env); } /* end else */ return status; } /* end Java_hdf_hdf5lib_H5_H5Literate */
value hdf5_h5l_iterate(value group_v, value index_type_v, value order_v, value idx_v, value op_v, value op_data_v) { CAMLparam5(group_v, index_type_v, order_v, idx_v, op_v); CAMLxparam1(op_data_v); CAMLlocal1(exception); struct operator_data op_data; hsize_t idx, ret; op_data.callback = &op_v; op_data.operator_data = &op_data_v; op_data.exception = &exception; idx = Is_block(idx_v) ? Int_val(Field(Field(idx_v, 0), 0)) : 0; exception = Val_unit; ret = H5Literate(Hid_val(group_v), H5_index_val(index_type_v), H5_iter_order_val(order_v), Is_block(idx_v) ? &idx : NULL, hdf5_h5l_operator, &op_data); if (Is_block(idx_v)) Store_field(Field(idx_v, 0), 0, Val_int(idx)); if (exception != Val_unit) caml_raise(exception); CAMLreturn(Val_h5_iter(ret)); }
int main (void) { hid_t file; hid_t grp; hid_t dataset, dataspace; hid_t plist; herr_t status; hsize_t dims[2]; hsize_t cdims[2]; int idx_f, idx_g; /* * Create a file. */ file = H5Fcreate(H5FILE_NAME, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT); /* * Create a group in the file. */ grp = H5Gcreate(file, "/Data", H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT); /* * Create dataset "Compressed Data" in the group using absolute * name. Dataset creation property list is modified to use * GZIP compression with the compression effort set to 6. * Note that compression can be used only when dataset is chunked. */ dims[0] = 1000; dims[1] = 20; cdims[0] = 20; cdims[1] = 20; dataspace = H5Screate_simple(RANK, dims, NULL); plist = H5Pcreate(H5P_DATASET_CREATE); H5Pset_chunk(plist, 2, cdims); H5Pset_deflate( plist, 6); dataset = H5Dcreate(file, "/Data/Compressed_Data", H5T_NATIVE_INT, dataspace, H5P_DEFAULT, plist, H5P_DEFAULT); /* * Close the first dataset . */ H5Sclose(dataspace); H5Dclose(dataset); /* * Create the second dataset. */ dims[0] = 500; dims[1] = 20; dataspace = H5Screate_simple(RANK, dims, NULL); dataset = H5Dcreate(file, "/Data/Float_Data", H5T_NATIVE_FLOAT, dataspace, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT); /* *Close the second dataset and file. */ H5Sclose(dataspace); H5Dclose(dataset); H5Pclose(plist); H5Gclose(grp); H5Fclose(file); /* * Now reopen the file and group in the file. */ file = H5Fopen(H5FILE_NAME, H5F_ACC_RDWR, H5P_DEFAULT); grp = H5Gopen(file, "Data", H5P_DEFAULT); /* * Access "Compressed_Data" dataset in the group. */ dataset = H5Dopen(grp, "Compressed_Data", H5P_DEFAULT); if( dataset < 0) printf(" Dataset 'Compressed-Data' is not found. \n"); printf("\"/Data/Compressed_Data\" dataset is open \n"); /* * Close the dataset. */ status = H5Dclose(dataset); /* * Create hard link to the Data group. */ status = H5Lcreate_hard(file, "Data", H5L_SAME_LOC, "Data_new", H5P_DEFAULT, H5P_DEFAULT); /* * We can access "Compressed_Data" dataset using created * hard link "Data_new". */ dataset = H5Dopen(file, "/Data_new/Compressed_Data", H5P_DEFAULT); if( dataset < 0) printf(" Dataset is not found. \n"); printf("\"/Data_new/Compressed_Data\" dataset is open \n"); /* * Close the dataset. */ status = H5Dclose(dataset); /* * Use iterator to see the names of the objects in the root group. */ idx_f = H5Literate(file, H5_INDEX_NAME, H5_ITER_INC, NULL, file_info, NULL); /* * Unlink name "Data" and use iterator to see the names * of the objects in the file root direvtory. */ if(H5Ldelete(file, "Data", H5P_DEFAULT) < 0) printf(" H5Ldelete failed \n"); else printf("\"Data\" is unlinked \n"); idx_f = H5Literate(file, H5_INDEX_NAME, H5_ITER_INC, NULL, file_info, NULL); /* * Use iterator to see the names of the objects in the group * /Data_new. */ idx_g = H5Literate_by_name(grp, "/Data_new", H5_INDEX_NAME, H5_ITER_INC, NULL, group_info, NULL, H5P_DEFAULT); /* * Close the file. */ H5Gclose(grp); H5Fclose(file); return 0; }
u::logic HDF5FormatLib::GetHDF5StructFile(QString filePathJson1, QString filePathHdf) { hid_t file; herr_t status; H5O_info_t infobuf; struct opdata od; filePathJson = filePathJson1; try { FILE *pfile1; pfile1 = fopen(filePathJson1.toStdString().c_str(), "w"); if (!pfile1) { throw GenericExc(QObject::tr("Ошибка открытия json файла")); } fprintf(pfile1, "%s", "{\n"); fclose(pfile1); file = H5Fopen (filePathHdf.toStdString().c_str(), H5F_ACC_RDONLY, H5P_DEFAULT); if (file < 0) { throw GenericExc(QObject::tr("Ошибка открытия файла")); } status = H5Oget_info (file, &infobuf); if (status < 0) { throw GenericExc(QObject::tr("Ошибка получения информации о файле")); } od.recurs = 0; od.prev = NULL; od.addr = infobuf.addr; status = H5Literate (file, H5_INDEX_NAME, H5_ITER_NATIVE, NULL, op_func, (void *) &od); if (status < 0) { throw GenericExc(QObject::tr("Ошибка получения структуры файла")); } status = H5Fclose (file); if (status < 0) { throw GenericExc(QObject::tr("Ошибка закрытия файла")); } pfile1 = fopen(filePathJson.toStdString().c_str(), "a"); if (!pfile1) { throw GenericExc(QObject::tr("Ошибка открытия json файла")); } fprintf(pfile1, "%s", "}"); fclose(pfile1); return true; } catch (const GenericExc& exc) { m_errDescription = exc.GetWhat(); return false; } catch (...) { m_errDescription = QObject::tr("Неизвестная ошибка при получении структуры данных"); return false; } }
/**************************************************************** ** ** test_iter_group_large(): Test group iteration functionality ** for groups with large #'s of objects ** ****************************************************************/ static void test_iter_group_large(hid_t fapl) { hid_t file; /* HDF5 File IDs */ hid_t dataset; /* Dataset ID */ hid_t group; /* Group ID */ hid_t sid; /* Dataspace ID */ hid_t tid; /* Datatype ID */ hsize_t dims[] = {SPACE1_DIM1}; herr_t ret; /* Generic return value */ char gname[20]; /* Temporary group name */ iter_info names[ITER_NGROUPS+2]; /* Names of objects in the root group */ iter_info *curr_name; /* Pointer to the current name in the root group */ int i; /* Compound datatype */ typedef struct s1_t { unsigned int a; unsigned int b; float c; } s1_t; HDmemset(names, 0, sizeof names); /* Output message about test being performed */ MESSAGE(5, ("Testing Large Group Iteration Functionality\n")); /* Create file */ file = H5Fcreate(DATAFILE, H5F_ACC_TRUNC, H5P_DEFAULT, fapl); CHECK(file, FAIL, "H5Fcreate"); /* Create dataspace for datasets */ sid = H5Screate_simple(SPACE1_RANK, dims, NULL); CHECK(sid, FAIL, "H5Screate_simple"); /* Create a bunch of groups */ for(i = 0; i < ITER_NGROUPS; i++) { sprintf(gname, "Group_%d", i); /* Add the name to the list of objects in the root group */ HDstrcpy(names[i].name, gname); names[i].type = H5O_TYPE_GROUP; /* Create a group */ group = H5Gcreate2(file, gname, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT); CHECK(group, FAIL, "H5Gcreate2"); /* Close a group */ ret = H5Gclose(group); CHECK(ret, FAIL, "H5Gclose"); } /* end for */ /* Create a dataset */ dataset = H5Dcreate2(file, "Dataset1", H5T_STD_U32LE, sid, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT); CHECK(dataset, FAIL, "H5Dcreate2"); /* Add the name to the list of objects in the root group */ HDstrcpy(names[ITER_NGROUPS].name, "Dataset1"); names[ITER_NGROUPS].type = H5O_TYPE_DATASET; /* Close Dataset */ ret = H5Dclose(dataset); CHECK(ret, FAIL, "H5Dclose"); /* Close Dataspace */ ret = H5Sclose(sid); CHECK(ret, FAIL, "H5Sclose"); /* Create a datatype */ tid = H5Tcreate(H5T_COMPOUND, sizeof(s1_t)); CHECK(tid, FAIL, "H5Tcreate"); /* Insert fields */ ret = H5Tinsert(tid, "a", HOFFSET(s1_t, a), H5T_NATIVE_INT); CHECK(ret, FAIL, "H5Tinsert"); ret = H5Tinsert(tid, "b", HOFFSET(s1_t, b), H5T_NATIVE_INT); CHECK(ret, FAIL, "H5Tinsert"); ret = H5Tinsert(tid, "c", HOFFSET(s1_t, c), H5T_NATIVE_FLOAT); CHECK(ret, FAIL, "H5Tinsert"); /* Save datatype for later */ ret = H5Tcommit2(file, "Datatype1", tid, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT); CHECK(ret, FAIL, "H5Tcommit2"); /* Add the name to the list of objects in the root group */ HDstrcpy(names[ITER_NGROUPS + 1].name, "Datatype1"); names[ITER_NGROUPS + 1].type = H5O_TYPE_NAMED_DATATYPE; /* Close datatype */ ret = H5Tclose(tid); CHECK(ret, FAIL, "H5Tclose"); /* Need to sort the names in the root group, cause that's what the library does */ HDqsort(names, (size_t)(ITER_NGROUPS + 2), sizeof(iter_info), iter_strcmp2); /* Iterate through the file to see members of the root group */ curr_name = &names[0]; ret = H5Literate(file, H5_INDEX_NAME, H5_ITER_INC, NULL, liter_cb2, curr_name); CHECK(ret, FAIL, "H5Literate"); for(i = 1; i < 100; i++) { hsize_t idx = i; curr_name = &names[i]; ret = H5Literate(file, H5_INDEX_NAME, H5_ITER_INC, &idx, liter_cb2, curr_name); CHECK(ret, FAIL, "H5Literate"); } /* end for */ /* Close file */ ret = H5Fclose(file); CHECK(ret, FAIL, "H5Fclose"); } /* test_iterate_group_large() */
/**************************************************************** ** ** test_iter_group(): Test group iteration functionality ** ****************************************************************/ static void test_iter_group(hid_t fapl, hbool_t new_format) { hid_t file; /* File ID */ hid_t dataset; /* Dataset ID */ hid_t datatype; /* Common datatype ID */ hid_t filespace; /* Common dataspace ID */ hid_t root_group,grp; /* Root group ID */ int i; /* counting variable */ hsize_t idx; /* Index in the group */ char name[NAMELEN]; /* temporary name buffer */ char *lnames[NDATASETS + 2];/* Names of the links created */ char dataset_name[NAMELEN]; /* dataset name */ iter_info info; /* Custom iteration information */ H5G_info_t ginfo; /* Buffer for querying object's info */ herr_t ret; /* Generic return value */ /* Output message about test being performed */ MESSAGE(5, ("Testing Group Iteration Functionality\n")); /* Create the test file with the datasets */ file = H5Fcreate(DATAFILE, H5F_ACC_TRUNC, H5P_DEFAULT, fapl); CHECK(file, FAIL, "H5Fcreate"); /* Test iterating over empty group */ info.command = RET_ZERO; idx = 0; ret = H5Literate(file, H5_INDEX_NAME, H5_ITER_INC, &idx, liter_cb, &info); VERIFY(ret, SUCCEED, "H5Literate"); datatype = H5Tcopy(H5T_NATIVE_INT); CHECK(datatype, FAIL, "H5Tcopy"); filespace=H5Screate(H5S_SCALAR); CHECK(filespace, FAIL, "H5Screate"); for(i=0; i< NDATASETS; i++) { sprintf(name,"Dataset %d",i); dataset = H5Dcreate2(file, name, datatype, filespace, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT); CHECK(dataset, FAIL, "H5Dcreate2"); /* Keep a copy of the dataset names around for later */ lnames[i] = HDstrdup(name); CHECK(lnames[i], NULL, "strdup"); ret = H5Dclose(dataset); CHECK(ret, FAIL, "H5Dclose"); } /* end for */ /* Create a group and named datatype under root group for testing */ grp = H5Gcreate2(file, "grp", H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT); CHECK(ret, FAIL, "H5Gcreate2"); lnames[NDATASETS] = HDstrdup("grp"); CHECK(lnames[NDATASETS], NULL, "strdup"); ret = H5Tcommit2(file, "dtype", datatype, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT); CHECK(ret, FAIL, "H5Tcommit2"); lnames[NDATASETS + 1] = HDstrdup("dtype"); CHECK(lnames[NDATASETS], NULL, "strdup"); /* Close everything up */ ret = H5Tclose(datatype); CHECK(ret, FAIL, "H5Tclose"); ret = H5Gclose(grp); CHECK(ret, FAIL, "H5Gclose"); ret = H5Sclose(filespace); CHECK(ret, FAIL, "H5Sclose"); ret = H5Fclose(file); CHECK(ret, FAIL, "H5Fclose"); /* Sort the dataset names */ HDqsort(lnames, (size_t)(NDATASETS + 2), sizeof(char *), iter_strcmp); /* Iterate through the datasets in the root group in various ways */ file = H5Fopen(DATAFILE, H5F_ACC_RDONLY, fapl); CHECK(file, FAIL, "H5Fopen"); /* These two functions, H5Oget_info_by_idx and H5Lget_name_by_idx, actually * iterate through B-tree for group members in internal library design. */ root_group = H5Gopen2(file, "/", H5P_DEFAULT); CHECK(root_group, FAIL, "H5Gopen2"); ret = H5Gget_info(root_group, &ginfo); CHECK(ret, FAIL, "H5Gget_info"); VERIFY(ginfo.nlinks, (NDATASETS + 2), "H5Gget_info"); for(i = 0; i< (int)ginfo.nlinks; i++) { H5O_info_t oinfo; /* Object info */ ret = (herr_t)H5Lget_name_by_idx(root_group, ".", H5_INDEX_NAME, H5_ITER_INC, (hsize_t)i, dataset_name, (size_t)NAMELEN, H5P_DEFAULT); CHECK(ret, FAIL, "H5Lget_name_by_idx"); ret = H5Oget_info_by_idx(root_group, ".", H5_INDEX_NAME, H5_ITER_INC, (hsize_t)i, &oinfo, H5P_DEFAULT); CHECK(ret, FAIL, "H5Oget_info_by_idx"); } /* end for */ H5E_BEGIN_TRY { ret = (herr_t)H5Lget_name_by_idx(root_group, ".", H5_INDEX_NAME, H5_ITER_INC, (hsize_t)(NDATASETS+3), dataset_name, (size_t)NAMELEN, H5P_DEFAULT); } H5E_END_TRY; VERIFY(ret, FAIL, "H5Lget_name_by_idx"); ret = H5Gclose(root_group); CHECK(ret, FAIL, "H5Gclose"); /* These two functions, H5Oget_info_by_idx and H5Lget_name_by_idx, actually * iterate through B-tree for group members in internal library design. * (Same as test above, but with the file ID instead of opening the root group) */ ret = H5Gget_info(file, &ginfo); CHECK(ret, FAIL, "H5Gget_info"); VERIFY(ginfo.nlinks, NDATASETS + 2, "H5Gget_info"); for(i = 0; i< (int)ginfo.nlinks; i++) { H5O_info_t oinfo; /* Object info */ ret = (herr_t)H5Lget_name_by_idx(file, ".", H5_INDEX_NAME, H5_ITER_INC, (hsize_t)i, dataset_name, (size_t)NAMELEN, H5P_DEFAULT); CHECK(ret, FAIL, "H5Lget_name_by_idx"); ret = H5Oget_info_by_idx(file, ".", H5_INDEX_NAME, H5_ITER_INC, (hsize_t)i, &oinfo, H5P_DEFAULT); CHECK(ret, FAIL, "H5Oget_info_by_idx"); } /* end for */ H5E_BEGIN_TRY { ret = (herr_t)H5Lget_name_by_idx(file, ".", H5_INDEX_NAME, H5_ITER_INC, (hsize_t)(NDATASETS + 3), dataset_name, (size_t)NAMELEN, H5P_DEFAULT); } H5E_END_TRY; VERIFY(ret, FAIL, "H5Lget_name_by_idx"); /* Test invalid indices for starting iteration */ info.command = RET_ZERO; idx = (hsize_t)-1; H5E_BEGIN_TRY { ret = H5Literate(file, H5_INDEX_NAME, H5_ITER_INC, &idx, liter_cb, &info); } H5E_END_TRY; VERIFY(ret, FAIL, "H5Literate"); /* Test skipping exactly as many entries as in the group */ idx = NDATASETS + 2; H5E_BEGIN_TRY { ret = H5Literate(file, H5_INDEX_NAME, H5_ITER_INC, &idx, liter_cb, &info); } H5E_END_TRY; VERIFY(ret, FAIL, "H5Literate"); /* Test skipping more entries than are in the group */ idx = NDATASETS + 3; H5E_BEGIN_TRY { ret = H5Literate(file, H5_INDEX_NAME, H5_ITER_INC, &idx, liter_cb, &info); } H5E_END_TRY; VERIFY(ret, FAIL, "H5Literate"); /* Test all objects in group, when callback always returns 0 */ info.command = RET_ZERO; idx = 0; if((ret = H5Literate(file, H5_INDEX_NAME, H5_ITER_INC, &idx, liter_cb, &info)) > 0) TestErrPrintf("Group iteration function didn't return zero correctly!\n"); /* Test all objects in group, when callback always returns 1 */ /* This also tests the "restarting" ability, because the index changes */ info.command = RET_TWO; idx = i = 0; while((ret = H5Literate(file, H5_INDEX_NAME, H5_ITER_INC, &idx, liter_cb, &info)) > 0) { /* Verify return value from iterator gets propagated correctly */ VERIFY(ret, 2, "H5Literate"); /* Increment the number of times "2" is returned */ i++; /* Verify that the index is the correct value */ VERIFY(idx, (hsize_t)i, "H5Literate"); if(idx > (NDATASETS + 2)) TestErrPrintf("Group iteration function walked too far!\n"); /* Verify that the correct name is retrieved */ if(HDstrcmp(info.name, lnames[(size_t)(idx - 1)]) != 0) TestErrPrintf("Group iteration function didn't return name correctly for link - lnames[%u] = '%s'!\n", (unsigned)(idx - 1), lnames[(size_t)(idx - 1)]); } /* end while */ VERIFY(ret, -1, "H5Literate"); if(i != (NDATASETS + 2)) TestErrPrintf("%u: Group iteration function didn't perform multiple iterations correctly!\n", __LINE__); /* Test all objects in group, when callback changes return value */ /* This also tests the "restarting" ability, because the index changes */ info.command = new_format ? RET_CHANGE2 : RET_CHANGE; idx = i = 0; while((ret = H5Literate(file, H5_INDEX_NAME, H5_ITER_INC, &idx, liter_cb, &info)) >= 0) { /* Verify return value from iterator gets propagated correctly */ VERIFY(ret, 1, "H5Literate"); /* Increment the number of times "1" is returned */ i++; /* Verify that the index is the correct value */ VERIFY(idx, (hsize_t)(i + 10), "H5Literate"); if(idx > (NDATASETS + 2)) TestErrPrintf("Group iteration function walked too far!\n"); /* Verify that the correct name is retrieved */ if(HDstrcmp(info.name, lnames[(size_t)(idx - 1)]) != 0) TestErrPrintf("Group iteration function didn't return name correctly for link - lnames[%u] = '%s'!\n", (unsigned)(idx - 1), lnames[(size_t)(idx - 1)]); } /* end while */ VERIFY(ret, -1, "H5Literate"); if(i != 42 || idx != 52) TestErrPrintf("%u: Group iteration function didn't perform multiple iterations correctly!\n", __LINE__); ret = H5Fclose(file); CHECK(ret, FAIL, "H5Fclose"); /* Free the dataset names */ for(i = 0; i< (NDATASETS + 2); i++) HDfree(lnames[i]); } /* test_iter_group() */
int seek_chromosome(char *chrom, genome_t *genome, chromosome_t *chromosome, bool verbose) { hid_t h5file = -1; hid_t h5group = -1; H5G_info_t h5group_info; char *where = NULL; /* must be specified to H5Literate; allows interruption and resumption, but I don't use it */ hsize_t idx = 0; err_state_t err_state; if (verbose) { fprintf(stderr, "%s\n", chrom); } assert(is_valid_genome(genome)); /* close old chromosome and start creating the new one */ close_chromosome(chromosome); chromosome->chrom = chrom; if (genome->dirname) { /* if genome is a directory, compute path and open h5file */ char *h5filename = NULL; char *h5filename_suffix; /* allocate space for h5filename, including 2 bytes for '/' and '\0' */ h5filename = xmalloc((strlen(genome->dirname) + strlen(chrom) + strlen(SUFFIX_H5) + 2) * sizeof(char)); assert(h5filename); /* set h5filename */ h5filename_suffix = stpcpy(h5filename, genome->dirname); h5filename_suffix = stpcpy(h5filename_suffix, "/"); h5filename_suffix = stpcpy(h5filename_suffix, chrom); strcpy(h5filename_suffix, SUFFIX_H5); /* open the chromosome file */ disable_h5_errors(&err_state); h5file = H5Fopen(h5filename, H5F_ACC_RDWR, H5P_DEFAULT); enable_h5_errors(&err_state); /* read chromosome from the root group */ chromosome->h5file = h5file; /* allocate space for where = "/\0" */ where = strdup("/"); assert(where); /* free no-longer-used filename */ free(h5filename); } else { /* if genome is a file, compute internal path and open group */ if (genome->h5file >= 0) { h5file = genome->h5file; char *where_suffix; /* allocate space for where, including 2 bytes for '/' and '\0' */ where = xmalloc((strlen(chrom) + 2) * sizeof(char)); assert(where); /* read chromosome from subgroup of h5file */ where_suffix = stpcpy(where, "/"); strcpy(where_suffix, chrom); } } if (h5file >= 0) { /* Open the chromosome group, regardless of dir/file implementation */ disable_h5_errors(&err_state); h5group = H5Gopen(h5file, where, H5P_DEFAULT); enable_h5_errors(&err_state); } chromosome->h5group = h5group; /* clean up memory before returning */ free(where); /* if opening failed, then return -1 with h5file set bad */ if (is_valid_chromosome(chromosome)) { /* allocate supercontig metadata array */ assert(H5Gget_info(chromosome->h5group, &h5group_info) >= 0); init_supercontig_array(h5group_info.nlinks, chromosome); /* populate supercontig metadata array */ assert(H5Literate(chromosome->h5group, H5_INDEX_NAME, H5_ITER_INC, &idx, supercontig_visitor, chromosome) == 0); return 0; } else { if (verbose) { fprintf(stderr, " can't open chromosome: %s\n", chromosome->chrom); } return -1; } }
/*--------------------------------------------------------------*/ int NXVvalidateGroup(pNXVcontext self, hid_t groupID, xmlNodePtr groupNode) { hash_table namesSeen, baseNames; xmlNodePtr cur = NULL; xmlChar *name = NULL, *myClass = NULL; xmlChar *target = NULL; hid_t childID; char fName[256], childName[512], nxdlChildPath[512], childPath[512]; char mynxdlPath[512]; char *savedNXDLPath, *pPtr; SecondPassData spd; hsize_t idx = 0; /* manage nxdlPath, xmlGetNodePath does not work */ savedNXDLPath = self->nxdlPath; myClass = xmlGetProp(groupNode,(xmlChar *)"type"); if(self->nxdlPath == NULL) { snprintf(mynxdlPath,sizeof(mynxdlPath),"/%s", (char *) myClass); } else { snprintf(mynxdlPath,sizeof(mynxdlPath),"%s/%s", self->nxdlPath, (char *) myClass); } self->nxdlPath = mynxdlPath; /* tell what we are doing */ H5Iget_name(groupID,fName,sizeof(fName)); NXVsetLog(self,"sev","debug"); NXVsetLog(self,"message","Validating group"); NXVsetLog(self,"nxdlPath",self->nxdlPath); NXVsetLog(self,"dataPath",fName); NXVlog(self); validateGroupAttributes(self, groupID, groupNode); hash_construct_table(&namesSeen,100); /* first pass */ cur = groupNode->xmlChildrenNode; while(cur != NULL){ if(xmlStrcmp(cur->name,(xmlChar *) "group") == 0){ childID = findGroup(self, groupID, cur); if(childID >= 0){ H5Iget_name(childID, childName,sizeof(childName)); /* we have to get at the HDF5 name. There may be no name in the NXDL, but a suitable group has been found by NXclass. */ pPtr = strrchr(childName,'/'); if(pPtr != NULL){ hash_insert(pPtr+1,strdup(""),&namesSeen); } else { hash_insert(childName,strdup(""),&namesSeen); } NXVvalidateGroup(self,childID,cur); } else { name = xmlGetProp(cur,(xmlChar *)"type"); snprintf(nxdlChildPath,sizeof(nxdlChildPath),"%s/%s", self->nxdlPath, (char *)name); xmlFree(name); NXVsetLog(self,"dataPath",fName); NXVsetLog(self,"nxdlPath", nxdlChildPath); if(!isOptional(cur)){ NXVsetLog(self,"sev","error"); NXVsetLog(self,"message","Required group missing"); NXVlog(self); self->errCount++; } else { NXVsetLog(self,"sev","warnopt"); NXVsetLog(self,"message","Optional group missing"); NXVlog(self); } } } if(xmlStrcmp(cur->name,(xmlChar *) "field") == 0){ name = xmlGetProp(cur,(xmlChar *)"name"); if(H5LTfind_dataset(groupID,(char *)name) ) { childID = H5Dopen(groupID,(char *)name,H5P_DEFAULT); } else { childID = -1; } snprintf(childPath,sizeof(childPath),"%s/%s", fName,name); if(childID < 0){ NXVsetLog(self,"dataPath",childPath); snprintf(nxdlChildPath,sizeof(nxdlChildPath), "%s/%s", self->nxdlPath, name); NXVsetLog(self,"nxdlPath", nxdlChildPath); if(!isOptional(cur)){ NXVsetLog(self,"sev","error"); NXVsetLog(self,"message","Required field missing"); NXVlog(self); self->errCount++; } else { NXVsetLog(self,"sev","warnopt"); NXVsetLog(self,"message","Optional field missing"); NXVlog(self); } } else { if(xmlStrcmp(name,(xmlChar *)"depends_on") == 0){ /* This must b validated from the field level. As it might point to fields which are not in the application definition */ validateDependsOn(self,groupID,childID); } else { NXVvalidateField(self,childID, cur); } hash_insert((char *)name,strdup(""),&namesSeen); } xmlFree(name); } if(xmlStrcmp(cur->name,(xmlChar *) "link") == 0){ name = xmlGetProp(cur,(xmlChar *)"name"); target = xmlGetProp(cur,(xmlChar *)"target"); hash_insert((char *)name,strdup(""),&namesSeen); validateLink(self,groupID,name, target); xmlFree(name); xmlFree(target); } cur = cur->next; } /* Second pass: search the HDF5 group for additional stuff which have not checked yet. Most of the hard work is in the SecondPassIterator. */ hash_construct_table(&baseNames,100); NXVloadBaseClass(self,&baseNames,(char *)myClass); spd.baseNames = &baseNames; spd.namesSeen = &namesSeen; spd.self = self; NXVsetLog(self,"nxdlPath", mynxdlPath); H5Literate(groupID, H5_INDEX_NAME, H5_ITER_INC, &idx, SecondPassIterator, &spd); /* clean up */ hash_free_table(&namesSeen,free); hash_free_table(&baseNames,free); xmlFree(myClass); /* restore my paths... */ self->nxdlPath = savedNXDLPath; return 0; }
H5RandomReader::H5RandomReader(const std::string fileName, const std::string groupPath) throw (InvalidFileException) { try { file.openFile(fileName, H5F_ACC_RDONLY);} catch ( H5::FileIException ) { throw InvalidFileException("Cannot acces file");} try { group = file.openGroup(groupPath);} catch ( H5::GroupIException ) { file.close(); throw InvalidFileException("Cannot access group");} /* * extract timeline. This is also necessary to get the nbSteps. */ try { timeline = group.openDataSet("timeline"); nSteps = timeline.getSpace().getSimpleExtentNpoints();} catch ( H5::DataSetIException error ) { //error.printError(); group.close(); file.close(); throw InvalidFileException("Cannot access timeline dataset");} if (logging::info) std::cerr << "Opened group \"" << fileName << groupPath << "\" which has " << nSteps << " steps.\n"; /* * extract objects names in the xpGroup */ std::vector<std::string> names; H5Literate(group.getId(), H5_INDEX_NAME, H5_ITER_INC, NULL, iterInGroup, &names); /* * extract data from object in xpGroup * these data can be of 3 types: matrix, translate or wrench * each data are saved in related map */ for (unsigned int i=0; i<names.size(); i++){ //TODO: skip timeline H5::DataSet dSet = group.openDataSet(names[i]); if (H5Aexists(dSet.getId(), "ArborisViewerType")) { H5::Attribute att = dSet.openAttribute("ArborisViewerType"); std::string type; att.read(att.getDataType(), type); if (type == "matrix"){ H5::DataSpace dSpace = dSet.getSpace(); bool dimension_ok = false; if (dSpace.getSimpleExtentNdims()==3) { hsize_t dims[3]; dSpace.getSimpleExtentDims (dims); if (dims[0] == nSteps && dims[1] == 4 && dims[2] == 4) dimension_ok = true;} if (dimension_ok) matrices[names[i]] = dSet; else { if (logging::warning) std::cerr << "Skipping dataset \"" << names[i] << "\" which has wrong dimensions. I was expecting (" << nSteps << ",4,4).\n"; dSet.close();}} else if (type == "translate"){ H5::DataSpace dSpace = dSet.getSpace(); bool dimension_ok = false; if (dSpace.getSimpleExtentNdims()==2) { hsize_t dims[2]; dSpace.getSimpleExtentDims (dims); if (dims[0] == nSteps && dims[1] == 3) dimension_ok = true;} if (dimension_ok) translates[names[i]] = dSet; else { if (logging::warning) std::cerr << "Skipping dataset \"" << names[i] << "\" which has wrong dimensions. I was expecting (" << nSteps << ",3).\n"; dSet.close();}} else if (type == "wrench") { H5::DataSpace dSpace = dSet.getSpace(); bool dimension_ok = false; if (dSpace.getSimpleExtentNdims()==2) { hsize_t dims[2]; dSpace.getSimpleExtentDims (dims); if (dims[0] == nSteps && dims[1] == 6) dimension_ok = true;} if (dimension_ok) wrenches[names[i]] = dSet; else { if (logging::warning) std::cerr << "Skipping dataset \"" << names[i] << "\" which as wrong dimensions. I was expecting (" << nSteps << ",6).\n"; dSet.close();}} else { if (logging::warning) std::cerr << "Skipping dataset \"" << names[i] << "\" whose ArborisViewerType attribute as unknown value \"" << type << "\".\n"; dSet.close();} att.close(); } else { if (logging::info) std::cerr << "Skipping dataset \"" << names[i] << "\" which has no ArborisViewerType attribute.\n"; dSet.close(); } } };
int main() { printf("\n*** Checking HDF5 file functions.\n"); printf("*** Creating HDF5 file in the canonical netCDF-4 way..."); { hid_t fapl_id, fcpl_id, fileid, grpid, fileid2; hsize_t num_obj; /* Create file access and create property lists. */ if ((fapl_id = H5Pcreate(H5P_FILE_ACCESS)) < 0) ERR; if ((fcpl_id = H5Pcreate(H5P_FILE_CREATE)) < 0) ERR; /* Set latest_format in access propertly list. This ensures that * the latest, greatest, HDF5 versions are used in the file. */ /* if (H5Pset_libver_bounds(fapl_id, H5F_LIBVER_LATEST, H5F_LIBVER_LATEST) < 0) ERR;*/ /* Set H5P_CRT_ORDER_TRACKED in the creation property list. This * turns on HDF5 creation ordering in the file. */ 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; /* Set close degree. */ if (H5Pset_fclose_degree(fapl_id, H5F_CLOSE_STRONG)) ERR; /* Create the file. */ if ((fileid = H5Fcreate(FILE_NAME, H5F_ACC_TRUNC, fcpl_id, fapl_id)) < 0) ERR; /* Open the root group. */ if ((grpid = H5Gopen2(fileid, "/", H5P_DEFAULT)) < 0) ERR; /* Close up. */ if (H5Pclose(fapl_id) < 0 || H5Pclose(fcpl_id) < 0 || H5Gclose(grpid) < 0 || H5Fclose(fileid) < 0) ERR; /* Reopen the file and check it. */ if ((fapl_id = H5Pcreate(H5P_FILE_ACCESS)) < 0) ERR; if (H5Pset_fclose_degree(fapl_id, H5F_CLOSE_STRONG)) ERR; if ((fileid = H5Fopen(FILE_NAME, H5F_ACC_RDWR, fapl_id)) < 0) ERR; if (H5Gget_num_objs(fileid, &num_obj) < 0) ERR; if (num_obj) ERR; /* Open another copy of the same file. Must use the same file * access degree or HDF5 will not open the file. */ if ((fileid2 = H5Fopen(FILE_NAME, H5F_ACC_RDWR, fapl_id)) < 0) ERR; if (H5Fclose(fileid) < 0) ERR; if (H5Fclose(fileid2) < 0) ERR; if (H5Pclose(fapl_id) < 0) ERR; } SUMMARIZE_ERR; printf("*** Opening a HDF5 file with H5Literate..."); { hid_t fapl_id, fileid, grpid; hsize_t idx = 0; char obj_name[STR_LEN + 1]; hsize_t num_obj; int i; 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 ((fileid = H5Fopen(FILE_NAME, H5F_ACC_RDONLY, fapl_id)) < 0) ERR; if ((grpid = H5Gopen2(fileid, "/", H5P_DEFAULT)) < 0) ERR; if (H5Gget_num_objs(grpid, &num_obj) < 0) ERR; for (i = 0; i < num_obj; i++) { if (H5Literate(grpid, H5_INDEX_CRT_ORDER, H5_ITER_INC, &idx, op_func, (void *)obj_name) != 1) ERR; printf("encountered object %s\n", obj_name); } if (H5Gclose(grpid) < 0) ERR; if (H5Fclose(fileid) < 0) ERR; if (H5Pclose(fapl_id) < 0) ERR; } SUMMARIZE_ERR; printf("*** Opening a HDF5 file in the canonical netCDF-4 way..."); { hid_t fapl_id, fileid, grpid; H5_index_t idx_field = H5_INDEX_CRT_ORDER; H5O_info_t obj_info; hsize_t num_obj; ssize_t size; char obj_name[STR_LEN + 1]; int i; 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 ((fileid = H5Fopen(FILE_NAME, H5F_ACC_RDONLY, fapl_id)) < 0) ERR; if ((grpid = H5Gopen2(fileid, "/", H5P_DEFAULT)) < 0) ERR; /* How many objects in this group? */ if (H5Gget_num_objs(grpid, &num_obj) < 0) ERR; for (i = 0; i < num_obj; i++) { if (H5Oget_info_by_idx(grpid, ".", H5_INDEX_CRT_ORDER, H5_ITER_INC, i, &obj_info, H5P_DEFAULT)) ERR; if ((size = H5Lget_name_by_idx(grpid, ".", idx_field, H5_ITER_INC, i, NULL, 0, H5P_DEFAULT)) < 0) ERR; if (H5Lget_name_by_idx(grpid, ".", idx_field, H5_ITER_INC, i, obj_name, size+1, H5P_DEFAULT) < 0) ERR; } if (H5Gclose(grpid) < 0) ERR; if (H5Fclose(fileid) < 0) ERR; if (H5Pclose(fapl_id) < 0) ERR; } SUMMARIZE_ERR; FINAL_RESULTS; }
void GalacticusReader::getOutputsMeta(long &numOutputs) { char line[1000]; double aexp; int snapnum; string s("Outputs"); Group group(fp->openGroup(s)); hsize_t size = group.getNumObjs(); cout << "Number of outputs stored in this file is " << size << endl; outputNames.clear(); int idx2 = H5Literate(group.getId(), H5_INDEX_NAME, H5_ITER_INC, NULL, file_info, &outputNames); // should close the group now group.close(); OutputMeta o; for (int i=0; i<size; i++) { string sg = s + string("/") + outputNames[i]; Group group(fp->openGroup(sg)); Attribute att = group.openAttribute("outputExpansionFactor"); // check type H5T_class_t type_class = att.getTypeClass(); if (type_class != H5T_FLOAT) { cout << "Float attribute does not have correct type!" << endl; abort(); } // check byte order FloatType intype = att.getFloatType(); H5std_string order_string; H5T_order_t order = intype.getOrder(order_string); // check again data sizes if (sizeof(double) != intype.getSize()) { cout << "Mismatch of double data type." << endl; abort(); } // read the attribute att.read(intype, &aexp); // assign values o.outputName = s + string("/") + outputNames[i] + string("/") + string("nodeData"); // complete name to access the data block o.outputExpansionFactor = (float) aexp; // get snapshot number = number at the end of "Output%d" string prefix = "Output"; // Is this always the case??? Could also search for a number using boost regex string numstr = outputNames[i].substr(prefix.length(),outputNames[i].length()); o.ioutput = (int) atoi(numstr.c_str()); snapnum = getSnapnum(o.ioutput); o.snapnum = snapnum; // store in map outputMetaMap[snapnum] = o; // close the group group.close(); } numOutputs = size; return; }
int GalacticusReader::readNextBlock(string outputName) { // read one complete Output* block from Galacticus HDF5-file // should fit into memory ... if not, need to adjust this // and provide the number of values to be read each time long nvalues; //char outputname[1000]; //performance output stuff boost::posix_time::ptime startTime; boost::posix_time::ptime endTime; string newtext = ""; boost::regex re(":z[0-9.]*"); startTime = boost::posix_time::microsec_clock::universal_time(); // first get names of all DataSets in nodeData group and their item size //cout << "outputName: " << outputName<< endl; Group group(fp->openGroup(outputName)); // maybe check here that it worked? hsize_t len = group.getNumObjs(); //cout << "Iterating over Datasets in the group ... " << endl; //H5L_iterate_t //vector<string> dsnames; dataSetNames.clear(); // actually, the names should be exactly the same as for the group before!! --> check this??? int idx2 = H5Literate(group.getId(), H5_INDEX_NAME, H5_ITER_INC, NULL, file_info, &dataSetNames); string s; string dsname; string matchname; int numDataSets = dataSetNames.size(); //cout << "numDataSets: " << numDataSets << endl; // create a key-value map for the dataset names, do it from scratch for each block, // and remove redshifts from the dataset names (where necessary) dataSetMap.clear(); for (int k=0; k<numDataSets; k++) { dsname = dataSetNames[k]; // convert to matchname, i.e. remove possibly given redshift from the name: string matchname = boost::regex_replace(dsname, re, newtext); dataSetMap[matchname] = k; //dataSetMatchNames.push_back(matchname); } // clear datablocks from previous block, before reading new ones: datablocks.clear(); // read each desired data set, use corresponding read routine for different types for (int k=0; k<numDataSets; k++) { dsname = dataSetNames[k]; s = string(outputName) + string("/") + dsname; DataSet *dptr = new DataSet(fp->openDataSet(s)); DataSet dataset = *dptr; // for convenience // check class type H5T_class_t type_class = dataset.getTypeClass(); if (type_class == H5T_INTEGER) { //cout << "DataSet has long type!" << endl; long *data = readLongDataSet(s, nvalues); } else if (type_class == H5T_FLOAT) { //cout << "DataSet has double type!" << endl; double *data2 = readDoubleDataSet(s, nvalues); } //cout << nvalues << " values read." << endl; } // How to proceed from here onwards?? // Could read all data into data[0] to data[104] or so, // but I need to keep the information which is which! // Alternatively create one big structure to hold it all? // => use a small class that contains // 1) name of dataset // 2) array of values, number of values // use vector<newclass> to create a vector of these datasets. // maybe can use datasets themselves, so no need to define own class? // => assigning to the new class has already happened now inside the read-class. endTime = boost::posix_time::microsec_clock::universal_time(); printf("Time for reading output %s (%ld rows): %lld ms\n", outputName.c_str(), nvalues, (long long int) (endTime-startTime).total_milliseconds()); fflush(stdout); return nvalues; //assume that nvalues is the same for each dataset (datablock) inside one Output-group (same redshift) }
/*-------------------------------------------------------------- Finding groups is hideous: * They may be specified by name. This seems easy but is complicated by the fact that the group name can either be a name attribute or an attribute field. A design flaw of NXDL, IMHO. * They may be specified by type and I need to search by NX_class. ---------------------------------------------------------------*/ static hid_t findGroup(pNXVcontext self, hid_t parentGroup, xmlNodePtr groupNode) { xmlChar *name = NULL, *nxClass = NULL, *nodePath = NULL; xmlNodePtr cur = NULL; findByClassData fbcd; hid_t gid, status; hsize_t idx = 0; name = xmlGetProp(groupNode,(xmlChar *)"name"); if(name == NULL){ cur = groupNode->xmlChildrenNode; while(cur != NULL){ if(xmlStrcmp(cur->name,(xmlChar *)"attribute") == 0){ name = xmlGetProp(cur,(xmlChar *)"name"); if(name != NULL){ break; } } cur = cur->next; } } if(name != NULL){ if(H5LTpath_valid(parentGroup,(char *)name, 1)){ status = H5Gopen(parentGroup,(char *)name,H5P_DEFAULT); } else { status = -1; } xmlFree(name); return status; } /* no name to be found: search by type */ nxClass = xmlGetProp(groupNode,(xmlChar *)"type"); if(nxClass == NULL){ NXVsetLog(self,"sev","error"); nodePath = xmlGetNodePath(cur); NXVsetLog(self,"nxdlPath", (char *)nodePath); NXVsetLog(self,"message","Malformed group entry, type missing"); NXVlog(self); xmlFree(nodePath); self->errCount++; return -1; } fbcd.nxClass = (char *)nxClass; fbcd.name = NULL; H5Literate(parentGroup, H5_INDEX_NAME, H5_ITER_INC, &idx, FindByClassIterator, &fbcd); if(fbcd.name != NULL){ gid = H5Gopen(parentGroup,fbcd.name,H5P_DEFAULT); free(fbcd.name); xmlFree(fbcd.nxClass); return gid; } xmlFree(fbcd.nxClass); return -1; }