void CheMPS2::DMRG::loadMPS(const std::string name, TensorT ** MPSlocation, bool * isConverged){
//The hdf5 file
hid_t file_id = H5Fopen(name.c_str(), H5F_ACC_RDONLY, H5P_DEFAULT);
//Whether the MPS was converged or not
hid_t group_id = H5Gopen(file_id, "/Convergence", H5P_DEFAULT);
hid_t dataset_id = H5Dopen(group_id, "Converged_yn", H5P_DEFAULT);
int toRead;
H5Dread(dataset_id, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, &toRead);
isConverged[0] = (toRead==0)?false:true;
H5Dclose(dataset_id);
H5Gclose(group_id);
//The MPS
for (int site=0; site<L; site++){
std::stringstream sstream;
sstream << "/MPS_" << site;
hid_t group_id3 = H5Gopen(file_id, sstream.str().c_str(), H5P_DEFAULT);
hid_t dataset_id3 = H5Dopen(group_id3, "Values", H5P_DEFAULT);
H5Dread(dataset_id3, H5T_NATIVE_DOUBLE, H5S_ALL, H5S_ALL, H5P_DEFAULT, MPSlocation[site]->gStorage());
H5Dclose(dataset_id3);
H5Gclose(group_id3);
}
H5Fclose(file_id);
}
H5Converter::H5Converter(const std::string& h5_fname, const std::string& out_dir) :
out_dir_(out_dir)
{
file_id_ = H5Fopen(h5_fname.c_str(), H5F_ACC_RDONLY, H5P_DEFAULT);
root_ = H5Gopen(file_id_, "/", H5P_DEFAULT);
aux_ = H5Gopen(file_id_, "/aux", H5P_DEFAULT);
// <aux info>
// read target ids
read_dataset(aux_, "ids", targ_ids_);
std::cerr << "[h5dump] number of targets: " << targ_ids_.size() <<
std::endl;
n_targs_ = targ_ids_.size();
read_dataset(aux_, "lengths", lengths_);
assert( n_targs_ == lengths_.size() );
read_dataset(aux_, "eff_lengths", eff_lengths_);
assert( n_targs_ == eff_lengths_.size() );
// read bootstrap info
std::vector<int> n_bs_vec;
read_dataset(aux_, "num_bootstrap", n_bs_vec);
n_bs_ = n_bs_vec[0];
std::cerr << "[h5dump] number of bootstraps: " << n_bs_ << std::endl;
// </aux info>
if (n_bs_ > 0) {
bs_ = H5Gopen(file_id_, "/bootstrap", H5P_DEFAULT);
}
std::vector<std::string> tmp;
read_dataset(aux_, "kallisto_version", tmp);
kal_version_ = tmp[0];
tmp.clear();
std::cerr << "[h5dump] kallisto version: " << kal_version_ << std::endl;
std::vector<int> idx_version;
read_dataset(aux_, "index_version", idx_version);
idx_version_ = static_cast<size_t>(idx_version[0]);
std::cerr << "[h5dump] index version: " << idx_version_ << std::endl;
read_dataset(aux_, "start_time", tmp);
start_time_ = tmp[0];
tmp.clear();
std::cerr << "[h5dump] start time: " << start_time_ << std::endl;
read_dataset(aux_, "call", tmp);
call_ = tmp[0];
tmp.clear();
std::cerr << "[h5dump] shell call: " << call_ << std::endl;
alpha_buf_.resize( n_targs_, 0.0 );
assert( n_targs_ == alpha_buf_.size() );
tpm_buf_.resize( n_targs_, 0.0 );
assert( n_targs_ == tpm_buf_.size() );
}
/*-------------------------------------------------------------------------
* Function: test_misc
*
* Purpose: Test miscellaneous group stuff.
*
* Return: Success: 0
*
* Failure: number of errors
*
* Programmer: Robb Matzke
* Tuesday, November 24, 1998
*
* Modifications:
* Robb Matzke, 2002-03-28
* File is opened by parent instead of here.
*-------------------------------------------------------------------------
*/
static int
test_misc(hid_t file)
{
hid_t g1=-1, g2=-1, g3=-1;
char comment[64];
/* Test current working groups */
TESTING("miscellaneous group tests");
/* Create initial groups for testing, then close */
if ((g1=H5Gcreate(file, "test_1a", 0))<0) goto error;
if ((g2=H5Gcreate(g1, "sub_1", 0))<0) goto error;
if ((g3=H5Gcreate(file, "test_1b", 0))<0) goto error;
if (H5Gset_comment(g3, ".", "hello world")<0) goto error;
if (H5Gclose(g1)<0) goto error;
if (H5Gclose(g2)<0) goto error;
if (H5Gclose(g3)<0) goto error;
/* Open all groups with absolute names to check for exsistence */
if ((g1=H5Gopen(file, "/test_1a"))<0) goto error;
if ((g2=H5Gopen(file, "/test_1a/sub_1"))<0) goto error;
if ((g3=H5Gopen(file, "/test_1b"))<0) goto error;
if (H5Gget_comment(g3, "././.", sizeof comment, comment)<0) goto error;
if (strcmp(comment, "hello world")) {
H5_FAILED();
puts(" Read the wrong comment string from the group.");
printf(" got: \"%s\"\n ans: \"hello world\"\n", comment);
goto error;
}
if (H5Gclose(g1)<0) goto error;
if (H5Gclose(g2)<0) goto error;
if (H5Gclose(g3)<0) goto error;
/* Check that creating groups with no-op names isn't allowed */
H5E_BEGIN_TRY {
g1=H5Gcreate(file, "/", 0);
} H5E_END_TRY
if(g1 >= 0) goto error;
H5E_BEGIN_TRY {
g1=H5Gcreate(file, "./././", 0);
} H5E_END_TRY
if(g1 >= 0) goto error;
PASSED();
return 0;
error:
H5E_BEGIN_TRY {
H5Gclose(g1);
H5Gclose(g2);
H5Gclose(g3);
} H5E_END_TRY;
return 1;
}
static void _extract_all_tasks(FILE *fp, hid_t gid_step, hid_t gid_nodes,
int nnodes, int stepx)
{
hid_t gid_tasks, gid_task = 0, gid_node = -1, gid_level = -1;
H5G_info_t group_info;
int ntasks, itx, len, task_id;
char task_name[MAX_GROUP_NAME+1];
char* node_name;
char buf[MAX_GROUP_NAME+1];
bool hd = true;
gid_tasks = get_group(gid_step, GRP_TASKS);
if (gid_tasks < 0)
fatal("No tasks in step %d", stepx);
H5Gget_info(gid_tasks, &group_info);
ntasks = (int) group_info.nlinks;
if (ntasks <= 0)
fatal("No tasks in step %d", stepx);
for (itx = 0; itx<ntasks; itx++) {
// Get the name of the group.
len = H5Lget_name_by_idx(gid_tasks, ".", H5_INDEX_NAME,
H5_ITER_INC, itx, buf, MAX_GROUP_NAME,
H5P_DEFAULT);
if ((len > 0) && (len < MAX_GROUP_NAME)) {
gid_task = H5Gopen(gid_tasks, buf, H5P_DEFAULT);
if (gid_task < 0)
fatal("Failed to open %s", buf);
} else
fatal("Illegal task name %s",buf);
task_id = get_int_attribute(gid_task, ATTR_TASKID);
node_name = get_string_attribute(gid_task, ATTR_NODENAME);
sprintf(task_name,"%s_%d", GRP_TASK, task_id);
gid_node = H5Gopen(gid_nodes, node_name, H5P_DEFAULT);
if (gid_node < 0)
fatal("Failed to open %s for Task_%d",
node_name, task_id);
gid_level = get_group(gid_node, GRP_SAMPLES);
if (gid_level < 0)
fatal("Failed to open group %s for node=%s task=%d",
GRP_SAMPLES,node_name, task_id);
_extract_series(fp, stepx, hd, gid_level, node_name, task_name);
hd = false;
xfree(node_name);
H5Gclose(gid_level);
H5Gclose(gid_node);
H5Gclose(gid_task);
}
H5Gclose(gid_tasks);
}
static void _merge_node_step_data(hid_t fid_job, char* file_name, int nodeIndex,
char* node_name, hid_t jgid_nodes,
hid_t jgid_tasks)
{
hid_t fid_nodestep, jgid_node, nsgid_root, nsgid_node;
char *start_time;
char group_name[MAX_GROUP_NAME+1];
jgid_node = H5Gcreate(jgid_nodes, node_name,
H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
if (jgid_node < 0) {
error("Failed to create group %s",node_name);
return;
}
put_string_attribute(jgid_node, ATTR_NODENAME, node_name);
// Process node step file
// Open the file and the node group.
fid_nodestep = H5Fopen(file_name, H5F_ACC_RDONLY, H5P_DEFAULT);
if (fid_nodestep < 0) {
H5Gclose(jgid_node);
error("Failed to open %s",file_name);
return;
}
nsgid_root = H5Gopen(fid_nodestep,"/", H5P_DEFAULT);
sprintf(group_name, "/%s_%s", GRP_NODE, node_name);
nsgid_node = H5Gopen(nsgid_root, group_name, H5P_DEFAULT);
if (nsgid_node < 0) {
H5Gclose(fid_nodestep);
H5Gclose(jgid_node);
error("Failed to open node group");
return;;
}
start_time = get_string_attribute(nsgid_node,ATTR_STARTTIME);
if (start_time == NULL) {
info("No %s attribute", ATTR_STARTTIME);
} else {
put_string_attribute(jgid_node, ATTR_STARTTIME, start_time);
xfree(start_time);
}
_merge_node_totals(jgid_node, nsgid_node);
_merge_task_totals(jgid_tasks, nsgid_node, node_name);
_merge_series_data(jgid_tasks, jgid_node, nsgid_node);
H5Gclose(nsgid_node);
H5Fclose(fid_nodestep);
H5Gclose(jgid_node);
if (!params.keepfiles)
remove(file_name);
return;
}
/*-------------------------------------------------------------------------
* Function: read_new
*
* Purpose: Test reading a file with "new style" (compact) groups
*
* Return: Success: 0
*
* Failure: -1
*
* Programmer: Quincey Koziol
* Monday, October 24, 2005
*
*-------------------------------------------------------------------------
*/
static int
read_new(hid_t fapl)
{
hid_t fid = (-1); /* File ID */
hid_t gid = (-1); /* Group ID */
char *srcdir = HDgetenv("srcdir"); /*where the src code is located*/
char filename[512]=""; /* test file name */
TESTING("reading new groups");
/* Generate correct name for test file by prepending the source path */
if(srcdir && ((HDstrlen(srcdir) + HDstrlen(FILE_NEW_GROUPS) + 1) < sizeof(filename))) {
HDstrcpy(filename, srcdir);
HDstrcat(filename, "/");
}
HDstrcat(filename, FILE_NEW_GROUPS);
/* Open file */
if((fid = H5Fopen(filename, H5F_ACC_RDONLY, fapl)) < 0) TEST_ERROR;
/* Attempt to open root group */
if((gid = H5Gopen(fid, "/")) < 0) TEST_ERROR;
/* Attempt to open new "empty" group (should fail) */
H5E_BEGIN_TRY {
if(H5Gopen(gid, "empty") >= 0) TEST_ERROR;
} H5E_END_TRY;
/* Attempt to open new group with link messages (should fail) */
H5E_BEGIN_TRY {
if(H5Gopen(gid, "links") >= 0) TEST_ERROR;
} H5E_END_TRY;
/* Close root group */
if(H5Gclose(gid) < 0) TEST_ERROR;
/* Close first file */
if(H5Fclose(fid)<0) TEST_ERROR;
PASSED();
return 0;
error:
H5E_BEGIN_TRY {
H5Gclose(gid);
H5Fclose(fid);
} H5E_END_TRY;
return 1;
} /* end read_new() */
fast5_raw_scaling fast5_get_channel_params(fast5_file& fh, const std::string& read_id)
{
// from scrappie
fast5_raw_scaling scaling = { NAN, NAN, NAN, NAN };
std::string scaling_path = fh.is_multi_fast5 ? "/read_" + read_id + "/channel_id"
: "/UniqueGlobalKey/channel_id";
hid_t scaling_group = H5Gopen(fh.hdf5_file, scaling_path.c_str(), H5P_DEFAULT);
if (scaling_group < 0) {
#ifdef DEBUG_FAST5_IO
fprintf(stderr, "Failed to open group %s\n", scaling_path.c_str());
#endif
return scaling;
}
scaling.digitisation = fast5_read_float_attribute(scaling_group, "digitisation");
scaling.offset = fast5_read_float_attribute(scaling_group, "offset");
scaling.range = fast5_read_float_attribute(scaling_group, "range");
scaling.sample_rate = fast5_read_float_attribute(scaling_group, "sampling_rate");
H5Gclose(scaling_group);
return scaling;
}
/*+++++++++++++++++++++++++
.IDENTifer PYTABLE_open_group
.PURPOSE Open/Create a group in an exsisting HDF5-file
.INPUT/OUTPUT
call as grpID = PYTABLE_open_group( locID, name, sz_hint );
input:
hid_t locID : HDF5 object id
char name[] : name of the group
.RETURNS A negative value is returned on failure.
.COMMENTS none
-------------------------*/
hid_t PYTABLE_open_group( hid_t locID, const char *name )
{
hid_t grpID;
/*
* check if the group exists, if not create it
*/
H5E_BEGIN_TRY {
if ( (grpID = H5Gopen( locID, name, H5P_DEFAULT )) < 0 ) {
grpID = H5Gcreate( locID, name,
H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT );
(void) H5LTset_attribute_string( locID, name, "CLASS",
PY_GROUP_CLASS );
(void) H5LTset_attribute_string( locID, name,
"PYTABLES_FORMAT_VERSION",
PY_FORMAT_VERSION );
(void) H5LTset_attribute_string( locID, name, "TITLE",
name );
(void) H5LTset_attribute_string( locID, name, "VERSION",
PY_GROUP_VERSION );
}
} H5E_END_TRY;
/*
* return id of the group
*/
return grpID;
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void DataContainer::ReadDataContainerStructure(hid_t dcArrayGroupId, DataContainerArrayProxy& proxy, QString h5InternalPath)
{
QList<QString> dataContainers;
QH5Utilities::getGroupObjects(dcArrayGroupId, H5Utilities::H5Support_GROUP, dataContainers);
foreach(QString dataContainerName, dataContainers)
{
if(__SHOW_DEBUG_MSG__)
{
std::cout << "Data Container:" << dataContainerName.toStdString() << std::endl;
}
hid_t containerGid = H5Gopen(dcArrayGroupId, dataContainerName.toLatin1().constData(), H5P_DEFAULT);
if (containerGid < 0)
{
continue;
}
HDF5ScopedGroupSentinel sentinel(&containerGid, false);
DataContainerProxy dcProxy(dataContainerName);
dcProxy.name = dataContainerName;
dcProxy.flag = Qt::Checked;
QString h5Path = h5InternalPath + "/" + dataContainerName;
// Read the Attribute Matricies for this Data Container
AttributeMatrix::ReadAttributeMatrixStructure(containerGid, dcProxy, h5Path);
// Insert the DataContainerProxy proxy into the DataContainerArrayProxy
proxy.dataContainers.insert(dcProxy.name, dcProxy);
}
}
extern hid_t get_group(hid_t parent, const char *name)
{
char buf[MAX_GROUP_NAME];
hsize_t nobj;
hid_t gid;
int i, len;
H5G_info_t group_info;
if (parent < 0) {
debug3("PROFILE: parent is not HDF5 object");
return -1;
}
H5Gget_info(parent, &group_info);
nobj = group_info.nlinks;
for (i = 0; (nobj>0) && (i<nobj); i++) {
// Get the name of the group.
len = H5Lget_name_by_idx(parent, ".", H5_INDEX_NAME,
H5_ITER_INC, i, buf, MAX_GROUP_NAME,
H5P_DEFAULT);
if ((len > 0) && (len < MAX_GROUP_NAME)) {
if (strcmp(buf, name) == 0) {
gid = H5Gopen(parent, name, H5P_DEFAULT);
if (gid < 0)
error("PROFILE: Failed to open %s",
name);
return gid;
}
}
}
return -1;
}
void MultiChain::record() {
//h_config = H5Gopen(h_file,"MultiChain");
typedef Bead::RealType PosType;
typedef Bead::Buffer_t Buffer_t;
Buffer_t chain_buffer,bead_buffer;
(*(this->begin()))->registerData(bead_buffer);
chain_buffer.rewind();
copyToBuffer(chain_buffer);
HDFAttribIO<Buffer_t> mcout(chain_buffer);
mcout.overwrite(h_config,"state");
std::deque<Bead*>::iterator bead_it(this->begin());
std::deque<Bead*>::iterator bead_end(this->end());
//create the group and increment counter
char GrpName[128];
int ibead=0;
while(bead_it != bead_end) {
sprintf(GrpName,"bead%04d",ibead);
hid_t bead_id = H5Gopen(h_config,GrpName);
bead_buffer.rewind();
Bead& bead(**bead_it);
bead.copyToBuffer(bead_buffer);
HDFAttribIO<Buffer_t> bout(bead_buffer);
bout.overwrite(bead_id,"state");
H5Gclose(bead_id);
++bead_it;
++ibead;
}
}
int H5Lexists_safe(hid_t base, char *path)
// -----------------------------------------------------------------------------
// The HDF5 specification only allows H5Lexists to be called on an immediate
// child of the current object. However, you may wish to see whether a whole
// relative path exists, returning false if any of the intermediate links are
// not present. This function does that.
// http://www.hdfgroup.org/HDF5/doc/RM/RM_H5L.html#Link-Exists
// -----------------------------------------------------------------------------
{
hid_t last = base, next;
char *pch;
char pathc[2048];
strcpy(pathc, path);
pch = strtok(pathc, "/");
while (pch != NULL) {
int exists = H5Lexists(last, pch, H5P_DEFAULT);
if (!exists) {
if (last != base) H5Gclose(last);
return 0;
}
else {
next = H5Gopen(last, pch, H5P_DEFAULT);
if (last != base) H5Gclose(last);
last = next;
}
pch = strtok(NULL, "/");
}
if (last != base) H5Gclose(last);
return 1;
}
static int
scan_for_max_id( FileHandle* file_ptr, mhdf_Status* status )
{
hid_t group_id;
herr_t rval;
/* Check for new format, with max_id as attrib of root group */
#if defined(H5Gopen_vers) && H5Gopen_vers > 1
group_id = H5Gopen2( file_ptr->hdf_handle, ROOT_GROUP, H5P_DEFAULT );
#else
group_id = H5Gopen( file_ptr->hdf_handle, ROOT_GROUP );
#endif
if (group_id < 0)
{
mhdf_setFail( status, "Internal error - invalid file.");
return 0;
}
if (mhdf_read_scalar_attrib( group_id, MAX_ID_ATTRIB,
H5T_NATIVE_ULONG, &file_ptr->max_id,
status ))
{
H5Gclose( group_id );
return 1;
}
/* Didn't find it, scan the elements group */
rval = H5Giterate( group_id, ELEMENT_GROUP_NAME, 0, &max_id_iter, &file_ptr->max_id );
if (rval)
{
H5Gclose( group_id );
mhdf_setFail( status, "Internal error -- invalid file." );
return 0;
}
/* Check node table too */
rval = get_max_id( group_id, NODE_GROUP_NAME, "coordinates", (unsigned long*)(&file_ptr->max_id) );
if (rval)
{
H5Gclose( group_id );
mhdf_setFail( status, "Internal error -- invalid file." );
return 0;
}
/* Check set table, if it exists */
rval = mhdf_is_in_group( group_id, SET_GROUP_NAME, status );
if (rval < 1)
{
H5Gclose( group_id );
return !rval;
}
rval = get_max_id( group_id, SET_GROUP_NAME, SET_META_NAME, (unsigned long*)(&file_ptr->max_id) );
H5Gclose( group_id );
if (rval)
{
mhdf_setFail( status, "Internal error -- invalid file." );
return 0;
}
return 1;
}
void h5_value_doubles(hid_t file_id, char *group, char *name, double **values,
int *numValues)
{
int kk;
hid_t group_id = H5Gopen(file_id, group, H5P_DEFAULT);
hid_t data_id = H5Dopen(group_id, name, H5P_DEFAULT);
hid_t data_space = H5Dget_space(data_id);
int rank = H5Sget_simple_extent_ndims(data_space);
hsize_t dims[H5S_MAX_RANK], maxdim[H5S_MAX_RANK];
H5Sget_simple_extent_dims(data_space, dims, maxdim);
hid_t data_type = H5Dget_type(data_id);
H5T_class_t data_class = H5Tget_native_type(data_type, H5T_DIR_DEFAULT);
size_t data_size = H5Tget_size(data_class);
hsize_t elements = 1;
for (kk=0; kk<rank; kk++)
elements *= dims[kk];
void *buf = (void *) MALLOC((size_t)(elements*data_size));
H5Dread(data_id, data_class, H5S_ALL, H5S_ALL, H5P_DEFAULT, buf);
*values = buf;
*numValues = elements;
H5Tclose(data_type);
H5Tclose(data_class);
H5Sclose(data_space);
H5Dclose(data_id);
H5Gclose(group_id);
}
/* write eigen value and eigen vector for (ibnd, ispin) */
void F77_FUNC_(pwhdf_write_band,PWHDF_WRITE_BAND)(const int* ibnd,
const int* ispin, const double* e,
const double* eigv, const int* ngtot)
{
char spinname[16];
sprintf(spinname,"band%i/spin%i",(*ibnd)-1,(*ispin)-1);
hid_t h_spin = H5Gopen(h_twist,spinname);
hsize_t dim=1;
hid_t dataspace= H5Screate_simple(1, &dim, NULL);
hid_t dataset= H5Dcreate(h_spin, "eigenvalue", H5T_NATIVE_DOUBLE, dataspace, H5P_DEFAULT);
hid_t ret = H5Dwrite(dataset, H5T_NATIVE_DOUBLE, H5S_ALL, H5S_ALL, H5P_DEFAULT,e);
H5Sclose(dataspace);
H5Dclose(dataset);
hsize_t dims[2];
dims[0] = *ngtot;
dims[1] = 2;
dataspace = H5Screate_simple(2, dims, NULL);
dataset = H5Dcreate(h_spin, "eigenvector", H5T_NATIVE_DOUBLE, dataspace, H5P_DEFAULT);
ret = H5Dwrite(dataset, H5T_NATIVE_DOUBLE, H5S_ALL, H5S_ALL, H5P_DEFAULT,eigv);
H5Sclose(dataspace);
H5Dclose(dataset);
H5Gclose(h_spin);
}
CXI_Data * cxi_open_data(CXI_Data_Reference * ref){
cxi_debug("opening data");
char buffer[1024];
if(!ref){
return NULL;
}
CXI_Data * data = calloc(sizeof(CXI_Data),1);
if(!data){
return NULL;
}
data->handle = H5Gopen(ref->parent_handle,ref->group_name,H5P_DEFAULT);
if(data->handle < 0){
free(data);
return NULL;
}
ref->data = data;
if(H5Lexists(data->handle,"data",H5P_DEFAULT)){
data->data = calloc(sizeof(CXI_Dataset_Reference),1);
data->data->parent_handle = data->handle;
data->data->group_name = malloc(sizeof(char)*(strlen(buffer)+1));
strcpy(data->data->group_name,"data");
}
if(H5Lexists(data->handle,"errors",H5P_DEFAULT)){
data->errors = calloc(sizeof(CXI_Dataset_Reference),1);
data->errors->parent_handle = data->handle;
data->errors->group_name = malloc(sizeof(char)*(strlen(buffer)+1));
strcpy(data->errors->group_name,"errors");
}
return data;
}
static int _series_data(void)
{
FILE *fp;
bool hd = false;
hid_t fid_job;
hid_t jgid_root;
hid_t jgid_step;
int nsteps;
int stepx;
char jgrp_step_name[MAX_GROUP_NAME + 1];
fp = fopen(params.output, "w");
if (fp == NULL) {
error("Failed open file %s -- %m", params.output);
return -1;
}
fid_job = H5Fopen(params.input, H5F_ACC_RDONLY, H5P_DEFAULT);
if (fid_job < 0) {
fclose(fp);
error("Failed to open %s", params.input);
return -1;
}
jgid_root = H5Gopen(fid_job, "/", H5P_DEFAULT);
if (jgid_root < 0) {
fclose(fp);
H5Fclose(fid_job);
error("Failed to open root");
return -1;
}
nsteps = get_int_attribute(jgid_root, ATTR_NSTEPS);
for (stepx = 0; stepx < nsteps; stepx++) {
if ((params.step_id != -1) && (stepx != params.step_id))
continue;
sprintf(jgrp_step_name, "%s_%d", GRP_STEP, stepx);
jgid_step = get_group(jgid_root, jgrp_step_name);
if (jgid_step < 0) {
error("Failed to open group %s", jgrp_step_name);
return -1;
}
if (strncmp(params.series,GRP_TASK,strlen(GRP_TASK)) == 0)
_get_all_task_series(fp,hd,jgid_step, stepx);
else
_get_all_node_series(fp,hd,jgid_step, stepx);
hd = true;
H5Gclose(jgid_step);
}
H5Gclose(jgid_root);
H5Fclose(fid_job);
fclose(fp);
return 0;
}
CXI_Image * cxi_open_image(CXI_Image_Reference * ref){
cxi_debug("opening image");
char buffer[1024];
if(!ref){
return NULL;
}
CXI_Image * image = calloc(sizeof(CXI_Image),1);
if(!image){
return NULL;
}
image->handle = H5Gopen(ref->parent_handle,ref->group_name,H5P_DEFAULT);
if(image->handle < 0){
free(image);
return NULL;
}
/* Search for Detector groups */
int n = find_max_suffix(image->handle, "detector");
image->detector_count = n;
image->detectors = calloc(sizeof(CXI_Detector_Reference *),n);
for(int i = 0;i<n;i++){
image->detectors[i] = calloc(sizeof(CXI_Detector_Reference),1);
sprintf(buffer,"detector_%d",i+1);
image->detectors[i]->parent_handle = image->handle;
image->detectors[i]->group_name = malloc(sizeof(char)*(strlen(buffer)+1));
strcpy(image->detectors[i]->group_name,buffer);
}
ref->image = image;
if(H5Lexists(image->handle,"data",H5P_DEFAULT)){
image->data = calloc(sizeof(CXI_Dataset_Reference),1);
image->data->parent_handle = image->handle;
image->data->group_name = malloc(sizeof(char)*(strlen(buffer)+1));
strcpy(image->data->group_name,"data");
}
if(H5Lexists(image->handle,"data_error",H5P_DEFAULT)){
image->data_error = calloc(sizeof(CXI_Dataset_Reference),1);
image->data_error->parent_handle = image->handle;
image->data_error->group_name = malloc(sizeof(char)*(strlen(buffer)+1));
strcpy(image->data_error->group_name,"data_error");
}
if(H5Lexists(image->handle,"mask",H5P_DEFAULT)){
image->mask = calloc(sizeof(CXI_Dataset_Reference),1);
image->mask->parent_handle = image->handle;
image->mask->group_name = malloc(sizeof(char)*(strlen(buffer)+1));
strcpy(image->mask->group_name,"mask");
}
// try_read_string(image->handle, "data_space",&image->data_space);
// try_read_string(image->handle, "data_type",&image->data_type);
image->dimensionality_valid = try_read_int(image->handle, "dimensionality",&image->dimensionality);
image->image_center_valid = try_read_float_array(image->handle, "image_center",image->image_center,3);
return image;
}
CXI_Attenuator * cxi_open_attenuator(CXI_Attenuator_Reference * ref){
cxi_debug("opening attenuator");
if(!ref){
return NULL;
}
CXI_Attenuator * attenuator = calloc(sizeof(CXI_Attenuator),1);
if(!attenuator){
return NULL;
}
attenuator->handle = H5Gopen(ref->parent_handle,ref->group_name,H5P_DEFAULT);
if(attenuator->handle < 0){
free(attenuator);
return NULL;
}
ref->attenuator = attenuator;
attenuator->distance_valid = try_read_float(attenuator->handle, "distance",&attenuator->distance);
attenuator->thickness_valid = try_read_float(attenuator->handle, "thickness",&attenuator->thickness);
attenuator->attenuator_transmission_valid = try_read_float(attenuator->handle, "attenuator_transmission",
&attenuator->attenuator_transmission);
try_read_string(attenuator->handle, "type",&attenuator->type);
return attenuator;
}
/* write eigen value and eigen vector for (ibnd, ispin) */
void F77_FUNC_(pwhdf_write_wfr,PWHDF_WRITE_WFR)(const int* ibnd,
const int* ispin, const double* e,
const double* eigr, const int* use_complex)
{
char spinname[16];
sprintf(spinname,"band%i/spin%i",(*ibnd)-1,(*ispin)-1);
/*sprintf(spinname,"band_%i",(*ibnd)-1);*/
hid_t h_spin = H5Gopen(h_twist,spinname);
/* write eigenvalue */
hsize_t dim=1;
hid_t dataspace= H5Screate_simple(1, &dim, NULL);
hid_t dataset= H5Dcreate(h_spin, "eigenvalue", H5T_NATIVE_DOUBLE, dataspace, H5P_DEFAULT);
hid_t ret = H5Dwrite(dataset, H5T_NATIVE_DOUBLE, H5S_ALL, H5S_ALL, H5P_DEFAULT,e);
H5Sclose(dataspace);
H5Dclose(dataset);
hsize_t dims_out=(*use_complex)?4:3;
hsize_t dims[4];
dims[0] = h_ngrid[0];
dims[1] = h_ngrid[1];
dims[2] = h_ngrid[2];
dims[3] = 2;
dataspace = H5Screate_simple(dims_out, dims, NULL);
dataset = H5Dcreate(h_spin, "eigenvector", H5T_NATIVE_DOUBLE, dataspace, H5P_DEFAULT);
ret = H5Dwrite(dataset, H5T_NATIVE_DOUBLE, H5S_ALL, H5S_ALL, H5P_DEFAULT,eigr);
H5Sclose(dataspace);
H5Dclose(dataset);
H5Gclose(h_spin);
}
void CheMPS2::DMRG::loadDIM(const std::string name, SyBookkeeper * BKlocation){
//The hdf5 file
hid_t file_id = H5Fopen(name.c_str(), H5F_ACC_RDONLY, H5P_DEFAULT);
//The current virtual dimensions
for (int bound=0; bound<=BKlocation->gL(); bound++){
for (int N=BKlocation->gNmin(bound); N<=BKlocation->gNmax(bound); N++){
for (int TwoS=BKlocation->gTwoSmin(bound,N); TwoS<=BKlocation->gTwoSmax(bound,N); TwoS+=2){
for (int Irrep=0; Irrep<BKlocation->getNumberOfIrreps(); Irrep++){
std::stringstream sstream;
sstream << "/VirtDim_" << bound << "_" << N << "_" << TwoS << "_" << Irrep;
hid_t group_id2 = H5Gopen(file_id, sstream.str().c_str(), H5P_DEFAULT);
hid_t dataset_id2 = H5Dopen(group_id2, "Value", H5P_DEFAULT);
int toRead;
H5Dread(dataset_id2, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, &toRead);
BKlocation->SetDim(bound, N, TwoS, Irrep, toRead);
H5Dclose(dataset_id2);
H5Gclose(group_id2);
}
}
}
}
H5Fclose(file_id);
}
int
main()
{
printf("\n*** Checking HDF5 file c0.nc.\n");
printf("*** Checking HDF5 objcts...");
{
hid_t fileid, grpid;
hsize_t num_obj, i;
char obj_name[MAX_NAME];
if ((fileid = H5Fopen(FILE_NAME, H5F_ACC_RDONLY, H5P_DEFAULT)) < 0) ERR;
if ((grpid = H5Gopen(fileid, "/")) < 0) ERR;
/* Find the variables. Read their metadata and attributes. */
if (H5Gget_num_objs(grpid, &num_obj) < 0) ERR;
for (i=0; i<num_obj; i++)
{
/* Get the class (i.e. group, dataset, etc.), and the name of
* the object. */
if (H5Gget_objtype_by_idx(grpid, i) < 0) ERR;
if (H5Gget_objname_by_idx(grpid, i, obj_name, MAX_NAME) < 0) ERR;
}
if (H5Gclose(grpid) < 0 ||
H5Fclose(fileid) < 0) ERR;
}
SUMMARIZE_ERR;
FINAL_RESULTS;
}
GDALDataset *HDF5Dataset::Open( GDALOpenInfo *poOpenInfo )
{
if( !Identify(poOpenInfo) )
return nullptr;
// Create datasource.
HDF5Dataset *const poDS = new HDF5Dataset();
poDS->SetDescription(poOpenInfo->pszFilename);
// Try opening the dataset.
poDS->hHDF5 = H5Fopen(poOpenInfo->pszFilename, H5F_ACC_RDONLY, H5P_DEFAULT);
if( poDS->hHDF5 < 0 )
{
delete poDS;
return nullptr;
}
poDS->hGroupID = H5Gopen(poDS->hHDF5, "/");
if( poDS->hGroupID < 0 )
{
poDS->bIsHDFEOS = false;
delete poDS;
return nullptr;
}
poDS->bIsHDFEOS = true;
poDS->ReadGlobalAttributes(true);
poDS->SetMetadata(poDS->papszMetadata);
if ( CSLCount(poDS->papszSubDatasets) / 2 >= 1 )
poDS->SetMetadata(poDS->papszSubDatasets, "SUBDATASETS");
// Make sure we don't try to do any pam stuff with this dataset.
poDS->nPamFlags |= GPF_NOSAVE;
// If we have single subdataset only, open it immediately.
int nSubDatasets = CSLCount(poDS->papszSubDatasets) / 2;
if( nSubDatasets == 1 )
{
CPLString osDSName =
CSLFetchNameValue(poDS->papszSubDatasets, "SUBDATASET_1_NAME");
delete poDS;
return (GDALDataset *)GDALOpen(osDSName, poOpenInfo->eAccess);
}
else
{
// Confirm the requested access is supported.
if( poOpenInfo->eAccess == GA_Update )
{
delete poDS;
CPLError(CE_Failure, CPLE_NotSupported,
"The HDF5 driver does not support update access to "
"existing datasets.");
return nullptr;
}
}
return poDS;
}
PetscErrorCode PetscViewerHDF5OpenGroup(PetscViewer viewer, hid_t *fileId, hid_t *groupId)
{
hid_t file_id, group;
const char *groupName = NULL;
PetscErrorCode ierr;
PetscFunctionBegin;
ierr = PetscViewerHDF5GetFileId(viewer, &file_id);CHKERRQ(ierr);
ierr = PetscViewerHDF5GetGroup(viewer, &groupName);CHKERRQ(ierr);
/* Open group */
if (groupName) {
PetscBool root;
ierr = PetscStrcmp(groupName, "/", &root);CHKERRQ(ierr);
if (!root && !H5Lexists(file_id, groupName, H5P_DEFAULT)) {
#if (H5_VERS_MAJOR * 10000 + H5_VERS_MINOR * 100 + H5_VERS_RELEASE >= 10800)
group = H5Gcreate2(file_id, groupName, 0, H5P_DEFAULT, H5P_DEFAULT);
#else /* deprecated HDF5 1.6 API */
group = H5Gcreate(file_id, groupName, 0);
#endif
if (group < 0) SETERRQ1(PETSC_COMM_SELF, PETSC_ERR_LIB, "Could not create group %s", groupName);
ierr = H5Gclose(group);CHKERRQ(ierr);
}
#if (H5_VERS_MAJOR * 10000 + H5_VERS_MINOR * 100 + H5_VERS_RELEASE >= 10800)
group = H5Gopen2(file_id, groupName, H5P_DEFAULT);
#else
group = H5Gopen(file_id, groupName);
#endif
if (group < 0) SETERRQ1(PETSC_COMM_SELF, PETSC_ERR_LIB, "Could not open group %s", groupName);
} else group = file_id;
*fileId = file_id;
*groupId = group;
PetscFunctionReturn(0);
}
hid_t
dat1GetParentID( hid_t objid, hdsbool_t allow_root, int * status ) {
hid_t parent_id = -1;
ssize_t lenstr = 0;
char * tempstr = NULL;
if (*status != SAI__OK) return parent_id;
/* Not sure if there is a specific API for this. For now,
get the full name of the object and then open the group
with the lowest part of the path removed */
tempstr = dat1GetFullName( objid, 0, &lenstr, status );
if (*status == SAI__OK && lenstr <= 1) {
*status = DAT__OBJIN;
emsRep("datParen_0",
"Object is the HDF5 root group and has no parent "
"group (possible programming error).", status);
goto CLEANUP;
}
/* Now walk through the name in reverse and nul out the first "/"
we encounter. */
if (*status == SAI__OK) {
ssize_t iposn;
ssize_t i;
for (i = 0; i < lenstr; i++) {
iposn = lenstr - (i+1);
if (tempstr[iposn] == '/') {
tempstr[iposn] = '\0';
break;
}
}
}
/* if this seems to be the root group we rewrite it to be "/" else,
optionally return an error. */
if (tempstr[0] == '\0') {
if (allow_root) {
tempstr[0] = '/';
tempstr[1] = '\0';
} else if (*status == SAI__OK) {
*status = DAT__OBJIN;
emsRep("datParen_1",
"Object is a top-level object and has no parent "
"structure (possible programming error).", status);
goto CLEANUP;
}
}
/* It seems you can open a group on an arbitrary
item (group or dataset) if you use a fully specified
path. This means you do not need to get an
explicit file_id to open the group */
CALLHDFE( hid_t, parent_id,
H5Gopen(objid, tempstr, H5P_DEFAULT),
DAT__HDF5E,
emsRepf("datParen_2", "Error opening parent structure '%s'",
status, tempstr );
);
int luaC_h5_open_group(lua_State *L)
{
const char *gname = luaL_checkstring(L, 1);
const char *mode = luaL_checkstring(L, 2);
hid_t grp = 0;
if (PresentFile < 0) {
luaL_error(L, "need an open file to open group\n");
}
else if (strcmp(mode, "w") == 0) {
if (H5Lexists(PresentFile, gname, H5P_DEFAULT)) {
H5Ldelete(PresentFile, gname, H5P_DEFAULT);
}
grp = H5Gcreate(PresentFile, gname, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
}
else if (strcmp(mode, "r+") == 0) {
if (H5Lexists(PresentFile, gname, H5P_DEFAULT)) {
grp = H5Gopen(PresentFile, gname, H5P_DEFAULT);
}
else {
grp = H5Gcreate(PresentFile, gname, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
}
}
else {
luaL_error(L, "invalid group access mode '%s'\n", mode);
}
lua_pushnumber(L, grp);
return 1;
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
int DataContainer::writeAttributeMatricesToHDF5(hid_t parentId)
{
int err;
hid_t attributeMatrixId;
for(QMap<QString, AttributeMatrix::Pointer>::iterator iter = m_AttributeMatrices.begin(); iter != m_AttributeMatrices.end(); ++iter)
{
err = QH5Utilities::createGroupsFromPath(iter.key(), parentId);
if(err < 0)
{
return err;
}
attributeMatrixId = H5Gopen(parentId, iter.key().toLatin1().data(), H5P_DEFAULT);
HDF5ScopedGroupSentinel gSentinel(&attributeMatrixId, false);
err = QH5Lite::writeScalarAttribute(parentId, iter.key(), DREAM3D::StringConstants::AttributeMatrixType, (*iter)->getType());
if(err < 0)
{
return err;
}
hsize_t size = (*iter)->getTupleDimensions().size();
err = QH5Lite::writePointerAttribute(parentId, iter.key(), DREAM3D::HDF5::TupleDimensions, 1, &size, (*iter)->getTupleDimensions().data());
if(err < 0)
{
return err;
}
err = (*iter)->writeAttributeArraysToHDF5(attributeMatrixId);
if(err < 0)
{
return err;
}
}
return 0;
}
asynStatus NDFileHDF5AttributeDataset::createHDF5Dataset()
{
asynStatus status = asynSuccess;
cparm_ = H5Pcreate(H5P_DATASET_CREATE);
H5Pset_fill_value(cparm_, datatype_, ptrFillValue_);
H5Pset_chunk(cparm_, rank_, chunk_);
dataspace_ = H5Screate_simple(rank_, dims_, maxdims_);
// Open the group by its name
hid_t dsetgroup;
if (groupName_ != ""){
dsetgroup = H5Gopen(file_, groupName_.c_str(), H5P_DEFAULT);
} else {
dsetgroup = file_;
}
// Now create the dataset
dataset_ = H5Dcreate2(dsetgroup, dsetName_.c_str(),
datatype_, dataspace_,
H5P_DEFAULT, cparm_, H5P_DEFAULT);
if (groupName_ != ""){
H5Gclose(dsetgroup);
}
memspace_ = H5Screate_simple(rank_, elementSize_, NULL);
return status;
}
void H5Writer::init(const std::string& fname, int num_bootstrap, uint compression,
size_t index_version, const std::string& shell_call,
const std::string& start_time)
{
primed_ = true;
num_bootstrap_ = num_bootstrap;
compression_ = compression;
file_id_ = H5Fcreate(fname.c_str(), H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);
root_ = H5Gopen(file_id_, "/", H5P_DEFAULT);
aux_ = H5Gcreate(file_id_, "/aux", H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
if (num_bootstrap_ > 0) {
bs_ = H5Gcreate(file_id_, "/bootstrap", H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
}
std::vector<int> n_bs {num_bootstrap};
vector_to_h5(n_bs, aux_, "num_bootstrap", false, compression_);
// info about run
std::vector<std::string> kal_version{ KALLISTO_VERSION };
vector_to_h5(kal_version, aux_, "kallisto_version", true, compression_);
std::vector<int> idx_version{ static_cast<int>(index_version) };
vector_to_h5(idx_version, aux_, "index_version", false, compression_);
std::vector<std::string> call{ shell_call };
vector_to_h5(call, aux_, "call", true, compression_);
std::vector<std::string> s_time{ start_time };
vector_to_h5(s_time, aux_, "start_time", true, compression_);
}
void ESHDFIonsParser::readESHDF()
{
int nspecies=0;
{
HDFAttribIO<int> a(nspecies);
a.read(hfile_id,"atoms/number_of_species");
}
SpeciesSet& tspecies(ref_.getSpeciesSet());
int icharge= tspecies.addAttribute("charge");//use charge
int iatnumber= tspecies.addAttribute(atomic_number_tag);
int massind= tspecies.addAttribute(mass_tag);
//add charge
//atomic_number is optional
for(int i=0; i<nspecies; ++i)
{
ostringstream o;
o << "atoms/species_"<<i;
hid_t g=H5Gopen(hfile_id,o.str().c_str());
string aname;
HDFAttribIO<string> a(aname);
a.read(g,"name");
int ii=tspecies.addSpecies(aname);
int q=-1;
HDFAttribIO<int> b(q);
b.read(g,charge_tag.c_str());
tspecies(icharge,ii)=q;
int atnum=0;
HDFAttribIO<int> c(atnum);
c.read(g,atomic_number_tag.c_str());
tspecies(iatnumber,ii)=atnum;
//close the group
H5Gclose(g);
}
for(int ig=0; ig<nspecies; ++ig)
tspecies(massind,ig)=1.0;
//just for checking
// tspecies(icharge,0)=15.0;
// tspecies(icharge,1)=6.0;
{
//get the unit cell
Tensor<double,3> alat;
HDFAttribIO<Tensor<double,3> > a(alat);
a.read(hfile_id,"supercell/primitive_vectors");
ref_.Lattice.set(alat);
}
{
//get the unit cell
int natoms=0;
HDFAttribIO<int> a(natoms);
a.read(hfile_id,"atoms/number_of_atoms");
ref_.create(natoms);
ref_.R.InUnit=PosUnit::CartesianUnit;
HDFAttribIO<ParticleSet::ParticlePos_t> b(ref_.R);
b.read(hfile_id,"atoms/positions");
HDFAttribIO<ParticleSet::ParticleIndex_t> c(ref_.GroupID);
c.read(hfile_id,"atoms/species_ids");
}
ref_.resetGroups();
}
