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);
}
/****************************************************************
**
** getHDF5ClassID(): Returns class ID for loc_id.name. -1 if error.
**
****************************************************************/
H5T_class_t getHDF5ClassID(hid_t loc_id,
const char *name,
H5D_layout_t *layout,
hid_t *type_id,
hid_t *dataset_id) {
H5T_class_t class_id;
hid_t plist;
/* Open the dataset. */
if ( (*dataset_id = H5Dopen( loc_id, name, H5P_DEFAULT )) < 0 )
return -1;
/* Get an identifier for the datatype. */
*type_id = H5Dget_type( *dataset_id );
/* Get the class. */
class_id = H5Tget_class( *type_id );
/* Get the layout of the datatype */
plist = H5Dget_create_plist(*dataset_id);
*layout = H5Pget_layout(plist);
H5Pclose(plist);
return class_id;
}
int luaC_h5_read_string(lua_State *L)
{
const char *dsetnm = luaL_checkstring(L, 1);
if (PresentFile < 0) {
luaL_error(L, "no open file");
}
hid_t dset = H5Dopen(PresentFile, dsetnm, H5P_DEFAULT);
if (dset < 0) {
luaL_error(L, "no data set named %s", dsetnm);
}
hid_t fspc = H5Dget_space(dset);
hid_t strn = H5Dget_type(dset);
hsize_t msize = H5Tget_size(strn);
char *string = (char*) malloc((msize+1)*sizeof(char));
H5Dread(dset, strn, fspc, fspc, H5P_DEFAULT, string);
string[msize] = '\0'; // Make sure to null-terminate the string
lua_pushstring(L, string);
H5Tclose(strn);
H5Sclose(fspc);
H5Dclose(dset);
free(string);
return 1;
}
/** Return the byte size of the voxel datatytpe
*/
int miget_data_type_size ( mihandle_t volume, misize_t *voxel_size )
{
hid_t grp_id;
hid_t dset_id;
hid_t type_id;
hid_t file_id = volume->hdf_id;
grp_id = midescend_path ( file_id, MI_FULLIMAGE_PATH );
if ( grp_id < 0 ) {
return ( MI_ERROR );
}
dset_id = H5Dopen1 ( grp_id, "image" );
if ( dset_id < 0 ) {
return ( MI_ERROR );
}
type_id = H5Dget_type ( dset_id );
if ( type_id < 0 ) {
return ( MI_ERROR );
}
*voxel_size = H5Tget_size ( type_id );
H5Tclose ( type_id );
H5Dclose ( dset_id );
H5Gclose ( grp_id );
return ( MI_NOERROR );
}
void H5Dataset_readPalette(H5Dataset *d, hid_t did)
{
hid_t pal_id=-1, tid=-1;
hobj_ref_t *refs;
if (!d || did<=0 ) return;
refs = H5Dataset_get_paletteRef(did);
if (refs) {
// use the fist palette
pal_id = H5Rdereference(d->fid, H5R_OBJECT, refs);
tid = H5Dget_type(pal_id);
if (H5Dget_storage_size(pal_id) <= 768)
{
H5Attribute *attr;
d->nattributes = 1;
d->attributes = (H5Attribute*)malloc(sizeof(H5Attribute));
attr = &(d->attributes[0]);
H5Attribute_ctor(attr);
attr->value = (unsigned char *)malloc(3*256);
memset(attr->value, 0, 768);
attr->nvalue = 768;
attr->name = (char*)malloc(20);
strcpy(attr->name, PALETTE_VALUE);
H5Dread( pal_id, tid, H5S_ALL, H5S_ALL, H5P_DEFAULT, attr->value);
}
if (tid > 0) H5Tclose(tid);
if (pal_id > 0) H5Dclose(pal_id);
free(refs);
}
}
H5T_class_t HdfDataset::type() const
{
hid_t tid = H5Dget_type( d->id );
H5T_class_t t_class = H5Tget_class( tid );
H5Tclose( tid );
return t_class;
}
/*+++++++++++++++++++++++++
.IDENTifer PYTABLE_write_records
.PURPOSE Write records to an HDF5 array
.INPUT/OUTPUT
call as stat = PYTABLE_write_records( locID, dset_name, start, step,
count, buffer );
input:
hid_t locID : HDF5 identifier of file or group
char *dset_name : name of dataset
hsize_t *start : index of first row to overwrite
hsize_t *step :
hsize_t *count : number of rows to write
void *buffer : data to write
.RETURNS A negative value is returned on failure.
.COMMENTS none
-------------------------*/
herr_t PYTABLE_write_records( hid_t locID, const char *dset_name,
hsize_t *start, hsize_t *step,
hsize_t *count, const void *buffer )
{
int rank;
hid_t dataID;
hid_t spaceID = -1;
hid_t mem_spaceID = -1;
hid_t typeID = -1;
/* open the dataset. */
if ( (dataID = H5Dopen( locID, dset_name, H5P_DEFAULT )) < 0 )
return -1;
/* get the dataspace handle */
if ( (spaceID = H5Dget_space( dataID )) < 0 )
goto done;
/* get rank */
if ( (rank = H5Sget_simple_extent_ndims( spaceID )) <= 0 )
goto done;
/* create a simple memory data space */
if ( (mem_spaceID = H5Screate_simple( rank, count, NULL )) < 0 )
goto done;
/* define a hyperslab in the dataset */
if ( H5Sselect_hyperslab( spaceID, H5S_SELECT_SET, start,
step, count, NULL ) < 0 )
goto done;
/* get an identifier for the datatype. */
if ( (typeID = H5Dget_type( dataID )) < 0 ) goto done;
/* write data to hyperslap */
if ( H5Dwrite( dataID, typeID, mem_spaceID, spaceID,
H5P_DEFAULT, buffer ) < 0 )
goto done;
/* terminate access to the datatype */
if ( H5Tclose( typeID ) < 0 ) goto done;
/* end access to the dataset */
if ( H5Dclose( dataID ) ) goto done;
/* terminate access to the dataspace */
if ( H5Sclose( mem_spaceID ) < 0 ) goto done;
if ( H5Sclose( spaceID ) < 0 ) goto done;
return 0;
done:
if ( typeID > 0 ) (void) H5Tclose( typeID );
if ( spaceID > 0 ) (void) H5Sclose( spaceID );
if ( mem_spaceID > 0 ) (void) H5Sclose( mem_spaceID );
if ( dataID > 0 ) (void) H5Dclose( dataID );
return -1;
}
VsDataset::VsDataset(VsRegistry* r, VsObject* parentObject,
const std::string& datasetName, hid_t id):
VsObject(r, parentObject, datasetName, id) {
dataType = H5Tget_native_type(H5Dget_type(id), H5T_DIR_DEFAULT);
loadDims();
registry->add(this);
}
hdf5dataset::hdf5dataset(hdf5file& hfile, const std::string& pname) : _hfile(hfile), _name(pname)
{
_dataset_id = H5Dopen(_hfile.handle(), _name.c_str(), H5P_DEFAULT);
if(_dataset_id < 0)
throw std::runtime_error("Failed to open dataset (" + _hfile.filename() + ") in file (" + _name + ")");
_type_id = H5Dget_type(_dataset_id);
_own_type_id = true;
}
//--------------------------------------------------------------------------
// Function: IntType overloaded constructor
///\brief Gets the integer datatype of the specified dataset.
///\param dataset - IN: Dataset that this integer datatype associates with
///\exception H5::DataTypeIException
// Programmer Binh-Minh Ribler - 2000
//--------------------------------------------------------------------------
IntType::IntType( const DataSet& dataset ) : AtomType()
{
// Calls C function H5Dget_type to get the id of the datatype
id = H5Dget_type( dataset.getId() );
if( id < 0 )
{
throw DataSetIException("IntType constructor", "H5Dget_type failed");
}
}
H5Type & H5Dataset::getDataType()
{
hid_t type = H5Dget_type(dataset);
if (type < 0)
{
throw H5Exception(__LINE__, __FILE__, _("Cannot get the dataspace associated with dataset named %s."), name.c_str());
}
return *new H5Type(*this, type);
}
/*--------------------------------------------------------------*/
static void validateDependsOn(pNXVcontext self, hid_t groupID,
hid_t fieldID)
{
char fname[512], dpData[1024];
hid_t h5type, dpfieldID;
H5T_class_t h5class;
memset(fname,0,sizeof(fname));
memset(dpData,0,sizeof(dpData));
H5Iget_name(fieldID,fname,sizeof(fname));
NXVsetLog(self,"dataPath",fname);
NXVsetLog(self,"sev","debug");
NXVprintLog(self,"message","Validating depends_on chain starting at %s",
fname);
NXVlog(self);
/*
test that the depends_on field is of the right type
*/
h5type = H5Dget_type(fieldID);
h5class = H5Tget_class(h5type);
H5Tclose(h5type);
if(h5class != H5T_STRING){
NXVsetLog(self,"sev","error");
NXVsetLog(self,"message",
"depends_on field is of wrong type, expect string");
NXVlog(self);
self->errCount++;
return;
}
/*
read the field
*/
H5LTread_dataset_string(groupID,"depends_on",dpData);
/*
find the field and start iterating through the chain
*/
dpfieldID = findDependentField(self,fieldID,dpData);
if(dpfieldID < 0){
NXVsetLog(self,"sev","error");
NXVprintLog(self,"message",
"Cannot even find the starting point of the depends_on chain, %s",
dpData);
NXVlog(self);
self->errCount++;
return;
} else {
validateDependsOnField(self,groupID,dpfieldID);
H5Dclose(dpfieldID);
}
}
//--------------------------------------------------------------------------
// Function: CompType overloaded constructor
///\brief Gets the compound datatype of the specified dataset.
///\param dataset - IN: Dataset that this enum datatype associates with
///\return CompType instance
///\exception H5::DataTypeIException
// Programmer Binh-Minh Ribler - 2000
//--------------------------------------------------------------------------
CompType::CompType( const DataSet& dataset ) : DataType()
{
// Calls C function H5Dget_type to get the id of the datatype
id = H5Dget_type( dataset.getId() );
// If the datatype id is invalid, throw exception
if( id < 0 )
{
throw DataSetIException("CompType constructor", "H5Dget_type failed");
}
}
asynStatus hdf5Driver::getFrameData (int frame, void *pData)
{
const char *functionName = "getFrameData";
asynStatus status = asynSuccess;
struct dsetInfo *pDSet;
hid_t dSpace, dType, mSpace;
pDSet = getDatasetByFrame(frame);
if(!pDSet)
return asynError;
hsize_t offset[3] = {(hsize_t)(frame - pDSet->imageNrLow), 0, 0};
hsize_t count[3] = {1, pDSet->height, pDSet->width};
if((dSpace = H5Dget_space(pDSet->id)) < 0)
{
asynPrint(pasynUserSelf, ASYN_TRACE_ERROR,
"%s:%s couldn't get dataspace\n",
driverName, functionName);
return asynError;
}
dType = H5Dget_type(pDSet->id);
mSpace = H5Screate_simple(3, count, NULL);
// Select the hyperslab
if(H5Sselect_hyperslab(dSpace, H5S_SELECT_SET, offset, NULL, count,
NULL) < 0)
{
asynPrint(pasynUserSelf, ASYN_TRACE_ERROR,
"%s:%s couldn't select hyperslab\n",
driverName, functionName);
status = asynError;
goto end;
}
// and finally read the image
if(H5Dread(pDSet->id, dType, mSpace, dSpace, H5P_DEFAULT, pData) < 0)
{
asynPrint(pasynUserSelf, ASYN_TRACE_ERROR,
"%s:%s couldn't read image\n",
driverName, functionName);
status = asynError;
}
end:
H5Tclose(dType);
H5Sclose(mSpace);
return status;
}
void Fast5Files::getFastq(hid_t dataset){
hid_t dt;
size_t size;
char *data;
dt = H5Dget_type(dataset);
size = H5Tget_size(dt);
data = (char*)malloc(size);
H5Dread(dataset, H5T_C_S1, H5S_ALL, H5S_ALL, H5P_DEFAULT, data);
qDebug() << data;
free(data);
H5Dclose(dataset);
}
void PWParameterSet::checkVersion(hid_t h)
{
if(is_manager())
{
hid_t dataset=H5Dopen(h,"version");
hid_t datatype=H5Dget_type(dataset);
H5T_class_t classtype = H5Tget_class(datatype);
H5Tclose(datatype);
H5Dclose(dataset);
if(classtype == H5T_INTEGER)
{
HDFAttribIO<TinyVector<int,2> > hdfver(version);
hdfver.read(h,"version");
}
else
if(classtype == H5T_FLOAT)
{
TinyVector<double,2> vt;
HDFAttribIO<TinyVector<double,2> > hdfver(vt);
hdfver.read(h,"version");
version[0]=int(vt[0]);
version[1]=int(vt[1]);
}
//else
//{
// APP_ABORT("PWParameterSet::checkVersion The type of version is not integer or double.");
//}
}
myComm->bcast(version);
app_log() << "\tWavefunction HDF version: " << version[0] << "." << version[1] << endl;
if(version[0] == 0)
{
if(version[1] == 11)
{
hasSpin=false;
paramTag="parameters_0";
basisTag="basis_1";
pwTag="planewaves";
pwMultTag="multipliers";
eigTag="eigenstates_3";
twistTag="twist_";
bandTag="band_";
}
else
if(version[1] == 10)
{
pwMultTag="planewaves";
pwTag="0";
}
}
}
static int try_read_string(hid_t loc, char * name, char ** dest){
if(H5Lexists(loc,name,H5P_DEFAULT)){
hid_t ds = H5Dopen(loc,name,H5P_DEFAULT);
hid_t t = H5Dget_type(ds);
if(H5Tget_class(t) == H5T_STRING){
*dest = malloc(sizeof(char)*H5Tget_size(t));
H5Dread(ds,t,H5S_ALL,H5S_ALL,H5P_DEFAULT,*dest);
}
H5Tclose(t);
H5Dclose(ds);
return 1;
}
return 0;
}
static int try_read_float_array(hid_t loc, char * name, double * dest, int size){
if(H5Lexists(loc,name,H5P_DEFAULT)){
hid_t ds = H5Dopen(loc,name,H5P_DEFAULT);
hid_t t = H5Dget_type(ds);
hid_t s = H5Dget_space(ds);
if(H5Tget_class(t) == H5T_FLOAT && array_total_size(ds) == size){
H5Dread(ds,H5T_NATIVE_DOUBLE,H5S_ALL,H5S_ALL,H5P_DEFAULT,dest);
}
H5Tclose(t);
H5Sclose(s);
H5Dclose(ds);
return 1;
}
return 0;
}
static int try_read_int(hid_t loc, char * name, int * dest){
if(H5Lexists(loc,name,H5P_DEFAULT)){
hid_t ds = H5Dopen(loc,name,H5P_DEFAULT);
hid_t t = H5Dget_type(ds);
hid_t s = H5Dget_space(ds);
if(H5Tget_class(t) == H5T_INTEGER && is_scalar(ds)){
H5Dread(ds,H5T_NATIVE_INT32,H5S_ALL,H5S_ALL,H5P_DEFAULT,dest);
}
H5Tclose(t);
H5Sclose(s);
H5Dclose(ds);
return 1;
}
return 0;
}
bool DCDataSet::open(hid_t group)
throw (DCException)
{
if (checkExistence && !H5Lexists(group, name.c_str(), H5P_LINK_ACCESS_DEFAULT))
return false;
dataset = H5Dopen(group, name.c_str(), H5P_DATASET_ACCESS_DEFAULT);
if (dataset < 0)
throw DCException(getExceptionString("open: Failed to open dataset"));
datatype = H5Dget_type(dataset);
if (datatype < 0)
{
H5Dclose(dataset);
throw DCException(getExceptionString("open: Failed to get type of dataset"));
}
dataspace = H5Dget_space(dataset);
if (dataspace < 0)
{
H5Dclose(dataset);
throw DCException(getExceptionString("open: Failed to open dataspace"));
}
int dims_result = H5Sget_simple_extent_ndims(dataspace);
if (dims_result < 0)
{
close();
throw DCException(getExceptionString("open: Failed to get dimensions"));
}
ndims = dims_result;
getLogicalSize().set(1, 1, 1);
if (H5Sget_simple_extent_dims(dataspace, getLogicalSize().getPointer(), NULL) < 0)
{
close();
throw DCException(getExceptionString("open: Failed to get sizes"));
}
getLogicalSize().swapDims(ndims);
opened = true;
return true;
}
int_f
h5dget_type_c ( hid_t_f *dset_id , hid_t_f *type_id)
/******/
{
int ret_value = -1;
hid_t c_dset_id;
hid_t c_type_id;
c_dset_id = (hid_t)*dset_id;
c_type_id = H5Dget_type(c_dset_id);
if(c_type_id < 0 ) return ret_value;
*type_id = (hid_t_f)c_type_id;
ret_value = 0;
return ret_value;
}
/*
* - Name : _MEDdatasetRead
* - Description : writes a HDF dataset
* - Parameters :
* - id (IN) : dataset ID
* - val (OUT) : datset values
* - Result :
* - if success : 0
* - if failure : -1
*/
hdf_err HDFdatasetRead(hdf_idt id, void *val)
{
hdf_idt datatype;
hdf_err ret;
if ((datatype = H5Dget_type(id)) < 0)
return -1;
//#if defined (PCLINUX) || defined (PCLINUX64)
if ((H5Tget_class(datatype) == H5T_INTEGER) && (H5Tget_size(datatype) == 4))
datatype = H5T_NATIVE_INT;
//#endif
if ((ret = H5Dread(id,datatype,H5S_ALL,H5S_ALL,H5P_DEFAULT, val)) < 0)
return -1;
return 0;
}
extern void
gridReaderHDF5_readIntoPatchForVar(gridReader_t reader,
gridPatch_t patch,
int idxOfVar)
{
assert(reader != NULL);
assert(reader->type = GRIDIO_TYPE_HDF5);
assert(patch != NULL);
assert(idxOfVar >= 0 && idxOfVar < gridPatch_getNumVars(patch));
hid_t dataSet;
hid_t dataSpaceFile, dataTypeFile;
hid_t dataSpacePatch, dataTypePatch;
gridPointUint32_t idxLoPatch, dimsPatch;
dataVar_t var = gridPatch_getVarHandle(patch, idxOfVar);
void *data = gridPatch_getVarDataHandle(patch, idxOfVar);
gridPatch_getIdxLo(patch, idxLoPatch);
gridPatch_getDims(patch, dimsPatch);
dataSet = H5Dopen(((gridReaderHDF5_t)reader)->file,
dataVar_getName(var), H5P_DEFAULT);
dataTypeFile = H5Dget_type(dataSet);
dataSpaceFile = H5Dget_space(dataSet);
dataTypePatch = dataVar_getHDF5Datatype(var);
dataSpacePatch = gridUtilHDF5_getDataSpaceFromDims(dimsPatch);
gridUtilHDF5_selectHyperslab(dataSpaceFile, idxLoPatch, dimsPatch);
if (H5Tequal(dataTypeFile, dataTypePatch)) {
H5Dread(dataSet, dataTypeFile, dataSpacePatch,
dataSpaceFile, H5P_DEFAULT, data);
} else {
fprintf(stderr, "ERROR: Datatype in memory differs from file.\n");
diediedie(EXIT_FAILURE);
}
H5Sclose(dataSpacePatch);
H5Tclose(dataTypePatch);
H5Sclose(dataSpaceFile);
H5Tclose(dataTypeFile);
H5Dclose(dataSet);
} /* gridReaderHDF5_readIntoPatchForVar */
hdf5_datatype::hdf5_datatype(hdf5_dataset const& dataset)
:
hdf5_object(H5Dget_type(dataset.get_id())),
type_class_(H5Tget_class(get_id()))
{
if(dataset.get_id() < 0) {
boost::serialization::throw_exception(
hdf5_archive_exception(
hdf5_archive_exception::hdf5_archive_dataset_access_error
)
);
}
if(get_id() < 0) {
boost::serialization::throw_exception(
hdf5_archive_exception(
hdf5_archive_exception::hdf5_archive_datatype_access_error
)
);
}
}
int H5mdfile::H5_Dopen2(int argc, char **argv, Tcl_Interp *interp)
{
/* Open an existing dataset */
dataset_id = H5Dopen2(file_id, argv[2], H5P_DEFAULT);
// Dataset properties
dataspace_id = H5Dget_space(dataset_id);
dataset_type_id = H5Dget_type(dataset_id);
datatype_size = H5Tget_size(dataset_type_id);
dataset_rank = H5Sget_simple_extent_dims(dataspace_id,dims,maxdims);
dataset_rank = H5Sget_simple_extent_dims(dataspace_id,dimstotal,maxdims);
prop_id = H5Dget_create_plist(dataset_id);
if (H5D_CHUNKED == H5Pget_layout(prop_id))
chunk_rank = H5Pget_chunk(prop_id, dataset_rank, chunk_dims);
// Dataset size
dset_data_size=1;
for(int i=0;i<dataset_rank;i++)
{
dset_data_size*=dims[i];
}
return TCL_OK;
}
/*+++++++++++++++++++++++++ Main Program or Function +++++++++++++++*/
int IDL_STDCALL _SDMF_RD_PT_CLUSDEF( int argc, void *argv[] )
{
IDL_STRING *dbName;
struct clusdef_rec *ClusDef;
hid_t fid = -1;
hid_t data_id = -1;
hid_t type_id = -1;
/*
* check number of parameters
*/
if ( argc != 2 ) NADC_GOTO_ERROR( NADC_ERR_PARAM, err_msg );
dbName = (IDL_STRING *) argv[0];
ClusDef = (struct clusdef_rec *) argv[1];
fid = H5Fopen( dbName->s, H5F_ACC_RDONLY, H5P_DEFAULT );
if ( fid < 0 ) NADC_GOTO_ERROR( NADC_ERR_HDF_FILE, dbName->s );
if ( (data_id = H5Dopen( fid, "ClusDef", H5P_DEFAULT )) < 0 )
NADC_GOTO_ERROR( NADC_ERR_HDF_DATA, "ClusDef" );
if ( (type_id = H5Dget_type( data_id )) < 0 )
NADC_GOTO_ERROR( NADC_ERR_HDF_DTYPE, "ClusDef" );
if ( H5LTread_dataset( fid, "ClusDef", type_id, ClusDef ) < 0 )
NADC_GOTO_ERROR( NADC_ERR_HDF_RD, "ClusDef" );
(void) H5Tclose( type_id );
(void) H5Dclose( data_id );
(void) H5Fclose( fid );
return 1;
done:
H5E_BEGIN_TRY {
(void) H5Tclose( type_id );
(void) H5Dclose( data_id );
(void) H5Fclose( fid );
} H5E_END_TRY;
return -1;
}
CXI_Dataset * cxi_open_dataset(CXI_Dataset_Reference * ref){
cxi_debug("opening dataset");
if(!ref){
return NULL;
}
cxi_debug("opening dataset");
CXI_Dataset * dataset = calloc(sizeof(CXI_Dataset),1);
if(!dataset){
return NULL;
}
dataset->handle = H5Dopen(ref->parent_handle,ref->group_name,H5P_DEFAULT);
hid_t s = H5Dget_space(dataset->handle);
dataset->dimension_count = H5Sget_simple_extent_ndims(s);
dataset->dimensions = calloc(sizeof(hsize_t),dataset->dimension_count);
H5Sget_simple_extent_dims(s,dataset->dimensions,NULL);
dataset->data_type = H5Dget_type(dataset->handle);
ref->dataset = dataset;
return dataset;
}
void print_trial_info(hid_t trial,int num_trial) {
char string_data[512];
hid_t string_type = H5Tcopy(H5T_C_S1);
size_t string_size = 512;
H5Tset_size(string_type,string_size);
printf("Trial #%d\n",num_trial);
hid_t data = H5Dopen(trial,"Date",H5P_DEFAULT);
H5Dread(data,string_type,H5S_ALL,H5S_ALL,H5P_DEFAULT,string_data);
H5Dclose(data);
printf("\tDate: %s\n",string_data);
data = H5Dopen(trial,"Synchronous Data/Channel Data",H5P_DEFAULT);
hsize_t nchans = H5Tget_size(H5Dget_type(data))/sizeof(double);
H5Dclose(data);
data = H5PTopen(trial,"Synchronous Data/Channel Data");
hsize_t nsamples;
H5PTget_num_packets(data,&nsamples);
printf("\t%llu Channels X %llu samples\n",nchans,nsamples);
for(int i=1;i<=nchans;++i) {
std::stringstream channel_name;
channel_name << "Synchronous Data/Channel " << i << " Name";
data = H5Dopen(trial,channel_name.str().c_str(),H5P_DEFAULT);
H5Dread(data,string_type,H5S_ALL,H5S_ALL,H5P_DEFAULT,string_data);
H5Dclose(data);
printf("\t\t#%d: %s\n",i,string_data);
}
printf("\n");
}
int main(void)
{
hid_t file_id, prop_id, memspace_id, type_id;
hid_t group_id;
hid_t dataset_id, dataspace_id;
herr_t status;
hsize_t dims[1];
hsize_t maxdims[1];
float data[NPOINTS];
float floatval;
unsigned numdataobj = 0;
unsigned i, j;
char name[80];
hsize_t start[1] = {0};
hsize_t stride[1] = {1};
hsize_t count[1] = {1};
/* Create a file */
file_id = H5Fcreate(FILEN, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);
/* Create a dataset to hold the number of data objects */
/* Create the data space */
dataspace_id = H5Screate(H5S_SCALAR);
/* Create dataset */
dataset_id = H5Dcreate2(file_id, "/NumDataObj",
H5T_NATIVE_UINT, dataspace_id, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
/* Write value to NumDataObj dataset */
status = H5Dwrite(dataset_id, H5T_NATIVE_UINT, H5S_ALL,
H5S_ALL, H5P_DEFAULT, &numdataobj);
/* Close the identifiers */
status = H5Dclose(dataset_id);
status = H5Sclose(dataspace_id);
/* Create extendible arrays */
/* Set up for extendible dataset */
prop_id = H5Pcreate(H5P_DATASET_CREATE);
dims[0] = CHUNK_SIZE;
status = H5Pset_chunk(prop_id, 1, dims);
/* Create dataspace */
dims[0]=1;
maxdims[0]=H5S_UNLIMITED;
dataspace_id = H5Screate_simple(1, dims, maxdims);
for(i=0; i<NEXTARRAYS; i++)
{
/* Create dataset */
sprintf(name, "/ExtArray%06d", i);
dataset_id = H5Dcreate2(file_id, name,
H5T_NATIVE_FLOAT, dataspace_id, H5P_DEFAULT, prop_id, H5P_DEFAULT);
/* Close the identifier */
status = H5Dclose(dataset_id);
}
/* Close the identifiers */
status = H5Sclose(dataspace_id);
status = H5Pclose(prop_id);
/* Create group to hold data object data arrays */
group_id = H5Gcreate2(file_id, "/DataArray", H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
H5Gclose(group_id);
for(j=0; j<NDATAOBJECTS; j++)
{
printf("\rWriting Object #%d of %d", j+1, NDATAOBJECTS);
fflush(stdout);
floatval = (float)j;
/* Create group to hold data arrays for this object */
sprintf(name, "/DataArray/%06d", j);
group_id = H5Gcreate2(file_id, name, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
if(group_id < 0) {
fprintf(stderr, "Failed to create DataArray group.\n");
status = H5Fclose(file_id);
return -1;
}
/* Loop over data arrays */
for(i=0; i<NDATAARRAYS; i++)
{
/* Create dataspace */
dims[0]=NPOINTS;
maxdims[0]=NPOINTS;
dataspace_id = H5Screate_simple(1 ,dims, maxdims);
/* Create dataset */
sprintf(name, "DataArray%06d", i);
dataset_id = H5Dcreate2(group_id, name,
H5T_NATIVE_FLOAT, dataspace_id, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
if(dataset_id < 0) {
fprintf(stderr, "Failed to create DataArray dataset.\n");
status = H5Fclose(file_id);
return -1;
}
/* Write the data array data */
status = H5Dwrite(dataset_id, H5T_NATIVE_FLOAT, H5S_ALL,
H5S_ALL, H5P_DEFAULT, data);
if(status < 0) {
fprintf(stderr, "Failed to write DataArray dataset.\n");
status = H5Fclose(file_id);
return -1;
}
/* Close the identifiers */
status = H5Dclose(dataset_id);
status = H5Sclose(dataspace_id);
}
/* Open NumDataObj dataset */
dataset_id = H5Dopen2(file_id, "/NumDataObj", H5P_DEFAULT);
if(dataset_id < 0) {
fprintf(stderr, "Failed to open NumDataObj dataset.\n");
status = H5Fclose(file_id);
return -1;
}
/* Write value to NumDataObj dataset */
numdataobj = j + 1;
status = H5Dwrite(dataset_id, H5T_NATIVE_UINT, H5S_ALL,
H5S_ALL, H5P_DEFAULT, &numdataobj);
if(status < 0) {
fprintf(stderr, "Failed to write NumDataObj dataset.\n");
status = H5Fclose(file_id);
return -1;
}
/* Close identifiers */
status = H5Dclose(dataset_id);
status = H5Gclose(group_id);
/* Extend attribute arrays */
for(i = 0; i < NEXTARRAYS; i++) {
/* Open extendable dataset */
sprintf(name, "/ExtArray%06d", i);
dataset_id = H5Dopen2(file_id, name, H5P_DEFAULT);
if(dataset_id < 0) {
fprintf(stderr, "Failed to open ExtArray dataset.\n");
status = H5Fclose(file_id);
return -1;
} /* end if */
/* Extend attribute dataset */
dims[0] = (hsize_t)j + 1;
status = H5Dset_extent(dataset_id, dims);
if(status < 0) {
fprintf(stderr, "Failed to extend DataArray dataset.\n");
status = H5Fclose(file_id);
return -1;
} /* end if */
/* Select element and write value to attribute dataset */
dims[0] = 1;
memspace_id = H5Screate_simple(1, dims, dims);
dataspace_id = H5Dget_space(dataset_id);
type_id = H5Dget_type(dataset_id);
start[0] = 0;
status = H5Sselect_hyperslab(memspace_id, H5S_SELECT_SET,
start, stride, count, NULL);
start[0] = (hssize_t)j;
status = H5Sselect_hyperslab(dataspace_id, H5S_SELECT_SET,
start, stride, count, NULL);
status = H5Dwrite(dataset_id, type_id, memspace_id,
dataspace_id, H5P_DEFAULT, &floatval);
if(status < 0)
{
fprintf(stderr, "Failed to write DataArray dataset.\n");
status = H5Fclose(file_id);
return -1;
}
/* Close identifiers */
status = H5Tclose(type_id);
status = H5Sclose(dataspace_id);
status = H5Sclose(memspace_id);
status = H5Dclose(dataset_id);
}
}
/* Close the file */
status = H5Fclose(file_id);
printf("\n");
return 0;
}
int do_copy_refobjs(hid_t fidin,
hid_t fidout,
trav_table_t *travt,
pack_opt_t *options) /* repack options */
{
hid_t grp_in=(-1); /* read group ID */
hid_t grp_out=(-1); /* write group ID */
hid_t dset_in=(-1); /* read dataset ID */
hid_t dset_out=(-1); /* write dataset ID */
hid_t type_in=(-1); /* named type ID */
hid_t dcpl_id=(-1); /* dataset creation property list ID */
hid_t space_id=(-1); /* space ID */
hid_t ftype_id=(-1); /* file data type ID */
hid_t mtype_id=(-1); /* memory data type ID */
size_t msize; /* memory size of memory type */
hsize_t nelmts; /* number of elements in dataset */
int rank; /* rank of dataset */
hsize_t dims[H5S_MAX_RANK]; /* dimensions of dataset */
unsigned int i, j;
int k;
/*-------------------------------------------------------------------------
* browse
*-------------------------------------------------------------------------
*/
for ( i = 0; i < travt->nobjs; i++)
{
switch ( travt->objs[i].type )
{
/*-------------------------------------------------------------------------
* H5G_GROUP
*-------------------------------------------------------------------------
*/
case H5G_GROUP:
/*-------------------------------------------------------------------------
* copy referenced objects in attributes
*-------------------------------------------------------------------------
*/
if ((grp_out=H5Gopen(fidout,travt->objs[i].name))<0)
goto error;
if((grp_in = H5Gopen (fidin,travt->objs[i].name))<0)
goto error;
if (copy_refs_attr(grp_in,grp_out,options,travt,fidout)<0)
goto error;
if (H5Gclose(grp_out)<0)
goto error;
if (H5Gclose(grp_in)<0)
goto error;
/*-------------------------------------------------------------------------
* check for hard links
*-------------------------------------------------------------------------
*/
if (travt->objs[i].nlinks)
{
for ( j=0; j<travt->objs[i].nlinks; j++)
{
H5Glink(fidout,
H5G_LINK_HARD,
travt->objs[i].name,
travt->objs[i].links[j].new_name);
}
}
break;
/*-------------------------------------------------------------------------
* H5G_DATASET
*-------------------------------------------------------------------------
*/
case H5G_DATASET:
if ((dset_in=H5Dopen(fidin,travt->objs[i].name))<0)
goto error;
if ((space_id=H5Dget_space(dset_in))<0)
goto error;
if ((ftype_id=H5Dget_type (dset_in))<0)
goto error;
if ((dcpl_id=H5Dget_create_plist(dset_in))<0)
goto error;
if ( (rank=H5Sget_simple_extent_ndims(space_id))<0)
goto error;
if ( H5Sget_simple_extent_dims(space_id,dims,NULL)<0)
goto error;
nelmts=1;
for (k=0; k<rank; k++)
nelmts*=dims[k];
if ((mtype_id=h5tools_get_native_type(ftype_id))<0)
goto error;
if ((msize=H5Tget_size(mtype_id))==0)
goto error;
/*-------------------------------------------------------------------------
* check if the dataset creation property list has filters that
* are not registered in the current configuration
* 1) the external filters GZIP and SZIP might not be available
* 2) the internal filters might be turned off
*-------------------------------------------------------------------------
*/
if (h5tools_canreadf((NULL),dcpl_id)==1)
{
/*-------------------------------------------------------------------------
* test for a valid output dataset
*-------------------------------------------------------------------------
*/
dset_out = FAIL;
/*-------------------------------------------------------------------------
* object references are a special case
* we cannot just copy the buffers, but instead we recreate the reference
*-------------------------------------------------------------------------
*/
if (H5Tequal(mtype_id, H5T_STD_REF_OBJ))
{
H5G_obj_t1 obj_type;
hid_t refobj_id;
hobj_ref_t *refbuf=NULL; /* buffer for object references */
hobj_ref_t *buf=NULL;
const char* refname;
unsigned u;
/*-------------------------------------------------------------------------
* read to memory
*-------------------------------------------------------------------------
*/
if (nelmts)
{
buf=(void *) HDmalloc((unsigned)(nelmts*msize));
if ( buf==NULL){
printf( "cannot read into memory\n" );
goto error;
}
if (H5Dread(dset_in,mtype_id,H5S_ALL,H5S_ALL,H5P_DEFAULT,buf)<0)
goto error;
if ((obj_type = H5Rget_obj_type(dset_in,H5R_OBJECT,buf))<0)
goto error;
refbuf=HDcalloc((unsigned)nelmts,msize);
if ( refbuf==NULL){
printf( "cannot allocate memory\n" );
goto error;
}
for ( u=0; u<nelmts; u++)
{
H5E_BEGIN_TRY {
if ((refobj_id = H5Rdereference(dset_in,H5R_OBJECT,&buf[u]))<0)
continue;
} H5E_END_TRY;
/* get the name. a valid name could only occur in the
second traversal of the file */
if ((refname=MapIdToName(refobj_id,travt))!=NULL)
{
/* create the reference, -1 parameter for objects */
if (H5Rcreate(&refbuf[u],fidout,refname,H5R_OBJECT,-1)<0)
goto error;
if(options->verbose)
{
printf(FORMAT_OBJ,"dset",travt->objs[i].name );
printf("object <%s> object reference created to <%s>\n",
travt->objs[i].name,
refname);
}
}/*refname*/
close_obj(obj_type,refobj_id);
}/* u */
}/*nelmts*/
/*-------------------------------------------------------------------------
* create/write dataset/close
*-------------------------------------------------------------------------
*/
if ((dset_out=H5Dcreate(fidout,travt->objs[i].name,mtype_id,space_id,dcpl_id))<0)
goto error;
if (nelmts) {
if (H5Dwrite(dset_out,mtype_id,H5S_ALL,H5S_ALL,H5P_DEFAULT,refbuf)<0)
goto error;
}
if (buf)
free(buf);
if (refbuf)
free(refbuf);
}/*H5T_STD_REF_OBJ*/
/*-------------------------------------------------------------------------
* dataset region references
*-------------------------------------------------------------------------
*/
else if (H5Tequal(mtype_id, H5T_STD_REF_DSETREG))
{
H5G_obj_t1 obj_type;
hid_t refobj_id;
hdset_reg_ref_t *refbuf=NULL; /* input buffer for region references */
hdset_reg_ref_t *buf=NULL; /* output buffer */
const char* refname;
unsigned u;
/*-------------------------------------------------------------------------
* read input to memory
*-------------------------------------------------------------------------
*/
if (nelmts)
{
buf=(void *) HDmalloc((unsigned)(nelmts*msize));
if ( buf==NULL){
printf( "cannot read into memory\n" );
goto error;
}
if (H5Dread(dset_in,mtype_id,H5S_ALL,H5S_ALL,H5P_DEFAULT,buf)<0)
goto error;
if ((obj_type = H5Rget_obj_type(dset_in,H5R_DATASET_REGION,buf))<0)
goto error;
/*-------------------------------------------------------------------------
* create output
*-------------------------------------------------------------------------
*/
refbuf=HDcalloc(sizeof(hdset_reg_ref_t),(size_t)nelmts); /*init to zero */
if ( refbuf==NULL){
printf( "cannot allocate memory\n" );
goto error;
}
for ( u=0; u<nelmts; u++)
{
H5E_BEGIN_TRY {
if ((refobj_id = H5Rdereference(dset_in,H5R_DATASET_REGION,&buf[u]))<0)
continue;
} H5E_END_TRY;
/* get the name. a valid name could only occur in the
second traversal of the file */
if ((refname=MapIdToName(refobj_id,travt))!=NULL)
{
hid_t region_id; /* region id of the referenced dataset */
if ((region_id = H5Rget_region(dset_in,H5R_DATASET_REGION,&buf[u]))<0)
goto error;
/* create the reference, we need the space_id */
if (H5Rcreate(&refbuf[u],fidout,refname,H5R_DATASET_REGION,region_id)<0)
goto error;
if (H5Sclose(region_id)<0)
goto error;
if(options->verbose)
{
printf(FORMAT_OBJ,"dset",travt->objs[i].name );
printf("object <%s> region reference created to <%s>\n",
travt->objs[i].name,
refname);
}
}/*refname*/
close_obj(obj_type,refobj_id);
}/* u */
}/*nelmts*/
/*-------------------------------------------------------------------------
* create/write dataset/close
*-------------------------------------------------------------------------
*/
if ((dset_out=H5Dcreate(fidout,travt->objs[i].name,mtype_id,space_id,dcpl_id))<0)
goto error;
if (nelmts) {
if (H5Dwrite(dset_out,mtype_id,H5S_ALL,H5S_ALL,H5P_DEFAULT,refbuf)<0)
goto error;
}
if (buf)
free(buf);
if (refbuf)
free(refbuf);
} /* H5T_STD_REF_DSETREG */
/*-------------------------------------------------------------------------
* not references, open previously created object in 1st traversal
*-------------------------------------------------------------------------
*/
else
{
if ((dset_out=H5Dopen(fidout,travt->objs[i].name))<0)
goto error;
}
assert(dset_out!=FAIL);
/*-------------------------------------------------------------------------
* copy referenced objects in attributes
*-------------------------------------------------------------------------
*/
if (copy_refs_attr(dset_in,dset_out,options,travt,fidout)<0)
goto error;
/*-------------------------------------------------------------------------
* check for hard links
*-------------------------------------------------------------------------
*/
if (travt->objs[i].nlinks)
{
for ( j=0; j<travt->objs[i].nlinks; j++){
H5Glink(fidout,
H5G_LINK_HARD,
travt->objs[i].name,
travt->objs[i].links[j].new_name);
}
}
if (H5Dclose(dset_out)<0)
goto error;
}/*can_read*/
