// expose restart2 to python
void read_solution(char * filename, mcomplex * C_ptr)
{
extern int qpts, dimR, dimQ, Nx, Nz;
extern mcomplex ****U, ****C;
extern mcomplex ****IU, ****IC;
int x, y, z;
hid_t file_id1, dataset_a, dataset_b; /* file identifier */
hid_t dataset_ia, dataset_ib;
hid_t complex_id;
/* define compound datatype for the complex number */
typedef struct {
double re; /*real part */
double im; /*imaginary part */
} complex_t;
complex_id = H5Tcreate(H5T_COMPOUND, sizeof(complex_t));
H5Tinsert(complex_id, "real", HOFFSET(complex_t, re),
H5T_NATIVE_DOUBLE);
H5Tinsert(complex_id, "imaginary", HOFFSET(complex_t, im),
H5T_NATIVE_DOUBLE);
/* define some temporal matrix to store the data to the hdf file */
complex_t Matrix1[dimR][Nz][Nx / 2];
complex_t Matrix2[dimR][Nz][Nx / 2];
complex_t IMatrix1[dimR][Nz][Nx / 2];
complex_t IMatrix2[dimR][Nz][Nx / 2];
// open the file and dataset
file_id1 = H5Fopen(filename, H5F_ACC_RDONLY, H5P_DEFAULT);
dataset_a = H5Dopen1(file_id1, "/data_alpha");
dataset_b = H5Dopen1(file_id1, "/data_beta");
dataset_ia = H5Dopen1(file_id1, "/data_ialpha");
dataset_ib = H5Dopen1(file_id1, "/data_ibeta");
assert(EXIT_SUCCESS ==
H5Dread(dataset_a, complex_id, H5S_ALL, H5S_ALL, H5P_DEFAULT,
Matrix1));
assert(EXIT_SUCCESS ==
H5Dread(dataset_b, complex_id, H5S_ALL, H5S_ALL, H5P_DEFAULT,
Matrix2));
assert(EXIT_SUCCESS ==
H5Dread(dataset_ia, complex_id, H5S_ALL, H5S_ALL, H5P_DEFAULT,
IMatrix1));
assert(EXIT_SUCCESS ==
H5Dread(dataset_ib, complex_id, H5S_ALL, H5S_ALL, H5P_DEFAULT,
IMatrix2));
assert(EXIT_SUCCESS == H5Dclose(dataset_a));
assert(EXIT_SUCCESS == H5Dclose(dataset_b));
assert(EXIT_SUCCESS == H5Dclose(dataset_ia));
assert(EXIT_SUCCESS == H5Dclose(dataset_ib));
assert(EXIT_SUCCESS == H5Fclose(file_id1));
for (y = 0; y < dimR; y++) {
for (z = 0; z < Nz; ++z) {
for (x = 0; x < Nx / 2; ++x) {
Re(C[z][ALPHA][y][x]) = Matrix1[y][z][x].re;
Im(C[z][ALPHA][y][x]) = Matrix1[y][z][x].im;
Re(C[z][BETA][y][x]) = Matrix2[y][z][x].re;
Im(C[z][BETA][y][x]) = Matrix2[y][z][x].im;
Re(IC[z][ALPHA][y][x]) = IMatrix1[y][z][x].re;
Im(IC[z][ALPHA][y][x]) = IMatrix1[y][z][x].im;
Re(IC[z][BETA][y][x]) = IMatrix2[y][z][x].re;
Im(IC[z][BETA][y][x]) = IMatrix2[y][z][x].im;
}
}
}
/* compute ux hat, uy hat, uz hat given alpha, beta,. */
initAlphaBeta2();
/* compute the boundary condition for previous stage or time step,
result is stored in Uxb and Uzb */
if (increBoundary() != NO_ERR) {
printf("increBoundary failure\n");
}
/* compute iux, iuy, iuz given i-alpha, i-beta */
incre_initAlphaBeta2();
memset(U[Nz / 2][0][0], 0, 5 * qpts * (Nx / 2) * sizeof(mcomplex));
memset(IU[Nz / 2][0][0], 0, 5 * qpts * (Nx / 2) * sizeof(mcomplex));
memmove(C_ptr, C[0][0][0], Nz * 2 * dimR * (Nx / 2) * sizeof(mcomplex));
}
void pyne::Material::_load_comp_protocol1(hid_t db, std::string datapath, int row) {
std::string nucpath;
hid_t data_set = H5Dopen2(db, datapath.c_str(), H5P_DEFAULT);
hsize_t data_offset[1] = {row};
if (row < 0) {
// Handle negative row indices
hid_t data_space = H5Dget_space(data_set);
hsize_t data_dims[1];
H5Sget_simple_extent_dims(data_space, data_dims, NULL);
data_offset[0] += data_dims[0];
};
// Grab the nucpath
hid_t nuc_attr = H5Aopen(data_set, "nucpath", H5P_DEFAULT);
H5A_info_t nuc_info;
H5Aget_info(nuc_attr, &nuc_info);
hsize_t nuc_attr_len = nuc_info.data_size;
hid_t str_attr = H5Tcopy(H5T_C_S1);
H5Tset_size(str_attr, nuc_attr_len);
char * nucpathbuf = new char [nuc_attr_len];
H5Aread(nuc_attr, str_attr, nucpathbuf);
nucpath = std::string(nucpathbuf, nuc_attr_len);
delete[] nucpathbuf;
// Grab the nuclides
std::vector<int> nuclides = h5wrap::h5_array_to_cpp_vector_1d<int>(db, nucpath, H5T_NATIVE_INT);
int nuc_size = nuclides.size();
hsize_t nuc_dims[1] = {nuc_size};
// Get the data hyperslab
hid_t data_hyperslab = H5Dget_space(data_set);
hsize_t data_count[1] = {1};
H5Sselect_hyperslab(data_hyperslab, H5S_SELECT_SET, data_offset, NULL, data_count, NULL);
// Get memory space for writing
hid_t mem_space = H5Screate_simple(1, data_count, NULL);
// Get material type
size_t material_struct_size = sizeof(pyne::material_struct) + sizeof(double)*nuc_size;
hid_t desc = H5Tcreate(H5T_COMPOUND, material_struct_size);
hid_t comp_values_array_type = H5Tarray_create2(H5T_NATIVE_DOUBLE, 1, nuc_dims);
// make the data table type
H5Tinsert(desc, "mass", HOFFSET(pyne::material_struct, mass), H5T_NATIVE_DOUBLE);
H5Tinsert(desc, "density", HOFFSET(pyne::material_struct, density),
H5T_NATIVE_DOUBLE);
H5Tinsert(desc, "atoms_per_molecule", HOFFSET(pyne::material_struct, atoms_per_mol),
H5T_NATIVE_DOUBLE);
H5Tinsert(desc, "comp", HOFFSET(pyne::material_struct, comp), comp_values_array_type);
// make the data array, have to over-allocate
material_struct * mat_data = new material_struct [material_struct_size];
// Finally, get data and put in on this instance
H5Dread(data_set, desc, mem_space, data_hyperslab, H5P_DEFAULT, mat_data);
mass = (*mat_data).mass;
density = (*mat_data).density;
atoms_per_molecule = (*mat_data).atoms_per_mol;
for (int i = 0; i < nuc_size; i++)
comp[nuclides[i]] = (double) (*mat_data).comp[i];
delete[] mat_data;
H5Tclose(str_attr);
//
// Get metadata from associated dataset, if available
//
std::string attrpath = datapath + "_metadata";
bool attrpath_exists = h5wrap::path_exists(db, attrpath);
if (!attrpath_exists)
return;
hid_t metadatapace, attrtype, metadataet, metadatalab, attrmemspace;
int attrrank;
hvl_t attrdata [1];
attrtype = H5Tvlen_create(H5T_NATIVE_CHAR);
// Get the metadata from the file
metadataet = H5Dopen2(db, attrpath.c_str(), H5P_DEFAULT);
metadatalab = H5Dget_space(metadataet);
H5Sselect_hyperslab(metadatalab, H5S_SELECT_SET, data_offset, NULL, data_count, NULL);
attrmemspace = H5Screate_simple(1, data_count, NULL);
H5Dread(metadataet, attrtype, attrmemspace, metadatalab, H5P_DEFAULT, attrdata);
// convert to in-memory JSON
Json::Reader reader;
reader.parse((char *) attrdata[0].p, (char *) attrdata[0].p+attrdata[0].len, metadata, false);
// close attr data objects
H5Fflush(db, H5F_SCOPE_GLOBAL);
H5Dclose(metadataet);
H5Sclose(metadatapace);
H5Tclose(attrtype);
// Close out the HDF5 file
H5Fclose(db);
};
int
add_attrs(hid_t objid)
{
hid_t scalar_spaceid = -1;
hid_t vlstr_typeid = -1, fixstr_typeid = -1;
char *vlstr;
hid_t attid = -1;
/* Create scalar dataspace */
if ((scalar_spaceid = H5Screate(H5S_SCALAR)) < 0) ERR_GOTO;
/* Create string datatypes */
if ((vlstr_typeid = H5Tcreate(H5T_STRING, (size_t)H5T_VARIABLE)) < 0) ERR_GOTO;
if ((fixstr_typeid = H5Tcreate(H5T_STRING, (size_t)10)) < 0) ERR_GOTO;
/* Create attribute with VL string datatype on object */
if ((attid = H5Acreate2(objid, VSTR_ATT1_NAME, vlstr_typeid, scalar_spaceid, H5P_DEFAULT, H5P_DEFAULT)) < 0) ERR_GOTO;
/* No write, use fill value */
if (H5Aclose(attid) < 0) ERR_GOTO;
/* Create attribute with VL string datatype on object */
if ((attid = H5Acreate2(objid, VSTR_ATT2_NAME, vlstr_typeid, scalar_spaceid, H5P_DEFAULT, H5P_DEFAULT)) < 0) ERR_GOTO;
vlstr = NULL;
if (H5Awrite(attid, vlstr_typeid, &vlstr) < 0) ERR_GOTO;
if (H5Aclose(attid) < 0) ERR_GOTO;
/* Create attribute with VL string datatype on object */
if ((attid = H5Acreate2(objid, VSTR_ATT3_NAME, vlstr_typeid, scalar_spaceid, H5P_DEFAULT, H5P_DEFAULT)) < 0) ERR_GOTO;
vlstr = malloc(10);
*vlstr = '\0';
if (H5Awrite(attid, vlstr_typeid, &vlstr) < 0) ERR_GOTO;
if (H5Aclose(attid) < 0) ERR_GOTO;
/* Create attribute with VL string datatype on object */
if ((attid = H5Acreate2(objid, VSTR_ATT4_NAME, vlstr_typeid, scalar_spaceid, H5P_DEFAULT, H5P_DEFAULT)) < 0) ERR_GOTO;
strcpy(vlstr, "foo");
if (H5Awrite(attid, vlstr_typeid, &vlstr) < 0) ERR_GOTO;
free(vlstr);
if (H5Aclose(attid) < 0) ERR_GOTO;
/* Create attribute with fixed-length string datatype on object */
if ((attid = H5Acreate2(objid, FSTR_ATT_NAME, fixstr_typeid, scalar_spaceid, H5P_DEFAULT, H5P_DEFAULT)) < 0) ERR_GOTO;
if (H5Aclose(attid) < 0) ERR_GOTO;
/* Create attribute with native integer datatype on object */
if ((attid = H5Acreate2(objid, INT_ATT_NAME, H5T_NATIVE_INT, scalar_spaceid, H5P_DEFAULT, H5P_DEFAULT)) < 0) ERR_GOTO;
if (H5Aclose(attid) < 0) ERR_GOTO;
/* Clean up objects created */
if (H5Sclose(scalar_spaceid) < 0) ERR_GOTO;
if (H5Tclose(vlstr_typeid) < 0) ERR_GOTO;
if (H5Tclose(fixstr_typeid) < 0) ERR_GOTO;
return(0);
error:
H5E_BEGIN_TRY {
H5Aclose(attid);
H5Sclose(scalar_spaceid);
H5Tclose(vlstr_typeid);
H5Tclose(fixstr_typeid);
} H5E_END_TRY;
return(-1);
}
int
main (void)
{
hid_t file, filetype, memtype, strtype, space, dset;
/* Handles */
herr_t status;
hsize_t dims[1] = {DIM0};
sensor_t wdata[DIM0], /* Write buffer */
*rdata; /* Read buffer */
int ndims,
i;
/*
* Initialize data.
*/
wdata[0].serial_no = 1153;
wdata[0].location = "Exterior (static)";
wdata[0].temperature = 53.23;
wdata[0].pressure = 24.57;
wdata[1].serial_no = 1184;
wdata[1].location = "Intake";
wdata[1].temperature = 55.12;
wdata[1].pressure = 22.95;
wdata[2].serial_no = 1027;
wdata[2].location = "Intake manifold";
wdata[2].temperature = 103.55;
wdata[2].pressure = 31.23;
wdata[3].serial_no = 1313;
wdata[3].location = "Exhaust manifold";
wdata[3].temperature = 1252.89;
wdata[3].pressure = 84.11;
/*
* Create a new file using the default properties.
*/
file = H5Fcreate (FILE, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);
/*
* Create variable-length string datatype.
*/
strtype = H5Tcopy (H5T_C_S1);
status = H5Tset_size (strtype, H5T_VARIABLE);
/*
* Create the compound datatype for memory.
*/
memtype = H5Tcreate (H5T_COMPOUND, sizeof (sensor_t));
status = H5Tinsert (memtype, "Serial number",
HOFFSET (sensor_t, serial_no), H5T_NATIVE_INT);
status = H5Tinsert (memtype, "Location", HOFFSET (sensor_t, location),
strtype);
status = H5Tinsert (memtype, "Temperature (F)",
HOFFSET (sensor_t, temperature), H5T_NATIVE_DOUBLE);
status = H5Tinsert (memtype, "Pressure (inHg)",
HOFFSET (sensor_t, pressure), H5T_NATIVE_DOUBLE);
/*
* Create the compound datatype for the file. Because the standard
* types we are using for the file may have different sizes than
* the corresponding native types, we must manually calculate the
* offset of each member.
*/
filetype = H5Tcreate (H5T_COMPOUND, 8 + sizeof (hvl_t) + 8 + 8);
status = H5Tinsert (filetype, "Serial number", 0, H5T_STD_I64BE);
status = H5Tinsert (filetype, "Location", 8, strtype);
status = H5Tinsert (filetype, "Temperature (F)", 8 + sizeof (hvl_t),
H5T_IEEE_F64BE);
status = H5Tinsert (filetype, "Pressure (inHg)", 8 + sizeof (hvl_t) + 8,
H5T_IEEE_F64BE);
/*
* Create dataspace. Setting maximum size to NULL sets the maximum
* size to be the current size.
*/
space = H5Screate_simple (1, dims, NULL);
/*
* Create the dataset and write the compound data to it.
*/
dset = H5Dcreate (file, DATASET, filetype, space, H5P_DEFAULT);
status = H5Dwrite (dset, memtype, H5S_ALL, H5S_ALL, H5P_DEFAULT, wdata);
/*
* Close and release resources.
*/
status = H5Dclose (dset);
status = H5Sclose (space);
status = H5Tclose (filetype);
status = H5Fclose (file);
/*
* Now we begin the read section of this example. Here we assume
* the dataset has the same name and rank, but can have any size.
* Therefore we must allocate a new array to read in data using
* malloc(). For simplicity, we do not rebuild memtype.
*/
/*
* Open file and dataset.
*/
file = H5Fopen (FILE, H5F_ACC_RDONLY, H5P_DEFAULT);
dset = H5Dopen (file, DATASET);
/*
* Get dataspace and allocate memory for read buffer.
*/
space = H5Dget_space (dset);
ndims = H5Sget_simple_extent_dims (space, dims, NULL);
rdata = (sensor_t *) malloc (dims[0] * sizeof (sensor_t));
/*
* Read the data.
*/
status = H5Dread (dset, memtype, H5S_ALL, H5S_ALL, H5P_DEFAULT, rdata);
/*
* Output the data to the screen.
*/
for (i=0; i<dims[0]; i++) {
printf ("%s[%d]:\n", DATASET, i);
printf ("Serial number : %d\n", rdata[i].serial_no);
printf ("Location : %s\n", rdata[i].location);
printf ("Temperature (F) : %f\n", rdata[i].temperature);
printf ("Pressure (inHg) : %f\n\n", rdata[i].pressure);
}
/*
* Close and release resources. H5Dvlen_reclaim will automatically
* traverse the structure and free any vlen data (strings in this
* case).
*/
status = H5Dvlen_reclaim (memtype, space, H5P_DEFAULT, rdata);
free (rdata);
status = H5Dclose (dset);
status = H5Sclose (space);
status = H5Tclose (memtype);
status = H5Tclose (strtype);
status = H5Fclose (file);
return 0;
}
extern int acct_gather_profile_p_create_dataset(
const char* name, int parent, acct_gather_profile_dataset_t *dataset)
{
size_t type_size;
size_t offset, field_size;
hid_t dtype_id;
hid_t field_id;
hid_t table_id;
acct_gather_profile_dataset_t *dataset_loc = dataset;
if (g_profile_running <= ACCT_GATHER_PROFILE_NONE)
return SLURM_ERROR;
debug("acct_gather_profile_p_create_dataset %s", name);
/* compute the size of the type needed to create the table */
type_size = sizeof(uint64_t) * 2; /* size for time field */
while (dataset_loc && (dataset_loc->type != PROFILE_FIELD_NOT_SET)) {
switch (dataset_loc->type) {
case PROFILE_FIELD_UINT64:
type_size += sizeof(uint64_t);
break;
case PROFILE_FIELD_DOUBLE:
type_size += sizeof(double);
break;
case PROFILE_FIELD_NOT_SET:
break;
}
dataset_loc++;
}
/* create the datatype for the dataset */
if ((dtype_id = H5Tcreate(H5T_COMPOUND, type_size)) < 0) {
debug3("PROFILE: failed to create datatype for table %s",
name);
return SLURM_ERROR;
}
/* insert fields */
if (H5Tinsert(dtype_id, "ElapsedTime", 0,
H5T_NATIVE_UINT64) < 0)
return SLURM_ERROR;
if (H5Tinsert(dtype_id, "EpochTime", sizeof(uint64_t),
H5T_NATIVE_UINT64) < 0)
return SLURM_ERROR;
dataset_loc = dataset;
offset = sizeof(uint64_t) * 2;
while (dataset_loc && (dataset_loc->type != PROFILE_FIELD_NOT_SET)) {
switch (dataset_loc->type) {
case PROFILE_FIELD_UINT64:
field_id = H5T_NATIVE_UINT64;
field_size = sizeof(uint64_t);
break;
case PROFILE_FIELD_DOUBLE:
field_id = H5T_NATIVE_DOUBLE;
field_size = sizeof(double);
break;
case PROFILE_FIELD_NOT_SET:
break;
}
if (H5Tinsert(dtype_id, dataset_loc->name,
offset, field_id) < 0)
return SLURM_ERROR;
offset += field_size;
dataset_loc++;
}
/* create the table */
if (parent < 0)
parent = gid_node; /* default parent is the node group */
table_id = H5PTcreate_fl(parent, name, dtype_id, HDF5_CHUNK_SIZE,
HDF5_COMPRESS);
if (table_id < 0) {
error("PROFILE: Impossible to create the table %s", name);
H5Tclose(dtype_id);
return SLURM_ERROR;
}
H5Tclose(dtype_id); /* close the datatype since H5PT keeps a copy */
/* resize the tables array if full */
if (tables_cur_len == tables_max_len) {
if (tables_max_len == 0)
++tables_max_len;
tables_max_len *= 2;
tables = xrealloc(tables, tables_max_len * sizeof(table_t));
}
/* reserve a new table */
tables[tables_cur_len].table_id = table_id;
tables[tables_cur_len].type_size = type_size;
++tables_cur_len;
return tables_cur_len - 1;
}
void UPCdata::writeHDFfile(char* filename){
#if HDF5_AVAILABLE == 1
#define NRECORDS 50
//const int NRECORDS=samples.size();
const int NFIELDS = 5;
hsize_t chunk_size = 10; // ??
typedef struct _samplestruct{
float data[1020]; // having difficulties here; dynamic allocation?
float concentrations[3];
int samplenr;
int set;
int compoundnr;
}samplestruct_t;
cout << "converting data format" << endl;
samplestruct_t* sampledata=NULL;
sampledata=new samplestruct_t[NRECORDS];
for(int i=0;i<NRECORDS;i++){
for(int j=0;j<1020;j++)
sampledata[i].data[j]=samples[i].data[j];
sampledata[i].concentrations[0]=samples[i].concentrations[0];
sampledata[i].concentrations[1]=samples[i].concentrations[1];
sampledata[i].concentrations[2]=samples[i].concentrations[2];
sampledata[i].samplenr=samples[i].samplenr;
sampledata[i].set=samples[i].set;
sampledata[i].compoundnr=samples[i].compoundnr;
}
size_t dst_offset[NFIELDS] = {
HOFFSET(samplestruct_t, data),
HOFFSET(samplestruct_t, concentrations),
HOFFSET(samplestruct_t, samplenr),
HOFFSET(samplestruct_t, set),
HOFFSET(samplestruct_t, compoundnr),
};
size_t dst_sizes[NFIELDS] = {
sizeof( sampledata[0].data),
sizeof(sampledata[0].concentrations),
sizeof(sampledata[0].samplenr),
sizeof(sampledata[0].set),
sizeof(sampledata[0].compoundnr)
};
hsize_t dim[] = {NRECORDS}; /* Dataspace dimensions */
hid_t space = H5Screate_simple(1, dim, NULL); // one dimensional in this case
hid_t file = H5Fcreate(filename, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT); // Create a new file using default properties.
const hsize_t datadim[] = {1020};
const hsize_t concdim[] = {3};
hid_t dataarray = H5Tarray_create(H5T_NATIVE_FLOAT, 1, datadim);
hid_t concarray = H5Tarray_create(H5T_NATIVE_FLOAT, 1, concdim);
hid_t s_tid = H5Tcreate (H5T_COMPOUND, sizeof(samplestruct_t));
H5Tinsert(s_tid, "Data", HOFFSET(samplestruct_t, data), dataarray);
H5Tinsert(s_tid, "Concentrations", HOFFSET(samplestruct_t, concentrations), concarray);
H5Tinsert(s_tid, "samplenr", HOFFSET(samplestruct_t, samplenr), H5T_NATIVE_INT);
H5Tinsert(s_tid, "set", HOFFSET(samplestruct_t, set), H5T_NATIVE_INT);
H5Tinsert(s_tid, "compoundnr", HOFFSET(samplestruct_t, compoundnr), H5T_NATIVE_INT);
hid_t dataset = H5Dcreate1(file, "/dataset3", s_tid, space, H5P_DEFAULT);
herr_t status = H5Dwrite(dataset, s_tid, H5S_ALL, H5S_ALL, H5P_DEFAULT, sampledata);
delete [] sampledata;
H5Tclose(dataarray);
H5Tclose(concarray);
H5Tclose(s_tid);
H5Sclose(space);
H5Dclose(dataset);
H5Fclose(file);
#endif
}
void Field<FieldType>::get_h5type()
{
string type_name;
type_name = typeid(FieldType).name();
char str_array_size[20];
//string str_array_size;
array_size = 1;
int nt;
nt = 0;
//get the array size
if(type_name[0]=='A')
{
while(type_name[nt+1]!='_')
{
str_array_size[nt]=type_name[nt+1];
nt++;
}
str_array_size[nt]='\0';
nt = nt + 2;
if(type_name[nt]=='A')
{
COUT<<"LATField2d::Field::save_hdf5 : Cannot recognize type of field: "<< type_name <<endl;
COUT<<"LATField2d::Field::save_hdf5 : ---------------------------------------------------------------------------------" <<endl;
COUT<<"LATField2d::Field::save_hdf5 : List of accepted type : short, unsigned short, int, unsigned int, long," <<endl;
COUT<<"LATField2d::Field::save_hdf5 : unsigned long, long long, unsigned long long, float, double, long double, Imag ." <<endl;
COUT<<"LATField2d::Field::save_hdf5 : 1 dimensional array of those type are also accepted" <<endl;
COUT<<"LATField2d::Field::save_hdf5 : ---------------------------------------------------------------------------------" <<endl;
return;
}
array_size=atoi(str_array_size);
}
//get the type
if(type_name[nt]=='s')
{
//COUT << " type : short ; size : "<<array_size<<endl;
type_id = H5T_NATIVE_SHORT;
}
else if(type_name[nt]=='t')
{
//COUT << " type : unsigned short ; size : "<<array_size<<endl;
type_id = H5T_NATIVE_USHORT;
}
else if(type_name[nt]=='i')
{
//COUT << " type : int ; size : "<<array_size<<endl;
type_id = H5T_NATIVE_INT;
}
else if(type_name[nt]=='j')
{
//COUT << " type : unsigned int ; size : "<<array_size<<endl;
type_id = H5T_NATIVE_UINT;
}
else if(type_name[nt]=='l')
{
//COUT << " type : long ; size : "<<array_size<<endl;
type_id = H5T_NATIVE_LONG;
}
else if(type_name[nt]=='m')
{
//COUT << " type : unsigned long ; size : "<<array_size<<endl;
type_id = H5T_NATIVE_ULONG;
}
else if(type_name[nt]=='x')
{
//COUT << " type : long long ; size : "<<array_size<<endl;
type_id = H5T_NATIVE_LLONG;
}
else if(type_name[nt]=='y')
{
//COUT << " type : unsigned long long ; size : "<<array_size<<endl;
type_id = H5T_NATIVE_ULLONG;
}
else if(type_name[nt]=='f')
{
//COUT << " type : float ; size : "<<array_size<<endl;
type_id = H5T_NATIVE_FLOAT;
}
else if(type_name[nt]=='d')
{
//COUT << " type : double ; size : "<<array_size<<endl;
type_id = H5T_NATIVE_DOUBLE;
}
else if(type_name[nt]=='e')
{
//COUT << " type : long double ; size : "<<array_size<<endl;
type_id = H5T_NATIVE_LDOUBLE;
}
else if (type_name[nt]=='N'&&type_name[nt+12]=='I'&&type_name[nt+13]=='m'&&type_name[nt+14]=='a'&&type_name[nt+15]=='g')
{
type_id = H5Tcreate (H5T_COMPOUND, sizeof (Imag));
#ifdef SINGLE
H5Tinsert (type_id, "real", 0,H5T_NATIVE_FLOAT);
H5Tinsert (type_id, "imaginary", sizeof(Real),H5T_NATIVE_FLOAT);
#else
H5Tinsert (type_id, "real", 0,H5T_NATIVE_DOUBLE);
H5Tinsert (type_id, "imaginary", sizeof(Real),H5T_NATIVE_DOUBLE);
#endif
}
else
{
COUT<<"LATField2d::Field::save_hdf5 : Cannot recognize type of field: " << type_name <<endl;
COUT<<"LATField2d::Field::save_hdf5 : ---------------------------------------------------------------------------------" <<endl;
COUT<<"LATField2d::Field::save_hdf5 : List of accepted type : short, unsigned short, int, unsigned int, long," <<endl;
COUT<<"LATField2d::Field::save_hdf5 : unsigned long, long long, unsigned long long, float, double, long double, Imag ." <<endl;
COUT<<"LATField2d::Field::save_hdf5 : 1 dimensional array of those type are also accepted" <<endl;
COUT<<"LATField2d::Field::save_hdf5 : ---------------------------------------------------------------------------------" <<endl;
}
}
/*
* test_compound
* Test that compound datatypes can have UTF-8 field names.
*/
void test_compound(hid_t fid, const char * string)
{
/* Define two compound structures, s1_t and s2_t.
* s2_t is a subset of s1_t, with two out of three
* fields.
* This is stolen from the h5_compound example.
*/
typedef struct s1_t {
int a;
double c;
float b;
} s1_t;
typedef struct s2_t {
double c;
int a;
} s2_t;
/* Actual variable declarations */
s1_t s1;
s2_t s2;
hid_t s1_tid, s2_tid;
hid_t space_id, dset_id;
hsize_t dim = 1;
char *readbuf;
herr_t ret;
/* Initialize compound data */
HDmemset(&s1, 0, sizeof(s1_t)); /* To make purify happy */
s1.a = COMP_INT_VAL;
s1.c = COMP_DOUBLE_VAL;
s1.b = COMP_FLOAT_VAL;
/* Create compound datatypes using UTF-8 field name */
s1_tid = H5Tcreate (H5T_COMPOUND, sizeof(s1_t));
CHECK(s1_tid, FAIL, "H5Tcreate");
ret = H5Tinsert(s1_tid, string, HOFFSET(s1_t, a), H5T_NATIVE_INT);
CHECK(ret, FAIL, "H5Tinsert");
/* Check that the field name was stored correctly */
readbuf = H5Tget_member_name(s1_tid, 0);
ret = HDstrcmp(readbuf, string);
VERIFY(ret, 0, "strcmp");
free(readbuf);
/* Add the other fields to the datatype */
ret = H5Tinsert(s1_tid, "c_name", HOFFSET(s1_t, c), H5T_NATIVE_DOUBLE);
CHECK(ret, FAIL, "H5Tinsert");
ret = H5Tinsert(s1_tid, "b_name", HOFFSET(s1_t, b), H5T_NATIVE_FLOAT);
CHECK(ret, FAIL, "H5Tinsert");
/* Create second datatype, with only two fields. */
s2_tid = H5Tcreate (H5T_COMPOUND, sizeof(s2_t));
CHECK(s2_tid, FAIL, "H5Tcreate");
ret = H5Tinsert(s2_tid, "c_name", HOFFSET(s2_t, c), H5T_NATIVE_DOUBLE);
CHECK(ret, FAIL, "H5Tinsert");
ret = H5Tinsert(s2_tid, string, HOFFSET(s2_t, a), H5T_NATIVE_INT);
CHECK(ret, FAIL, "H5Tinsert");
/* Create the dataspace and dataset. */
space_id = H5Screate_simple(1, &dim, NULL);
CHECK(space_id, FAIL, "H5Screate_simple");
dset_id = H5Dcreate2(fid, DSET4_NAME, s1_tid, space_id, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
CHECK(dset_id, FAIL, "H5Dcreate2");
/* Write data to the dataset. */
ret = H5Dwrite(dset_id, s1_tid, H5S_ALL, H5S_ALL, H5P_DEFAULT, &s1);
CHECK(ret, FAIL, "H5Dwrite");
/* Ensure that data can be read back by field name into s2 struct */
ret = H5Dread(dset_id, s2_tid, H5S_ALL, H5S_ALL, H5P_DEFAULT, &s2);
CHECK(ret, FAIL, "H5Dread");
VERIFY(s2.a, COMP_INT_VAL, "H5Dread");
VERIFY(s2.c, COMP_DOUBLE_VAL, "H5Dread");
/* Clean up */
ret = H5Tclose(s1_tid);
CHECK(ret, FAIL, "H5Tclose");
ret = H5Tclose(s2_tid);
CHECK(ret, FAIL, "H5Tclose");
ret = H5Sclose(space_id);
CHECK(ret, FAIL, "H5Sclose");
ret = H5Dclose(dset_id);
CHECK(ret, FAIL, "H5Dclose");
}
int
main (int argc, char *argv[])
{
inp_t input_params;
mdl_t source_mdl;
net_t network;
int cell_index;
int verbose = 1;
char *input_file;
/* Parse options and command line arguments. Diplay help
message if no (or more than one) argument is given. */
{
int opt;
static struct option longopts[] = {
{"help", no_argument, NULL, 'h'},
{"version", no_argument, NULL, 'V'},
{"verbose", no_argument, NULL, 'v'},
{"quiet", no_argument, NULL, 'q'},
{0, 0, 0, 0}
};
while ((opt = getopt_long (argc, argv, "hVvq", longopts, NULL)) != -1)
{
switch (opt)
{
case 'h':
usage ();
return EXIT_SUCCESS;
break;
case 'V':
version ();
return EXIT_SUCCESS;
break;
case 'v':
verbose = 2;
break;
case 'q':
verbose = 0;
break;
default:
usage ();
return EXIT_FAILURE;
}
};
argc -= optind;
argv += optind;
if (argc != 1)
{
usage ();
return EXIT_FAILURE;
}
input_file = argv[0];
}
/* Read the input file */
if( read_input_file_names (input_file, &input_params.files, verbose) != EXIT_SUCCESS )
{
return EXIT_FAILURE;
}
/* Read the chemical network file */
if( read_network (input_params.files.chem_file, &network, verbose) != EXIT_SUCCESS )
{
return EXIT_FAILURE;
}
/* Read the input file */
if( read_input (input_file, &input_params, &network, verbose) != EXIT_SUCCESS )
{
return EXIT_FAILURE;
}
/* Read the source model file */
if( read_source (input_params.files.source_file, &source_mdl, &input_params,
verbose) != EXIT_SUCCESS )
{
return EXIT_FAILURE;
}
// Hdf5 files, datatype and dataspace
hid_t fid, datatype, dataspace, dataset, tsDataset, tsDataspace, speciesDataset, speciesDataspace, speciesType;
datatype = H5Tcopy(H5T_NATIVE_DOUBLE);
hsize_t dimsf[ ROUTE_DATASET_RANK ]={ source_mdl.n_cells, source_mdl.ts.n_time_steps, input_params.output.n_output_species, N_OUTPUT_ROUTES };
fid = H5Fcreate( "astrochem_output.h5", H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);
dataspace = H5Screate_simple( ABUNDANCE_DATASET_RANK, dimsf, NULL);
// Add Atributes
hid_t simpleDataspace = H5Screate(H5S_SCALAR);
hid_t attrType = H5Tcopy(H5T_C_S1);
H5Tset_size ( attrType, MAX_CHAR_FILENAME );
H5Tset_strpad(attrType,H5T_STR_NULLTERM);
hid_t attrNetwork = H5Acreate( fid, "chem_file", attrType, simpleDataspace, H5P_DEFAULT, H5P_DEFAULT);
H5Awrite( attrNetwork, attrType, realpath( input_params.files.chem_file, NULL ) );
H5Aclose( attrNetwork );
hid_t attrModel = H5Acreate( fid, "source_file", attrType, simpleDataspace, H5P_DEFAULT, H5P_DEFAULT);
H5Awrite( attrModel, attrType, realpath( input_params.files.source_file, NULL ) );
H5Aclose( attrModel );
H5Tclose( attrType );
H5Sclose( simpleDataspace );
// Define chunk property
hsize_t chunk_dims[ ROUTE_DATASET_RANK ] = { 1, 1, input_params.output.n_output_species, N_OUTPUT_ROUTES };
hid_t prop_id = H5Pcreate(H5P_DATASET_CREATE);
H5Pset_chunk(prop_id, ABUNDANCE_DATASET_RANK , chunk_dims);
// Create dataset
dataset = H5Dcreate(fid, "Abundances", datatype, dataspace, H5P_DEFAULT, prop_id, H5P_DEFAULT);
int i;
hid_t dataspaceRoute, route_t_datatype, r_t_datatype, route_prop_id, routeGroup;
hid_t routeDatasets[ input_params.output.n_output_species ];
if (input_params.output.trace_routes)
{
// Create route dataspace
dataspaceRoute = H5Screate_simple( ROUTE_DATASET_RANK, dimsf, NULL);
// Create route datatype
r_t_datatype = H5Tcreate (H5T_COMPOUND, sizeof(r_t));
H5Tinsert( r_t_datatype, "reaction_number", HOFFSET(r_t, reaction_no ), H5T_NATIVE_INT);
H5Tinsert( r_t_datatype, "reaction_rate", HOFFSET(r_t, rate), H5T_NATIVE_DOUBLE);
route_t_datatype = H5Tcreate (H5T_COMPOUND, sizeof(rout_t));
H5Tinsert( route_t_datatype, "formation_rate", HOFFSET(rout_t, formation ), r_t_datatype );
H5Tinsert( route_t_datatype, "destruction_rate", HOFFSET(rout_t, destruction ), r_t_datatype );
// Define route chunk property
route_prop_id = H5Pcreate(H5P_DATASET_CREATE);
H5Pset_chunk( route_prop_id, ROUTE_DATASET_RANK, chunk_dims);
// Create each named route dataset
routeGroup = H5Gcreate( fid, "Routes", H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT );
char routeName[6] = "route_";
char tempName[ MAX_CHAR_SPECIES + sizeof( routeName ) ];
for( i = 0; i < input_params.output.n_output_species ; i++ )
{
strcpy( tempName, routeName );
strcat( tempName, network.species[input_params.output.output_species_idx[i]].name );
routeDatasets[i] = H5Dcreate( routeGroup, tempName, route_t_datatype, dataspaceRoute, H5P_DEFAULT, route_prop_id, H5P_DEFAULT);
}
}
// Timesteps and species
hsize_t n_ts = source_mdl.ts.n_time_steps;
hsize_t n_species = input_params.output.n_output_species ;
tsDataspace = H5Screate_simple( 1, &n_ts, NULL);
speciesDataspace = H5Screate_simple( 1, &n_species, NULL);
speciesType = H5Tcopy (H5T_C_S1);
H5Tset_size (speciesType, MAX_CHAR_SPECIES );
H5Tset_strpad(speciesType,H5T_STR_NULLTERM);
// Create ts and species datasets
tsDataset = H5Dcreate(fid, "TimeSteps", datatype, tsDataspace, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
speciesDataset = H5Dcreate(fid, "Species", speciesType, speciesDataspace, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
double* convTs = (double*) malloc( sizeof(double)* source_mdl.ts.n_time_steps );
for( i=0; i< source_mdl.ts.n_time_steps; i++ )
{
convTs[i] = source_mdl.ts.time_steps[i] / CONST_MKSA_YEAR;
}
H5Dwrite( tsDataset, datatype, H5S_ALL, H5S_ALL, H5P_DEFAULT, convTs );
char speciesName [ input_params.output.n_output_species ][ MAX_CHAR_SPECIES ];
for( i = 0; i < input_params.output.n_output_species ; i++ )
{
strcpy( speciesName[i], network.species[input_params.output.output_species_idx[i]].name );
}
H5Dwrite( speciesDataset, speciesType, H5S_ALL, H5S_ALL, H5P_DEFAULT, speciesName );
free( convTs );
H5Dclose( tsDataset );
H5Dclose( speciesDataset );
H5Tclose( speciesType );
H5Sclose( tsDataspace );
H5Sclose( speciesDataspace );
#ifdef HAVE_OPENMP
/*Initialize lock*/
omp_init_lock(&lock);
/* Solve the ODE system for each cell. */
{
#pragma omp parallel for schedule (dynamic, 1)
#endif
for (cell_index = 0; cell_index < source_mdl.n_cells; cell_index++)
{
if (verbose >= 1)
fprintf (stdout, "Computing abundances in cell %d...\n",
cell_index);
if( full_solve ( fid, dataset, routeDatasets, dataspace, dataspaceRoute, datatype, route_t_datatype, cell_index, &input_params, source_mdl.mode,
&source_mdl.cell[cell_index], &network, &source_mdl.ts, verbose) != EXIT_SUCCESS )
{
exit (EXIT_FAILURE);
}
if (verbose >= 1)
fprintf (stdout, "Done with cell %d.\n", cell_index);
}
#ifdef HAVE_OPENMP
}
/*Finished lock mechanism, destroy it*/
omp_destroy_lock(&lock);
#endif
/*
* Close/release hdf5 resources.
*/
if (input_params.output.trace_routes)
{
for( i = 0; i < input_params.output.n_output_species ; i++ )
{
H5Dclose(routeDatasets[i] );
}
H5Sclose(dataspaceRoute);
H5Gclose(routeGroup);
H5Pclose(route_prop_id);
H5Tclose(r_t_datatype);
H5Tclose(route_t_datatype);
}
H5Dclose(dataset);
H5Pclose(prop_id);
H5Sclose(dataspace);
H5Tclose(datatype);
H5Fclose(fid);
free_input (&input_params);
free_mdl (&source_mdl);
free_network (&network);
return (EXIT_SUCCESS);
}
void restart(int restart_flag)
{
extern int qpts, dimR, dimQ, Nx, Nz;
extern mcomplex ****U, ****C;
extern mcomplex ****IU, ****IC;
int x, y, z, i;
hid_t file_id1, dataset_u, dataset_v,dataset_w; /* file identifier */
hid_t fid1,dataset_iu, dataset_iv,dataset_iw ;
hid_t complex_id;
hsize_t fdim[]={ qpts, Nz, Nx/2};
herr_t ret;
char filename [50];
/* define compound datatype for the complex number */
typedef struct
{
double re; /*real part*/
double im; /*imaginary part*/
} complex_t;
complex_id = H5Tcreate (H5T_COMPOUND, sizeof (complex_t));
H5Tinsert (complex_id, "real", HOFFSET(complex_t,re), H5T_NATIVE_DOUBLE);
H5Tinsert (complex_id, "imaginary", HOFFSET(complex_t,im), H5T_NATIVE_DOUBLE);
/* define some temporal matrix to store the data to the hdf file */
complex_t Matrix1[qpts][Nz][Nx/2];
complex_t Matrix2[qpts][Nz][Nx/2];
complex_t Matrix3[qpts][Nz][Nx/2];
complex_t IMatrix1[qpts][Nz][Nx/2];
complex_t IMatrix2[qpts][Nz][Nx/2];
complex_t IMatrix3[qpts][Nz][Nx/2]; // find the restart file
sprintf(filename, "data_t=%d", restart_flag);
// open the file and dataset
file_id1 = H5Fopen(filename, H5F_ACC_RDONLY, H5P_DEFAULT);
dataset_u = H5Dopen(file_id1,"/data_u");
dataset_v = H5Dopen(file_id1,"/data_v");
dataset_w = H5Dopen(file_id1,"/data_w");
dataset_iu = H5Dopen(file_id1,"/data_iu");
dataset_iv = H5Dopen(file_id1,"/data_iv");
dataset_iw = H5Dopen(file_id1,"/data_iw");
ret = H5Dread(dataset_u, complex_id, H5S_ALL, H5S_ALL, H5P_DEFAULT, Matrix1);
ret = H5Dread(dataset_v, complex_id, H5S_ALL, H5S_ALL, H5P_DEFAULT, Matrix2);
ret = H5Dread(dataset_w, complex_id, H5S_ALL, H5S_ALL, H5P_DEFAULT, Matrix3);
ret = H5Dread(dataset_iu, complex_id, H5S_ALL, H5S_ALL, H5P_DEFAULT, IMatrix1);
ret = H5Dread(dataset_iv, complex_id, H5S_ALL, H5S_ALL, H5P_DEFAULT, IMatrix2);
ret = H5Dread(dataset_iw, complex_id, H5S_ALL, H5S_ALL, H5P_DEFAULT, IMatrix3);
ret=H5Dclose(dataset_u);
ret=H5Dclose(dataset_v);
ret=H5Dclose(dataset_w);
ret=H5Dclose(dataset_iu);
ret=H5Dclose(dataset_iv);
ret=H5Dclose(dataset_iw);
ret=H5Fclose(file_id1);
for (y=0; y<qpts; y++)
{
for (z=0; z<Nz; ++z)
{
for(x=0; x<Nx/2; ++x)
{
Re(U[z][XEL][y][x])=Matrix1[y][z][x].re;
Im(U[z][XEL][y][x])=Matrix1[y][z][x].im;
Re(U[z][YEL][y][x])=Matrix2[y][z][x].re;
Im(U[z][YEL][y][x])=Matrix2[y][z][x].im;
Re(U[z][ZEL][y][x])=Matrix3[y][z][x].re;
Im(U[z][ZEL][y][x])=Matrix3[y][z][x].im;
Re(IU[z][XEL][y][x])=IMatrix1[y][z][x].re;
Im(IU[z][XEL][y][x])=IMatrix1[y][z][x].im;
Re(IU[z][YEL][y][x])=IMatrix2[y][z][x].re;
Im(IU[z][YEL][y][x])=IMatrix2[y][z][x].im;
Re(IU[z][ZEL][y][x])=IMatrix3[y][z][x].re;
Im(IU[z][ZEL][y][x])=IMatrix3[y][z][x].im;
}
}
}
/* compute inital coefficients in expansion given the value of ux hat, uy hat, uz hat. */
initAlphaBeta();
/* compute the boundary condition for previous stage or time step, result is stored in Uxb and Uzb*/
if (increBoundary()!= NO_ERR)
{
printf("increBoundary failure\n");
}
/* compute initial coefficients for incremental state solver */
incre_initAlphaBeta();
printf(" restart computed coefficients!\n");
for (i = 0; i < dimQ; ++i)
{
for (z= 0; z < Nz; ++z)
{
for (x = 0; x < Nx/2; ++x)
{
printf(" IC[%d][ALPHA][%d][%d]=%f+%fi\n", z, i, x,Re(IC[z][ALPHA][i][x]), Im(IC[z][ALPHA][i][x]));
}
}
}
for (i = 0; i < dimR; ++i)
{
for (z= 0; z < Nz; ++z)
{
for (x = 0; x < Nx/2; ++x)
{
printf(" IC[%d][BETA][%d][%d]=%f+%fi\n", z, i, x,Re(IC[z][BETA][i][x]), Im(IC[z][BETA][i][x]));
}
}
}
printf(" finish restart computing coefficients!\n\n");
}
/*
* test_objnames
* Tests that UTF-8 can be used for object names in the file.
* Tests groups, datasets, named datatypes, and soft links.
* Note that this test doesn't actually mark the names as being
* in UTF-8. At the time this test was written, that feature
* didn't exist in HDF5, and when the character encoding property
* was added to links it didn't change how they were stored in the file,
* -JML 2/2/2006
*/
void test_objnames(hid_t fid, const char* string)
{
hid_t grp_id, grp1_id, grp2_id, grp3_id;
hid_t type_id, dset_id, space_id;
char read_buf[MAX_STRING_LENGTH];
char path_buf[MAX_PATH_LENGTH];
hsize_t dims=1;
hobj_ref_t obj_ref;
herr_t ret;
/* Create a group with a UTF-8 name */
grp_id = H5Gcreate2(fid, string, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
CHECK(grp_id, FAIL, "H5Gcreate2");
/* Set a comment on the group to test that we can access the group
* Also test that UTF-8 comments can be read.
*/
ret = H5Oset_comment_by_name(fid, string, string, H5P_DEFAULT);
CHECK(ret, FAIL, "H5Oset_comment_by_name");
ret = H5Oget_comment_by_name(fid, string, read_buf, (size_t)MAX_STRING_LENGTH, H5P_DEFAULT);
CHECK(ret, FAIL, "H5Oget_comment_by_name");
ret = H5Gclose(grp_id);
CHECK(ret, FAIL, "H5Gclose");
VERIFY(HDstrcmp(string, read_buf), 0, "strcmp");
/* Create a new dataset with a UTF-8 name */
grp1_id = H5Gcreate2(fid, GROUP1_NAME, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
CHECK(grp1_id, FAIL, "H5Gcreate2");
space_id = H5Screate_simple(RANK, &dims, NULL);
CHECK(space_id, FAIL, "H5Screate_simple");
dset_id = H5Dcreate2(grp1_id, string, H5T_NATIVE_INT, space_id, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
CHECK(dset_id, FAIL, "H5Dcreate2");
/* Make sure that dataset can be opened again */
ret = H5Dclose(dset_id);
CHECK(ret, FAIL, "H5Dclose");
ret = H5Sclose(space_id);
CHECK(ret, FAIL, "H5Sclose");
dset_id = H5Dopen2(grp1_id, string, H5P_DEFAULT);
CHECK(ret, FAIL, "H5Dopen2");
ret = H5Dclose(dset_id);
CHECK(ret, FAIL, "H5Dclose");
ret = H5Gclose(grp1_id);
CHECK(ret, FAIL, "H5Gclose");
/* Do the same for a named datatype */
grp2_id = H5Gcreate2(fid, GROUP2_NAME, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
CHECK(grp2_id, FAIL, "H5Gcreate2");
type_id = H5Tcreate(H5T_OPAQUE, (size_t)1);
CHECK(type_id, FAIL, "H5Tcreate");
ret = H5Tcommit2(grp2_id, string, type_id, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
CHECK(type_id, FAIL, "H5Tcommit2");
ret = H5Tclose(type_id);
CHECK(type_id, FAIL, "H5Tclose");
type_id = H5Topen2(grp2_id, string, H5P_DEFAULT);
CHECK(type_id, FAIL, "H5Topen2");
ret = H5Tclose(type_id);
CHECK(type_id, FAIL, "H5Tclose");
/* Don't close the group -- use it to test that object references
* can refer to objects named in UTF-8 */
space_id = H5Screate_simple(RANK, &dims, NULL);
CHECK(space_id, FAIL, "H5Screate_simple");
dset_id = H5Dcreate2(grp2_id, DSET3_NAME, H5T_STD_REF_OBJ, space_id, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
CHECK(ret, FAIL, "H5Dcreate2");
/* Create reference to named datatype */
ret = H5Rcreate(&obj_ref, grp2_id, string, H5R_OBJECT, -1);
CHECK(ret, FAIL, "H5Rcreate");
/* Write selection and read it back*/
ret = H5Dwrite(dset_id, H5T_STD_REF_OBJ, H5S_ALL, H5S_ALL, H5P_DEFAULT, &obj_ref);
CHECK(ret, FAIL, "H5Dwrite");
ret = H5Dread(dset_id, H5T_STD_REF_OBJ, H5S_ALL, H5S_ALL, H5P_DEFAULT, &obj_ref);
CHECK(ret, FAIL, "H5Dread");
/* Ensure that we can open named datatype using object reference */
type_id = H5Rdereference(dset_id, H5R_OBJECT, &obj_ref);
CHECK(type_id, FAIL, "H5Rdereference");
ret = H5Tcommitted(type_id);
VERIFY(ret, 1, "H5Tcommitted");
ret = H5Tclose(type_id);
CHECK(type_id, FAIL, "H5Tclose");
ret = H5Dclose(dset_id);
CHECK(ret, FAIL, "H5Dclose");
ret = H5Sclose(space_id);
CHECK(ret, FAIL, "H5Sclose");
ret = H5Gclose(grp2_id);
CHECK(ret, FAIL, "H5Gclose");
/* Create "group3". Build a hard link from group3 to group2, which has
* a datatype with the UTF-8 name. Create a soft link in group3
* pointing through the hard link to the datatype. Give the soft
* link a name in UTF-8. Ensure that the soft link works. */
grp3_id = H5Gcreate2(fid, GROUP3_NAME, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
CHECK(grp3_id, FAIL, "H5Gcreate2");
ret = H5Lcreate_hard(fid, GROUP2_NAME, grp3_id, GROUP2_NAME, H5P_DEFAULT, H5P_DEFAULT);
CHECK(ret, FAIL, "H5Lcreate_hard");
HDstrcpy(path_buf, GROUP2_NAME);
HDstrcat(path_buf, "/");
HDstrcat(path_buf, string);
ret = H5Lcreate_hard(grp3_id, path_buf, H5L_SAME_LOC, string, H5P_DEFAULT, H5P_DEFAULT);
CHECK(ret, FAIL, "H5Lcreate_hard");
/* Open named datatype using soft link */
type_id = H5Topen2(grp3_id, string, H5P_DEFAULT);
CHECK(type_id, FAIL, "H5Topen2");
ret = H5Tclose(type_id);
CHECK(type_id, FAIL, "H5Tclose");
ret = H5Gclose(grp3_id);
CHECK(ret, FAIL, "H5Gclose");
}
/*-------------------------------------------------------------------------
* Function: gent_att_compound_vlstr
*
* Purpose: Generate a dataset and a group.
* Both has an attribute with a compound datatype consisting
* of a variable length string
*
*-------------------------------------------------------------------------
*/
static void gent_att_compound_vlstr(hid_t loc_id)
{
typedef struct { /* Compound structure for the attribute */
int i;
char *v;
} s1;
hsize_t dim[1] = {1}; /* Dimension size */
hid_t sid = -1; /* Dataspace ID */
hid_t tid = -1; /* Datatype ID */
hid_t aid = -1; /* Attribute ID */
hid_t did = -1; /* Dataset ID */
hid_t gid = -1; /* Group ID */
hid_t vl_str_tid = -1; /* Variable length datatype ID */
hid_t cmpd_tid = -1; /* Compound datatype ID */
hid_t null_sid = -1; /* Null dataspace ID */
s1 buf; /* Buffer */
buf.i = 9;
buf.v = "ThisIsAString";
/* Create an integer datatype */
if((tid = H5Tcopy(H5T_NATIVE_INT)) < 0)
goto error;
/* Create a variable length string */
if((vl_str_tid = H5Tcopy(H5T_C_S1)) < 0)
goto error;
if(H5Tset_size(vl_str_tid, H5T_VARIABLE) < 0)
goto error;
/* Create a compound datatype with a variable length string and an integer */
if((cmpd_tid = H5Tcreate(H5T_COMPOUND, sizeof(s1))) < 0)
goto error;
if(H5Tinsert(cmpd_tid, "i", HOFFSET(s1, i), tid) < 0)
goto error;
if(H5Tinsert(cmpd_tid, "v", HOFFSET(s1, v), vl_str_tid) < 0)
goto error;
/* Create a dataset */
if((null_sid = H5Screate(H5S_NULL)) < 0)
goto error;
if((did = H5Dcreate2(loc_id, DATASET_ATTR, H5T_NATIVE_INT, null_sid, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT)) < 0)
goto error;
/* Attach an attribute with the compound datatype to the dataset */
if((sid = H5Screate_simple(1, dim, dim)) < 0)
goto error;
if((aid = H5Acreate2(did, ATTR, cmpd_tid, sid, H5P_DEFAULT, H5P_DEFAULT)) < 0)
goto error;
/* Write the attribute */
buf.i = 9;
buf.v = "ThisIsAString";
if(H5Awrite(aid, cmpd_tid, &buf) < 0)
goto error;
/* Close the dataset and its attribute */
if(H5Dclose(did) < 0)
goto error;
if(H5Aclose(aid) < 0)
goto error;
/* Create a group */
if((gid = H5Gcreate2(loc_id, GROUP_ATTR, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT)) < 0)
goto error;
/* Attach an attribute with the compound datatype to the group */
if((aid = H5Acreate2(gid, ATTR, cmpd_tid, sid, H5P_DEFAULT, H5P_DEFAULT)) < 0)
goto error;
if(H5Awrite(aid, cmpd_tid, &buf) < 0)
goto error;
/* Close the group and its attribute */
if(H5Aclose(aid) < 0)
goto error;
if(H5Gclose(gid) < 0)
goto error;
/* Close dataspaces */
if(H5Sclose(sid) < 0)
goto error;
if(H5Sclose(null_sid) < 0)
goto error;
/* Close datatypes */
if(H5Tclose(tid) < 0)
goto error;
if(H5Tclose(vl_str_tid) < 0)
goto error;
if(H5Tclose(cmpd_tid) < 0)
goto error;
error:
H5E_BEGIN_TRY {
H5Tclose(tid);
H5Tclose(vl_str_tid);
H5Tclose(cmpd_tid);
H5Sclose(null_sid);
H5Sclose(sid);
H5Dclose(did);
H5Aclose(aid);
H5Gclose(gid);
} H5E_END_TRY;
} /* gen_att_compound_vlstr() */
int main(void)
{
hid_t fil,spc,set;
hid_t cs6, cmp, fix;
hid_t cmp1, cmp2, cmp3;
hid_t plist;
hid_t array_dt;
hsize_t dim[2];
hsize_t cdim[4];
char string5[5];
float fok[2] = {1234., 2341.};
float fnok[2] = {5678., 6785.};
float *fptr;
char *data = NULL;
int result = 0;
herr_t error = 1;
printf("%-70s", "Testing alignment in compound datatypes");
strcpy(string5, "Hi!");
HDunlink(fname);
fil = H5Fcreate(fname, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);
if (fil < 0) {
puts("*FAILED*");
return 1;
}
H5E_BEGIN_TRY {
(void)H5Ldelete(fil, setname, H5P_DEFAULT);
} H5E_END_TRY;
cs6 = H5Tcopy(H5T_C_S1);
H5Tset_size(cs6, sizeof(string5));
H5Tset_strpad(cs6, H5T_STR_NULLPAD);
cmp = H5Tcreate(H5T_COMPOUND, sizeof(fok) + sizeof(string5) + sizeof(fnok));
H5Tinsert(cmp, "Awkward length", 0, cs6);
cdim[0] = sizeof(fok) / sizeof(float);
array_dt = H5Tarray_create2(H5T_NATIVE_FLOAT, 1, cdim);
H5Tinsert(cmp, "Ok", sizeof(string5), array_dt);
H5Tclose(array_dt);
cdim[0] = sizeof(fnok) / sizeof(float);
array_dt = H5Tarray_create2(H5T_NATIVE_FLOAT, 1, cdim);
H5Tinsert(cmp, "Not Ok", sizeof(fok) + sizeof(string5), array_dt);
H5Tclose(array_dt);
fix = h5tools_get_native_type(cmp);
cmp1 = H5Tcreate(H5T_COMPOUND, sizeof(fok));
cdim[0] = sizeof(fok) / sizeof(float);
array_dt = H5Tarray_create2(H5T_NATIVE_FLOAT, 1, cdim);
H5Tinsert(cmp1, "Ok", 0, array_dt);
H5Tclose(array_dt);
cmp2 = H5Tcreate(H5T_COMPOUND, sizeof(string5));
H5Tinsert(cmp2, "Awkward length", 0, cs6);
cmp3 = H5Tcreate(H5T_COMPOUND, sizeof(fnok));
cdim[0] = sizeof(fnok) / sizeof(float);
array_dt = H5Tarray_create2(H5T_NATIVE_FLOAT, 1, cdim);
H5Tinsert(cmp3, "Not Ok", 0, array_dt);
H5Tclose(array_dt);
plist = H5Pcreate(H5P_DATASET_XFER);
if((error = H5Pset_preserve(plist, 1)) < 0)
goto out;
/*
* Create a small dataset, and write data into it we write each field
* in turn so that we are avoid alignment issues at this point
*/
dim[0] = 1;
spc = H5Screate_simple(1, dim, NULL);
set = H5Dcreate2(fil, setname, cmp, spc, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
H5Dwrite(set, cmp1, spc, H5S_ALL, plist, fok);
H5Dwrite(set, cmp2, spc, H5S_ALL, plist, string5);
H5Dwrite(set, cmp3, spc, H5S_ALL, plist, fnok);
H5Dclose(set);
/* Now open the set, and read it back in */
data = malloc(H5Tget_size(fix));
if(!data) {
perror("malloc() failed");
abort();
}
set = H5Dopen2(fil, setname, H5P_DEFAULT);
H5Dread(set, fix, spc, H5S_ALL, H5P_DEFAULT, data);
fptr = (float *)(data + H5Tget_member_offset(fix, 1));
out:
if(error < 0) {
result = 1;
puts("*FAILED - HDF5 library error*");
} else if(fok[0] != fptr[0] || fok[1] != fptr[1]
|| fnok[0] != fptr[2] || fnok[1] != fptr[3]) {
char *mname;
result = 1;
mname = H5Tget_member_name(fix, 0);
printf("%14s (%2d) %6s = %s\n",
mname ? mname : "(null)", (int)H5Tget_member_offset(fix,0),
string5, (char *)(data + H5Tget_member_offset(fix, 0)));
if(mname)
free(mname);
fptr = (float *)(data + H5Tget_member_offset(fix, 1));
mname = H5Tget_member_name(fix, 1);
printf("Data comparison:\n"
"%14s (%2d) %6f = %f\n"
" %6f = %f\n",
mname ? mname : "(null)", (int)H5Tget_member_offset(fix,1),
fok[0], fptr[0],
fok[1], fptr[1]);
if(mname)
free(mname);
fptr = (float *)(data + H5Tget_member_offset(fix, 2));
mname = H5Tget_member_name(fix, 2);
printf("%14s (%2d) %6f = %f\n"
" %6f = %6f\n",
mname ? mname : "(null)", (int)H5Tget_member_offset(fix,2),
fnok[0], fptr[0],
fnok[1], fptr[1]);
if(mname)
free(mname);
fptr = (float *)(data + H5Tget_member_offset(fix, 1));
printf("\n"
"Short circuit\n"
" %6f = %f\n"
" %6f = %f\n"
" %6f = %f\n"
" %6f = %f\n",
fok[0], fptr[0],
fok[1], fptr[1],
fnok[0], fptr[2],
fnok[1], fptr[3]);
puts("*FAILED - compound type alignmnent problem*");
} else {
puts(" PASSED");
}
if(data)
free(data);
H5Sclose(spc);
H5Tclose(cmp);
H5Tclose(cmp1);
H5Tclose(cmp2);
H5Tclose(cmp3);
H5Pclose(plist);
H5Fclose(fil);
HDunlink(fname);
fflush(stdout);
return result;
}
int main (int argc, char ** argv)
{
char filename [256];
int rank, size, gidx, i, j, k,l;
MPI_Comm comm_dummy = MPI_COMM_WORLD; /* MPI_Comm is defined through adios_read.h */
enum ADIOS_DATATYPES attr_type;
void * data = NULL;
uint64_t start[] = {0,0,0,0,0,0,0,0,0,0};
uint64_t count[MAX_DIMS], hcount[MAX_DIMS], bytes_read = 0;
herr_t h5_err;
char h5name[256],aname[256],fname[256];
int dims [MAX_DIMS];
int h5rank[MAX_DIMS];
int h5i, level;
hid_t grp_id [GMAX+1], space_id, dataset_id;
hid_t memspace_id, dataspace_id, att_id;
char ** grp_name;
hid_t type_id;
hid_t h5_type_id;
hsize_t adims;
if (argc < 2) {
printf("Usage: %s <BP-file> <HDF5-file>\n", argv[0]);
return 1;
}
MPI_Init(&argc, &argv);
h5_err = H5Eset_auto(NULL, NULL );
ADIOS_FILE * f = adios_fopen (argv[1], comm_dummy);
HDF5_FILE = H5Fcreate(argv[2],H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);
/* create the complex types for HDF5 */
complex_real_id = H5Tcreate (H5T_COMPOUND, sizeof (complex_real_t));
H5Tinsert (complex_real_id, "real", HOFFSET(complex_real_t,re), H5T_NATIVE_FLOAT);
H5Tinsert (complex_real_id, "imaginary", HOFFSET(complex_real_t,im), H5T_NATIVE_FLOAT);
complex_double_id = H5Tcreate (H5T_COMPOUND, sizeof (complex_double_t));
H5Tinsert (complex_double_id, "real", HOFFSET(complex_double_t,re), H5T_NATIVE_DOUBLE);
H5Tinsert (complex_double_id, "imaginary", HOFFSET(complex_double_t,im), H5T_NATIVE_DOUBLE);
if (f == NULL) {
if (DEBUG) printf ("%s\n", adios_errmsg());
return -1;
}
/* For all groups */
for (gidx = 0; gidx < f->groups_count; gidx++) {
if (DEBUG) printf("Group %s:\n", f->group_namelist[gidx]);
ADIOS_GROUP * g = adios_gopen (f, f->group_namelist[gidx]);
if (g == NULL) {
if (DEBUG) printf ("%s\n", adios_errmsg());
return -1;
}
/* First create all of the groups */
grp_id [0] = HDF5_FILE;
for (i = 0; i < g->vars_count; i++) {
ADIOS_VARINFO * v = adios_inq_var_byid (g, i);
strcpy(h5name,g->var_namelist[i]);
grp_name = bp_dirparser (h5name, &level);
for (j = 0; j < level-1; j++) {
grp_id [j + 1] = H5Gopen (grp_id [j], grp_name [j]);
if (grp_id [j + 1] < 0) {
grp_id [j + 1] = H5Gcreate (grp_id [j], grp_name [j], 0);
}
}
for (j=1; j<level; j++) {
H5Gclose(grp_id[j]);
}
}
/* Now we can write data into these scalars */
/* For all variables */
if (DEBUG) printf(" Variables=%d:\n", g->vars_count);
for (i = 0; i < g->vars_count; i++) {
ADIOS_VARINFO * v = adios_inq_var_byid (g, i);
uint64_t total_size = adios_type_size (v->type, v->value);
for (j = 0; j < v->ndim; j++)
total_size *= v->dims[j];
strcpy(h5name,g->var_namelist[i]);
if (DEBUG) printf(" %-9s %s", adios_type_to_string(v->type), g->var_namelist[i]);
h5_err = bp_getH5TypeId (v->type, &h5_type_id);
if (v->type==adios_string) H5Tset_size(h5_type_id,strlen(v->value));
if (v->ndim == 0) {
/* Scalars do not need to be read in, we get it from the metadata
when using adios_inq_var */
if (DEBUG) printf(" = %s\n", value_to_string(v->type, v->value, 0));
// add the hdf5 dataset, these are scalars
for (h5i = 0;h5i<MAX_DIMS;h5i++)
count[0] = 0;
count[0] = 1; // we are writing just 1 element, RANK=1
h5_err = bp_getH5TypeId (v->type, &h5_type_id);
H5LTmake_dataset(HDF5_FILE,h5name,1,count,h5_type_id,v->value);
} else {
h5_err = readVar(g, v, h5name);
}
adios_free_varinfo (v);
} /* variables */
/* For all attributes */
if (DEBUG) printf(" Attributes=%d:\n", g->attrs_count);
for (i = 0; i < g->attrs_count; i++) {
enum ADIOS_DATATYPES atype;
int asize;
void *adata;
adios_get_attr_byid (g, i, &atype, &asize, &adata);
grp_name = bp_dirparser (g->attr_namelist[i], &level);
strcpy(aname,grp_name[level-1]);
// the name of the attribute is the last in the array
// we then need to concat the rest together
strcpy(fname,"/");
for (j=0;j<level-1;j++) {
strcat(fname,grp_name[j]);
}
h5_err = bp_getH5TypeId (atype, &h5_type_id);
// let's create the attribute
adims = 1;
if (atype==adios_string) H5Tset_size(h5_type_id,strlen(adata));
space_id = H5Screate(H5S_SCALAR); // just a scalar
att_id = H5Acreate(HDF5_FILE, g->attr_namelist[i], h5_type_id, space_id,H5P_DEFAULT);
h5_err = H5Awrite(att_id, h5_type_id, adata);
h5_err = H5Aclose(att_id);
h5_err = H5Sclose(space_id);
if (DEBUG) printf(" %-9s %s = %s\n", adios_type_to_string(atype),
g->attr_namelist[i], value_to_string(atype, adata, 0));
free(adata);
} /* attributes */
adios_gclose (g);
} /* groups */
adios_fclose (f);
h5_err = H5Fclose(HDF5_FILE);
MPI_Finalize();
return 0;
}
void h5_write_header_info_sp_(int* MyPE,
int* nvar_out, /* num vars to store */
hid_t* file_identifier, /* file handle */
char file_creation_time[],/* time / date stamp */
char flash_version[], /* FLASH version num */
char run_comment[], /* runtime comment */
int* total_blocks, /* total # of blocks */
float* time, /* simulation time */
float* timestep, /* current timestep */
int* nsteps, /* # of timestep */
int nzones_block[3], /* nxb, nyb, nzb */
char unk_labels[][5]) /* unknown labels */
{
hid_t dataspace, dataset;
herr_t status;
int rank;
hsize_t dimens_1d, dimens_2d[2];
int string_size;
hid_t string_type, sp_type;
typedef struct sim_params_t {
int total_blocks;
int nsteps;
int nxb;
int nyb;
int nzb;
float time;
float timestep;
} sim_params_t;
sim_params_t sim_params;
/* file creation time */
rank = 1;
dimens_1d = 1;
/* manually set the string size, and make it null terminated */
string_size = 40;
/* setup the datatype for this string length */
string_type = H5Tcopy(H5T_C_S1);
H5Tset_size(string_type, string_size);
dataspace = H5Screate_simple(rank, &dimens_1d, NULL);
dataset = H5Dcreate(*file_identifier, "file creation time",
string_type, dataspace, H5P_DEFAULT);
if (*MyPE == 0) {
status = H5Dwrite(dataset, string_type, H5S_ALL, H5S_ALL,
H5P_DEFAULT, file_creation_time);
#ifdef DEBUG_IO
printf("MyPE = %d, wrote file creation time, status = %d\n",
*MyPE, (int) status);
#endif
}
H5Tclose(string_type);
H5Sclose(dataspace);
H5Dclose(dataset);
/* FLASH version */
/* manually set the string size, and make it null terminated */
string_size = 20;
/* setup the datatype for this string length */
string_type = H5Tcopy(H5T_C_S1);
H5Tset_size(string_type, string_size);
dataspace = H5Screate_simple(rank, &dimens_1d, NULL);
dataset = H5Dcreate(*file_identifier, "FLASH version",
string_type, dataspace, H5P_DEFAULT);
if (*MyPE == 0) {
status = H5Dwrite(dataset, string_type, H5S_ALL, H5S_ALL,
H5P_DEFAULT, flash_version);
#ifdef DEBUG_IO
printf("wrote flash version, status = %d\n", (int) status);
#endif
}
H5Tclose(string_type);
H5Sclose(dataspace);
H5Dclose(dataset);
/*-----------------------------------------------------------------------
create a compound datatype to hold the simulation parameters -- this
will cut down on the number of writes issued, and should improve
performance
------------------------------------------------------------------------- */
sim_params.total_blocks = *total_blocks;
sim_params.time = *time;
sim_params.timestep = *timestep;
sim_params.nsteps = *nsteps;
sim_params.nxb = nzones_block[0];
sim_params.nyb = nzones_block[1];
sim_params.nzb = nzones_block[2];
rank = 1;
dimens_1d = 1;
rank = 1;
dimens_1d = 1;
dataspace = H5Screate_simple(rank, &dimens_1d, NULL);
sp_type = H5Tcreate(H5T_COMPOUND, sizeof(sim_params_t));
H5Tinsert(sp_type,
"total blocks",
offsetof(sim_params_t, total_blocks),
H5T_NATIVE_INT);
H5Tinsert(sp_type,
"time",
offsetof(sim_params_t, time),
H5T_NATIVE_FLOAT);
H5Tinsert(sp_type,
"timestep",
offsetof(sim_params_t, timestep),
H5T_NATIVE_FLOAT);
H5Tinsert(sp_type,
"number of steps",
offsetof(sim_params_t, nsteps),
H5T_NATIVE_INT);
H5Tinsert(sp_type,
"nxb",
offsetof(sim_params_t, nxb),
H5T_NATIVE_INT);
H5Tinsert(sp_type,
"nyb",
offsetof(sim_params_t, nyb),
H5T_NATIVE_INT);
H5Tinsert(sp_type,
"nzb",
offsetof(sim_params_t, nzb),
H5T_NATIVE_INT);
dataset = H5Dcreate(*file_identifier, "simulation parameters", sp_type,
dataspace, H5P_DEFAULT);
if (*MyPE == 0) {
status = H5Dwrite(dataset, sp_type, H5S_ALL, H5S_ALL,
H5P_DEFAULT, &sim_params);
}
H5Sclose(dataspace);
H5Dclose(dataset);
H5Tclose(sp_type);
/* unknown names */
rank = 2;
dimens_2d[0] = (hsize_t) *nvar_out;
dimens_2d[1] = 1;
/* manually set the string size */
string_size = 4;
/* setup the datatype for this string length */
string_type = H5Tcopy(H5T_C_S1);
status = H5Tset_size(string_type, string_size);
#ifdef DEBUG_IO
printf("MyPE = %d, string type = %d, set size status = %d\n",
*MyPE, (int) string_type, (int) status);
#endif
dataspace = H5Screate_simple(rank, dimens_2d, NULL);
dataset = H5Dcreate(*file_identifier, "unknown names",
string_type, dataspace, H5P_DEFAULT);
if (*MyPE == 0) {
status = H5Dwrite(dataset, string_type, H5S_ALL, H5S_ALL,
H5P_DEFAULT, unk_labels);
}
H5Tclose(string_type);
H5Sclose(dataspace);
H5Dclose(dataset);
}
/****************************************************************
**
** 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() */
int write_data2(int n)
{
hid_t file_id1, dataset_a, dataset_b; /* file identifier */
hid_t fid1, dataset_ia, dataset_ib;
hid_t fid2, dataset_Nx, dataset_Ny, dataset_Nz, dataset_dt, dataset_Re,
dataset_mpg;
hid_t complex_id;
hsize_t fdim[] = { dimR, Nz, Nx / 2 };
hsize_t fdim2[] = { 1 };
herr_t ret;
char filename[50];
extern mcomplex ****C, ****IC;
extern int qpts, Nx, Nz, dimR, dimQ;
extern double dt, re, mpg;
int x, y, z;
int Ny = qpts * 2 / 3;
/* define compound datatype for the complex number */
typedef struct {
double re; /*real part */
double im; /*imaginary part */
} complex_t;
complex_id = H5Tcreate(H5T_COMPOUND, sizeof(complex_t));
H5Tinsert(complex_id, "real", HOFFSET(complex_t, re),
H5T_NATIVE_DOUBLE);
H5Tinsert(complex_id, "imaginary", HOFFSET(complex_t, im),
H5T_NATIVE_DOUBLE);
/* define some temporal matrix to store the data to the hdf file */
complex_t Matrix1[dimR][Nz][Nx / 2];
complex_t Matrix2[dimR][Nz][Nx / 2];
complex_t IMatrix1[dimR][Nz][Nx / 2];
complex_t IMatrix2[dimR][Nz][Nx / 2];
for (y = 0; y < dimR; y++) {
for (z = 0; z < Nz; ++z) {
for (x = 0; x < Nx / 2; ++x) {
Matrix1[y][z][x].re = Re(C[z][ALPHA][y][x]); /* storing solved solutions to Matrix */
Matrix1[y][z][x].im = Im(C[z][ALPHA][y][x]);
Matrix2[y][z][x].re = Re(C[z][BETA][y][x]);
Matrix2[y][z][x].im = Im(C[z][BETA][y][x]);
IMatrix1[y][z][x].re = Re(IC[z][ALPHA][y][x]); /* storing solved solutions to Matrix */
IMatrix1[y][z][x].im = Im(IC[z][ALPHA][y][x]);
IMatrix2[y][z][x].re = Re(IC[z][BETA][y][x]);
IMatrix2[y][z][x].im = Im(IC[z][BETA][y][x]);
}
}
}
sprintf(filename, "data_t=%d.h5", n);
/* create File data.h5 for three data sets */
file_id1 =
H5Fcreate(filename, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);
/* create the dataspace */
fid1 = H5Screate_simple(3, fdim, NULL);
fid2 = H5Screate_simple(1, fdim2, NULL);
/* create datasets with name u v w */
dataset_a =
H5Dcreate1(file_id1, "/data_alpha", complex_id, fid1, H5P_DEFAULT);
dataset_b =
H5Dcreate1(file_id1, "/data_beta", complex_id, fid1, H5P_DEFAULT);
dataset_ia =
H5Dcreate1(file_id1, "/data_ialpha", complex_id, fid1,
H5P_DEFAULT);
dataset_ib =
H5Dcreate1(file_id1, "/data_ibeta", complex_id, fid1, H5P_DEFAULT);
dataset_Nx =
H5Dcreate1(file_id1, "data_Nx", H5T_STD_I32LE, fid2, H5P_DEFAULT);
dataset_Ny =
H5Dcreate1(file_id1, "data_Ny", H5T_STD_I32LE, fid2, H5P_DEFAULT);
dataset_Nz =
H5Dcreate1(file_id1, "data_Nz", H5T_STD_I32LE, fid2, H5P_DEFAULT);
dataset_dt =
H5Dcreate1(file_id1, "data_dt", H5T_IEEE_F64LE, fid2, H5P_DEFAULT);
dataset_Re =
H5Dcreate1(file_id1, "data_Re", H5T_IEEE_F64LE, fid2, H5P_DEFAULT);
dataset_mpg =
H5Dcreate1(file_id1, "data_mpg", H5T_IEEE_F64LE, fid2,
H5P_DEFAULT);
/* write data to corresponding datasets */
ret =
H5Dwrite(dataset_a, complex_id, H5S_ALL, fid1, H5P_DEFAULT,
Matrix1);
ret =
H5Dwrite(dataset_b, complex_id, H5S_ALL, fid1, H5P_DEFAULT,
Matrix2);
ret =
H5Dwrite(dataset_ia, complex_id, H5S_ALL, fid1, H5P_DEFAULT,
IMatrix1);
ret =
H5Dwrite(dataset_ib, complex_id, H5S_ALL, fid1, H5P_DEFAULT,
IMatrix2);
ret =
H5Dwrite(dataset_Nx, H5T_NATIVE_INT, H5S_ALL, fid2, H5P_DEFAULT,
&Nx);
ret =
H5Dwrite(dataset_Ny, H5T_NATIVE_INT, H5S_ALL, fid2, H5P_DEFAULT,
&Ny);
ret =
H5Dwrite(dataset_Nz, H5T_NATIVE_INT, H5S_ALL, fid2, H5P_DEFAULT,
&Nz);
ret =
H5Dwrite(dataset_dt, H5T_IEEE_F64LE, H5S_ALL, fid2, H5P_DEFAULT,
&dt);
ret =
H5Dwrite(dataset_Re, H5T_IEEE_F64LE, H5S_ALL, fid2, H5P_DEFAULT,
&re);
ret =
H5Dwrite(dataset_mpg, H5T_IEEE_F64LE, H5S_ALL, fid2, H5P_DEFAULT,
&mpg);
/* close datasets and file */
ret = H5Dclose(dataset_a);
ret = H5Dclose(dataset_b);
ret = H5Dclose(dataset_ia);
ret = H5Dclose(dataset_ib);
ret = H5Dclose(dataset_Nx);
ret = H5Dclose(dataset_Ny);
ret = H5Dclose(dataset_Nz);
ret = H5Dclose(dataset_dt);
ret = H5Dclose(dataset_Re);
ret = H5Dclose(dataset_mpg);
ret = H5Sclose(fid1);
ret = H5Sclose(fid2);
ret = H5Fclose(file_id1);
return (EXIT_SUCCESS);
}
int
main()
{
printf("\n*** Checking HDF5 attribute functions for memory leaks.\n");
#ifdef EXTRA_TESTS
printf("*** Checking vlen of compound file...");
{
#define NUM_OBJ_2 2
#define ATT_NAME "Poseidon"
hid_t fapl_id, fcpl_id;
size_t chunk_cache_size = MY_CHUNK_CACHE_SIZE;
size_t chunk_cache_nelems = CHUNK_CACHE_NELEMS;
float chunk_cache_preemption = CHUNK_CACHE_PREEMPTION;
hid_t fileid, grpid, attid, spaceid;
hid_t s1_typeid, vlen_typeid;
hid_t file_typeid1[NUM_OBJ_2], native_typeid1[NUM_OBJ_2];
hid_t file_typeid2, native_typeid2;
hsize_t num_obj;
H5O_info_t obj_info;
char obj_name[STR_LEN + 1];
hsize_t dims[1] = {ATT_LEN}; /* netcdf attributes always 1-D. */
struct s1
{
float x;
double y;
};
/* vc stands for "Vlen of Compound." */
hvl_t *vc_out;
int i, k;
/* Create some output data: an array of vlen (length ATT_LEN) of
* struct s1. */
if (!(vc_out = calloc(sizeof(hvl_t), ATT_LEN))) ERR;
for (i = 0; i < ATT_LEN; i++)
{
vc_out[i].len = i + 1;
if (!(vc_out[i].p = calloc(sizeof(struct s1), vc_out[i].len))) ERR;
for (k = 0; k < vc_out[i].len; k++)
{
((struct s1 *)vc_out[i].p)[k].x = 42.42;
((struct s1 *)vc_out[i].p)[k].y = 2.0;
}
}
/* Create the HDF5 file, with cache control, creation order, and
* all the timmings. */
if ((fapl_id = H5Pcreate(H5P_FILE_ACCESS)) < 0) ERR;
if (H5Pset_fclose_degree(fapl_id, H5F_CLOSE_STRONG)) ERR;
if (H5Pset_cache(fapl_id, 0, chunk_cache_nelems, chunk_cache_size,
chunk_cache_preemption) < 0) ERR;
if ((fcpl_id = H5Pcreate(H5P_FILE_CREATE)) < 0) ERR;
if (H5Pset_link_creation_order(fcpl_id, (H5P_CRT_ORDER_TRACKED |
H5P_CRT_ORDER_INDEXED)) < 0) ERR;
if (H5Pset_attr_creation_order(fcpl_id, (H5P_CRT_ORDER_TRACKED |
H5P_CRT_ORDER_INDEXED)) < 0) ERR;
if ((fileid = H5Fcreate(FILE_NAME, H5F_ACC_TRUNC, fcpl_id, fapl_id)) < 0) ERR;
if (H5Pclose(fapl_id) < 0) ERR;
if (H5Pclose(fcpl_id) < 0) ERR;
/* Open the root group. */
if ((grpid = H5Gopen2(fileid, "/", H5P_DEFAULT)) < 0) ERR;
/* Create the compound type for struct s1. */
if ((s1_typeid = H5Tcreate(H5T_COMPOUND, sizeof(struct s1))) < 0) ERR;
if (H5Tinsert(s1_typeid, X_NAME, offsetof(struct s1, x),
H5T_NATIVE_FLOAT) < 0) ERR;
if (H5Tinsert(s1_typeid, Y_NAME, offsetof(struct s1, y),
H5T_NATIVE_DOUBLE) < 0) ERR;
if (H5Tcommit(grpid, S1_TYPE_NAME, s1_typeid) < 0) ERR;
/* Create a vlen type. Its a vlen of stuct s1. */
if ((vlen_typeid = H5Tvlen_create(s1_typeid)) < 0) ERR;
if (H5Tcommit(grpid, VLEN_TYPE_NAME, vlen_typeid) < 0) ERR;
/* Create an attribute of this new type. */
if ((spaceid = H5Screate_simple(1, dims, NULL)) < 0) ERR;
if ((attid = H5Acreate(grpid, ATT_NAME, vlen_typeid, spaceid,
H5P_DEFAULT)) < 0) ERR;
if (H5Awrite(attid, vlen_typeid, vc_out) < 0) ERR;
/* Close the types. */
if (H5Tclose(s1_typeid) < 0 ||
H5Tclose(vlen_typeid) < 0) ERR;
/* Close the att. */
if (H5Aclose(attid) < 0) ERR;
/* Close the space. */
if (H5Sclose(spaceid) < 0) ERR;
/* Close the group and file. */
if (H5Gclose(grpid) < 0 ||
H5Fclose(fileid) < 0) ERR;
/* Reopen the file. */
if ((fileid = H5Fopen(FILE_NAME, H5F_ACC_RDWR, H5P_DEFAULT)) < 0) ERR;
if ((grpid = H5Gopen(fileid, "/")) < 0) ERR;
/* How many objects in this group? (There should be 2, the
* types. Atts don't count as objects to HDF5.) */
if (H5Gget_num_objs(grpid, &num_obj) < 0) ERR;
if (num_obj != NUM_OBJ_2) ERR;
/* For each object in the group... */
for (i = 0; i < num_obj; i++)
{
/* Get the name, and make sure this is a type. */
if (H5Oget_info_by_idx(grpid, ".", H5_INDEX_CRT_ORDER, H5_ITER_INC,
i, &obj_info, H5P_DEFAULT) < 0) ERR;
if (H5Lget_name_by_idx(grpid, ".", H5_INDEX_NAME, H5_ITER_INC, i,
obj_name, STR_LEN + 1, H5P_DEFAULT) < 0) ERR;
if (obj_info.type != H5O_TYPE_NAMED_DATATYPE) ERR;
/* Get the typeid and native typeid. */
if ((file_typeid1[i] = H5Topen2(grpid, obj_name, H5P_DEFAULT)) < 0) ERR;
if ((native_typeid1[i] = H5Tget_native_type(file_typeid1[i],
H5T_DIR_DEFAULT)) < 0) ERR;
}
/* There is one att: open it by index. */
if ((attid = H5Aopen_idx(grpid, 0)) < 0) ERR;
/* Get file and native typeids of the att. */
if ((file_typeid2 = H5Aget_type(attid)) < 0) ERR;
if ((native_typeid2 = H5Tget_native_type(file_typeid2, H5T_DIR_DEFAULT)) < 0) ERR;
/* Close the attribute. */
if (H5Aclose(attid) < 0) ERR;
/* Close the typeids. */
for (i = 0; i < NUM_OBJ_2; i++)
{
if (H5Tclose(file_typeid1[i]) < 0) ERR;
if (H5Tclose(native_typeid1[i]) < 0) ERR;
}
if (H5Tclose(file_typeid2) < 0) ERR;
if (H5Tclose(native_typeid2) < 0) ERR;
/* Close the group and file. */
if (H5Gclose(grpid) < 0 ||
H5Fclose(fileid) < 0) ERR;
/* Deallocate our vlens. */
for (i = 0; i < ATT_LEN; i++)
free(vc_out[i].p);
free(vc_out);
}
SUMMARIZE_ERR;
#endif /* EXTRA_TESTS */
FINAL_RESULTS;
}
void UPCdata::writeHDF5file(char* filename){
#define LENGTH 5
#if HDF5_AVAILABLE==1
typedef struct s1_t {
int a;
float b;
double c;
} s1_t;
s1_t s1[LENGTH];
hid_t s1_tid; /* File datatype identifier */
hid_t file, dataset, space; /* Handles */
herr_t status;
hsize_t dim[] = {LENGTH}; /* Dataspace dimensions */
/*
* Initialize the data
*/
for (int i = 0; i< LENGTH; i++) {
s1[i].a = i;
s1[i].b = i*i;
s1[i].c = 1./(i+1);
}
/*
* Create the data space.
*/
space = H5Screate_simple(1, dim, NULL); // one dimensional in this case
/*
* Create the file.
*/
file = H5Fcreate(filename, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);
/*
* Create the memory datatype.
*/
s1_tid = H5Tcreate (H5T_COMPOUND, sizeof(s1_t));
H5Tinsert(s1_tid, "a_name", HOFFSET(s1_t, a), H5T_NATIVE_INT);
H5Tinsert(s1_tid, "c_name", HOFFSET(s1_t, c), H5T_NATIVE_DOUBLE);
H5Tinsert(s1_tid, "b_name", HOFFSET(s1_t, b), H5T_NATIVE_FLOAT);
/*
* Create the dataset.
*/
dataset = H5Dcreate1(file, "/dataset3", s1_tid, space, H5P_DEFAULT);
/*
* Write data to the dataset;
*/
status = H5Dwrite(dataset, s1_tid, H5S_ALL, H5S_ALL, H5P_DEFAULT, s1);
/*
* Release resources
*/
H5Tclose(s1_tid);
H5Sclose(space);
H5Dclose(dataset);
H5Fclose(file);
#endif
}
int
main (void)
{
hid_t sourcetype, desttype, strtype, space;
/* Handles */
herr_t status;
hsize_t dims[1] = {DIM0};
reading_t *reading; /* Conversion buffer */
sensor_t *sensor, /* Conversion buffer */
bkgrd[DIM0]; /* Background buffer */
int i;
/*
* Allocate memory for conversion buffer. We will allocate space
* for it to hold DIM0 elements of the destination type, as the
* type conversion is performed in place. Of course, if the
* destination type were smaller than the source type, we would
* allocate space to hold DIM0 elements of the source type.
*/
reading = (reading_t *) malloc (DIM0 * sizeof (sensor_t));
/*
* Assign the allocated space to a pointer of the destination type,
* to allow the buffer to be accessed correctly after the
* conversion has taken place.
*/
sensor = (sensor_t *) reading;
/*
* Initialize data.
*/
bkgrd[0].serial_no = 1153;
bkgrd[0].location = "Exterior (static)";
bkgrd[0].temperature = 53.23;
bkgrd[0].pressure = 24.57;
bkgrd[1].serial_no = 1184;
bkgrd[1].location = "Intake";
bkgrd[1].temperature = 55.12;
bkgrd[1].pressure = 22.95;
bkgrd[2].serial_no = 1027;
bkgrd[2].location = "Intake manifold";
bkgrd[2].temperature = 103.55;
bkgrd[2].pressure = 31.23;
bkgrd[3].serial_no = 1313;
bkgrd[3].location = "Exhaust manifold";
bkgrd[3].temperature = 1252.89;
bkgrd[3].pressure = 84.11;
reading[0].temperature = 54.84;
reading[0].pressure = 24.76;
reading[1].temperature = 56.63;
reading[1].pressure = 23.10;
reading[2].temperature = 102.69;
reading[2].pressure = 30.97;
reading[3].temperature = 1238.27;
reading[3].pressure = 82.15;
/*
* Create variable-length string datatype.
*/
strtype = H5Tcopy (H5T_C_S1);
status = H5Tset_size (strtype, H5T_VARIABLE);
/*
* Create the compound datatype for memory.
*/
sourcetype = H5Tcreate (H5T_COMPOUND, sizeof (reading_t));
status = H5Tinsert (sourcetype, "Temperature (F)",
HOFFSET (reading_t, temperature), H5T_NATIVE_DOUBLE);
status = H5Tinsert (sourcetype, "Pressure (inHg)",
HOFFSET (reading_t, pressure), H5T_NATIVE_DOUBLE);
desttype = H5Tcreate (H5T_COMPOUND, sizeof (sensor_t));
status = H5Tinsert (desttype, "Serial number",
HOFFSET (sensor_t, serial_no), H5T_NATIVE_INT);
status = H5Tinsert (desttype, "Location", HOFFSET (sensor_t, location),
strtype);
status = H5Tinsert (desttype, "Temperature (F)",
HOFFSET (sensor_t, temperature), H5T_NATIVE_DOUBLE);
status = H5Tinsert (desttype, "Pressure (inHg)",
HOFFSET (sensor_t, pressure), H5T_NATIVE_DOUBLE);
/*
* Create dataspace. Setting maximum size to NULL sets the maximum
* size to be the current size.
*/
space = H5Screate_simple (1, dims, NULL);
/*
* Convert the buffer in reading from sourcetype to desttype.
* After this conversion we will use sensor to access the buffer,
* as the buffer now matches its type.
*/
status = H5Tconvert (sourcetype, desttype, DIM0, reading, bkgrd,
H5P_DEFAULT);
/*
* Output the data to the screen.
*/
for (i=0; i<DIM0; i++) {
printf ("sensor[%d]:\n", i);
printf ("Serial number : %d\n", sensor[i].serial_no);
printf ("Location : %s\n", sensor[i].location);
printf ("Temperature (F) : %f\n", sensor[i].temperature);
printf ("Pressure (inHg) : %f\n\n", sensor[i].pressure);
}
/*
* Close and release resources. In this case H5Tconvert preserves
* the memory locations of the variable-length strings in
* "location", so we do not need to free those strings as they were
* initialized as string constants.
*/
free (sensor);
status = H5Sclose (space);
status = H5Tclose (sourcetype);
status = H5Tclose (desttype);
status = H5Tclose (strtype);
return 0;
}
herr_t write_complexe_1D_dataset(hid_t loc_id, const char* path,
float_complex* values, int nbvalues)
{
int i,rank = 1;
hsize_t dims[1];
hid_t dataspace_id, dset_id, dtr_id, dti_id;
size_t type_size;
hid_t type_id;
herr_t status, status_2;
float *real_part, *imag_part;
status_2 = 0;
real_part = (float *)malloc(nbvalues * sizeof(float));
imag_part = (float *)malloc(nbvalues * sizeof(float));
for( i=0;i<nbvalues;i++)
{
real_part[i] = crealf(values[i]);
imag_part[i] = cimagf(values[i]);
}
type_id = create_real_type_id();
dims[0] = nbvalues;
dataspace_id = H5Screate_simple(rank, dims, NULL);
dset_id = H5Dcreate(loc_id,path,type_id,dataspace_id,
H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
//Create datatype for writing
type_size = H5Tget_size(H5T_NATIVE_FLOAT);
dtr_id = H5Tcreate(H5T_COMPOUND,type_size);
status = H5Tinsert(dtr_id,"r",0, H5T_NATIVE_FLOAT);
if(status<0)
{
printf("Can insert real part \n");
status_2=-1;
}
dti_id = H5Tcreate(H5T_COMPOUND,type_size);
status = H5Tinsert(dti_id,"i",0, H5T_NATIVE_FLOAT);
if(status<0)
{
printf("Can insert imaginary part \n");
status_2=-1;
}
//write data
status = H5Dwrite(dset_id,dtr_id,H5S_ALL,H5S_ALL,H5P_DEFAULT,real_part);
if(status<0)
{
printf("Can write real part \n");
status_2=-1;
}
status = H5Dwrite(dset_id,dti_id,H5S_ALL,H5S_ALL,H5P_DEFAULT,imag_part);
if(status<0)
{
printf("Can write imaginary part \n");
status_2=-1;
}
status = H5Tclose(dtr_id);
status = H5Tclose(dti_id);
status = H5Tclose(dset_id);
status = H5Tclose(dataspace_id);
free(real_part);
free(imag_part);
return status_2;
}
int writetoh5(std::string tmpfileo, struct param par) {
hid_t h5file_id;
hid_t dtype_id;
hid_t dspace_id;
hid_t dset_id;
char *buffer;
int err;
std::string cpath, cname;
std::string patho = (std::string) par.patho;
std::string conto = (std::string) par.conto;
std::string grupo = (std::string) par.grupo;
std::string fileo = (std::string) par.fileo;
cpath = patho + "/" + conto;
cname = grupo + "/" + fileo;
/* open image */
FILE *fi = fopen(tmpfileo.c_str(),"r"); CHKRTN(!fi, FILEERR);
/* get file length */
fseek(fi, 0, SEEK_END);
hsize_t filen = ftell(fi);
fseek(fi, 0, SEEK_SET);
/* allocate memory */
buffer = (char *)malloc(filen+1); CHKRTN(!buffer, MEMERR);
/* read image */
fread(buffer, filen, 1, fi);
/* close file */
fclose(fi);
/* open container. it has to be created somewhere else. */
h5file_id = H5Fopen(cpath.c_str(), H5F_ACC_RDWR, H5P_DEFAULT);
CHKRTN(h5file_id < 0, FILEERR);
/* Create the datatype */
dtype_id = H5Tcreate(H5T_OPAQUE, 1);
/* Set the datatype tag */
err = H5Tset_tag(dtype_id, "Opaque Test Tag"); CHKERR(err);
/* Create the dataspace */
dspace_id = H5Screate_simple(1, &filen, NULL);
/* Create the dataset */
dset_id = H5Dcreate(h5file_id, cname.c_str(), dtype_id, dspace_id, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
/* Write the data out to the dataset */
err = H5Dwrite(dset_id, dtype_id, H5S_ALL, H5S_ALL, H5P_DEFAULT, buffer); CHKERR(err);
/* Close resource handles */
err = H5Dclose(dset_id); CHKERR(err);
err = H5Sclose(dspace_id); CHKERR(err);
err = H5Tclose(dtype_id); CHKERR(err);
err = H5Fclose(h5file_id); CHKERR(err);
free(buffer);
return EXIT_SUCCESS;
}
int
main(void)
{
/* First structure and dataset*/
typedef struct s1_t {
int a;
float b;
double c;
} s1_t;
s1_t s1[LENGTH];
hid_t s1_tid; /* File datatype identifier */
/* Second structure (subset of s1_t) and dataset*/
typedef struct s2_t {
double c;
int a;
} s2_t;
s2_t s2[LENGTH];
hid_t s2_tid; /* Memory datatype handle */
/* Third "structure" ( will be used to read float field of s1) */
hid_t s3_tid; /* Memory datatype handle */
float s3[LENGTH];
int i;
hid_t file, dataset, space; /* Handles */
herr_t status;
hsize_t dim[] = {LENGTH}; /* Dataspace dimensions */
/*
* Initialize the data
*/
for (i = 0; i< LENGTH; i++) {
s1[i].a = i;
s1[i].b = i*i;
s1[i].c = 1./(i+1);
}
/*
* Create the data space.
*/
space = H5Screate_simple(RANK, dim, NULL);
/*
* Create the file.
*/
file = H5Fcreate(H5FILE_NAME, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);
/*
* Create the memory data type.
*/
s1_tid = H5Tcreate (H5T_COMPOUND, sizeof(s1_t));
H5Tinsert(s1_tid, "a_name", HOFFSET(s1_t, a), H5T_NATIVE_INT);
H5Tinsert(s1_tid, "c_name", HOFFSET(s1_t, c), H5T_NATIVE_DOUBLE);
H5Tinsert(s1_tid, "b_name", HOFFSET(s1_t, b), H5T_NATIVE_FLOAT);
/*
* Create the dataset.
*/
dataset = H5Dcreate(file, DATASETNAME, s1_tid, space, H5P_DEFAULT);
/*
* Wtite data to the dataset;
*/
status = H5Dwrite(dataset, s1_tid, H5S_ALL, H5S_ALL, H5P_DEFAULT, s1);
/*
* Release resources
*/
H5Tclose(s1_tid);
H5Sclose(space);
H5Dclose(dataset);
H5Fclose(file);
/*
* Open the file and the dataset.
*/
file = H5Fopen(H5FILE_NAME, H5F_ACC_RDONLY, H5P_DEFAULT);
dataset = H5Dopen(file, DATASETNAME);
/*
* Create a data type for s2
*/
s2_tid = H5Tcreate(H5T_COMPOUND, sizeof(s2_t));
H5Tinsert(s2_tid, "c_name", HOFFSET(s2_t, c), H5T_NATIVE_DOUBLE);
H5Tinsert(s2_tid, "a_name", HOFFSET(s2_t, a), H5T_NATIVE_INT);
/*
* Read two fields c and a from s1 dataset. Fields in the file
* are found by their names "c_name" and "a_name".
*/
status = H5Dread(dataset, s2_tid, H5S_ALL, H5S_ALL, H5P_DEFAULT, s2);
/*
* Display the fields
*/
printf("\n");
printf("Field c : \n");
for( i = 0; i < LENGTH; i++) printf("%.4f ", s2[i].c);
printf("\n");
printf("\n");
printf("Field a : \n");
for( i = 0; i < LENGTH; i++) printf("%d ", s2[i].a);
printf("\n");
/*
* Create a data type for s3.
*/
s3_tid = H5Tcreate(H5T_COMPOUND, sizeof(float));
status = H5Tinsert(s3_tid, "b_name", 0, H5T_NATIVE_FLOAT);
/*
* Read field b from s1 dataset. Field in the file is found by its name.
*/
status = H5Dread(dataset, s3_tid, H5S_ALL, H5S_ALL, H5P_DEFAULT, s3);
/*
* Display the field
*/
printf("\n");
printf("Field b : \n");
for( i = 0; i < LENGTH; i++) printf("%.4f ", s3[i]);
printf("\n");
/*
* Release resources
*/
H5Tclose(s2_tid);
H5Tclose(s3_tid);
H5Dclose(dataset);
H5Fclose(file);
return 0;
}
int
main(void) {
hid_t fid1; /* HDF5 File IDs */
hid_t dataset; /* Dataset ID */
hid_t group; /* Group ID */
hid_t sid1; /* Dataspace ID */
hid_t tid1; /* Datatype ID */
hsize_t dims1[] = {SPACE1_DIM1};
hobj_ref_t *wbuf; /* buffer to write to disk */
int *tu32; /* Temporary pointer to int data */
int i; /* counting variables */
const char *write_comment="Foo!"; /* Comments for group */
herr_t ret; /* Generic return value */
/* Compound datatype */
typedef struct s1_t {
unsigned int a;
unsigned int b;
float c;
} s1_t;
/* Allocate write buffers */
wbuf=(hobj_ref_t *)malloc(sizeof(hobj_ref_t)*SPACE1_DIM1);
tu32=malloc(sizeof(int)*SPACE1_DIM1);
/* Create file */
fid1 = H5Fcreate(FILE1, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);
/* Create dataspace for datasets */
sid1 = H5Screate_simple(SPACE1_RANK, dims1, NULL);
/* Create a group */
group=H5Gcreate(fid1,"Group1",-1);
/* Set group's comment */
ret=H5Gset_comment(group,".",write_comment);
/* Create a dataset (inside Group1) */
dataset=H5Dcreate(group,"Dataset1",H5T_STD_U32LE,sid1,H5P_DEFAULT);
for(i=0; i<SPACE1_DIM1; i++)
tu32[i] = i*3;
/* Write selection to disk */
ret=H5Dwrite(dataset,H5T_NATIVE_INT,H5S_ALL,H5S_ALL,H5P_DEFAULT,tu32);
/* Close Dataset */
ret = H5Dclose(dataset);
/* Create another dataset (inside Group1) */
dataset=H5Dcreate(group,"Dataset2",H5T_NATIVE_UCHAR,sid1,H5P_DEFAULT);
/* Close Dataset */
ret = H5Dclose(dataset);
/* Create a datatype to refer to */
tid1 = H5Tcreate (H5T_COMPOUND, sizeof(s1_t));
/* Insert fields */
ret=H5Tinsert (tid1, "a", HOFFSET(s1_t,a), H5T_NATIVE_INT);
ret=H5Tinsert (tid1, "b", HOFFSET(s1_t,b), H5T_NATIVE_INT);
ret=H5Tinsert (tid1, "c", HOFFSET(s1_t,c), H5T_NATIVE_FLOAT);
/* Save datatype for later */
ret=H5Tcommit (group, "Datatype1", tid1);
/* Close datatype */
ret = H5Tclose(tid1);
/* Close group */
ret = H5Gclose(group);
/* Create a dataset to store references */
dataset=H5Dcreate(fid1,"Dataset3",H5T_STD_REF_OBJ,sid1,H5P_DEFAULT);
/* Create reference to dataset */
ret = H5Rcreate(&wbuf[0],fid1,"/Group1/Dataset1",H5R_OBJECT,-1);
/* Create reference to dataset */
ret = H5Rcreate(&wbuf[1],fid1,"/Group1/Dataset2",H5R_OBJECT,-1);
/* Create reference to group */
ret = H5Rcreate(&wbuf[2],fid1,"/Group1",H5R_OBJECT,-1);
/* Create reference to named datatype */
ret = H5Rcreate(&wbuf[3],fid1,"/Group1/Datatype1",H5R_OBJECT,-1);
/* Write selection to disk */
ret=H5Dwrite(dataset,H5T_STD_REF_OBJ,H5S_ALL,H5S_ALL,H5P_DEFAULT,wbuf);
/* Close disk dataspace */
ret = H5Sclose(sid1);
/* Close Dataset */
ret = H5Dclose(dataset);
/* Close file */
ret = H5Fclose(fid1);
free(wbuf);
free(tu32);
return 0;
}
void pyne::Material::write_hdf5(std::string filename, std::string datapath,
std::string nucpath, float row, int chunksize) {
int row_num = (int) row;
// Turn off annoying HDF5 errors
H5Eset_auto2(H5E_DEFAULT, NULL, NULL);
//Set file access properties so it closes cleanly
hid_t fapl;
fapl = H5Pcreate(H5P_FILE_ACCESS);
H5Pset_fclose_degree(fapl,H5F_CLOSE_STRONG);
// Create new/open datafile.
hid_t db;
if (pyne::file_exists(filename)) {
bool ish5 = H5Fis_hdf5(filename.c_str());
if (!ish5)
throw h5wrap::FileNotHDF5(filename);
db = H5Fopen(filename.c_str(), H5F_ACC_RDWR, fapl);
}
else
db = H5Fcreate(filename.c_str(), H5F_ACC_TRUNC, H5P_DEFAULT, fapl);
//
// Read in nuclist if available, write it out if not
//
bool nucpath_exists = h5wrap::path_exists(db, nucpath);
std::vector<int> nuclides;
int nuc_size;
hsize_t nuc_dims[1];
if (nucpath_exists) {
nuclides = h5wrap::h5_array_to_cpp_vector_1d<int>(db, nucpath, H5T_NATIVE_INT);
nuc_size = nuclides.size();
nuc_dims[0] = nuc_size;
} else {
nuclides = std::vector<int>();
for (pyne::comp_iter i = comp.begin(); i != comp.end(); i++)
nuclides.push_back(i->first);
nuc_size = nuclides.size();
// Create the data if it doesn't exist
int nuc_data [nuc_size];
for (int n = 0; n != nuc_size; n++)
nuc_data[n] = nuclides[n];
nuc_dims[0] = nuc_size;
hid_t nuc_space = H5Screate_simple(1, nuc_dims, NULL);
hid_t nuc_set = H5Dcreate2(db, nucpath.c_str(), H5T_NATIVE_INT, nuc_space,
H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
H5Dwrite(nuc_set, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, nuc_data);
H5Fflush(db, H5F_SCOPE_GLOBAL);
};
//
// Write out the data itself to the file
//
hid_t data_set, data_space, data_hyperslab;
int data_rank = 1;
hsize_t data_dims[1] = {1};
hsize_t data_max_dims[1] = {H5S_UNLIMITED};
hsize_t data_offset[1] = {0};
size_t material_struct_size = sizeof(pyne::material_struct) + sizeof(double)*nuc_size;
hid_t desc = H5Tcreate(H5T_COMPOUND, material_struct_size);
hid_t comp_values_array_type = H5Tarray_create2(H5T_NATIVE_DOUBLE, 1, nuc_dims);
// make the data table type
H5Tinsert(desc, "mass", HOFFSET(pyne::material_struct, mass), H5T_NATIVE_DOUBLE);
H5Tinsert(desc, "density", HOFFSET(pyne::material_struct, density),
H5T_NATIVE_DOUBLE);
H5Tinsert(desc, "atoms_per_molecule", HOFFSET(pyne::material_struct, atoms_per_mol),
H5T_NATIVE_DOUBLE);
H5Tinsert(desc, "comp", HOFFSET(pyne::material_struct, comp),
comp_values_array_type);
material_struct * mat_data = new material_struct[material_struct_size];
(*mat_data).mass = mass;
(*mat_data).density = density;
(*mat_data).atoms_per_mol = atoms_per_molecule;
for (int n = 0; n != nuc_size; n++) {
if (0 < comp.count(nuclides[n]))
(*mat_data).comp[n] = comp[nuclides[n]];
else
(*mat_data).comp[n] = 0.0;
};
// get / make the data set
bool datapath_exists = h5wrap::path_exists(db, datapath);
if (datapath_exists) {
data_set = H5Dopen2(db, datapath.c_str(), H5P_DEFAULT);
data_space = H5Dget_space(data_set);
data_rank = H5Sget_simple_extent_dims(data_space, data_dims, data_max_dims);
// Determine the row size.
if (std::signbit(row))
row_num = data_dims[0] + row; // careful, row is negative
if (data_dims[0] <= row_num) {
// row == -0, extend to data set so that we can append, or
// row_num is larger than current dimension, resize to accomodate.
data_dims[0] = row_num + 1;
H5Dset_extent(data_set, data_dims);
}
data_offset[0] = row_num;
} else {
// Get full space
data_space = H5Screate_simple(1, data_dims, data_max_dims);
// Make data set properties to enable chunking
hid_t data_set_params = H5Pcreate(H5P_DATASET_CREATE);
hsize_t chunk_dims[1] ={chunksize};
H5Pset_chunk(data_set_params, 1, chunk_dims);
H5Pset_deflate(data_set_params, 1);
material_struct * data_fill_value = new material_struct[material_struct_size];
(*data_fill_value).mass = -1.0;
(*data_fill_value).density= -1.0;
(*data_fill_value).atoms_per_mol = -1.0;
for (int n = 0; n != nuc_size; n++)
(*data_fill_value).comp[n] = 0.0;
H5Pset_fill_value(data_set_params, desc, &data_fill_value);
// Create the data set
data_set = H5Dcreate2(db, datapath.c_str(), desc, data_space, H5P_DEFAULT,
data_set_params, H5P_DEFAULT);
H5Dset_extent(data_set, data_dims);
// Add attribute pointing to nuc path
hid_t nuc_attr_type = H5Tcopy(H5T_C_S1);
H5Tset_size(nuc_attr_type, nucpath.length());
hid_t nuc_attr_space = H5Screate(H5S_SCALAR);
hid_t nuc_attr = H5Acreate2(data_set, "nucpath", nuc_attr_type, nuc_attr_space,
H5P_DEFAULT, H5P_DEFAULT);
H5Awrite(nuc_attr, nuc_attr_type, nucpath.c_str());
H5Fflush(db, H5F_SCOPE_GLOBAL);
// Remember to de-allocate
delete[] data_fill_value;
};
// Get the data hyperslab
data_hyperslab = H5Dget_space(data_set);
hsize_t data_count[1] = {1};
H5Sselect_hyperslab(data_hyperslab, H5S_SELECT_SET, data_offset, NULL, data_count, NULL);
// Get a memory space for writing
hid_t mem_space = H5Screate_simple(1, data_count, data_max_dims);
// Write the row...
H5Dwrite(data_set, desc, mem_space, data_hyperslab, H5P_DEFAULT, mat_data);
// Close out the Dataset
H5Fflush(db, H5F_SCOPE_GLOBAL);
H5Dclose(data_set);
H5Sclose(data_space);
H5Tclose(desc);
//
// Write out the metadata to the file
//
std::string attrpath = datapath + "_metadata";
hid_t metadatapace, attrtype, metadataet, metadatalab, attrmemspace;
int attrrank;
attrtype = H5Tvlen_create(H5T_NATIVE_CHAR);
// get / make the data set
bool attrpath_exists = h5wrap::path_exists(db, attrpath);
if (attrpath_exists) {
metadataet = H5Dopen2(db, attrpath.c_str(), H5P_DEFAULT);
metadatapace = H5Dget_space(metadataet);
attrrank = H5Sget_simple_extent_dims(metadatapace, data_dims, data_max_dims);
if (data_dims[0] <= row_num) {
// row == -0, extend to data set so that we can append, or
// row_num is larger than current dimension, resize to accomodate.
data_dims[0] = row_num + 1;
H5Dset_extent(metadataet, data_dims);
}
data_offset[0] = row_num;
} else {
hid_t metadataetparams;
hsize_t attrchunkdims [1];
// Make data set properties to enable chunking
metadataetparams = H5Pcreate(H5P_DATASET_CREATE);
attrchunkdims[0] = chunksize;
H5Pset_chunk(metadataetparams, 1, attrchunkdims);
H5Pset_deflate(metadataetparams, 1);
hvl_t attrfillvalue [1];
attrfillvalue[0].len = 3;
attrfillvalue[0].p = (char *) "{}\n";
H5Pset_fill_value(metadataetparams, attrtype, &attrfillvalue);
// make dataset
metadatapace = H5Screate_simple(1, data_dims, data_max_dims);
metadataet = H5Dcreate2(db, attrpath.c_str(), attrtype, metadatapace,
H5P_DEFAULT, metadataetparams, H5P_DEFAULT);
H5Dset_extent(metadataet, data_dims);
};
// set the attr string
hvl_t attrdata [1];
Json::FastWriter writer;
std::string metadatatr = writer.write(metadata);
attrdata[0].p = (char *) metadatatr.c_str();
attrdata[0].len = metadatatr.length();
// write the attr
metadatalab = H5Dget_space(metadataet);
H5Sselect_hyperslab(metadatalab, H5S_SELECT_SET, data_offset, NULL, data_count, NULL);
attrmemspace = H5Screate_simple(1, data_count, data_max_dims);
H5Dwrite(metadataet, attrtype, attrmemspace, metadatalab, H5P_DEFAULT, attrdata);
// close attr data objects
H5Fflush(db, H5F_SCOPE_GLOBAL);
H5Dclose(metadataet);
H5Sclose(metadatapace);
H5Tclose(attrtype);
// Close out the HDF5 file
H5Fclose(db);
// Remember the milk!
// ...by which I mean to deallocate
delete[] mat_data;
};
char dsetpath[8];
size_t l;
//
#if ISAREAL==1
#define TYPEA double
#else
#define TYPEA double complex
#endif
#if ISAREAL==1
#define TYPEL double
#else
#define TYPEL double complex
typedef struct { double re; double im; } complex_t;
hid_t complex_memtype = H5Tcreate (H5T_COMPOUND, sizeof(double complex));
H5Tinsert (complex_memtype, "r", HOFFSET(complex_t,re), H5T_NATIVE_DOUBLE);
H5Tinsert (complex_memtype, "i", HOFFSET(complex_t,im), H5T_NATIVE_DOUBLE);
#endif
//
////////////////////////////////////////////////////////////////////////
#if ISDENSITY==0
////////////////////////////////////////////////////////////////////////
// STATE
////////////////////////////////////////////////////////////////////////
hsize_t dims_out_idS[3];
size_t tjp1,ajp1,tjtp1,tjt,sup,aj,sdown,tj;
size_t dimsTxA, dimsT;
int
main()
{
printf("\n*** Creating file with datasets & attributes that have scalar dataspaces...");
{
hid_t fileid;
hid_t fcplid;
hid_t dsetid;
hid_t dcplid;
hid_t scalar_spaceid;
hid_t vlstr_typeid, fixstr_typeid;
hid_t attid;
/* Create scalar dataspace */
if ((scalar_spaceid = H5Screate(H5S_SCALAR)) < 0) ERR;
/* Set creation ordering for file, so we can revise its contents later */
if ((fcplid = H5Pcreate(H5P_FILE_CREATE)) < 0) ERR;
if (H5Pset_link_creation_order(fcplid, H5P_CRT_ORDER_TRACKED) < 0) ERR;
if (H5Pset_attr_creation_order(fcplid, H5P_CRT_ORDER_TRACKED) < 0) ERR;
/* Create new file, using default properties */
if ((fileid = H5Fcreate(FILE_NAME, H5F_ACC_TRUNC, fcplid, H5P_DEFAULT)) < 0) ERR;
/* Close file creation property list */
if (H5Pclose(fcplid) < 0) ERR;
/* Create variable-length string datatype */
if ((vlstr_typeid = H5Tcreate(H5T_STRING, (size_t)H5T_VARIABLE)) < 0) ERR;
/* Create fixed-length string datatype */
if ((fixstr_typeid = H5Tcreate(H5T_STRING, (size_t)10)) < 0) ERR;
/* Set creation ordering for dataset, so we can revise its contents later */
if ((dcplid = H5Pcreate(H5P_DATASET_CREATE)) < 0) ERR;
if (H5Pset_attr_creation_order(dcplid, H5P_CRT_ORDER_TRACKED) < 0) ERR;
/* Create scalar dataset with VL string datatype */
if ((dsetid = H5Dcreate2(fileid, VSTR_VAR1_NAME, vlstr_typeid, scalar_spaceid, H5P_DEFAULT, dcplid, H5P_DEFAULT)) < 0) ERR;
/* Add attributes to dataset */
if (add_attrs(dsetid) < 0) ERR;
/* Close VL string dataset */
if (H5Dclose(dsetid) < 0) ERR;
/* Create scalar dataset with fixed-length string datatype */
if ((dsetid = H5Dcreate2(fileid, FSTR_VAR_NAME, fixstr_typeid, scalar_spaceid, H5P_DEFAULT, dcplid, H5P_DEFAULT)) < 0) ERR;
/* Add attributes to dataset */
if (add_attrs(dsetid) < 0) ERR;
/* Close fixed-length string dataset */
if (H5Dclose(dsetid) < 0) ERR;
/* Create scalar dataset with native integer datatype */
if ((dsetid = H5Dcreate2(fileid, INT_VAR_NAME, H5T_NATIVE_INT, scalar_spaceid, H5P_DEFAULT, dcplid, H5P_DEFAULT)) < 0) ERR;
/* Add attributes to dataset */
if (add_attrs(dsetid) < 0) ERR;
/* Close native integer dataset */
if (H5Dclose(dsetid) < 0) ERR;
/* Add attributes to root group */
if (add_attrs(fileid) < 0) ERR;
/* Close dataset creation property list */
if (H5Pclose(dcplid) < 0) ERR;
/* Close string datatypes */
if (H5Tclose(vlstr_typeid) < 0) ERR;
if (H5Tclose(fixstr_typeid) < 0) ERR;
/* Close rest */
if (H5Sclose(scalar_spaceid) < 0) ERR;
if (H5Fclose(fileid) < 0) ERR;
}
SUMMARIZE_ERR;
printf("*** Checking accessing file through netCDF-4 API...");
{
int ncid, varid;
size_t len;
nc_type type;
int ndims;
char *vlstr;
int x;
if (nc_open(FILE_NAME, NC_NOWRITE, &ncid)) ERR;
/* Check the global attributes are OK */
if (check_attrs(ncid, NC_GLOBAL) < 0) ERR;
/* Verify that the VL string dataset is present and OK */
if (nc_inq_varid(ncid, VSTR_VAR1_NAME, &varid)) ERR;
if (varid != 0) ERR;
if (nc_inq_vartype(ncid, varid, &type)) ERR;
if (type != NC_STRING) ERR;
if (nc_inq_varndims(ncid, varid, &ndims)) ERR;
if (ndims != 0) ERR;
vlstr = NULL;
if (nc_get_var(ncid, varid, &vlstr)) ERR;
if (NULL != vlstr) ERR;
/* Check the variable's attributes are OK */
if (check_attrs(ncid, varid) < 0) ERR;
/* Verify that the fixed-length string dataset is present and OK */
if (nc_inq_varid(ncid, FSTR_VAR_NAME, &varid)) ERR;
if (varid != 1) ERR;
if (nc_inq_vartype(ncid, varid, &type)) ERR;
if (type != NC_STRING) ERR;
if (nc_inq_varndims(ncid, varid, &ndims)) ERR;
if (ndims != 0) ERR;
vlstr = NULL;
if (nc_get_var(ncid, varid, &vlstr)) ERR;
if ('\0' != *vlstr) ERR;
free(vlstr);
/* Check the variable's attributes are OK */
if (check_attrs(ncid, varid) < 0) ERR;
/* Verify that the integer dataset is present and OK */
if (nc_inq_varid(ncid, INT_VAR_NAME, &varid)) ERR;
if (varid != 2) ERR;
if (nc_inq_vartype(ncid, varid, &type)) ERR;
if (type != NC_INT) ERR;
if (nc_inq_varndims(ncid, varid, &ndims)) ERR;
if (ndims != 0) ERR;
x = -1;
if (nc_get_var(ncid, varid, &x)) ERR;
if (0 != x) ERR;
/* Check the variable's attributes are OK */
if (check_attrs(ncid, varid) < 0) ERR;
if (nc_close(ncid)) ERR;
}
SUMMARIZE_ERR;
printf("*** Checking revising file through netCDF-4 API...");
{
int ncid, varid;
char *vlstr;
if (nc_open(FILE_NAME, NC_WRITE, &ncid)) ERR;
/* Write to the VL string variable */
if (nc_inq_varid(ncid, VSTR_VAR1_NAME, &varid)) ERR;
vlstr = NULL;
if (nc_put_var(ncid, varid, &vlstr)) ERR;
vlstr = malloc(10);
*vlstr = '\0';
if (nc_put_var(ncid, varid, &vlstr)) ERR;
strcpy(vlstr, "foo");
if (nc_put_var(ncid, varid, &vlstr)) ERR;
free(vlstr);
/* Write to a VL string attribute */
vlstr = NULL;
if (nc_put_att(ncid, varid, VSTR_ATT1_NAME, NC_STRING, 1, &vlstr)) ERR;
vlstr = malloc(10);
*vlstr = '\0';
if (nc_put_att(ncid, varid, VSTR_ATT1_NAME, NC_STRING, 1, &vlstr)) ERR;
strcpy(vlstr, "foo");
if (nc_put_att(ncid, varid, VSTR_ATT1_NAME, NC_STRING, 1, &vlstr)) ERR;
free(vlstr);
/* Define a new VL string variable */
if (nc_def_var(ncid, VSTR_VAR2_NAME , NC_STRING, 0, NULL, &varid)) ERR;
/* Write to the variable's fill-value */
vlstr = NULL;
if (nc_put_att(ncid, varid, _FillValue, NC_STRING, 1, &vlstr)) ERR;
vlstr = malloc(10);
*vlstr = '\0';
if (nc_put_att(ncid, varid, _FillValue, NC_STRING, 1, &vlstr)) ERR;
strcpy(vlstr, "foo");
if (nc_put_att(ncid, varid, _FillValue, NC_STRING, 1, &vlstr)) ERR;
free(vlstr);
if (nc_close(ncid)) ERR;
}
SUMMARIZE_ERR;
FINAL_RESULTS;
}
hid_t arma_H5Tcreate(H5T_class_t cl, size_t size)
{
return H5Tcreate(cl, size);
}
int
main()
{
printf("\n*** Checking HDF5 attribute functions some more.\n");
printf("*** Creating tst_xplatform2_3.nc with HDF only...");
{
hid_t fapl_id, fcpl_id;
size_t chunk_cache_size = MY_CHUNK_CACHE_SIZE;
size_t chunk_cache_nelems = CHUNK_CACHE_NELEMS;
float chunk_cache_preemption = CHUNK_CACHE_PREEMPTION;
hid_t fileid, grpid, attid, spaceid;
hid_t s1_typeid, vlen_typeid, s3_typeid;
hid_t file_typeid1[NUM_OBJ], native_typeid1[NUM_OBJ];
hid_t file_typeid2, native_typeid2;
hsize_t num_obj;
H5O_info_t obj_info;
char obj_name[NC_MAX_NAME + 1];
hsize_t dims[1] = {ATT_LEN}; /* netcdf attributes always 1-D. */
struct s1
{
float x;
double y;
};
struct s3
{
nc_vlen_t data[NUM_VL];
};
/* cvc stands for "Compound with Vlen of Compound." */
struct s3 cvc_out[ATT_LEN];
int i, j, k;
/* Create some output data: a struct s3 array (length ATT_LEN)
* which holds an array of vlen (length NUM_VL) of struct s1. */
for (i = 0; i < ATT_LEN; i++)
for (j = 0; j < NUM_VL; j++)
{
cvc_out[i].data[j].len = i + 1;
if (!(cvc_out[i].data[j].p = malloc(sizeof(struct s1) * cvc_out[i].data[j].len)))
return NC_ENOMEM;
for (k = 0; k < cvc_out[i].data[j].len; k++)
{
((struct s1 *)cvc_out[i].data[j].p)[k].x = 42.42;
((struct s1 *)cvc_out[i].data[j].p)[k].y = 2.0;
}
}
/* Create the HDF5 file, with cache control, creation order, and
* all the timmings. */
if ((fapl_id = H5Pcreate(H5P_FILE_ACCESS)) < 0) ERR;
if (H5Pset_fclose_degree(fapl_id, H5F_CLOSE_STRONG)) ERR;
if (H5Pset_cache(fapl_id, 0, chunk_cache_nelems, chunk_cache_size,
chunk_cache_preemption) < 0) ERR;
if (H5Pset_libver_bounds(fapl_id, H5F_LIBVER_LATEST,
H5F_LIBVER_LATEST) < 0) ERR;
if ((fcpl_id = H5Pcreate(H5P_FILE_CREATE)) < 0) ERR;
if (H5Pset_link_creation_order(fcpl_id, (H5P_CRT_ORDER_TRACKED |
H5P_CRT_ORDER_INDEXED)) < 0) ERR;
if (H5Pset_attr_creation_order(fcpl_id, (H5P_CRT_ORDER_TRACKED |
H5P_CRT_ORDER_INDEXED)) < 0) ERR;
if ((fileid = H5Fcreate(FILE_NAME, H5F_ACC_TRUNC, fcpl_id, fapl_id)) < 0) ERR;
if (H5Pclose(fapl_id) < 0) ERR;
if (H5Pclose(fcpl_id) < 0) ERR;
/* Open the root group. */
if ((grpid = H5Gopen2(fileid, "/", H5P_DEFAULT)) < 0) ERR;
/* Create the compound type for struct s1. */
if ((s1_typeid = H5Tcreate(H5T_COMPOUND, sizeof(struct s1))) < 0) ERR;
if (H5Tinsert(s1_typeid, X_NAME, offsetof(struct s1, x),
H5T_NATIVE_FLOAT) < 0) ERR;
if (H5Tinsert(s1_typeid, Y_NAME, offsetof(struct s1, y),
H5T_NATIVE_DOUBLE) < 0) ERR;
if (H5Tcommit(grpid, S1_TYPE_NAME, s1_typeid) < 0) ERR;
/* Create a vlen type. Its a vlen of stuct s1. */
if ((vlen_typeid = H5Tvlen_create(s1_typeid)) < 0) ERR;
if (H5Tcommit(grpid, VLEN_TYPE_NAME, vlen_typeid) < 0) ERR;
/* Create the struct s3 type, which contains the vlen. */
if ((s3_typeid = H5Tcreate(H5T_COMPOUND, sizeof(struct s3))) < 0) ERR;
if (H5Tinsert(s3_typeid, VL_NAME, offsetof(struct s3, data),
vlen_typeid) < 0) ERR;
if (H5Tcommit(grpid, S3_TYPE_NAME, s3_typeid) < 0) ERR;
/* Create an attribute of this new type. */
if ((spaceid = H5Screate_simple(1, dims, NULL)) < 0) ERR;
if ((attid = H5Acreate(grpid, S3_ATT_NAME, s3_typeid, spaceid,
H5P_DEFAULT)) < 0) ERR;
if (H5Awrite(attid, s3_typeid, cvc_out) < 0) ERR;
/* Close the types. */
if (H5Tclose(s1_typeid) < 0 ||
H5Tclose(vlen_typeid) < 0 ||
H5Tclose(s3_typeid) < 0) ERR;
/* Close the att. */
if (H5Aclose(attid) < 0) ERR;
/* Close the space. */
if (H5Sclose(spaceid) < 0) ERR;
/* Close the group and file. */
if (H5Gclose(grpid) < 0 ||
H5Fclose(fileid) < 0) ERR;
/* Reopen the file. */
if ((fileid = H5Fopen(FILE_NAME, H5F_ACC_RDWR, H5P_DEFAULT)) < 0) ERR;
if ((grpid = H5Gopen(fileid, "/")) < 0) ERR;
/* How many objects in this group? (There should be 3, the
* types. Atts don't count as objects to HDF5.) */
if (H5Gget_num_objs(grpid, &num_obj) < 0) ERR;
if (num_obj != NUM_OBJ) ERR;
/* For each object in the group... */
for (i = 0; i < num_obj; i++)
{
/* Get the name, and make sure this is a type. */
if (H5Oget_info_by_idx(grpid, ".", H5_INDEX_CRT_ORDER, H5_ITER_INC,
i, &obj_info, H5P_DEFAULT) < 0) ERR;
if (H5Lget_name_by_idx(grpid, ".", H5_INDEX_NAME, H5_ITER_INC, i,
obj_name, NC_MAX_NAME + 1, H5P_DEFAULT) < 0) ERR;
if (obj_info.type != H5O_TYPE_NAMED_DATATYPE) ERR;
/* Get the typeid and native typeid. */
if ((file_typeid1[i] = H5Topen2(grpid, obj_name, H5P_DEFAULT)) < 0) ERR;
if ((native_typeid1[i] = H5Tget_native_type(file_typeid1[i],
H5T_DIR_DEFAULT)) < 0) ERR;
}
/* There is one att: open it by index. */
if ((attid = H5Aopen_idx(grpid, 0)) < 0) ERR;
/* Get file and native typeids of the att. */
if ((file_typeid2 = H5Aget_type(attid)) < 0) ERR;
if ((native_typeid2 = H5Tget_native_type(file_typeid2, H5T_DIR_DEFAULT)) < 0) ERR;
/* Close the attribute. */
if (H5Aclose(attid) < 0) ERR;
/* Close the typeids. */
for (i = 0; i < NUM_OBJ; i++)
{
printf(" free types %d ", i);
if (H5Tclose(file_typeid1[i]) < 0) ERR;
if (H5Tclose(native_typeid1[i]) < 0) ERR;
}
if (H5Tclose(file_typeid2) < 0) ERR;
if (H5Tclose(native_typeid2) < 0) ERR;
/* Close the group and file. */
if (H5Gclose(grpid) < 0 ||
H5Fclose(fileid) < 0) ERR;
/* Deallocate our vlens. */
for (i = 0; i < ATT_LEN; i++)
for (j = 0; j < NUM_VL; j++)
free(cvc_out[i].data[j].p);
}
SUMMARIZE_ERR;
FINAL_RESULTS;
}
void OHDF5mpipp::initialize(const double T)
{
#pragma omp single
{
T_ = T;
/*
* Create the compound datatype for memory.
*/
//spike
if (spike_datasets.size()>0) {
spike_dataset.sizeof_entry = 3*sizeof (int);
spike_dataset.memtype = H5Tcreate (H5T_COMPOUND, spike_dataset.sizeof_entry);
status = H5Tinsert (spike_dataset.memtype, "id",0, H5T_NATIVE_INT);
status = H5Tinsert (spike_dataset.memtype, "neuron id", 1*sizeof(int), H5T_NATIVE_INT);
status = H5Tinsert (spike_dataset.memtype, "timestamp",2*sizeof(int), H5T_NATIVE_INT);
spike_dataset.window_size=predictNewSpikeWindowSize(0, spike_dataset);
setNodeOffsetAndAllWindowSize(spike_dataset);
registerHDF5DataSet(spike_dataset, "SpikeDetectors");
spike_dataset.next_nodeoffset = 0;
spike_dataset.filespace = H5Dget_space (spike_dataset.dset_id);
}
//multi
if (multi_datasets.size()>0) {
//numberOfValues has to be the max numberOfValues of all nodes
multi_dataset.max_numberOfValues = 0;
for (int i=0; i<multi_datasets.size(); i++) {
if (multi_dataset.max_numberOfValues<multi_datasets[i].head.numberOfValues)
multi_dataset.max_numberOfValues = multi_datasets[i].head.numberOfValues;
}
int send_buf=multi_dataset.max_numberOfValues;
MPI_Allreduce(&send_buf, &multi_dataset.max_numberOfValues, 1, MPI_INT, MPI_MAX, MPI_COMM_WORLD);
multi_dataset.sizeof_entry = 3*sizeof (int)+multi_dataset.max_numberOfValues*sizeof(double);
multi_dataset.memtype = H5Tcreate (H5T_COMPOUND, multi_dataset.sizeof_entry);
status = H5Tinsert (multi_dataset.memtype, "id", 0, H5T_NATIVE_INT);
status = H5Tinsert (multi_dataset.memtype, "neuron id", sizeof(int), H5T_NATIVE_INT);
status = H5Tinsert (multi_dataset.memtype, "timestamp", 2*sizeof(int), H5T_NATIVE_INT);
for (int i=0; i<multi_dataset.max_numberOfValues; i++) {
std::stringstream ss;
ss << "V" << i;
status = H5Tinsert (multi_dataset.memtype, ss.str().c_str(),3*sizeof(int)+i*sizeof(double), H5T_NATIVE_DOUBLE);
}
multi_dataset.window_size=0;
for (int i=0; i<multi_datasets.size(); i++) {
multi_dataset.window_size += T_/multi_datasets[i].interval;
}
//std::cout << "multi window size=" << multi_dataset.window_size << std::endl;
setNodeOffsetAndAllWindowSize(multi_dataset);
registerHDF5DataSet(multi_dataset, "Multimeters");
}
}
}