/*-------------------------------------------------------------------------
* Function: create_nbit_dsets_float
*
* Purpose: Create a dataset of FLOAT datatype with nbit filter
*
* Return: Success: 0
* Failure: -1
*
* Programmer: Raymond Lu
* 29 March 2011
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
int
create_nbit_dsets_float(hid_t fid, hid_t fsid, hid_t msid)
{
hid_t dataset = -1; /* dataset handles */
hid_t datatype = -1;
hid_t dcpl = -1;
size_t precision, offset;
float data[NX][NY]; /* data to write */
float fillvalue = -2.2f;
hsize_t chunk[RANK] = {CHUNK0, CHUNK1};
int i, j;
/*
* Data and output buffer initialization.
*/
for (j = 0; j < NX; j++) {
for (i = 0; i < NY; i++)
data[j][i] = ((float)(i + j + 1))/3;
}
/*
* Create the dataset creation property list, add the Scale-Offset
* filter, set the chunk size, and set the fill value.
*/
if((dcpl = H5Pcreate(H5P_DATASET_CREATE)) < 0)
TEST_ERROR
if(H5Pset_nbit(dcpl) < 0)
TEST_ERROR
if(H5Pset_chunk(dcpl, RANK, chunk) < 0)
TEST_ERROR
if(H5Pset_fill_value(dcpl, H5T_NATIVE_FLOAT, &fillvalue) < 0)
TEST_ERROR
/* Define user-defined single-precision floating-point type for dataset.
* A 20-bit little-endian data type. */
if((datatype = H5Tcopy(H5T_IEEE_F32LE)) < 0)
TEST_ERROR
if(H5Tset_fields(datatype, (size_t)26, (size_t)20, (size_t)6, (size_t)7, (size_t)13) < 0)
TEST_ERROR
offset = 7;
if(H5Tset_offset(datatype,offset) < 0)
TEST_ERROR
precision = 20;
if(H5Tset_precision(datatype,precision) < 0)
TEST_ERROR
if(H5Tset_size(datatype, (size_t)4) < 0)
TEST_ERROR
if(H5Tset_ebias(datatype, (size_t)31) < 0)
TEST_ERROR
/*
* Create a new dataset within the file using defined dataspace,
* user-defined datatype, and default dataset creation properties.
*/
if((dataset = H5Dcreate2(fid, DATASETNAME22, datatype, fsid,
H5P_DEFAULT, dcpl, H5P_DEFAULT)) < 0)
TEST_ERROR
/*
* Write the data to the dataset using default transfer properties.
*/
if(H5Dwrite(dataset, H5T_NATIVE_FLOAT, msid, fsid, H5P_DEFAULT, data) < 0)
TEST_ERROR
/* Close dataset */
if(H5Dclose(dataset) < 0)
TEST_ERROR
/* Now create a dataset with a big-endian type */
if(H5Tset_order(datatype, H5T_ORDER_BE) < 0)
TEST_ERROR
if((dataset = H5Dcreate2(fid, DATASETNAME23, datatype, fsid,
H5P_DEFAULT, dcpl, H5P_DEFAULT)) < 0)
TEST_ERROR
if(H5Dwrite(dataset, H5T_NATIVE_FLOAT, msid, fsid, H5P_DEFAULT, data) < 0)
TEST_ERROR
if(H5Dclose(dataset) < 0)
TEST_ERROR
/*
* Close/release resources.
*/
if(H5Pclose(dcpl) < 0)
TEST_ERROR
return 0;
error:
H5E_BEGIN_TRY {
H5Pclose(dcpl);
H5Dclose(dataset);
} H5E_END_TRY;
return -1;
}
int main(int argc, char *argv[])
{
(void)argc;
(void)argv;
typedef struct rt {
int channels;
char date[DATELEN];
char time[TIMELEN];
} rt;
// H5Fis_hdf5("/dev/null");
/*
* Create a new file using H5ACC_TRUNC access,
* default file creation properties, and default file
* access properties.
* Then close the file.
*/
const int NRECORDS = 1;
const int NFIELDS = 3;
char fName[] = "tmp.h5";
/* Calculate the size and the offsets of our struct members in memory */
size_t rt_offset[NFIELDS] = { HOFFSET( rt, channels ),
HOFFSET( rt, date ),
HOFFSET( rt, time )};
rt p_data;
p_data.channels = 1;
strcpy( p_data.date, "1234-Dec-31");
strcpy( p_data.time, "12:34:56");
hid_t file_id = H5Fcreate(fName, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);
/* Define field information */
const char *field_names[NFIELDS] = { "channels", "date", "time" };
hid_t field_type[NFIELDS];
/* Initialize the field field_type */
hid_t string_type1 = H5Tcopy( H5T_C_S1 );
hid_t string_type2 = H5Tcopy( H5T_C_S1 );
H5Tset_size( string_type1, strlen(p_data.date));
H5Tset_size( string_type2, strlen(p_data.time));
field_type[0] = H5T_NATIVE_INT;
field_type[1] = string_type1;
field_type[2] = string_type2;
std::ostringstream desc;
desc << "Description of " << fName;
herr_t status = H5TBmake_table( desc.str().c_str(), file_id, "description", (hsize_t)NFIELDS, (hsize_t)NRECORDS, sizeof(rt),
field_names, rt_offset, field_type, 10, NULL, 0, &p_data );
if (status < 0) {
perror("Exception while writing description in stfio::exportHDF5File");
H5Fclose(file_id);
H5close();
exit(-1);
}
H5Fclose(file_id);
return(0);
}
hid_t H5PTcreate_fl ( hid_t loc_id,
const char *dset_name,
hid_t dtype_id,
hsize_t chunk_size,
int compression )
{
htbl_t * table = NULL;
hid_t dset_id = H5I_BADID;
hid_t space_id = H5I_BADID;
hid_t plist_id = H5I_BADID;
hsize_t dims[1];
hsize_t dims_chunk[1];
hsize_t maxdims[1];
hid_t ret_value;
/* Register the packet table ID type if this is the first table created */
if(H5PT_ptable_id_type < 0)
if((H5PT_ptable_id_type = H5Iregister_type((size_t)H5PT_HASH_TABLE_SIZE, 0, (H5I_free_t)free)) < 0)
goto out;
/* Get memory for the table identifier */
table = (htbl_t *)malloc(sizeof(htbl_t));
/* Create a simple data space with unlimited size */
dims[0] = 0;
dims_chunk[0] = chunk_size;
maxdims[0] = H5S_UNLIMITED;
if((space_id = H5Screate_simple(1, dims, maxdims)) < 0)
goto out;
/* Modify dataset creation properties to enable chunking */
plist_id = H5Pcreate(H5P_DATASET_CREATE);
if(H5Pset_chunk(plist_id, 1, dims_chunk) < 0)
goto out;
if(compression >= 0 && compression <= 9)
if(H5Pset_deflate(plist_id, (unsigned)compression) < 0)
goto out;
/* Create the dataset. */
if((dset_id = H5Dcreate2(loc_id, dset_name, dtype_id, space_id, H5P_DEFAULT, plist_id, H5P_DEFAULT)) < 0)
goto out;
/* Terminate access to the data space. */
if(H5Sclose(space_id) < 0)
goto out;
/* End access to the property list */
if(H5Pclose(plist_id) < 0)
goto out;
/* Create the table identifier */
table->dset_id = dset_id;
if((table->type_id = H5Tcopy(dtype_id)) < 0)
goto out;
H5PT_create_index(table);
table->size = 0;
/* Get an ID for this table */
ret_value = H5Iregister(H5PT_ptable_id_type, table);
if(ret_value != H5I_INVALID_HID)
H5PT_ptable_count++;
else
H5PT_close(table);
return ret_value;
out:
H5E_BEGIN_TRY
H5Sclose(space_id);
H5Pclose(plist_id);
H5Dclose(dset_id);
if(table)
free(table);
H5E_END_TRY
return H5I_INVALID_HID;
}
/*
* Generate HDF5 file with latest format with
* NUM_GRPS groups and NUM_ATTRS attributes for the dataset
*
*/
static void
gen_newgrat_file(const char *fname)
{
hid_t fapl; /* File access property */
hid_t fid; /* File id */
hid_t gid; /* Group id */
hid_t tid; /* Datatype id */
hid_t sid; /* Dataspace id */
hid_t attr_id; /* Attribute id */
hid_t did; /* Dataset id */
char name[30]; /* Group name */
char attrname[30]; /* Attribute name */
int i; /* Local index variable */
/* Get a copy file access property list */
if((fapl = H5Pcreate(H5P_FILE_ACCESS)) < 0)
goto error;
/* Set to use latest library format */
if(H5Pset_libver_bounds(fapl, H5F_LIBVER_LATEST, H5F_LIBVER_LATEST) < 0)
goto error;
/* Create dataset */
if((fid = H5Fcreate(NEWGRAT_FILE, H5F_ACC_TRUNC, H5P_DEFAULT, fapl)) < 0)
goto error;
/* Create NUM_GRPS groups in the root group */
for(i = 1; i <= NUM_GRPS; i++) {
sprintf(name, "%s%d", GROUP_NAME,i);
if((gid = H5Gcreate2(fid, name, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT)) < 0)
goto error;
if(H5Gclose(gid) < 0)
goto error;
} /* end for */
/* Create a datatype to commit and use */
if((tid = H5Tcopy(H5T_NATIVE_INT)) < 0)
goto error;
/* Create dataspace for dataset */
if((sid = H5Screate(H5S_SCALAR)) < 0)
goto error;
/* Create dataset */
if((did = H5Dcreate2(fid, DATASET_NAME, tid, sid, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT)) < 0)
goto error;
/* Create NUM_ATTRS for the dataset */
for(i = 1; i <= NUM_ATTRS; i++) {
sprintf(attrname, "%s%d", ATTR_NAME,i);
if((attr_id = H5Acreate2(did, attrname, tid, sid, H5P_DEFAULT, H5P_DEFAULT)) < 0)
goto error;
if(H5Aclose(attr_id) < 0)
goto error;
} /* end for */
/* Close dataset, dataspace, datatype, file */
if(H5Dclose(did) < 0)
goto error;
if(H5Sclose(sid) < 0)
goto error;
if(H5Tclose(tid) < 0)
goto error;
if(H5Fclose(fid) < 0)
goto error;
error:
H5E_BEGIN_TRY {
H5Aclose(attr_id);
H5Dclose(did);
H5Tclose(tid);
H5Sclose(sid);
H5Gclose(gid);
H5Fclose(fid);
} H5E_END_TRY;
} /* gen_newgrat_file() */
/*-------------------------------------------------------------------------
* Function: test_multi
*
* Purpose: Tests the file handle interface for MUTLI driver
*
* Return: Success: 0
* Failure: -1
*
* Programmer: Raymond Lu
* Tuesday, Sept 24, 2002
*
* Modifications:
*
* Raymond Lu
* Wednesday, June 23, 2004
* Added test for H5Fget_filesize.
*
*-------------------------------------------------------------------------
*/
static herr_t
test_multi(void)
{
hid_t file=(-1), fapl, fapl2=(-1), dset=(-1), space=(-1);
hid_t root, attr, aspace, atype;
hid_t access_fapl = -1;
char filename[1024];
int *fhandle2=NULL, *fhandle=NULL;
hsize_t file_size;
H5FD_mem_t mt, memb_map[H5FD_MEM_NTYPES];
hid_t memb_fapl[H5FD_MEM_NTYPES];
haddr_t memb_addr[H5FD_MEM_NTYPES];
const char *memb_name[H5FD_MEM_NTYPES];
char sv[H5FD_MEM_NTYPES][32];
hsize_t dims[2]={MULTI_SIZE, MULTI_SIZE};
hsize_t adims[1]={1};
char dname[]="dataset";
char meta[] = "this is some metadata on this file";
int i, j;
int buf[MULTI_SIZE][MULTI_SIZE];
TESTING("MULTI file driver");
/* Set file access property list for MULTI driver */
fapl = h5_fileaccess();
HDmemset(memb_map, 0, sizeof memb_map);
HDmemset(memb_fapl, 0, sizeof memb_fapl);
HDmemset(memb_name, 0, sizeof memb_name);
HDmemset(memb_addr, 0, sizeof memb_addr);
HDmemset(sv, 0, sizeof sv);
for(mt=H5FD_MEM_DEFAULT; mt<H5FD_MEM_NTYPES; H5_INC_ENUM(H5FD_mem_t,mt)) {
memb_fapl[mt] = H5P_DEFAULT;
memb_map[mt] = H5FD_MEM_SUPER;
}
memb_map[H5FD_MEM_DRAW] = H5FD_MEM_DRAW;
memb_map[H5FD_MEM_BTREE] = H5FD_MEM_BTREE;
memb_map[H5FD_MEM_GHEAP] = H5FD_MEM_GHEAP;
sprintf(sv[H5FD_MEM_SUPER], "%%s-%c.h5", 's');
memb_name[H5FD_MEM_SUPER] = sv[H5FD_MEM_SUPER];
memb_addr[H5FD_MEM_SUPER] = 0;
sprintf(sv[H5FD_MEM_BTREE], "%%s-%c.h5", 'b');
memb_name[H5FD_MEM_BTREE] = sv[H5FD_MEM_BTREE];
memb_addr[H5FD_MEM_BTREE] = HADDR_MAX/4;
sprintf(sv[H5FD_MEM_DRAW], "%%s-%c.h5", 'r');
memb_name[H5FD_MEM_DRAW] = sv[H5FD_MEM_DRAW];
memb_addr[H5FD_MEM_DRAW] = HADDR_MAX/2;
sprintf(sv[H5FD_MEM_GHEAP], "%%s-%c.h5", 'g');
memb_name[H5FD_MEM_GHEAP] = sv[H5FD_MEM_GHEAP];
memb_addr[H5FD_MEM_GHEAP] = HADDR_MAX*3/4;
if(H5Pset_fapl_multi(fapl, memb_map, memb_fapl, memb_name, memb_addr, TRUE) < 0)
TEST_ERROR;
h5_fixname(FILENAME[4], fapl, filename, sizeof filename);
if((file=H5Fcreate(filename, H5F_ACC_TRUNC, H5P_DEFAULT, fapl)) < 0)
TEST_ERROR;
if(H5Fclose(file) < 0)
TEST_ERROR;
/* Test wrong ways to reopen multi files */
if(test_multi_opens(filename) < 0)
TEST_ERROR;
/* Reopen the file */
if((file=H5Fopen(filename, H5F_ACC_RDWR, fapl)) < 0)
TEST_ERROR;
/* Create and write data set */
if((space=H5Screate_simple(2, dims, NULL)) < 0)
TEST_ERROR;
/* Retrieve the access property list... */
if ((access_fapl = H5Fget_access_plist(file)) < 0)
TEST_ERROR;
/* ...and close the property list */
if (H5Pclose(access_fapl) < 0)
TEST_ERROR;
/* Check file size API */
if(H5Fget_filesize(file, &file_size) < 0)
TEST_ERROR;
/* Before any data is written, the raw data file is empty. So
* the file size is only the size of b-tree + HADDR_MAX/4.
*/
if(file_size < HADDR_MAX/4 || file_size > HADDR_MAX/2)
TEST_ERROR;
if((dset=H5Dcreate2(file, dname, H5T_NATIVE_INT, space, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT)) < 0)
TEST_ERROR;
for(i=0; i<MULTI_SIZE; i++)
for(j=0; j<MULTI_SIZE; j++)
buf[i][j] = i*10000+j;
if(H5Dwrite(dset, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, buf) < 0)
TEST_ERROR;
if((fapl2=H5Pcreate(H5P_FILE_ACCESS)) < 0)
TEST_ERROR;
if(H5Pset_multi_type(fapl2, H5FD_MEM_SUPER) < 0)
TEST_ERROR;
if(H5Fget_vfd_handle(file, fapl2, (void **)&fhandle) < 0)
TEST_ERROR;
if(*fhandle<0)
TEST_ERROR;
if(H5Pset_multi_type(fapl2, H5FD_MEM_DRAW) < 0)
TEST_ERROR;
if(H5Fget_vfd_handle(file, fapl2, (void **)&fhandle2) < 0)
TEST_ERROR;
if(*fhandle2<0)
TEST_ERROR;
/* Check file size API */
if(H5Fget_filesize(file, &file_size) < 0)
TEST_ERROR;
/* After the data is written, the file size is huge because the
* beginning of raw data file is set at HADDR_MAX/2. It's supposed
* to be (HADDR_MAX/2 + 128*128*4)
*/
if(file_size < HADDR_MAX/2 || file_size > HADDR_MAX)
TEST_ERROR;
if(H5Sclose(space) < 0)
TEST_ERROR;
if(H5Dclose(dset) < 0)
TEST_ERROR;
if(H5Pclose(fapl2) < 0)
TEST_ERROR;
/* Create and write attribute for the root group. */
if((root = H5Gopen2(file, "/", H5P_DEFAULT)) < 0)
FAIL_STACK_ERROR
/* Attribute string. */
if((atype = H5Tcopy(H5T_C_S1)) < 0)
TEST_ERROR;
if(H5Tset_size(atype, strlen(meta) + 1) < 0)
TEST_ERROR;
if(H5Tset_strpad(atype, H5T_STR_NULLTERM) < 0)
TEST_ERROR;
/* Create and write attribute */
if((aspace = H5Screate_simple(1, adims, NULL)) < 0)
TEST_ERROR;
if((attr = H5Acreate2(root, "Metadata", atype, aspace, H5P_DEFAULT, H5P_DEFAULT)) < 0)
TEST_ERROR;
if(H5Awrite(attr, atype, meta) < 0)
TEST_ERROR;
/* Close IDs */
if(H5Tclose(atype) < 0)
TEST_ERROR;
if(H5Sclose(aspace) < 0)
TEST_ERROR;
if(H5Aclose(attr) < 0)
TEST_ERROR;
if(H5Fclose(file) < 0)
TEST_ERROR;
h5_cleanup(FILENAME, fapl);
PASSED();
return 0;
error:
H5E_BEGIN_TRY {
H5Sclose(space);
H5Dclose(dset);
H5Pclose(fapl);
H5Pclose(fapl2);
H5Fclose(file);
} H5E_END_TRY;
return -1;
}
/*
adds different types of attributes to an object.
returns the number of attributes added to the objects.
*/
int add_attrs(hid_t oid, int idx)
{
char name[32];
int i0, i1, i2, j, nattrs=0;
hid_t aid, tid, tid1, sid;
hvl_t i_vlen[4];
hobj_ref_t ref;
zipcode_t cmp_data[4];
unsigned int i = 0xffffffff;
long long l = -2147483647;
float f = 123456789.987654321;
double d = 987654321.123456789;
char *s[7] = {"Parting", "is such", "sweeter", "sorrow."};
float f_array[4] = {1.0, 2.22, 3.333, 4.444};
char *s_vlen[4] = {"Parting", "is such", "sweet", "sorrow."};
hsize_t dims1[1]={1}, dims2[1]={4}, dims3[2]={3,5};
int int3d[4][3][5];
size_t offset = 0;
for (i0=0; i0<4; i0++) {
i_vlen[i0].len = (i0+1);
i_vlen[i0].p = (int *)calloc(i_vlen[i0].len, sizeof(int));
for (j=0; j<i_vlen[i0].len; j++)
((int *)i_vlen[i0].p)[j] = i0*100+j;
for (i1=0; i1<3; i1++) {
for (i2=0; i2<5; i2++)
int3d[i0][i1][i2] = i0*i1-i1*i2+i0*i2;
}
}
cmp_data[0].zipcode = 01001;
cmp_data[0].city = "Agawam, Massachusetts";
cmp_data[1].zipcode = 99950;
cmp_data[1].city = "Ketchikan, Alaska";
cmp_data[2].zipcode = 00501;
cmp_data[2].city = "Holtsville, New York";
cmp_data[3].zipcode = 61820;
cmp_data[3].city = "Champaign, Illinois";
/* 1 scalar point */
sid = H5Screate (H5S_SCALAR);
sprintf(name, "%05d scalar int", idx);
nattrs += add_attr(oid, name, H5T_NATIVE_UINT, sid, &i);
sprintf(name, "%05d scalar ulong", idx);
nattrs += add_attr(oid, name, H5T_NATIVE_INT64, sid, &l);
sprintf(name, "%05d scalar str", idx);
tid = H5Tcopy (H5T_C_S1);
H5Tset_size (tid, H5T_VARIABLE);
nattrs += add_attr(oid, name, tid, sid, &s[2]);
H5Tclose(tid);
H5Sclose(sid);
/* 4 single point */
sid = H5Screate_simple (1, dims1, NULL);
H5Rcreate(&ref, oid, ".", H5R_OBJECT, -1);
sprintf(name, "%05d single float", idx);
nattrs += add_attr(oid, name, H5T_NATIVE_FLOAT, sid, &f);
sprintf(name, "%05d single double", idx);
nattrs += add_attr(oid, name, H5T_NATIVE_DOUBLE, sid, &d);
sprintf(name, "%05d single obj_ref", idx);
nattrs += add_attr(oid, name, H5T_STD_REF_OBJ, sid, &ref);
H5Sclose(sid);
/* 7 fixed length 1D array */
sid = H5Screate_simple (1, dims1, NULL);
tid = H5Tarray_create (H5T_NATIVE_FLOAT, 1, dims2);
sprintf(name, "%05d array float", idx);
nattrs += add_attr(oid, name, tid, sid, &f_array[0]);
H5Tclose(tid);
tid = H5Tcopy (H5T_C_S1);
H5Tset_size (tid, strlen(s[0])+1);
tid1 = H5Tarray_create (tid, 1, dims2);
sprintf(name, "%05d array str", idx);
nattrs += add_attr(oid, name, tid1, sid, s);
H5Tclose(tid1);
H5Tclose(tid);
H5Sclose(sid);
/* 9 fixed length 2D int arrays */
sid = H5Screate_simple (1, dims2, NULL);
tid = H5Tarray_create (H5T_NATIVE_INT, 2, dims3);
sprintf(name, "%05d array int 2D", idx);
nattrs += add_attr(oid, name, tid, sid, int3d[0][0]);
H5Tclose(tid);
H5Sclose(sid);
/* 10 variable length arrays */
sid = H5Screate_simple (1, dims2, NULL);
tid = H5Tcopy (H5T_C_S1);
H5Tset_size (tid, H5T_VARIABLE);
sprintf(name, "%05d vlen strings", idx);
nattrs += add_attr(oid, name, tid, sid, s_vlen);
H5Tclose(tid);
tid = H5Tvlen_create (H5T_NATIVE_INT);;
sprintf(name, "%05d vlen int array", idx);
nattrs += add_attr(oid, name, tid, sid, i_vlen);
H5Tclose(tid);
H5Sclose(sid);
/* 12 compound data */
sid = H5Screate_simple (1, dims2, NULL);
tid = H5Tcreate (H5T_COMPOUND, sizeof (zipcode_t));
tid1 = H5Tcopy (H5T_C_S1);
H5Tset_size (tid1, H5T_VARIABLE);
H5Tinsert (tid, "zip code", 0, H5T_NATIVE_INT); offset += sizeof(H5T_NATIVE_INT);
H5Tinsert (tid, "City", offset, tid1); offset += sizeof(char *);
sprintf(name, "%05d compound data", idx);
nattrs += add_attr(oid, name, tid, sid, cmp_data);
H5Tclose(tid1);
H5Tclose(tid);
H5Sclose(sid);
for (i0=0; i0<4; i0++)
free(i_vlen[i0].p);
return nattrs;
}
/*! This function reads a snapshot file and distributes the data it contains
* to tasks 'readTask' to 'lastTask'.
*/
void read_file(char *fname, int readTask, int lastTask)
{
int blockmaxlen;
int i, n_in_file, n_for_this_task, ntask, pc, offset = 0, task;
int blksize1, blksize2;
MPI_Status status;
FILE *fd = 0;
int nall;
int type;
char label[4];
int nstart, bytes_per_blockelement, npart, nextblock, typelist[6];
enum iofields blocknr;
#ifdef HAVE_HDF5
char buf[500];
int rank, pcsum;
hid_t hdf5_file, hdf5_grp[6], hdf5_dataspace_in_file;
hid_t hdf5_datatype, hdf5_dataspace_in_memory, hdf5_dataset;
hsize_t dims[2], count[2], start[2];
#endif
#define SKIP {my_fread(&blksize1,sizeof(int),1,fd);}
#define SKIP2 {my_fread(&blksize2,sizeof(int),1,fd);}
if(ThisTask == readTask)
{
if(All.ICFormat == 1 || All.ICFormat == 2)
{
if(!(fd = fopen(fname, "r")))
{
printf("can't open file `%s' for reading initial conditions.\n", fname);
endrun(123);
}
if(All.ICFormat == 2)
{
SKIP;
my_fread(&label, sizeof(char), 4, fd);
my_fread(&nextblock, sizeof(int), 1, fd);
printf("Reading header => '%c%c%c%c' (%d byte)\n", label[0], label[1], label[2], label[3],
nextblock);
SKIP2;
}
SKIP;
my_fread(&header, sizeof(header), 1, fd);
SKIP2;
if(blksize1 != 256 || blksize2 != 256)
{
printf("incorrect header format\n");
fflush(stdout);
endrun(890);
}
}
#ifdef HAVE_HDF5
if(All.ICFormat == 3)
{
read_header_attributes_in_hdf5(fname);
hdf5_file = H5Fopen(fname, H5F_ACC_RDONLY, H5P_DEFAULT);
for(type = 0; type < 6; type++)
{
if(header.npart[type] > 0)
{
sprintf(buf, "/PartType%d", type);
hdf5_grp[type] = H5Gopen(hdf5_file, buf);
}
}
}
#endif
for(task = readTask + 1; task <= lastTask; task++)
MPI_Ssend(&header, sizeof(header), MPI_BYTE, task, TAG_HEADER, MPI_COMM_WORLD);
}
else
MPI_Recv(&header, sizeof(header), MPI_BYTE, readTask, TAG_HEADER, MPI_COMM_WORLD, &status);
if(All.TotNumPart == 0)
{
if(header.num_files <= 1)
for(i = 0; i < 6; i++)
header.npartTotal[i] = header.npart[i];
All.TotN_gas = header.npartTotal[0] + (((long long) header.npartTotalHighWord[0]) << 32);
for(i = 0, All.TotNumPart = 0; i < 6; i++)
{
All.TotNumPart += header.npartTotal[i];
All.TotNumPart += (((long long) header.npartTotalHighWord[i]) << 32);
}
for(i = 0; i < 6; i++)
All.MassTable[i] = header.mass[i];
All.MaxPart = All.PartAllocFactor * (All.TotNumPart / NTask); /* sets the maximum number of particles that may */
All.MaxPartSph = All.PartAllocFactor * (All.TotN_gas / NTask); /* sets the maximum number of particles that may
reside on a processor */
allocate_memory();
if(RestartFlag == 2)
All.Time = All.TimeBegin = header.time;
}
if(ThisTask == readTask)
{
for(i = 0, n_in_file = 0; i < 6; i++)
n_in_file += header.npart[i];
printf("\nreading file `%s' on task=%d (contains %d particles.)\n"
"distributing this file to tasks %d-%d\n"
"Type 0 (gas): %8d (tot=%6d%09d) masstab=%g\n"
"Type 1 (halo): %8d (tot=%6d%09d) masstab=%g\n"
"Type 2 (disk): %8d (tot=%6d%09d) masstab=%g\n"
"Type 3 (bulge): %8d (tot=%6d%09d) masstab=%g\n"
"Type 4 (stars): %8d (tot=%6d%09d) masstab=%g\n"
"Type 5 (bndry): %8d (tot=%6d%09d) masstab=%g\n\n", fname, ThisTask, n_in_file, readTask,
lastTask, header.npart[0], (int) (header.npartTotal[0] / 1000000000),
(int) (header.npartTotal[0] % 1000000000), All.MassTable[0], header.npart[1],
(int) (header.npartTotal[1] / 1000000000), (int) (header.npartTotal[1] % 1000000000),
All.MassTable[1], header.npart[2], (int) (header.npartTotal[2] / 1000000000),
(int) (header.npartTotal[2] % 1000000000), All.MassTable[2], header.npart[3],
(int) (header.npartTotal[3] / 1000000000), (int) (header.npartTotal[3] % 1000000000),
All.MassTable[3], header.npart[4], (int) (header.npartTotal[4] / 1000000000),
(int) (header.npartTotal[4] % 1000000000), All.MassTable[4], header.npart[5],
(int) (header.npartTotal[5] / 1000000000), (int) (header.npartTotal[5] % 1000000000),
All.MassTable[5]);
fflush(stdout);
}
ntask = lastTask - readTask + 1;
/* to collect the gas particles all at the beginning (in case several
snapshot files are read on the current CPU) we move the collisionless
particles such that a gap of the right size is created */
for(type = 0, nall = 0; type < 6; type++)
{
n_in_file = header.npart[type];
n_for_this_task = n_in_file / ntask;
if((ThisTask - readTask) < (n_in_file % ntask))
n_for_this_task++;
nall += n_for_this_task;
}
memmove(&P[N_gas + nall], &P[N_gas], (NumPart - N_gas) * sizeof(struct particle_data));
nstart = N_gas;
for(blocknr = 0; blocknr < IO_NBLOCKS; blocknr++)
{
if(blockpresent(blocknr))
{
if(RestartFlag == 0 && blocknr > IO_U)
continue; /* ignore all other blocks in initial conditions */
bytes_per_blockelement = get_bytes_per_blockelement(blocknr);
blockmaxlen = ((int) (All.BufferSize * 1024 * 1024)) / bytes_per_blockelement;
npart = get_particles_in_block(blocknr, &typelist[0]);
if(npart > 0)
{
if(ThisTask == readTask)
{
if(All.ICFormat == 2)
{
SKIP;
my_fread(&label, sizeof(char), 4, fd);
my_fread(&nextblock, sizeof(int), 1, fd);
printf("Reading header => '%c%c%c%c' (%d byte)\n", label[0], label[1], label[2],
label[3], nextblock);
SKIP2;
if(strncmp(label, Tab_IO_Labels[blocknr], 4) != 0)
{
printf("incorrect block-structure!\n");
printf("expected '%c%c%c%c' but found '%c%c%c%c'\n",
label[0], label[1], label[2], label[3],
Tab_IO_Labels[blocknr][0], Tab_IO_Labels[blocknr][1],
Tab_IO_Labels[blocknr][2], Tab_IO_Labels[blocknr][3]);
fflush(stdout);
endrun(1890);
}
}
if(All.ICFormat == 1 || All.ICFormat == 2)
SKIP;
}
for(type = 0, offset = 0; type < 6; type++)
{
n_in_file = header.npart[type];
#ifdef HAVE_HDF5
pcsum = 0;
#endif
if(typelist[type] == 0)
{
n_for_this_task = n_in_file / ntask;
if((ThisTask - readTask) < (n_in_file % ntask))
n_for_this_task++;
offset += n_for_this_task;
}
else
{
for(task = readTask; task <= lastTask; task++)
{
n_for_this_task = n_in_file / ntask;
if((task - readTask) < (n_in_file % ntask))
n_for_this_task++;
if(task == ThisTask)
if(NumPart + n_for_this_task > All.MaxPart)
{
printf("too many particles\n");
endrun(1313);
}
do
{
pc = n_for_this_task;
if(pc > blockmaxlen)
pc = blockmaxlen;
if(ThisTask == readTask)
{
if(All.ICFormat == 1 || All.ICFormat == 2)
my_fread(CommBuffer, bytes_per_blockelement, pc, fd);
#ifdef HAVE_HDF5
if(All.ICFormat == 3)
{
get_dataset_name(blocknr, buf);
hdf5_dataset = H5Dopen(hdf5_grp[type], buf);
dims[0] = header.npart[type];
dims[1] = get_values_per_blockelement(blocknr);
if(dims[1] == 1)
rank = 1;
else
rank = 2;
hdf5_dataspace_in_file = H5Screate_simple(rank, dims, NULL);
dims[0] = pc;
hdf5_dataspace_in_memory = H5Screate_simple(rank, dims, NULL);
start[0] = pcsum;
start[1] = 0;
count[0] = pc;
count[1] = get_values_per_blockelement(blocknr);
pcsum += pc;
H5Sselect_hyperslab(hdf5_dataspace_in_file, H5S_SELECT_SET,
start, NULL, count, NULL);
switch (get_datatype_in_block(blocknr))
{
case 0:
hdf5_datatype = H5Tcopy(H5T_NATIVE_UINT);
break;
case 1:
hdf5_datatype = H5Tcopy(H5T_NATIVE_FLOAT);
break;
case 2:
hdf5_datatype = H5Tcopy(H5T_NATIVE_UINT64);
break;
}
H5Dread(hdf5_dataset, hdf5_datatype, hdf5_dataspace_in_memory,
hdf5_dataspace_in_file, H5P_DEFAULT, CommBuffer);
H5Tclose(hdf5_datatype);
H5Sclose(hdf5_dataspace_in_memory);
H5Sclose(hdf5_dataspace_in_file);
H5Dclose(hdf5_dataset);
}
#endif
}
if(ThisTask == readTask && task != readTask)
MPI_Ssend(CommBuffer, bytes_per_blockelement * pc, MPI_BYTE, task, TAG_PDATA,
MPI_COMM_WORLD);
if(ThisTask != readTask && task == ThisTask)
MPI_Recv(CommBuffer, bytes_per_blockelement * pc, MPI_BYTE, readTask,
TAG_PDATA, MPI_COMM_WORLD, &status);
if(ThisTask == task)
{
empty_read_buffer(blocknr, nstart + offset, pc, type);
offset += pc;
}
n_for_this_task -= pc;
}
while(n_for_this_task > 0);
}
}
}
if(ThisTask == readTask)
{
if(All.ICFormat == 1 || All.ICFormat == 2)
{
SKIP2;
if(blksize1 != blksize2)
{
printf("incorrect block-sizes detected!\n");
printf("Task=%d blocknr=%d blksize1=%d blksize2=%d\n", ThisTask, blocknr,
blksize1, blksize2);
fflush(stdout);
endrun(1889);
}
}
}
}
}
}
for(type = 0; type < 6; type++)
{
n_in_file = header.npart[type];
n_for_this_task = n_in_file / ntask;
if((ThisTask - readTask) < (n_in_file % ntask))
n_for_this_task++;
NumPart += n_for_this_task;
if(type == 0)
N_gas += n_for_this_task;
}
if(ThisTask == readTask)
{
if(All.ICFormat == 1 || All.ICFormat == 2)
fclose(fd);
#ifdef HAVE_HDF5
if(All.ICFormat == 3)
{
for(type = 5; type >= 0; type--)
if(header.npart[type] > 0)
H5Gclose(hdf5_grp[type]);
H5Fclose(hdf5_file);
}
#endif
}
}
bool stfio::exportHDF5File(const std::string& fName, const Recording& WData, ProgressInfo& progDlg) {
hid_t file_id = H5Fcreate(fName.c_str(), H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);
const int NRECORDS = 1;
const int NFIELDS = 3;
/* Calculate the size and the offsets of our struct members in memory */
size_t rt_offset[NFIELDS] = { HOFFSET( rt, channels ),
HOFFSET( rt, date ),
HOFFSET( rt, time )};
/* Define an array of root tables */
rt p_data;
p_data.channels = WData.size();
struct tm t = WData.GetDateTime();
std::size_t date_length = snprintf(p_data.date, DATELEN, "%04i-%02i-%02i", t.tm_year+1900, t.tm_mon+1, t.tm_mday);
std::size_t time_length = snprintf(p_data.time, TIMELEN, "%02i:%02i:%02i", t.tm_hour, t.tm_min, t.tm_sec);
// ensure that an undefine string is set to "\0", and that the terminating \0 is counted in string length
p_data.date[date_length++] = 0;
p_data.time[time_length++] = 0;
/* Define field information */
const char *field_names[NFIELDS] = { "channels", "date", "time" };
hid_t field_type[NFIELDS];
/* Initialize the field field_type */
hid_t string_type1 = H5Tcopy( H5T_C_S1 );
hid_t string_type2 = H5Tcopy( H5T_C_S1 );
H5Tset_size( string_type1, date_length);
H5Tset_size( string_type2, time_length);
field_type[0] = H5T_NATIVE_INT;
field_type[1] = string_type1;
field_type[2] = string_type2;
std::ostringstream desc;
desc << "Description of " << fName;
herr_t status = H5TBmake_table( desc.str().c_str(), file_id, "description", (hsize_t)NFIELDS, (hsize_t)NRECORDS, sizeof(rt),
field_names, rt_offset, field_type, 10, NULL, 0, &p_data );
if (status < 0) {
std::string errorMsg("Exception while writing description in stfio::exportHDF5File");
H5Fclose(file_id);
H5close();
throw std::runtime_error(errorMsg);
}
hid_t comment_group = H5Gcreate2( file_id,"/comment", H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
/* File comment. */
std::string description(WData.GetFileDescription());
if (description.length() <= 0) {
description = "No description";
}
status = H5LTmake_dataset_string(file_id, "/comment/description", description.c_str());
if (status < 0) {
std::string errorMsg("Exception while writing description in stfio::exportHDF5File");
H5Fclose(file_id);
H5close();
throw std::runtime_error(errorMsg);
}
std::string comment(WData.GetComment());
if (comment.length() <= 0) {
comment = "No comment";
}
status = H5LTmake_dataset_string(file_id, "/comment/comment", comment.c_str());
if (status < 0) {
std::string errorMsg("Exception while writing comment in stfio::exportHDF5File");
H5Fclose(file_id);
H5close();
throw std::runtime_error(errorMsg);
}
H5Gclose(comment_group);
std::vector<std::string> channel_name(WData.size());
hid_t channels_group = H5Gcreate2( file_id,"/channels", H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
for ( std::size_t n_c=0; n_c < WData.size(); ++n_c) {
/* Channel descriptions. */
std::ostringstream ossname;
ossname << WData[n_c].GetChannelName();
if ( ossname.str() == "" ) {
ossname << "ch" << (n_c);
}
channel_name[n_c] = ossname.str();
hsize_t dimsc[1] = { 1 };
hid_t string_typec = H5Tcopy( H5T_C_S1 );
std::size_t cn_length = channel_name[n_c].length();
if (cn_length <= 0) cn_length = 1;
H5Tset_size( string_typec, cn_length );
std::vector<char> datac(channel_name[n_c].length());
std::copy(channel_name[n_c].begin(),channel_name[n_c].end(), datac.begin());
std::ostringstream desc_path; desc_path << "/channels/ch" << (n_c);
status = H5LTmake_dataset(file_id, desc_path.str().c_str(), 1, dimsc, string_typec, &datac[0]);
if (status < 0) {
std::string errorMsg("Exception while writing channel name in stfio::exportHDF5File");
H5Fclose(file_id);
H5close();
throw std::runtime_error(errorMsg);
}
std::ostringstream channel_path; channel_path << "/" << channel_name[n_c];
hid_t channel_group = H5Gcreate2( file_id, channel_path.str().c_str(), H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
if (channel_group < 0) {
std::ostringstream errorMsg;
errorMsg << "Exception while creating channel group for "
<< channel_path.str().c_str();
H5Fclose(file_id);
H5close();
throw std::runtime_error(errorMsg.str());
}
/* Calculate the size and the offsets of our struct members in memory */
size_t ct_size = sizeof( ct );
size_t ct_offset[1] = { HOFFSET( rt, channels ) };
/* Define an array of channel tables */
ct c_data = { (int)WData[n_c].size() };
/* Define field information */
const char *cfield_names[1] = { "n_sections" };
hid_t cfield_type[1] = {H5T_NATIVE_INT};
std::ostringstream c_desc;
c_desc << "Description of channel " << n_c;
status = H5TBmake_table( c_desc.str().c_str(), channel_group, "description", (hsize_t)1, (hsize_t)1, ct_size,
cfield_names, ct_offset, cfield_type, 10, NULL, 0, &c_data );
if (status < 0) {
std::string errorMsg("Exception while writing channel description in stfio::exportHDF5File");
H5Fclose(file_id);
H5close();
throw std::runtime_error(errorMsg);
}
int max_log10 = 0;
if (WData[n_c].size() > 1) {
max_log10 = int(log10((double)WData[n_c].size()-1.0));
}
for (std::size_t n_s=0; n_s < WData[n_c].size(); ++n_s) {
int progbar =
// Channel contribution:
(int)(((double)n_c/(double)WData.size())*100.0+
// Section contribution:
(double)(n_s)/(double)WData[n_c].size()*(100.0/WData.size()));
std::ostringstream progStr;
progStr << "Writing channel #" << n_c + 1 << " of " << WData.size()
<< ", Section #" << n_s << " of " << WData[n_c].size();
progDlg.Update(progbar, progStr.str());
// construct a number with leading zeros:
int n10 = 0;
if (n_s > 0) {
n10 = int(log10((double)n_s));
}
std::ostringstream strZero; strZero << "";
for (int n_z=n10; n_z < max_log10; ++n_z) {
strZero << "0";
}
// construct a section name:
std::ostringstream section_name; section_name << WData[n_c][n_s].GetSectionDescription();
if ( section_name.str() == "" ) {
section_name << "sec" << n_s;
}
// create a child group in the channel:
std::ostringstream section_path;
section_path << channel_path.str() << "/" << "section_" << strZero.str() << n_s;
hid_t section_group = H5Gcreate2( file_id, section_path.str().c_str(), H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
// add data and description, store as 32 bit little endian independent of machine:
hsize_t dims[1] = { WData[n_c][n_s].size() };
std::ostringstream data_path;
data_path << section_path.str() << "/data";
Vector_float data_cp(WData[n_c][n_s].get().size()); /* 32 bit */
for (std::size_t n_cp = 0; n_cp < WData[n_c][n_s].get().size(); ++n_cp) {
data_cp[n_cp] = float(WData[n_c][n_s][n_cp]);
}
status = H5LTmake_dataset(file_id, data_path.str().c_str(), 1, dims, H5T_IEEE_F32LE, &data_cp[0]);
if (status < 0) {
std::string errorMsg("Exception while writing data in stfio::exportHDF5File");
H5Fclose(file_id);
H5close();
throw std::runtime_error(errorMsg);
}
const int NSRECORDS = 1;
const int NSFIELDS = 3;
/* Calculate the size and the offsets of our struct members in memory */
size_t st_size = sizeof( st );
size_t st_offset[NSFIELDS] = { HOFFSET( st, dt ),
HOFFSET( st, xunits ),
HOFFSET( st, yunits )};
/* Define an array of root tables */
st s_data;
s_data.dt = WData.GetXScale();
if (WData.GetXUnits().length() < UNITLEN)
strcpy( s_data.xunits, WData.GetXUnits().c_str() );
if (WData[n_c].GetYUnits().length() < UNITLEN)
strcpy( s_data.yunits, WData[n_c].GetYUnits().c_str() );
/* Define field information */
const char *sfield_names[NSFIELDS] = { "dt", "xunits", "yunits" };
hid_t sfield_type[NSFIELDS];
/* Initialize the field field_type */
hid_t string_type4 = H5Tcopy( H5T_C_S1 );
hid_t string_type5 = H5Tcopy( H5T_C_S1 );
H5Tset_size( string_type4, 2);
std::size_t yu_length = WData[n_c].GetYUnits().length();
if (yu_length <= 0) yu_length = 1;
H5Tset_size( string_type5, yu_length );
sfield_type[0] = H5T_NATIVE_DOUBLE;
sfield_type[1] = string_type4;
sfield_type[2] = string_type5;
std::ostringstream sdesc;
sdesc << "Description of " << section_name.str();
status = H5TBmake_table( sdesc.str().c_str(), section_group, "description", (hsize_t)NSFIELDS, (hsize_t)NSRECORDS, st_size,
sfield_names, st_offset, sfield_type, 10, NULL, 0, &s_data );
if (status < 0) {
std::string errorMsg("Exception while writing section description in stfio::exportHDF5File");
H5Fclose(file_id);
H5close();
throw std::runtime_error(errorMsg);
}
H5Gclose(section_group);
}
H5Gclose(channel_group);
}
H5Gclose(channels_group);
/* Terminate access to the file. */
status = H5Fclose(file_id);
if (status < 0) {
std::string errorMsg("Exception while closing file in stfio::exportHDF5File");
throw std::runtime_error(errorMsg);
}
/* Release all hdf5 resources */
status = H5close();
if (status < 0) {
std::string errorMsg("Exception while closing file in stfio::exportHDF5File");
throw std::runtime_error(errorMsg);
}
return (status >= 0);
}
DataType DataType::copy(hid_t source) {
DataType hi_copy = H5Tcopy(source);
hi_copy.check("Could not copy type");
return hi_copy;
}
/****if* H5_f/h5init_types_c
* NAME
* h5init_types_c
* PURPOSE
* Initialize predefined datatypes in Fortran
* INPUTS
* types - array with the predefined Native Fortran
* type, its element and length must be the
* same as the types array defined in the
* H5f90global.f90
* floatingtypes - array with the predefined Floating Fortran
* type, its element and length must be the
* same as the floatingtypes array defined in the
* H5f90global.f90
* integertypes - array with the predefined Integer Fortran
* type, its element and length must be the
* same as the integertypes array defined in the
* H5f90global.f90
* RETURNS
* 0 on success, -1 on failure
* AUTHOR
* Elena Pourmal
* Tuesday, August 3, 1999
* SOURCE
*/
int_f
nh5init_types_c( hid_t_f * types, hid_t_f * floatingtypes, hid_t_f * integertypes )
/******/
{
int ret_value = -1;
hid_t c_type_id;
size_t tmp_val;
/* Fortran INTEGER is may not be the same as C in; do all checking to find
an appropriate size
*/
if (sizeof(int_f) == sizeof(int)) {
if ((types[0] = (hid_t_f)H5Tcopy(H5T_NATIVE_INT)) < 0) return ret_value;
} /*end if */
else if (sizeof(int_f) == sizeof(long)) {
if ((types[0] = (hid_t_f)H5Tcopy(H5T_NATIVE_LONG)) < 0) return ret_value;
} /*end if */
else
if (sizeof(int_f) == sizeof(long long)) {
if ((types[0] = (hid_t_f)H5Tcopy(H5T_NATIVE_LLONG)) < 0) return ret_value;
} /*end else */
/* Find appropriate size to store Fortran REAL */
if(sizeof(real_f)==sizeof(float)) {
if ((types[1] = (hid_t_f)H5Tcopy(H5T_NATIVE_FLOAT)) < 0) return ret_value;
} /* end if */
else if(sizeof(real_f)==sizeof(double)){
if ((types[1] = (hid_t_f)H5Tcopy(H5T_NATIVE_DOUBLE)) < 0) return ret_value;
} /* end if */
#if H5_SIZEOF_LONG_DOUBLE!=0
else if (sizeof(real_f) == sizeof(long double)) {
if ((types[1] = (hid_t_f)H5Tcopy(H5T_NATIVE_LDOUBLE)) < 0) return ret_value;
} /* end else */
#endif
/* Find appropriate size to store Fortran DOUBLE */
if(sizeof(double_f)==sizeof(double)) {
if ((types[2] = (hid_t_f)H5Tcopy(H5T_NATIVE_DOUBLE)) < 0) return ret_value;
}/*end if */
#if H5_SIZEOF_LONG_DOUBLE!=0
else if(sizeof(double_f)==sizeof(long double)) {
if ((types[2] = (hid_t_f)H5Tcopy(H5T_NATIVE_LDOUBLE)) < 0) return ret_value;
}/*end else */
#endif
/*
if ((types[3] = H5Tcopy(H5T_NATIVE_UINT8)) < 0) return ret_value;
*/
if ((c_type_id = H5Tcopy(H5T_FORTRAN_S1)) < 0) return ret_value;
tmp_val = 1;
if(H5Tset_size(c_type_id, tmp_val) < 0) return ret_value;
if(H5Tset_strpad(c_type_id, H5T_STR_SPACEPAD) < 0) return ret_value;
types[3] = (hid_t_f)c_type_id;
/*
if ((types[3] = H5Tcopy(H5T_C_S1)) < 0) return ret_value;
if(H5Tset_strpad(types[3],H5T_STR_NULLTERM) < 0) return ret_value;
if(H5Tset_size(types[3],1) < 0) return ret_value;
*/
/* if ((types[3] = H5Tcopy(H5T_STD_I8BE)) < 0) return ret_value;
*/
if ((types[4] = (hid_t_f)H5Tcopy(H5T_STD_REF_OBJ)) < 0) return ret_value;
if ((types[5] = (hid_t_f)H5Tcopy(H5T_STD_REF_DSETREG)) < 0) return ret_value;
/*
* FIND H5T_NATIVE_INTEGER_1
*/
if (sizeof(int_1_f) == sizeof(char)) {
if ((types[6] = (hid_t_f)H5Tcopy(H5T_NATIVE_CHAR)) < 0) return ret_value;
} /*end if */
else if (sizeof(int_1_f) == sizeof(short)) {
if ((types[6] = (hid_t_f)H5Tcopy(H5T_NATIVE_SHORT)) < 0) return ret_value;
} /*end if */
else if (sizeof(int_1_f) == sizeof(int)) {
if ((types[6] = (hid_t_f)H5Tcopy(H5T_NATIVE_INT)) < 0) return ret_value;
} /*end if */
else if (sizeof(int_1_f) == sizeof(long long)) {
if ((types[6] = (hid_t_f)H5Tcopy(H5T_NATIVE_LLONG)) < 0) return ret_value;
} /*end else */
/*
* FIND H5T_NATIVE_INTEGER_2
*/
if (sizeof(int_2_f) == sizeof(char)) {
if ((types[7] = (hid_t_f)H5Tcopy(H5T_NATIVE_CHAR)) < 0) return ret_value;
} /*end if */
else if (sizeof(int_2_f) == sizeof(short)) {
if ((types[7] = (hid_t_f)H5Tcopy(H5T_NATIVE_SHORT)) < 0) return ret_value;
} /*end if */
else if (sizeof(int_2_f) == sizeof(int)) {
if ((types[7] = (hid_t_f)H5Tcopy(H5T_NATIVE_INT)) < 0) return ret_value;
} /*end if */
else if (sizeof(int_2_f) == sizeof(long long)) {
if ((types[7] = (hid_t_f)H5Tcopy(H5T_NATIVE_LLONG)) < 0) return ret_value;
} /*end else */
/*
* FIND H5T_NATIVE_INTEGER_4
*/
if (sizeof(int_4_f) == sizeof(char)) {
if ((types[8] = (hid_t_f)H5Tcopy(H5T_NATIVE_CHAR)) < 0) return ret_value;
} /*end if */
else if (sizeof(int_4_f) == sizeof(short)) {
if ((types[8] = (hid_t_f)H5Tcopy(H5T_NATIVE_SHORT)) < 0) return ret_value;
} /*end if */
else if (sizeof(int_4_f) == sizeof(int)) {
if ((types[8] = (hid_t_f)H5Tcopy(H5T_NATIVE_INT)) < 0) return ret_value;
} /*end if */
else if (sizeof(int_4_f) == sizeof(long long)) {
if ((types[8] = (hid_t_f)H5Tcopy(H5T_NATIVE_LLONG)) < 0) return ret_value;
} /*end else */
/*
* FIND H5T_NATIVE_INTEGER_8
*/
if (sizeof(int_8_f) == sizeof(char)) {
if ((types[9] = (hid_t_f)H5Tcopy(H5T_NATIVE_CHAR)) < 0) return ret_value;
} /*end if */
else if (sizeof(int_8_f) == sizeof(short)) {
if ((types[9] = (hid_t_f)H5Tcopy(H5T_NATIVE_SHORT)) < 0) return ret_value;
} /*end if */
else if (sizeof(int_8_f) == sizeof(int)) {
if ((types[9] = (hid_t_f)H5Tcopy(H5T_NATIVE_INT)) < 0) return ret_value;
} /*end if */
else if (sizeof(int_8_f) == sizeof(long long)) {
if ((types[9] = (hid_t_f)H5Tcopy(H5T_NATIVE_LLONG)) < 0) return ret_value;
} /*end else */
/*
* FIND H5T_NATIVE_REAL_4
*/
if (sizeof(real_4_f) == sizeof(float)) {
if ((types[10] = (hid_t_f)H5Tcopy(H5T_NATIVE_FLOAT)) < 0) return ret_value;
} /*end if */
else if (sizeof(real_4_f) == sizeof(double)) {
if ((types[10] = (hid_t_f)H5Tcopy(H5T_NATIVE_DOUBLE)) < 0) return ret_value;
} /*end if */
#if H5_SIZEOF_LONG_DOUBLE!=0
else if (sizeof(real_4_f) == sizeof(long double)) {
if ((types[10] = (hid_t_f)H5Tcopy(H5T_NATIVE_LDOUBLE)) < 0) return ret_value;
} /*end else */
#endif
/*
* FIND H5T_NATIVE_REAL_8
*/
if (sizeof(real_8_f) == sizeof(float)) {
if ((types[11] = (hid_t_f)H5Tcopy(H5T_NATIVE_FLOAT)) < 0) return ret_value;
} /*end if */
else if (sizeof(real_8_f) == sizeof(double)) {
if ((types[11] = (hid_t_f)H5Tcopy(H5T_NATIVE_DOUBLE)) < 0) return ret_value;
} /*end if */
#if H5_SIZEOF_LONG_DOUBLE!=0
else if (sizeof(real_8_f) == sizeof(long double)) {
if ((types[11] = (hid_t_f)H5Tcopy(H5T_NATIVE_LDOUBLE)) < 0) return ret_value;
} /*end else */
#endif
/*
* FIND H5T_NATIVE_REAL_16
*/
if (sizeof(real_16_f) == sizeof(float)) {
if ((types[12] = (hid_t_f)H5Tcopy(H5T_NATIVE_FLOAT)) < 0) return ret_value;
} /*end if */
else if (sizeof(real_16_f) == sizeof(double)) {
if ((types[12] = (hid_t_f)H5Tcopy(H5T_NATIVE_DOUBLE)) < 0) return ret_value;
} /*end if */
#if H5_SIZEOF_LONG_DOUBLE!=0
else if (sizeof(real_16_f) == sizeof(long double)) {
if ((types[12] = (hid_t_f)H5Tcopy(H5T_NATIVE_LDOUBLE)) < 0) return ret_value;
} /*end else */
#endif
/*
* FIND H5T_NATIVE_B_8
*/
if ((types[13] = (hid_t_f)H5Tcopy(H5T_NATIVE_B8)) < 0) return ret_value;
if ((types[14] = (hid_t_f)H5Tcopy(H5T_NATIVE_B16)) < 0) return ret_value;
if ((types[15] = (hid_t_f)H5Tcopy(H5T_NATIVE_B32)) < 0) return ret_value;
if ((types[16] = (hid_t_f)H5Tcopy(H5T_NATIVE_B64)) < 0) return ret_value;
if ((floatingtypes[0] = (hid_t_f)H5Tcopy(H5T_IEEE_F32BE)) < 0) return ret_value;
if ((floatingtypes[1] = (hid_t_f)H5Tcopy(H5T_IEEE_F32LE)) < 0) return ret_value;
if ((floatingtypes[2] = (hid_t_f)H5Tcopy(H5T_IEEE_F64BE)) < 0) return ret_value;
if ((floatingtypes[3] = (hid_t_f)H5Tcopy(H5T_IEEE_F64LE)) < 0) return ret_value;
if ((integertypes[0] = (hid_t_f)H5Tcopy(H5T_STD_I8BE)) < 0) return ret_value;
if ((integertypes[1] = (hid_t_f)H5Tcopy(H5T_STD_I8LE)) < 0) return ret_value;
if ((integertypes[2] = (hid_t_f)H5Tcopy(H5T_STD_I16BE)) < 0) return ret_value;
if ((integertypes[3] = (hid_t_f)H5Tcopy(H5T_STD_I16LE)) < 0) return ret_value;
if ((integertypes[4] = (hid_t_f)H5Tcopy(H5T_STD_I32BE)) < 0) return ret_value;
if ((integertypes[5] = (hid_t_f)H5Tcopy(H5T_STD_I32LE)) < 0) return ret_value;
if ((integertypes[6] = (hid_t_f)H5Tcopy(H5T_STD_I64BE)) < 0) return ret_value;
if ((integertypes[7] = (hid_t_f)H5Tcopy(H5T_STD_I64LE)) < 0) return ret_value;
if ((integertypes[8] = (hid_t_f)H5Tcopy(H5T_STD_U8BE)) < 0) return ret_value;
if ((integertypes[9] = (hid_t_f)H5Tcopy(H5T_STD_U8LE)) < 0) return ret_value;
if ((integertypes[10] = (hid_t_f)H5Tcopy(H5T_STD_U16BE)) < 0) return ret_value;
if ((integertypes[11] = (hid_t_f)H5Tcopy(H5T_STD_U16LE)) < 0) return ret_value;
if ((integertypes[12] = (hid_t_f)H5Tcopy(H5T_STD_U32BE)) < 0) return ret_value;
if ((integertypes[13] = (hid_t_f)H5Tcopy(H5T_STD_U32LE)) < 0) return ret_value;
if ((integertypes[14] = (hid_t_f)H5Tcopy(H5T_STD_U64BE)) < 0) return ret_value;
if ((integertypes[15] = (hid_t_f)H5Tcopy(H5T_STD_U64LE)) < 0) return ret_value;
if ((integertypes[17] = (hid_t_f)H5Tcopy(H5T_STD_B8BE)) < 0) return ret_value;
if ((integertypes[18] = (hid_t_f)H5Tcopy(H5T_STD_B8LE)) < 0) return ret_value;
if ((integertypes[19] = (hid_t_f)H5Tcopy(H5T_STD_B16BE)) < 0) return ret_value;
if ((integertypes[20] = (hid_t_f)H5Tcopy(H5T_STD_B16LE)) < 0) return ret_value;
if ((integertypes[21] = (hid_t_f)H5Tcopy(H5T_STD_B32BE)) < 0) return ret_value;
if ((integertypes[22] = (hid_t_f)H5Tcopy(H5T_STD_B32LE)) < 0) return ret_value;
if ((integertypes[23] = (hid_t_f)H5Tcopy(H5T_STD_B64BE)) < 0) return ret_value;
if ((integertypes[24] = (hid_t_f)H5Tcopy(H5T_STD_B64LE)) < 0) return ret_value;
if ((integertypes[25] = (hid_t_f)H5Tcopy(H5T_FORTRAN_S1)) < 0) return ret_value;
if ((integertypes[26] = (hid_t_f)H5Tcopy(H5T_C_S1)) < 0) return ret_value;
/*
* Define Fortran H5T_STRING type to store non-fixed size strings
*/
if ((c_type_id = H5Tcopy(H5T_C_S1)) < 0) return ret_value;
if(H5Tset_size(c_type_id, H5T_VARIABLE) < 0) return ret_value;
integertypes[16] = c_type_id;
ret_value = 0;
return ret_value;
}
void stfio::importHDF5File(const std::string& fName, Recording& ReturnData, ProgressInfo& progDlg) {
/* Create a new file using default properties. */
hid_t file_id = H5Fopen(fName.c_str(), H5F_ACC_RDONLY, H5P_DEFAULT);
/* H5TBread_table
const int NRECORDS = 1;*/
const int NFIELDS = 3;
/* Calculate the size and the offsets of our struct members in memory */
size_t rt_offset[NFIELDS] = { HOFFSET( rt, channels ),
HOFFSET( rt, date ),
HOFFSET( rt, time )};
rt rt_buf[1];
size_t rt_sizes[NFIELDS] = { sizeof( rt_buf[0].channels),
sizeof( rt_buf[0].date),
sizeof( rt_buf[0].time)};
herr_t status=H5TBread_table( file_id, "description", sizeof(rt), rt_offset, rt_sizes, rt_buf );
if (status < 0) {
std::string errorMsg("Exception while reading description in stfio::importHDF5File");
throw std::runtime_error(errorMsg);
}
int numberChannels =rt_buf[0].channels;
if ( ReturnData.SetDate(rt_buf[0].date)
|| ReturnData.SetTime(rt_buf[0].time) ) {
std::cout << "Warning HDF5: could not decode date/time " << rt_buf[0].date << " " << rt_buf[0].time << std::endl;
}
/* Create the data space for the dataset. */
hsize_t dims;
H5T_class_t class_id;
size_t type_size;
std::string description, comment;
hid_t group_id = H5Gopen2(file_id, "/comment", H5P_DEFAULT);
status = H5Lexists(group_id, "/comment/description", 0);
if (status==1) {
status = H5LTget_dataset_info( file_id, "/comment/description", &dims, &class_id, &type_size );
if (status >= 0) {
description.resize( type_size );
status = H5LTread_dataset_string (file_id, "/comment/description", &description[0]);
if (status < 0) {
std::string errorMsg("Exception while reading description in stfio::importHDF5File");
throw std::runtime_error(errorMsg);
}
}
}
ReturnData.SetFileDescription(description);
status = H5Lexists(group_id, "/comment/comment", 0);
if (status==1) {
status = H5LTget_dataset_info( file_id, "/comment/comment", &dims, &class_id, &type_size );
if (status >= 0) {
comment.resize( type_size );
status = H5LTread_dataset_string (file_id, "/comment/comment", &comment[0]);
if (status < 0) {
std::string errorMsg("Exception while reading comment in stfio::importHDF5File");
throw std::runtime_error(errorMsg);
}
}
}
ReturnData.SetComment(comment);
double dt = 1.0;
std::string yunits = "";
for (int n_c=0;n_c<numberChannels;++n_c) {
/* Calculate the size and the offsets of our struct members in memory */
size_t ct_offset[NFIELDS] = { HOFFSET( ct, n_sections ) };
ct ct_buf[1];
size_t ct_sizes[NFIELDS] = { sizeof( ct_buf[0].n_sections) };
/* Read channel name */
hsize_t cdims;
H5T_class_t cclass_id;
size_t ctype_size;
std::ostringstream desc_path;
desc_path << "/channels/ch" << (n_c);
status = H5LTget_dataset_info( file_id, desc_path.str().c_str(), &cdims, &cclass_id, &ctype_size );
if (status < 0) {
std::string errorMsg("Exception while reading channel in stfio::importHDF5File");
throw std::runtime_error(errorMsg);
}
hid_t string_typec= H5Tcopy( H5T_C_S1 );
H5Tset_size( string_typec, ctype_size );
std::vector<char> szchannel_name(ctype_size);
// szchannel_name.reset( new char[ctype_size] );
status = H5LTread_dataset(file_id, desc_path.str().c_str(), string_typec, &szchannel_name[0] );
if (status < 0) {
std::string errorMsg("Exception while reading channel name in stfio::importHDF5File");
throw std::runtime_error(errorMsg);
}
std::ostringstream channel_name;
for (std::size_t c=0; c<ctype_size; ++c) {
channel_name << szchannel_name[c];
}
std::ostringstream channel_path;
channel_path << "/" << channel_name.str();
hid_t channel_group = H5Gopen2(file_id, channel_path.str().c_str(), H5P_DEFAULT );
status=H5TBread_table( channel_group, "description", sizeof(ct), ct_offset, ct_sizes, ct_buf );
if (status < 0) {
std::string errorMsg("Exception while reading channel description in stfio::importHDF5File");
throw std::runtime_error(errorMsg);
}
Channel TempChannel(ct_buf[0].n_sections);
TempChannel.SetChannelName( channel_name.str() );
int max_log10 = 0;
if (ct_buf[0].n_sections > 1) {
max_log10 = int(log10((double)ct_buf[0].n_sections-1.0));
}
for (int n_s=0; n_s < ct_buf[0].n_sections; ++n_s) {
int progbar =
// Channel contribution:
(int)(((double)n_c/(double)numberChannels)*100.0+
// Section contribution:
(double)(n_s)/(double)ct_buf[0].n_sections*(100.0/numberChannels));
std::ostringstream progStr;
progStr << "Reading channel #" << n_c + 1 << " of " << numberChannels
<< ", Section #" << n_s+1 << " of " << ct_buf[0].n_sections;
progDlg.Update(progbar, progStr.str());
// construct a number with leading zeros:
int n10 = 0;
if (n_s > 0) {
n10 = int(log10((double)n_s));
}
std::ostringstream strZero; strZero << "";
for (int n_z=n10; n_z < max_log10; ++n_z) {
strZero << "0";
}
// construct a section name:
std::ostringstream section_name;
section_name << "sec" << n_s;
// create a child group in the channel:
std::ostringstream section_path;
section_path << channel_path.str() << "/" << "section_" << strZero.str() << n_s;
hid_t section_group = H5Gopen2(file_id, section_path.str().c_str(), H5P_DEFAULT );
std::ostringstream data_path; data_path << section_path.str() << "/data";
hsize_t sdims;
H5T_class_t sclass_id;
size_t stype_size;
status = H5LTget_dataset_info( file_id, data_path.str().c_str(), &sdims, &sclass_id, &stype_size );
if (status < 0) {
std::string errorMsg("Exception while reading data information in stfio::importHDF5File");
throw std::runtime_error(errorMsg);
}
Vector_float TempSection(sdims);
status = H5LTread_dataset(file_id, data_path.str().c_str(), H5T_IEEE_F32LE, &TempSection[0]);
if (status < 0) {
std::string errorMsg("Exception while reading data in stfio::importHDF5File");
throw std::runtime_error(errorMsg);
}
Section TempSectionT(TempSection.size(), section_name.str());
for (std::size_t cp = 0; cp < TempSectionT.size(); ++cp) {
TempSectionT[cp] = double(TempSection[cp]);
}
// std::copy(TempSection.begin(),TempSection.end(),&TempSectionT[0]);
try {
TempChannel.InsertSection(TempSectionT,n_s);
}
catch (...) {
throw;
}
/* H5TBread_table
const int NSRECORDS = 1; */
const int NSFIELDS = 3;
/* Calculate the size and the offsets of our struct members in memory */
size_t st_offset[NSFIELDS] = { HOFFSET( st, dt ),
HOFFSET( st, xunits ),
HOFFSET( st, yunits )};
st st_buf[1];
size_t st_sizes[NSFIELDS] = { sizeof( st_buf[0].dt),
sizeof( st_buf[0].xunits),
sizeof( st_buf[0].yunits)};
status=H5TBread_table( section_group, "description", sizeof(st), st_offset, st_sizes, st_buf );
if (status < 0) {
std::string errorMsg("Exception while reading data description in stfio::importHDF5File");
throw std::runtime_error(errorMsg);
}
dt = st_buf[0].dt;
yunits = st_buf[0].yunits;
H5Gclose( section_group );
}
try {
if ((int)ReturnData.size()<numberChannels) {
ReturnData.resize(numberChannels);
}
ReturnData.InsertChannel(TempChannel,n_c);
ReturnData[n_c].SetYUnits( yunits );
}
catch (...) {
ReturnData.resize(0);
throw;
}
H5Gclose( channel_group );
}
ReturnData.SetXScale(dt);
/* Terminate access to the file. */
status = H5Fclose(file_id);
if (status < 0) {
std::string errorMsg("Exception while closing file in stfio::importHDF5File");
throw std::runtime_error(errorMsg);
}
/* Release all hdf5 resources */
status = H5close();
if (status < 0) {
std::string errorMsg("Exception while closing file in stfio::exportHDF5File");
throw std::runtime_error(errorMsg);
}
}
int main(int argc, char *argv[]){
if(argc!=8) usage(argv[0]);
char twop_type[Ntype][256];
strcpy(twop_type[0],"pseudoscalar");
strcpy(twop_type[1],"scalar");
strcpy(twop_type[2],"g5g1");
strcpy(twop_type[3],"g5g2");
strcpy(twop_type[4],"g5g3");
strcpy(twop_type[5],"g5g4");
strcpy(twop_type[6],"g1");
strcpy(twop_type[7],"g2");
strcpy(twop_type[8],"g3");
strcpy(twop_type[9],"g4");
char *h5_file, *out_file, *twop, *conf, *src_pos;
asprintf(&h5_file ,"%s",argv[1]);
asprintf(&out_file,"%s",argv[2]);
asprintf(&twop ,"%s",argv[3]);
asprintf(&conf ,"%s",argv[4]);
asprintf(&src_pos ,"%s",argv[5]);
int T = atoi(argv[6]);
int xtype = atoi(argv[7]);
bool twopOK = false;
int dt;
for(int i=0;(i<Ntype && !twopOK);i++)
if(strcmp(twop,twop_type[i])==0){
twopOK = true;
dt = i;
}
if(!twopOK){
printf("Error: Twop must be one of:\n");
for(int i=0;i<Ntype;i++) printf(" %s\n",twop_type[i]);
exit(-1);
}
printf("Got the following input:\n");
printf("h5_file: %s\n",h5_file);
printf("out_file: %s\n",out_file);
printf("twop: %d - %s\n",dt,twop);
printf("conf traj: %s\n",conf);
printf("src pos: %s\n",src_pos);
printf("T = %02d\n",T);
//-----------------------------------------
//-Open the h5 file
hid_t file_id = H5Fopen(h5_file, H5F_ACC_RDONLY, H5P_DEFAULT);
//-Get the momenta-related attributes
hid_t Qattr = H5Aopen (file_id, QSQ_STR , H5P_DEFAULT);
hid_t Mattr = H5Aopen (file_id, NMOM_STR, H5P_DEFAULT);
hid_t Qattr_type = H5Aget_type(Qattr);
hid_t Mattr_type = H5Aget_type(Mattr);
size_t Qattr_dim = H5Tget_size(Qattr_type);
size_t Mattr_dim = H5Tget_size(Mattr_type);
hid_t type_id = H5Tcopy(H5T_C_S1);
herr_t Qstatus = H5Tset_size (type_id, Qattr_dim);
herr_t Mstatus = H5Tset_size (type_id, Mattr_dim);
char *cQsq = (char*) malloc(Qattr_dim*sizeof(char));
char *cNmoms = (char*) malloc(Mattr_dim*sizeof(char));
Qstatus = H5Aread (Qattr, type_id, &(cQsq[0]));
Mstatus = H5Aread (Mattr, type_id, &(cNmoms[0]));
if (Mstatus<0 || Qstatus<0){
fprintf (stderr, "Momenta attributes read failed!\n");
Qstatus = H5Aclose(Qattr);
Mstatus = H5Aclose(Mattr);
Qstatus = H5Tclose(Qattr_type);
Mstatus = H5Tclose(Mattr_type);
Mstatus = H5Fclose(file_id);
exit(-1);
}
int Qsq = atoi(cQsq);
int Nmoms = atoi(cNmoms);
printf("Momenta attributes: Qsq = %d , Nmoms = %d\n",Qsq,Nmoms);
Qstatus = H5Aclose(Qattr);
Mstatus = H5Aclose(Mattr);
Qstatus = H5Tclose(Qattr_type);
Mstatus = H5Tclose(Mattr_type);
//------------------------------------------------------------------
//-Open the momenta dataset from the file and read the momenta
int *moms = (int*) malloc(Nmoms*3*sizeof(int));
hid_t Mdset_id = H5Dopen(file_id, MOM_DSET, H5P_DEFAULT);
Mstatus = H5Dread(Mdset_id, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, moms);
if (Mstatus<0){
fprintf (stderr, "Momenta Dataset read failed!\n");
Mstatus = H5Dclose(Mdset_id);
Mstatus = H5Fclose(file_id);
free(moms);
exit(-1);
}
//------------------------------------------------------------------
//-Open the desired dataset and write it in the ASCII file
hid_t group_id;
hid_t dset_id;
char *group_dir;
char *dset_name;
int Np,Ns;
if(xtype==0) Np = 2;
else Np = 1;
Ns = xtype/2;
float *twopBuf = (float*) malloc(Np*T*Nmoms*2*sizeof(float));
FILE *out = fopen(out_file,"w");
if(out==NULL){
fprintf(stderr,"Cannot open %s for writing. Exiting.\n",out_file);
exit(-1);
}
for(int ip=Ns;ip<(Np+Ns);ip++){
asprintf(&dset_name,"twop_meson_%d",ip+1);
asprintf(&group_dir,"/conf_%s/%s/%s",conf,src_pos,twop);
group_id = H5Gopen(file_id, group_dir, H5P_DEFAULT);
dset_id = H5Dopen(group_id, dset_name, H5P_DEFAULT);
herr_t status = H5Dread(dset_id, H5T_NATIVE_FLOAT, H5S_ALL, H5S_ALL, H5P_DEFAULT, &(twopBuf[(ip%Np)*T*Nmoms*2]));
if (status<0){
fprintf (stderr, "Dataset read failed!\n");
status = H5Gclose(group_id);
status = H5Dclose(dset_id);
status = H5Fclose(file_id);
fclose(out);
free(twopBuf);
exit(-1);
}
H5Dclose(dset_id);
H5Gclose(group_id);
}
H5Fclose(file_id);
//------------------------------------------------------------------
if(xtype==0){
for(int imom=0;imom<Nmoms;imom++){
for(int t=0;t<T;t++){
fprintf(out,"%d\t%02d\t%+d %+d %+d\t%+e %+e\t%+e %+e\n",dt,t,moms[0+3*imom],moms[1+3*imom],moms[2+3*imom],
twopBuf[0 + 2*imom + 2*Nmoms*t + 2*Nmoms*T*0],twopBuf[1 + 2*imom + 2*Nmoms*t + 2*Nmoms*T*0],
twopBuf[0 + 2*imom + 2*Nmoms*t + 2*Nmoms*T*1],twopBuf[1 + 2*imom + 2*Nmoms*t + 2*Nmoms*T*1]);
}//-t
}//-imom
}
else{
for(int imom=0;imom<Nmoms;imom++){
for(int t=0;t<T;t++){
fprintf(out,"%d\t%02d\t%+d %+d %+d\t%+e %+e\n",dt,t,moms[0+3*imom],moms[1+3*imom],moms[2+3*imom],twopBuf[0 + 2*imom + 2*Nmoms*t],twopBuf[1 + 2*imom + 2*Nmoms*t]);
}
}
}
fclose(out);
free(twopBuf);
free(moms);
printf("Extracting Two-point function completed successfully.\n");
return 0;
}
int main( void )
{
typedef struct Particle
{
char name[16];
int lati;
int longi;
float pressure;
double temperature;
} Particle;
Particle dst_buf[ NRECORDS + NRECORDS_INS ];
/* Calculate the size and the offsets of our struct members in memory */
size_t dst_size = sizeof( Particle );
size_t dst_offset[NFIELDS] = { HOFFSET( Particle, name ),
HOFFSET( Particle, lati ),
HOFFSET( Particle, longi ),
HOFFSET( Particle, pressure ),
HOFFSET( Particle, temperature )};
size_t dst_sizes[NFIELDS] = { sizeof( dst_buf[0].name),
sizeof( dst_buf[0].lati),
sizeof( dst_buf[0].longi),
sizeof( dst_buf[0].pressure),
sizeof( dst_buf[0].temperature)};
/* Define an array of Particles */
Particle p_data[NRECORDS] = {
{"zero",0,0, 0.0f, 0.0},
{"one",10,10, 1.0f, 10.0},
{"two", 20,20, 2.0f, 20.0},
{"three",30,30, 3.0f, 30.0},
{"four", 40,40, 4.0f, 40.0},
{"five", 50,50, 5.0f, 50.0},
{"six", 60,60, 6.0f, 60.0},
{"seven",70,70, 7.0f, 70.0}
};
/* Define field information */
const char *field_names[NFIELDS] =
{ "Name","Latitude", "Longitude", "Pressure", "Temperature" };
hid_t field_type[NFIELDS];
hid_t string_type;
hid_t file_id;
hsize_t chunk_size = 10;
int compress = 0;
Particle fill_data[1] =
{ {"no data",-1,-1, -99.0f, -99.0} }; /* Fill value particle */
hsize_t start1; /* Record to start reading from 1st table */
hsize_t nrecords; /* Number of records to insert */
hsize_t start2; /* Record to start writing in 2nd table */
herr_t status;
int i;
hsize_t nfields_out;
hsize_t nrecords_out;
/* Initialize the field field_type */
string_type = H5Tcopy( H5T_C_S1 );
H5Tset_size( string_type, 16 );
field_type[0] = string_type;
field_type[1] = H5T_NATIVE_INT;
field_type[2] = H5T_NATIVE_INT;
field_type[3] = H5T_NATIVE_FLOAT;
field_type[4] = H5T_NATIVE_DOUBLE;
/* Create a new file using default properties. */
file_id = H5Fcreate( "ex_table_09.h5", H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT );
/* Make 2 tables: TABLE2_NAME is empty */
status=H5TBmake_table( "Table Title",file_id,TABLE1_NAME,NFIELDS,NRECORDS,
dst_size,field_names, dst_offset, field_type,
chunk_size, fill_data, compress, p_data );
status=H5TBmake_table( "Table Title",file_id,TABLE2_NAME,NFIELDS,NRECORDS,
dst_size,field_names, dst_offset, field_type,
chunk_size, fill_data, compress, NULL );
/* Add 2 records from TABLE1_NAME to TABLE2_NAME */
start1 = 3;
nrecords = NRECORDS_INS;
start2 = 6;
status=H5TBadd_records_from( file_id, TABLE1_NAME, start1, nrecords, TABLE2_NAME, start2 );
/* read TABLE2_NAME: it should have 2 more records now */
status=H5TBread_table( file_id, TABLE2_NAME, dst_size, dst_offset, dst_sizes, dst_buf );
/* Get table info */
status=H5TBget_table_info (file_id,TABLE2_NAME, &nfields_out, &nrecords_out );
/* print */
printf ("Table has %d fields and %d records\n",(int)nfields_out,(int)nrecords_out);
/* print it by rows */
for (i=0; i<nrecords_out; i++) {
printf ("%-5s %-5d %-5d %-5f %-5f",
dst_buf[i].name,
dst_buf[i].lati,
dst_buf[i].longi,
dst_buf[i].pressure,
dst_buf[i].temperature);
printf ("\n");
}
/* Close the file. */
H5Fclose( file_id );
return 0;
}
int
main(int argc, char **argv)
{
printf("\n*** Testing HDF5/NetCDF-4 interoperability...\n");
printf("*** testing HDF5 compatibility...");
{
#define GRPA_NAME "grpa"
#define VAR_NAME "vara"
#define NDIMS 2
int nrowCur = 7; /* current size */
int ncolCur = 3;
int nrowMax = nrowCur + 0; /* maximum size */
int ncolMax = ncolCur + 0;
hid_t xdimId;
hid_t ydimId;
hsize_t xscaleDims[1];
hsize_t yscaleDims[1];
hid_t xdimSpaceId, spaceId;
hid_t fileId;
hid_t fapl;
hsize_t curDims[2];
hsize_t maxDims[2];
hid_t dataTypeId, dsPropertyId, grpaId, grpaPropId, dsId;
hid_t ydimSpaceId;
const char * dimNameBase
= "This is a netCDF dimension but not a netCDF variable.";
char dimNameBuf[1000];
char *varaName = "/grpa/vara";
short amat[nrowCur][ncolCur];
int ii, jj;
xscaleDims[0] = nrowCur;
yscaleDims[0] = ncolCur;
if ((xdimSpaceId = H5Screate_simple(1, xscaleDims, NULL)) < 0) ERR;
/* With the SEMI close degree, the HDF5 file close will fail if
* anything is left open. */
if ((fapl = H5Pcreate(H5P_FILE_ACCESS)) < 0) ERR;
if (H5Pset_fclose_degree(fapl, H5F_CLOSE_SEMI)) ERR;
/* Create file */
if((fileId = H5Fcreate(FILE_NAME, H5F_ACC_TRUNC,
H5Pcreate(H5P_FILE_CREATE), fapl)) < 0) ERR;
if (H5Pclose(fapl) < 0) ERR;
/* Create data space */
curDims[0] = nrowCur;
curDims[1] = ncolCur;
maxDims[0] = nrowMax;
maxDims[1] = ncolMax;
if ((spaceId = H5Screate_simple(2, curDims, maxDims)) < 0) ERR;
if ((dataTypeId = H5Tcopy(H5T_NATIVE_SHORT)) < 0) ERR;
if ((dsPropertyId = H5Pcreate(H5P_DATASET_CREATE)) < 0) ERR;
if ((grpaPropId = H5Pcreate(H5P_GROUP_CREATE)) < 0) ERR;
if ((grpaId = H5Gcreate2(fileId, GRPA_NAME, H5P_DEFAULT,
grpaPropId, H5P_DEFAULT)) < 0) ERR;
if (H5Pclose(grpaPropId) < 0) ERR;
/* Create vara dataset */
if ((dsId = H5Dcreate2(fileId, varaName, dataTypeId, spaceId,
H5P_DEFAULT, dsPropertyId,
H5P_DEFAULT)) < 0) ERR;
if (H5Pclose(dsPropertyId) < 0) ERR;
if (H5Tclose(dataTypeId) < 0) ERR;
if ((ydimSpaceId = H5Screate_simple(1, yscaleDims, NULL)) < 0) ERR;
/* Create xdim dimension dataset */
if ((xdimId = H5Dcreate2(fileId, "/xdim", H5T_IEEE_F32BE,
xdimSpaceId, H5P_DEFAULT, H5P_DEFAULT,
H5P_DEFAULT)) < 0) ERR;
if (H5Sclose(xdimSpaceId) < 0) ERR;
/* Create ydim dimension dataset */
if ((ydimId = H5Dcreate2(fileId, "/ydim", H5T_IEEE_F32BE,
ydimSpaceId, H5P_DEFAULT, H5P_DEFAULT,
H5P_DEFAULT)) < 0) ERR;
if (H5Sclose(ydimSpaceId) < 0) ERR;
/* Create xdim scale */
sprintf(dimNameBuf, "%s%10d", dimNameBase, nrowCur);
if (H5DSset_scale(xdimId, dimNameBuf) < 0) ERR;
/* Create ydim scale */
sprintf(dimNameBuf, "%s%10d", dimNameBase, ncolCur);
if (H5DSset_scale(ydimId, dimNameBuf) < 0) ERR;
/* Attach dimension scales to the dataset */
if (H5DSattach_scale(dsId, xdimId, 0) < 0) ERR;
if (H5DSattach_scale(dsId, ydimId, 1) < 0) ERR;
/* Close stuff. */
if (H5Dclose(xdimId) < 0) ERR;
if (H5Dclose(ydimId) < 0) ERR;
if (H5Dclose(dsId) < 0) ERR;
if (H5Gclose(grpaId) < 0) ERR;
if (H5Sclose(spaceId) < 0) ERR;
if (H5Fclose(fileId) < 0) ERR;
/* Create some data */
for (ii = 0; ii < nrowCur; ii++)
for (jj = 0; jj < ncolCur; jj++)
amat[ii][jj] = 100 * ii + jj;
/* Re-open file */
if ((fileId = H5Fopen(FILE_NAME, H5F_ACC_RDWR, H5P_DEFAULT)) < 0) ERR;
if ((grpaId = H5Gopen2(fileId, GRPA_NAME, H5P_DEFAULT)) < 0) ERR;
if ((dsId = H5Dopen2(grpaId, varaName, H5P_DEFAULT)) < 0) ERR;
/* Write dataset */
if (H5Dwrite(dsId, H5T_NATIVE_SHORT, H5S_ALL, H5S_ALL, H5P_DEFAULT,
amat) < 0) ERR;
/* Write dimension values for both xdim, ydim */
{
short xydimMat[ nrowCur >= ncolCur ? nrowCur : ncolCur];
for (ii = 0; ii < nrowCur; ii++)
xydimMat[ii] = 0; /*#### 100 * ii; */
/* Write xdim */
if ((xdimId = H5Dopen2(fileId, "/xdim", H5P_DEFAULT)) < 0) ERR;
if (H5Dwrite(xdimId, H5T_NATIVE_SHORT, H5S_ALL, H5S_ALL,
H5P_DEFAULT, xydimMat) < 0) ERR;
if (H5Dclose(xdimId) < 0) ERR;
/* Write ydim */
if ((ydimId = H5Dopen2(fileId, "/ydim", H5P_DEFAULT)) < 0) ERR;
if (H5Dwrite(ydimId, H5T_NATIVE_SHORT, H5S_ALL, H5S_ALL,
H5P_DEFAULT, xydimMat) < 0) ERR;
if (H5Dclose(ydimId) < 0) ERR;
}
if (H5Dclose(dsId) < 0) ERR;
if (H5Gclose(grpaId) < 0) ERR;
if (H5Fclose(fileId) < 0) ERR;
{
int ncid, grpid, nvars, ngatts, ndims, unlimdimid, ngrps;
char name_in[NC_MAX_NAME + 1];
nc_type xtype_in;
int ndims_in, natts_in, dimid_in[NDIMS];
/* nc_set_log_level(5);*/
if (nc_open(FILE_NAME, NC_NOWRITE, &ncid)) ERR;
if (nc_inq(ncid, &ndims, &nvars, &ngatts, &unlimdimid)) ERR;
if (ndims != 2 || nvars != 0 || ngatts != 0 || unlimdimid != -1) ERR;
if (nc_inq_grps(ncid, &ngrps, &grpid)) ERR;
if (ngrps != 1) ERR;
if (nc_inq(grpid, &ndims, &nvars, &ngatts, &unlimdimid)) ERR;
if (ndims != 0 || nvars != 1 || ngatts != 0 || unlimdimid != -1) ERR;
if (nc_inq_var(grpid, 0, name_in, &xtype_in, &ndims_in, dimid_in,
&natts_in)) ERR;
if (strcmp(name_in, VAR_NAME) || xtype_in != NC_SHORT || ndims_in != NDIMS ||
dimid_in[0] != 0 || dimid_in[1] != 1 || natts_in != 0) ERR;
if (nc_close(ncid)) ERR;
}
}
SUMMARIZE_ERR;
#ifdef USE_SZIP
printf("*** testing HDF5 compatibility with szip...");
{
#define DEFLATE_LEVEL 9
#define MAX_NAME 100
#define NUM_CD_ELEM 10
/* HDF5 defines this... */
#define DEFLATE_NAME "deflate"
#define DIM1_LEN 3000
#define GRP_NAME "George_Washington"
#define BATTLE_RECORD "Battle_Record"
hid_t fileid, grpid, spaceid, datasetid;
int data_out[DIM1_LEN], data_in[DIM1_LEN];
hsize_t dims[1] = {DIM1_LEN};
hid_t propid;
char name_in[MAX_NAME + 1];
int ncid, ndims_in, nvars_in, ngatts_in, unlimdimid_in, ngrps_in;
int nc_grpid;
int dimid_in[1], natts_in;
nc_type xtype_in;
int i;
for (i = 0; i < DIM1_LEN; i++)
data_out[i] = i;
/* Open file and create group. */
if ((fileid = H5Fcreate(FILE_NAME, H5F_ACC_TRUNC, H5P_DEFAULT,
H5P_DEFAULT)) < 0) ERR;
if ((grpid = H5Gcreate(fileid, GRP_NAME, 0)) < 0) ERR;
/* Write an array of bools, with szip compression. */
if ((propid = H5Pcreate(H5P_DATASET_CREATE)) < 0) ERR;
if (H5Pset_layout(propid, H5D_CHUNKED)) ERR;
if (H5Pset_chunk(propid, 1, dims)) ERR;
if (H5Pset_szip(propid, H5_SZIP_EC_OPTION_MASK, 32)) ERR;
if ((spaceid = H5Screate_simple(1, dims, dims)) < 0) ERR;
if ((datasetid = H5Dcreate(grpid, BATTLE_RECORD, H5T_NATIVE_INT,
spaceid, propid)) < 0) ERR;
if (H5Dwrite(datasetid, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT,
data_out) < 0) ERR;
if (H5Dclose(datasetid) < 0 ||
H5Pclose(propid) < 0 ||
H5Sclose(spaceid) < 0 ||
H5Gclose(grpid) < 0 ||
H5Fclose(fileid) < 0)
ERR;
/* Open the file with netCDF and check it. */
if (nc_open(FILE_NAME, NC_NOWRITE, &ncid)) ERR;
if (nc_inq(ncid, &ndims_in, &nvars_in, &ngatts_in, &unlimdimid_in)) ERR;
if (ndims_in != 0 || nvars_in != 0 || ngatts_in != 0 || unlimdimid_in != -1) ERR;
if (nc_inq_grps(ncid, &ngrps_in, &nc_grpid)) ERR;
if (ngrps_in != 1) ERR;
if (nc_inq(nc_grpid, &ndims_in, &nvars_in, &ngatts_in, &unlimdimid_in)) ERR;
if (ndims_in != 1 || nvars_in != 1 || ngatts_in != 0 || unlimdimid_in != -1) ERR;
/* Check the variable. */
if (nc_inq_var(nc_grpid, 0, name_in, &xtype_in, &ndims_in, dimid_in,
&natts_in)) ERR;
if (strcmp(name_in, BATTLE_RECORD) || xtype_in != NC_INT || ndims_in != 1 ||
dimid_in[0] != 0 || natts_in != 0) ERR;
/* Check the data. */
if (nc_get_var(nc_grpid, 0, data_in)) ERR;
for (i = 0; i < DIM1_LEN; i++)
if (data_in[i] != data_out[i]) ERR;
if (nc_close(ncid)) ERR;
}
SUMMARIZE_ERR;
#endif /* USE_SZIP */
FINAL_RESULTS;
}
int hdf5read(char *name, struct descriptor_xd *xd)
{
hid_t obj,type;
H5G_stat_t statbuf;
int item_type;
int idx = 0;
int status = FindItem(name, &obj, &item_type);
if (status & 1)
{
if (item_type == H5G_DATASET) {
int size;
char dtype;
int htype = 42;
int is_signed;
hsize_t ds_dims[64];
hid_t space = H5Dget_space(obj);
int n_ds_dims = H5Sget_simple_extent_dims(space,ds_dims,0);
size_t precision;
H5Sclose(space);
type = H5Dget_type(obj);
switch (H5Tget_class(type))
{
case H5T_COMPOUND:
{
printf("Compound data is not supported, skipping\n");
break;
}
case H5T_INTEGER:
precision = H5Tget_precision(type);
is_signed = (H5Tget_sign(type) != H5T_SGN_NONE);
size = precision/8;
switch (precision)
{
case 8:
dtype = is_signed ? DTYPE_B : DTYPE_BU;
htype = is_signed ? H5T_NATIVE_CHAR : H5T_NATIVE_UCHAR;
break;
case 16:
dtype = is_signed ? DTYPE_W : DTYPE_WU;
htype = is_signed ? H5T_NATIVE_SHORT : H5T_NATIVE_USHORT;
break;
case 32:
dtype = is_signed ? DTYPE_L : DTYPE_LU;
htype = is_signed ? H5T_NATIVE_INT : H5T_NATIVE_UINT;
break;
case 64:
dtype = is_signed ? DTYPE_Q : DTYPE_QU;
htype = is_signed ? H5T_NATIVE_LLONG : H5T_NATIVE_ULLONG;
break;
default:
dtype = 0;
break;
}
PutData(obj, dtype, htype, size, n_ds_dims, ds_dims,0,xd);
break;
case H5T_FLOAT:
precision = H5Tget_precision(type);
size = precision/8;
switch (precision)
{
case 32:
dtype = DTYPE_NATIVE_FLOAT;
htype = H5T_NATIVE_FLOAT;
break;
case 64:
dtype = DTYPE_NATIVE_DOUBLE;
htype = H5T_NATIVE_DOUBLE;
break;
default:
dtype = 0;
break;
}
PutData(obj, dtype, htype, size, n_ds_dims, ds_dims,0,xd);
break;
case H5T_TIME:
printf("dataset is time ---- UNSUPPORTED\n"); break;
case H5T_STRING:
{
int slen = H5Tget_size(type);
hid_t st_id;
if (slen < 0) {
printf("Badly formed string attribute\n");
return;
}
#if H5_VERS_MAJOR>=1&&H5_VERS_MINOR>=6&&H5_VERS_RELEASE>=1
if(H5Tis_variable_str(type)) {
st_id = H5Tcopy (H5T_C_S1);
H5Tset_size(st_id, H5T_VARIABLE);
} else {
#endif
st_id = H5Tcopy (type);
H5Tset_cset(st_id, H5T_CSET_ASCII);
#if H5_VERS_MAJOR>=1&&H5_VERS_MINOR>=6&&H5_VERS_RELEASE>=1
}
#endif
if (H5Tget_size(st_id) > slen) {
slen = H5Tget_size(st_id);
}
H5Tset_size (st_id, slen);
PutData(obj, DTYPE_T, st_id, slen, n_ds_dims, ds_dims, 0, xd);
}
/* printf("dataset is string\n"); */
/* dtype = DTYPE_T; */
/* htype = H5T_STRING; */
/* PutData(obj, dtype, htype, 0, 0, 0, 1, xd); */
break;
case H5T_BITFIELD:
printf("dataset is bitfield ---- UNSUPPORTED\n"); break;
case H5T_OPAQUE:
printf("dataset is opaque ---- UNSUPPORTED\n"); break;
case H5T_ARRAY:
printf("dataset is array ---- UNSUPPORTED\n"); break;
case H5T_VLEN:
printf("dataset is vlen ---- UNSUPPORTED\n"); break;
}
H5Tclose(type);
}
else {
int size;
char dtype;
int htype = 42;
int is_signed;
hsize_t ds_dims[64];
hid_t space = H5Aget_space(obj);
int n_ds_dims = H5Sget_simple_extent_dims(space,ds_dims,0);
size_t precision;
H5Sclose(space);
type = H5Aget_type(obj);
switch (H5Tget_class(type))
{
case H5T_COMPOUND:
{
printf("Compound data is not supported, skipping\n");
break;
}
case H5T_INTEGER:
precision = H5Tget_precision(type);
is_signed = (H5Tget_sign(type) != H5T_SGN_NONE);
size = precision/8;
switch (precision)
{
case 8:
dtype = is_signed ? DTYPE_B : DTYPE_BU;
htype = is_signed ? H5T_NATIVE_CHAR : H5T_NATIVE_UCHAR;
break;
case 16:
dtype = is_signed ? DTYPE_W : DTYPE_WU;
htype = is_signed ? H5T_NATIVE_SHORT : H5T_NATIVE_USHORT;
break;
case 32:
dtype = is_signed ? DTYPE_L : DTYPE_LU;
htype = is_signed ? H5T_NATIVE_INT : H5T_NATIVE_UINT;
break;
case 64:
dtype = is_signed ? DTYPE_Q : DTYPE_QU;
htype = is_signed ? H5T_NATIVE_LLONG : H5T_NATIVE_ULLONG;
break;
default:
dtype = 0;
break;
}
PutData(obj, dtype, htype, size, n_ds_dims, ds_dims, 1, xd);
break;
case H5T_FLOAT:
precision = H5Tget_precision(type);
size = precision/8;
switch (precision)
{
case 32:
dtype = DTYPE_NATIVE_FLOAT;
htype = H5T_NATIVE_FLOAT;
break;
case 64:
dtype = DTYPE_NATIVE_DOUBLE;
htype = H5T_NATIVE_DOUBLE;
break;
default:
dtype = 0;
break;
}
PutData(obj, dtype, htype, size, n_ds_dims, ds_dims,1, xd);
break;
case H5T_TIME:
printf("dataset is time ---- UNSUPPORTED\n"); break;
case H5T_STRING:
{
int slen = H5Tget_size(type);
hid_t st_id;
if (slen < 0) {
printf("Badly formed string attribute\n");
return;
}
#if H5_VERS_MAJOR>=1&&H5_VERS_MINOR>=6&&H5_VERS_RELEASE>=1
if(H5Tis_variable_str(type)) {
st_id = H5Tcopy (H5T_C_S1);
H5Tset_size(st_id, H5T_VARIABLE);
} else {
#endif
st_id = H5Tcopy (type);
H5Tset_cset(st_id, H5T_CSET_ASCII);
#if H5_VERS_MAJOR>=1&&H5_VERS_MINOR>=6&&H5_VERS_RELEASE>=1
}
#endif
if (H5Tget_size(st_id) > slen) {
slen = H5Tget_size(st_id);
}
H5Tset_size (st_id, slen);
PutData(obj, DTYPE_T, st_id, slen, n_ds_dims, ds_dims, 1, xd);
}
/* dtype = DTYPE_T; */
/* htype = H5T_STRING; */
/* PutData(obj, dtype, htype, 0, 0, 0, 1, xd); */
break;
case H5T_BITFIELD:
printf("dataset is bitfield ---- UNSUPPORTED\n"); break;
case H5T_OPAQUE:
printf("dataset is opaque ---- UNSUPPORTED\n"); break;
case H5T_ARRAY:
printf("dataset is array ---- UNSUPPORTED\n"); break;
case H5T_VLEN:
printf("dataset is vlen ---- UNSUPPORTED\n"); break;
}
H5Tclose(type);
}
}
return status;
}
DataType DataType::makeStrType(size_t size) {
DataType str_type = H5Tcopy(H5T_C_S1);
str_type.check("Could not create string type");
str_type.size(size);
return str_type;
}
/*****************************************************************************
This function generates attributes, groups, and datasets of many types.
Parameters:
fname: file_name.
ngrps: number of top level groups.
ndsets: number of datasets.
attrs: number of attributes.
nrow: number of rows in a dataset.
chunk: chunk size (single number).
vlen: max vlen size.
comp: use latest format.
latest: use gzip comnpression.
Return: Non-negative on success/Negative on failure
Programmer: Peter Cao <*****@*****.**>, Jan. 2013
****************************************************************************/
herr_t create_perf_test_file(const char *fname, int ngrps, int ndsets,
int nattrs, hsize_t nrows, hsize_t dim0, hsize_t chunk, int vlen,
int compressed, int latest)
{
int i, j, k;
hid_t fid, sid_null, sid_scalar, sid_1d, sid_2d, did, aid, sid_2, sid_large,
fapl=H5P_DEFAULT, dcpl=H5P_DEFAULT, gid1, gid2, cmp_tid, tid_str,
tid_enum, tid_array_f, tid_vlen_i, tid_vlen_s;
char name[32], tmp_name1[32], tmp_name2[32], tmp_name3[32];
hsize_t dims[1]={dim0}, dims2d[2]={dim0, (dim0/4+1)}, dims_array[1]={FIXED_LEN},
dim1[1]={2};
char *enum_names[4] = {"SOLID", "LIQUID", "GAS", "PLASMA"};
test_comp_t *buf_comp=NULL, *buf_comp_large=NULL;
int *buf_int=NULL;
float (*buf_float_a)[FIXED_LEN]=NULL;
double **buf_double2d=NULL;
hvl_t *buf_vlen_i=NULL;
char (*buf_str)[FIXED_LEN];
char **buf_vlen_s=NULL;
hobj_ref_t buf_ref[2];
hdset_reg_ref_t buf_reg_ref[2];
size_t offset, len;
herr_t status;
char *names[NTYPES] = { "int", "ulong", "float", "double", "fixed string",
"enum", "fixed float array", "vlen int array", "vlen strings"};
hid_t types[NTYPES] = { H5T_NATIVE_INT, H5T_NATIVE_UINT64, H5T_NATIVE_FLOAT,
H5T_NATIVE_DOUBLE, tid_str, tid_enum, tid_array_f, tid_vlen_i, tid_vlen_s};
hsize_t coords[4][2] = { {0, 1}, {3, 5}, {1, 0}, {2, 4}}, start=0, stride=1, count=1;
if (nrows < NROWS) nrows = NROWS;
if (ngrps<NGROUPS) ngrps=NGROUPS;
if (ndsets<NDSETS) ndsets=NDSETS;
if (nattrs<NATTRS) nattrs=NATTRS;
if (dim0<DIM0) dim0=DIM0;
if (chunk>dim0) chunk=dim0/4;
if (chunk<1) chunk = 1;
if (vlen<1) vlen = MAXVLEN;
/* create fixed string datatype */
types[4] = tid_str = H5Tcopy (H5T_C_S1);
H5Tset_size (tid_str, FIXED_LEN);
/* create enum datatype */
types[5] = tid_enum = H5Tenum_create(H5T_NATIVE_INT);
for (i = (int) SOLID; i <= (int) PLASMA; i++) {
phase_t val = (phase_t) i;
status = H5Tenum_insert (tid_enum, enum_names[i], &val);
}
/* create float array datatype */
types[6] = tid_array_f = H5Tarray_create (H5T_NATIVE_FLOAT, 1, dims_array);
/* create variable length integer datatypes */
types[7] = tid_vlen_i = H5Tvlen_create (H5T_NATIVE_INT);
/* create variable length string datatype */
types[8] = tid_vlen_s = H5Tcopy (H5T_C_S1);
H5Tset_size (tid_vlen_s, H5T_VARIABLE);
/* create compound datatypes */
cmp_tid = H5Tcreate (H5T_COMPOUND, sizeof (test_comp_t));
offset = 0;
for (i=0; i<NTYPES-2; i++) {
H5Tinsert(cmp_tid, names[i], offset, types[i]);
offset += H5Tget_size(types[i]);
}
H5Tinsert(cmp_tid, names[7], offset, types[7]);
offset += sizeof (hvl_t);
H5Tinsert(cmp_tid, names[8], offset, types[8]);
/* create dataspace */
sid_1d = H5Screate_simple (1, dims, NULL);
sid_2d = H5Screate_simple (2, dims2d, NULL);
sid_2 = H5Screate_simple (1, dim1, NULL);
sid_large = H5Screate_simple (1, &nrows, NULL);
sid_null = H5Screate (H5S_NULL);
sid_scalar = H5Screate (H5S_SCALAR);
/* create fid access property */
fapl = H5Pcreate (H5P_FILE_ACCESS);
H5Pset_libver_bounds (fapl, H5F_LIBVER_LATEST, H5F_LIBVER_LATEST);
/* create dataset creation property */
dcpl = H5Pcreate (H5P_DATASET_CREATE);
/* set dataset chunk */
if (chunk>0) {
H5Pset_chunk (dcpl, 1, &chunk);
}
/* set dataset compression */
if (compressed) {
if (chunk<=0) {
chunk = dim0/10+1;;
H5Pset_chunk (dcpl, 1, &chunk);
}
H5Pset_shuffle (dcpl);
H5Pset_deflate (dcpl, 6);
}
/* allocate buffers */
buf_comp = (test_comp_t *)calloc(dim0, sizeof(test_comp_t));
buf_comp_large = (test_comp_t *)calloc(nrows, sizeof(test_comp_t));
buf_int = (int *)calloc(dim0, sizeof(int));
buf_float_a = malloc(dim0*sizeof(*buf_float_a));
buf_vlen_i = (hvl_t *)calloc(dim0, sizeof (hvl_t));
buf_vlen_s = (char **)calloc(dim0, sizeof(char *));
buf_str = malloc(dim0*sizeof (*buf_str));
/* allocate array of doulbe pointers */
buf_double2d = (double **)calloc(dims2d[0],sizeof(double *));
/* allocate a contigous chunk of memory for the data */
buf_double2d[0] = (double *)calloc( dims2d[0]*dims2d[1],sizeof(double) );
/* assign memory city to pointer array */
for (i=1; i <dims2d[0]; i++) buf_double2d[i] = buf_double2d[0]+i*dims2d[1];
/* fill buffer values */
len = 1;
for (i=0; i<dims[0]; i++) {
buf_comp[i].i = buf_int[i] = i-2147483648;
buf_comp[i].l = 0xffffffffffffffff-i;
buf_comp[i].f = 1.0/(i+1.0);
buf_comp[i].d = 987654321.0*i+1.0/(i+1.0);
buf_comp[i].e = (phase_t) (i % (int) (PLASMA + 1));
for (j=0; j<FIXED_LEN; j++) {
buf_comp[i].f_array[j] = buf_float_a[i][j] = i*100+j;
buf_str[i][j] = 'a' + (i%26);
}
buf_str[i][FIXED_LEN-1] = 0;
strcpy(buf_comp[i].s, buf_str[i]);
len = (1-cos(i/8.0))/2*vlen+1;
if (!i) len = vlen;
buf_vlen_i[i].len = len;
buf_vlen_i[i].p = (int *)calloc(len, sizeof(int));
for (j=0; j<len; j++) ((int*)(buf_vlen_i[i].p))[j] = i*100+j;
buf_comp[i].i_vlen = buf_vlen_i[i];
buf_vlen_s[i] = (char *)calloc(len, sizeof(char));
for (j=0; j<len-1; j++)
buf_vlen_s[i][j] = j%26+'A';
buf_comp[i].s_vlen = buf_vlen_s[i];
for (j=0; j<dims2d[1]; j++)
buf_double2d[i][j] = i+j/10000.0;
}
for (i=0; i<nrows; i++) {
buf_comp_large[i].i = i-2147483648;
buf_comp_large[i].l = 0xffffffffffffffff-i;
buf_comp_large[i].f = 1.0/(i+1.0);
buf_comp_large[i].d = 987654321.0*i+1.0/(i+1.0);
buf_comp_large[i].e = (phase_t) (i % (int) (PLASMA + 1));
for (j=0; j<FIXED_LEN-1; j++) {
buf_comp_large[i].f_array[j] = i*100+j;
buf_comp_large[i].s[j] = 'a' + (i%26);
}
len = i%vlen+1;
buf_comp_large[i].i_vlen.len = len;
buf_comp_large[i].i_vlen.p = (int *)calloc(len, sizeof(int));
for (j=0; j<len; j++) ((int*)(buf_comp_large[i].i_vlen.p))[j] = i*100+j;
buf_comp_large[i].s_vlen = (char *)calloc(i+2, sizeof(char));
for (j=0; j<i+1; j++) (buf_comp_large[i].s_vlen)[j] = j%26+'A';
}
/* create file */
if (latest)
fid = H5Fcreate (fname, H5F_ACC_TRUNC, H5P_DEFAULT, fapl);
else
fid = H5Fcreate (fname, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);
add_attrs(fid, 0);
sprintf(name, "a cmp ds of %d rows", nrows);
did = H5Dcreate (fid, name, cmp_tid, sid_large, H5P_DEFAULT, dcpl, H5P_DEFAULT);
H5Dwrite (did, cmp_tid, H5S_ALL, H5S_ALL, H5P_DEFAULT, buf_comp_large);
add_attrs(did, 0);
H5Dclose(did);
// /* add attributes*/
gid1 = H5Gcreate (fid, "attributes", H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
if (nattrs<1) nattrs = 1;
i=0;
while (i<nattrs) i += add_attrs(gid1, i);
H5Gclose(gid1);
/* add many sub groups to a group*/
gid1 = H5Gcreate (fid, "groups", H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
add_attrs(gid1, 0);
for (i=0; i<ngrps; i++) {
/* create sub groups */
sprintf(name, "g%02d", i);
gid2 = H5Gcreate (gid1, name, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
if (i<10) add_attrs(gid2, 0);
H5Gclose(gid2);
}
H5Gclose(gid1);
/* add many datasets to a group */
gid1 = H5Gcreate (fid, "datasets", H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
add_attrs(gid1, 0);
for (j=0; j<ndsets; j+=12) {
/* 1 add a null dataset */
sprintf(name, "%05d null dataset", j);
did = H5Dcreate (gid1, name, H5T_STD_I32LE, sid_null, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
if (!j) add_attrs(did, j);
H5Dclose(did);
/* 2 add scalar int point */
sprintf(name, "%05d scalar int point", j);
did = H5Dcreate (gid1, name, H5T_NATIVE_INT, sid_scalar, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
H5Dwrite (did, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, &j);
if (!j) add_attrs(did, j);
H5Dclose(did);
/* 3 scalar vlen string */
sprintf(name, "%05d scalar vlen string", j);
did = H5Dcreate (gid1, name, tid_vlen_s, sid_scalar, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
H5Dwrite (did, tid_vlen_s, H5S_ALL, H5S_ALL, H5P_DEFAULT, &buf_vlen_s[0]);
if (!j) add_attrs(did, j);
H5Dclose(did);
/* 4 add fixed-length float array */
sprintf(name, "%05d fixed-length float array", j);
did = H5Dcreate (gid1, name, tid_array_f, sid_1d, H5P_DEFAULT, dcpl, H5P_DEFAULT);
H5Dwrite (did, tid_array_f, H5S_ALL, H5S_ALL, H5P_DEFAULT, buf_float_a);
if (!j) add_attrs(did, j);
H5Dclose(did);
/* 5 add fixed-length strings */
sprintf(name, "%05d fixed-length strings", j);
did = H5Dcreate (gid1, name, tid_str, sid_1d, H5P_DEFAULT, dcpl, H5P_DEFAULT);
H5Dwrite (did, tid_str, H5S_ALL, H5S_ALL, H5P_DEFAULT, buf_str);
if (!j) add_attrs(did, j);
H5Dclose(did);
/* 6 add compound data */
sprintf(name, "%05d compund data", j);
did = H5Dcreate (gid1, name, cmp_tid, sid_1d, H5P_DEFAULT, dcpl, H5P_DEFAULT);
H5Dwrite (did, cmp_tid, H5S_ALL, H5S_ALL, H5P_DEFAULT, buf_comp);
if (!j) add_attrs(did, j);
H5Dclose(did);
/* 7 add 2D double */
sprintf(name, "%05d 2D double", j);
strcpy (tmp_name1, name);
did = H5Dcreate (gid1, name, H5T_NATIVE_DOUBLE, sid_2d, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
H5Dwrite (did, H5T_NATIVE_DOUBLE, H5S_ALL, H5S_ALL, H5P_DEFAULT, buf_double2d[0]);
if (!j) add_attrs(did, j);
H5Dclose(did);
/* 8 add 1D int array */
sprintf(name, "%05d 1D int array", j);
did = H5Dcreate (gid1, name, H5T_NATIVE_INT, sid_1d, H5P_DEFAULT, dcpl, H5P_DEFAULT);
H5Dwrite (did, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, buf_int);
if (!j) add_attrs(did, j);
H5Dclose(did);
/* 9 add vlen int array */
sprintf(name, "%05d vlen int array", j);
strcpy (tmp_name2, name);
did = H5Dcreate (gid1, name, tid_vlen_i, sid_1d, H5P_DEFAULT, dcpl, H5P_DEFAULT);
H5Dwrite (did, tid_vlen_i, H5S_ALL, H5S_ALL, H5P_DEFAULT, buf_vlen_i);
if (!j) add_attrs(did, j);
H5Dclose(did);
/* 10 add vlen strings */
sprintf(name, "%05d vlen strings", j);
strcpy (tmp_name3, name);
did = H5Dcreate (gid1, name, tid_vlen_s, sid_1d, H5P_DEFAULT, dcpl, H5P_DEFAULT);
H5Dwrite (did, tid_vlen_s, H5S_ALL, H5S_ALL, H5P_DEFAULT, buf_vlen_s);
if (!j) add_attrs(did, j);
H5Dclose(did);
/* 11 add object refs */
H5Rcreate(&buf_ref[0],gid1, ".", H5R_OBJECT, -1);
H5Rcreate(&buf_ref[1],gid1, tmp_name3, H5R_OBJECT, -1);
sprintf(name, "%05d obj refs", j);
did = H5Dcreate (gid1, name, H5T_STD_REF_OBJ, sid_2, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
H5Dwrite (did, H5T_STD_REF_OBJ, H5S_ALL, H5S_ALL, H5P_DEFAULT, buf_ref);
if (!j) add_attrs(did, j);
H5Dclose(did);
/* 12 add region refs */
H5Sselect_elements (sid_2d, H5S_SELECT_SET, 4, coords[0]);
H5Rcreate(&buf_reg_ref[0],gid1, tmp_name1, H5R_DATASET_REGION, sid_2d);
H5Sselect_none(sid_2d);
count = dims[0]/2+1;
H5Sselect_hyperslab (sid_1d, H5S_SELECT_SET, &start, &stride, &count,NULL);
H5Rcreate(&buf_reg_ref[1],gid1, tmp_name2, H5R_DATASET_REGION, sid_1d);
H5Sselect_none(sid_1d);
sprintf(name, "%05d region refs", j);
did = H5Dcreate (gid1, name, H5T_STD_REF_DSETREG, sid_2, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
H5Dwrite (did, H5T_STD_REF_DSETREG, H5S_ALL, H5S_ALL, H5P_DEFAULT, buf_reg_ref);
if (!j) add_attrs(did, j);
H5Dclose(did);
}
H5Gclose(gid1);
H5Tclose (tid_array_f);
H5Tclose (tid_vlen_i);
H5Tclose (tid_vlen_s);
H5Tclose (tid_enum);
H5Tclose (tid_str);
H5Tclose (cmp_tid);
H5Pclose (dcpl);
H5Pclose (fapl);
H5Sclose (sid_1d);
H5Sclose (sid_2d);
H5Sclose (sid_2);
H5Sclose (sid_large);
H5Sclose (sid_null);
H5Sclose (sid_scalar);
H5Fclose (fid);
for (i=0; i<dims[0]; i++) {
if (buf_vlen_i[i].p) free(buf_vlen_i[i].p);
if (buf_vlen_s[i]) free(buf_vlen_s[i]);
}
for (i=0; i<nrows; i++) {
if (buf_comp_large[i].i_vlen.p) free(buf_comp_large[i].i_vlen.p);
if (buf_comp_large[i].s_vlen) free(buf_comp_large[i].s_vlen);
}
free (buf_comp);
free (buf_comp_large);
free (buf_int);
free (buf_float_a);
free (buf_double2d[0]);
free (buf_double2d);
free (buf_str);
free(buf_vlen_i);
free(buf_vlen_s);
return 0;
}
int
NC4_write_ncproperties(NC_FILE_INFO_T* h5)
{
int retval = NC_NOERR;
hid_t hdf5grpid = -1;
hid_t attid = -1;
hid_t aspace = -1;
hid_t atype = -1;
char* text = NULL;
size_t len = 0;
LOG((3, "%s", __func__));
/* If the file is read-only, return an error. */
if (h5->no_write)
{retval = NC_EPERM; goto done;}
hdf5grpid = ((NC_HDF5_GRP_INFO_T *)(h5->root_grp->format_grp_info))->hdf_grpid;
if(H5Aexists(hdf5grpid,NCPROPS) > 0) /* Already exists, no overwrite */
goto done;
/* Build the attribute string */
if((retval = NC4_buildpropinfo(&h5->provenance->propattr,&text)))
goto done;
/* Build the HDF5 string type */
if ((atype = H5Tcopy(H5T_C_S1)) < 0)
{retval = NC_EHDFERR; goto done;}
if (H5Tset_strpad(atype, H5T_STR_NULLTERM) < 0)
{retval = NC_EHDFERR; goto done;}
if(H5Tset_cset(atype, H5T_CSET_ASCII) < 0)
{retval = NC_EHDFERR; goto done;}
len = strlen(text);
if(H5Tset_size(atype, len) < 0)
{retval = NC_EFILEMETA; goto done;}
/* Create NCPROPS attribute */
if((aspace = H5Screate(H5S_SCALAR)) < 0)
{retval = NC_EFILEMETA; goto done;}
if ((attid = H5Acreate(hdf5grpid, NCPROPS, atype, aspace, H5P_DEFAULT)) < 0)
{retval = NC_EFILEMETA; goto done;}
if (H5Awrite(attid, atype, text) < 0)
{retval = NC_EFILEMETA; goto done;}
/* Verify */
#if 0
{
hid_t spacev, typev;
hsize_t dsize, tsize;
typev = H5Aget_type(attid);
spacev = H5Aget_space(attid);
dsize = H5Aget_storage_size(attid);
tsize = H5Tget_size(typev);
fprintf(stderr,"dsize=%lu tsize=%lu\n",(unsigned long)dsize,(unsigned long)tsize);
}
#endif
done:
if(text != NULL) free(text);
/* Close out the HDF5 objects */
if(attid > 0 && H5Aclose(attid) < 0) retval = NC_EHDFERR;
if(aspace > 0 && H5Sclose(aspace) < 0) retval = NC_EHDFERR;
if(atype > 0 && H5Tclose(atype) < 0) retval = NC_EHDFERR;
/* For certain errors, actually fail, else log that attribute was invalid and ignore */
switch (retval) {
case NC_ENOMEM:
case NC_EHDFERR:
case NC_EPERM:
case NC_EFILEMETA:
case NC_NOERR:
break;
default:
LOG((0,"Invalid _NCProperties attribute"));
retval = NC_NOERR;
break;
}
return retval;
}
DataType DataType::copy () {
return DataType (Exception::check ("H5Tcopy", H5Tcopy (handle ())));
}
int
main (void)
{
hid_t file, filetype, memtype, space, dset, attr;
/* Handles */
herr_t status;
hsize_t dims[1] = {DIM0};
char *wdata[DIM0] = {"Parting", "is such", "sweet", "sorrow."},
/* Write buffer */
**rdata; /* Read buffer */
int ndims,
i;
/*
* Create a new file using the default properties.
*/
file = H5Fcreate (FILE, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);
/*
* Create file and memory datatypes. For this example we will save
* the strings as FORTRAN strings.
*/
filetype = H5Tcopy (H5T_FORTRAN_S1);
status = H5Tset_size (filetype, H5T_VARIABLE);
memtype = H5Tcopy (H5T_C_S1);
status = H5Tset_size (memtype, H5T_VARIABLE);
/*
* Create dataset with a null dataspace.
*/
space = H5Screate (H5S_NULL);
dset = H5Dcreate (file, DATASET, H5T_STD_I32LE, space, H5P_DEFAULT,
H5P_DEFAULT, H5P_DEFAULT);
status = H5Sclose (space);
/*
* Create dataspace. Setting maximum size to NULL sets the maximum
* size to be the current size.
*/
space = H5Screate_simple (1, dims, NULL);
/*
* Create the attribute and write the variable-length string data
* to it.
*/
attr = H5Acreate (dset, ATTRIBUTE, filetype, space, H5P_DEFAULT,
H5P_DEFAULT);
status = H5Awrite (attr, memtype, wdata);
/*
* Close and release resources.
*/
status = H5Aclose (attr);
status = H5Dclose (dset);
status = H5Sclose (space);
status = H5Tclose (filetype);
status = H5Tclose (memtype);
status = H5Fclose (file);
/*
* Now we begin the read section of this example. Here we assume
* the attribute has the same name and rank, but can have any size.
* Therefore we must allocate a new array to read in data using
* malloc().
*/
/*
* Open file, dataset, and attribute.
*/
file = H5Fopen (FILE, H5F_ACC_RDONLY, H5P_DEFAULT);
dset = H5Dopen (file, DATASET, H5P_DEFAULT);
attr = H5Aopen (dset, ATTRIBUTE, H5P_DEFAULT);
/*
* Get the datatype.
*/
filetype = H5Aget_type (attr);
/*
* Get dataspace and allocate memory for read buffer.
*/
space = H5Aget_space (attr);
ndims = H5Sget_simple_extent_dims (space, dims, NULL);
rdata = (char **) malloc (dims[0] * sizeof (char *));
/*
* Create the memory datatype.
*/
memtype = H5Tcopy (H5T_C_S1);
status = H5Tset_size (memtype, H5T_VARIABLE);
/*
* Read the data.
*/
status = H5Aread (attr, memtype, rdata);
/*
* Output the data to the screen.
*/
for (i=0; i<dims[0]; i++)
printf ("%s[%d]: %s\n", ATTRIBUTE, i, rdata[i]);
/*
* Close and release resources. Note that H5Dvlen_reclaim works
* for variable-length strings as well as variable-length arrays.
* Also note that we must still free the array of pointers stored
* in rdata, as H5Tvlen_reclaim only frees the data these point to.
*/
status = H5Dvlen_reclaim (memtype, space, H5P_DEFAULT, rdata);
free (rdata);
status = H5Aclose (attr);
status = H5Dclose (dset);
status = H5Sclose (space);
status = H5Tclose (filetype);
status = H5Tclose (memtype);
status = H5Fclose (file);
return 0;
}
/*+++++++++++++++++++++++++ Main Program or Function +++++++++++++++*/
void SCIA_OL2_WR_H5_CLD( struct param_record param, unsigned int nr_cld,
const struct cld_sci_ol *cld )
{
register unsigned int nr;
hid_t grp_id;
hbool_t compress;
hsize_t adim;
hvl_t *vdata;
hid_t cld_type[NFIELDS];
const char *cld_names[NFIELDS] = {
"dsr_time", "quality_flag", "integr_time", "pmd_read",
"cl_type_flags", "cloud_flags", "flag_output_flags",
"num_aero_param", "pmd_read_cl", "dsr_length",
"surface_pres", "cl_frac", "cl_frac_err", "cl_top_pres",
"cl_top_pres_err", "cl_opt_depth", "cl_opt_depth_err",
"cl_reflectance", "cl_reflectance_err",
"surface_reflectance", "surface_reflectance_err",
"aero_abso_ind", "aero_ind_diag"
};
/*
* check number of CLD records
*/
if ( nr_cld == 0 ) return;
/*
* set HDF5 boolean variable for compression
*/
if ( param.flag_deflate == PARAM_SET )
compress = TRUE;
else
compress = FALSE;
/*
* create group /MDS
*/
grp_id = NADC_OPEN_HDF5_Group( param.hdf_file_id, "/MDS" );
if ( grp_id < 0 ) NADC_RETURN_ERROR( NADC_ERR_HDF_GRP, "/MDS" );
/*
* define user-defined data types of the Table-fields
*/
cld_type[0] = H5Topen( param.hdf_file_id, "mjd", H5P_DEFAULT );
cld_type[1] = H5Tcopy( H5T_NATIVE_CHAR );
cld_type[2] = H5Tcopy( H5T_NATIVE_USHORT );
cld_type[3] = H5Tcopy( H5T_NATIVE_USHORT );
cld_type[4] = H5Tcopy( H5T_NATIVE_USHORT );
cld_type[5] = H5Tcopy( H5T_NATIVE_USHORT );
cld_type[6] = H5Tcopy( H5T_NATIVE_USHORT );
cld_type[7] = H5Tcopy( H5T_NATIVE_USHORT );
adim = 2;
cld_type[8] = H5Tarray_create( H5T_NATIVE_USHORT, 1, &adim );
cld_type[9] = H5Tcopy( H5T_NATIVE_UINT );
cld_type[10] = H5Tcopy( H5T_NATIVE_FLOAT );
cld_type[11] = H5Tcopy( H5T_NATIVE_FLOAT );
cld_type[12] = H5Tcopy( H5T_NATIVE_FLOAT );
cld_type[13] = H5Tcopy( H5T_NATIVE_FLOAT );
cld_type[14] = H5Tcopy( H5T_NATIVE_FLOAT );
cld_type[15] = H5Tcopy( H5T_NATIVE_FLOAT );
cld_type[16] = H5Tcopy( H5T_NATIVE_FLOAT );
cld_type[17] = H5Tcopy( H5T_NATIVE_FLOAT );
cld_type[18] = H5Tcopy( H5T_NATIVE_FLOAT );
cld_type[19] = H5Tcopy( H5T_NATIVE_FLOAT );
cld_type[20] = H5Tcopy( H5T_NATIVE_FLOAT );
cld_type[21] = H5Tcopy( H5T_NATIVE_FLOAT );
cld_type[22] = H5Tcopy( H5T_NATIVE_FLOAT );
/*
* create table
*/
(void) H5TBmake_table( "Cloud end Aerosol MDS", grp_id, "cld", NFIELDS,
nr_cld, cld_size, cld_names, cld_offs,
cld_type, nr_cld, NULL, compress, cld );
/*
* close interface
*/
for ( nr = 0; nr < NFIELDS; nr++ ) (void) H5Tclose( cld_type[nr] );
/*
* +++++ create/write variable part of the CLOUDS_AEROSOL record
*/
adim = (hsize_t) nr_cld;
/*
* Additional aerosol parameters
*/
vdata = (hvl_t *) malloc( nr_cld * sizeof(hvl_t) );
if ( vdata == NULL ) NADC_RETURN_ERROR( NADC_ERR_ALLOC, "vdata" );
nr = 0;
do {
vdata[nr].len = (size_t) cld[nr].numaeropars;
if ( cld[nr].numaeropars > 0 ) {
vdata[nr].p = malloc( vdata[nr].len * sizeof(float) );
if ( vdata[nr].p == NULL ) {
free( vdata );
NADC_RETURN_ERROR( NADC_ERR_ALLOC, "vdata.p" );
}
(void) memcpy( vdata[nr].p , cld[nr].aeropars,
vdata[nr].len * sizeof(float) );
}
} while ( ++nr < nr_cld );
NADC_WR_HDF5_Vlen_Dataset( compress, grp_id, "aeropars",
H5T_NATIVE_FLOAT, 1, &adim, vdata );
/*
* close interface
*/
(void) H5Gclose( grp_id );
}
/*! This function writes an actual snapshot file containing the data from
* processors 'writeTask' to 'lastTask'. 'writeTask' is the one that actually
* writes. Each snapshot file contains a header first, then particle
* positions, velocities and ID's. Particle masses are written only for
* those particle types with zero entry in MassTable. After that, first the
* internal energies u, and then the density is written for the SPH
* particles. If cooling is enabled, mean molecular weight and neutral
* hydrogen abundance are written for the gas particles. This is followed by
* the SPH smoothing length and further blocks of information, depending on
* included physics and compile-time flags. If HDF5 is used, the header is
* stored in a group called "/Header", and the particle data is stored
* separately for each particle type in groups calles "/PartType0",
* "/PartType1", etc. The sequence of the blocks is unimportant in this case.
*/
void write_file(char *fname, int writeTask, int lastTask)
{
int type, bytes_per_blockelement, npart, nextblock, typelist[6];
int n_for_this_task, ntask, n, p, pc, offset = 0, task;
int blockmaxlen, ntot_type[6], nn[6];
enum iofields blocknr;
int blksize;
MPI_Status status;
FILE *fd = 0;
#ifdef HAVE_HDF5
hid_t hdf5_file = 0, hdf5_grp[6], hdf5_headergrp = 0, hdf5_dataspace_memory;
hid_t hdf5_datatype = 0, hdf5_dataspace_in_file = 0, hdf5_dataset = 0;
herr_t hdf5_status;
hsize_t dims[2], count[2], start[2];
int rank, pcsum = 0;
char buf[500];
#endif
#define SKIP {my_fwrite(&blksize,sizeof(int),1,fd);}
/* determine particle numbers of each type in file */
if(ThisTask == writeTask)
{
for(n = 0; n < 6; n++)
ntot_type[n] = n_type[n];
for(task = writeTask + 1; task <= lastTask; task++)
{
MPI_Recv(&nn[0], 6, MPI_INT, task, TAG_LOCALN, MPI_COMM_WORLD, &status);
for(n = 0; n < 6; n++)
ntot_type[n] += nn[n];
}
for(task = writeTask + 1; task <= lastTask; task++)
MPI_Send(&ntot_type[0], 6, MPI_INT, task, TAG_N, MPI_COMM_WORLD);
}
else
{
MPI_Send(&n_type[0], 6, MPI_INT, writeTask, TAG_LOCALN, MPI_COMM_WORLD);
MPI_Recv(&ntot_type[0], 6, MPI_INT, writeTask, TAG_N, MPI_COMM_WORLD, &status);
}
/* fill file header */
for(n = 0; n < 6; n++)
{
header.npart[n] = ntot_type[n];
header.npartTotal[n] = (unsigned int) ntot_type_all[n];
header.npartTotalHighWord[n] = (unsigned int) (ntot_type_all[n] >> 32);
}
for(n = 0; n < 6; n++)
header.mass[n] = All.MassTable[n];
header.time = All.Time;
if(All.ComovingIntegrationOn)
header.redshift = 1.0 / All.Time - 1;
else
header.redshift = 0;
header.flag_sfr = 0;
header.flag_feedback = 0;
header.flag_cooling = 0;
header.flag_stellarage = 0;
header.flag_metals = 0;
#ifdef COOLING
header.flag_cooling = 1;
#endif
#ifdef SFR
header.flag_sfr = 1;
header.flag_feedback = 1;
#ifdef STELLARAGE
header.flag_stellarage = 1;
#endif
#ifdef METALS
header.flag_metals = 1;
#endif
#endif
header.num_files = All.NumFilesPerSnapshot;
header.BoxSize = All.BoxSize;
header.Omega0 = All.Omega0;
header.OmegaLambda = All.OmegaLambda;
header.HubbleParam = All.HubbleParam;
/* open file and write header */
if(ThisTask == writeTask)
{
if(All.SnapFormat == 3)
{
#ifdef HAVE_HDF5
sprintf(buf, "%s.hdf5", fname);
hdf5_file = H5Fcreate(buf, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);
hdf5_headergrp = H5Gcreate(hdf5_file, "/Header", 0);
for(type = 0; type < 6; type++)
{
if(header.npart[type] > 0)
{
sprintf(buf, "/PartType%d", type);
hdf5_grp[type] = H5Gcreate(hdf5_file, buf, 0);
}
}
write_header_attributes_in_hdf5(hdf5_headergrp);
#endif
}
else
{
if(!(fd = fopen(fname, "w")))
{
printf("can't open file `%s' for writing snapshot.\n", fname);
endrun(123);
}
if(All.SnapFormat == 2)
{
blksize = sizeof(int) + 4 * sizeof(char);
SKIP;
my_fwrite("HEAD", sizeof(char), 4, fd);
nextblock = sizeof(header) + 2 * sizeof(int);
my_fwrite(&nextblock, sizeof(int), 1, fd);
SKIP;
}
blksize = sizeof(header);
SKIP;
my_fwrite(&header, sizeof(header), 1, fd);
SKIP;
}
}
ntask = lastTask - writeTask + 1;
for(blocknr = 0; blocknr < IO_NBLOCKS; blocknr++)
{
if(blockpresent(blocknr))
{
bytes_per_blockelement = get_bytes_per_blockelement(blocknr);
blockmaxlen = ((int) (All.BufferSize * 1024 * 1024)) / bytes_per_blockelement;
npart = get_particles_in_block(blocknr, &typelist[0]);
if(npart > 0)
{
if(ThisTask == writeTask)
{
if(All.SnapFormat == 1 || All.SnapFormat == 2)
{
if(All.SnapFormat == 2)
{
blksize = sizeof(int) + 4 * sizeof(char);
SKIP;
my_fwrite(Tab_IO_Labels[blocknr], sizeof(char), 4, fd);
nextblock = npart * bytes_per_blockelement + 2 * sizeof(int);
my_fwrite(&nextblock, sizeof(int), 1, fd);
SKIP;
}
blksize = npart * bytes_per_blockelement;
SKIP;
}
}
for(type = 0; type < 6; type++)
{
if(typelist[type])
{
#ifdef HAVE_HDF5
if(ThisTask == writeTask && All.SnapFormat == 3 && header.npart[type] > 0)
{
switch (get_datatype_in_block(blocknr))
{
case 0:
hdf5_datatype = H5Tcopy(H5T_NATIVE_UINT);
break;
case 1:
hdf5_datatype = H5Tcopy(H5T_NATIVE_FLOAT);
break;
case 2:
hdf5_datatype = H5Tcopy(H5T_NATIVE_UINT64);
break;
}
dims[0] = header.npart[type];
dims[1] = get_values_per_blockelement(blocknr);
if(dims[1] == 1)
rank = 1;
else
rank = 2;
get_dataset_name(blocknr, buf);
hdf5_dataspace_in_file = H5Screate_simple(rank, dims, NULL);
hdf5_dataset =
H5Dcreate(hdf5_grp[type], buf, hdf5_datatype, hdf5_dataspace_in_file,
H5P_DEFAULT);
pcsum = 0;
}
#endif
for(task = writeTask, offset = 0; task <= lastTask; task++)
{
if(task == ThisTask)
{
n_for_this_task = n_type[type];
for(p = writeTask; p <= lastTask; p++)
if(p != ThisTask)
MPI_Send(&n_for_this_task, 1, MPI_INT, p, TAG_NFORTHISTASK, MPI_COMM_WORLD);
}
else
MPI_Recv(&n_for_this_task, 1, MPI_INT, task, TAG_NFORTHISTASK, MPI_COMM_WORLD,
&status);
while(n_for_this_task > 0)
{
pc = n_for_this_task;
if(pc > blockmaxlen)
pc = blockmaxlen;
if(ThisTask == task)
fill_write_buffer(blocknr, &offset, pc, type);
if(ThisTask == writeTask && task != writeTask)
MPI_Recv(CommBuffer, bytes_per_blockelement * pc, MPI_BYTE, task,
TAG_PDATA, MPI_COMM_WORLD, &status);
if(ThisTask != writeTask && task == ThisTask)
MPI_Ssend(CommBuffer, bytes_per_blockelement * pc, MPI_BYTE, writeTask,
TAG_PDATA, MPI_COMM_WORLD);
if(ThisTask == writeTask)
{
if(All.SnapFormat == 3)
{
#ifdef HAVE_HDF5
start[0] = pcsum;
start[1] = 0;
count[0] = pc;
count[1] = get_values_per_blockelement(blocknr);
pcsum += pc;
H5Sselect_hyperslab(hdf5_dataspace_in_file, H5S_SELECT_SET,
start, NULL, count, NULL);
dims[0] = pc;
dims[1] = get_values_per_blockelement(blocknr);
hdf5_dataspace_memory = H5Screate_simple(rank, dims, NULL);
hdf5_status =
H5Dwrite(hdf5_dataset, hdf5_datatype, hdf5_dataspace_memory,
hdf5_dataspace_in_file, H5P_DEFAULT, CommBuffer);
H5Sclose(hdf5_dataspace_memory);
#endif
}
else
my_fwrite(CommBuffer, bytes_per_blockelement, pc, fd);
}
n_for_this_task -= pc;
}
}
#ifdef HAVE_HDF5
if(ThisTask == writeTask && All.SnapFormat == 3 && header.npart[type] > 0)
{
if(All.SnapFormat == 3)
{
H5Dclose(hdf5_dataset);
H5Sclose(hdf5_dataspace_in_file);
H5Tclose(hdf5_datatype);
}
}
#endif
}
}
if(ThisTask == writeTask)
{
if(All.SnapFormat == 1 || All.SnapFormat == 2)
SKIP;
}
}
}
}
if(ThisTask == writeTask)
{
if(All.SnapFormat == 3)
{
#ifdef HAVE_HDF5
for(type = 5; type >= 0; type--)
if(header.npart[type] > 0)
H5Gclose(hdf5_grp[type]);
H5Gclose(hdf5_headergrp);
H5Fclose(hdf5_file);
#endif
}
else
fclose(fd);
}
}
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;
char *mname;
int result = 0;
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 {
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);
H5Pset_preserve(plist, 1);
/*
* 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));
if(fok[0] != fptr[0] || fok[1] != fptr[1]
|| fnok[0] != fptr[2] || fnok[1] != fptr[3]) {
result = 1;
printf("%14s (%2d) %6s = %s\n",
mname = H5Tget_member_name(fix, 0), (int)H5Tget_member_offset(fix,0),
string5, (char *)(data + H5Tget_member_offset(fix, 0)));
free(mname);
fptr = (float *)(data + H5Tget_member_offset(fix, 1));
printf("Data comparison:\n"
"%14s (%2d) %6f = %f\n"
" %6f = %f\n",
mname = H5Tget_member_name(fix, 1), (int)H5Tget_member_offset(fix,1),
fok[0], fptr[0],
fok[1], fptr[1]);
free(mname);
fptr = (float *)(data + H5Tget_member_offset(fix, 2));
printf("%14s (%2d) %6f = %f\n"
" %6f = %6f\n",
mname = H5Tget_member_name(fix, 2), (int)H5Tget_member_offset(fix,2),
fnok[0], fptr[0],
fnok[1], fptr[1]);
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*");
} else {
puts(" PASSED");
}
free(data);
H5Sclose(spc);
H5Tclose(cmp);
H5Tclose(cmp1);
H5Tclose(cmp2);
H5Tclose(cmp3);
H5Pclose(plist);
H5Fclose(fil);
HDunlink(fname);
fflush(stdout);
return result;
}
int main( void )
{
typedef struct Particle1
{
char name[16];
int lati;
int longi;
float pressure;
double temperature;
} Particle1;
/* Define an array of Particles */
Particle1 p_data[NRECORDS] = {
{"zero",0,0, 0.0f, 0.0},
{"one",10,10, 1.0f, 10.0},
{"two", 20,20, 2.0f, 20.0},
{"three",30,30, 3.0f, 30.0},
{"four", 40,40, 4.0f, 40.0},
{"five", 50,50, 5.0f, 50.0},
{"six", 60,60, 6.0f, 60.0},
{"seven",70,70, 7.0f, 70.0}
};
/* Calculate the size and the offsets of our struct members in memory */
size_t dst_size1 = sizeof( Particle1 );
size_t dst_offset1[NFIELDS] = { HOFFSET( Particle1, name ),
HOFFSET( Particle1, lati ),
HOFFSET( Particle1, longi ),
HOFFSET( Particle1, pressure ),
HOFFSET( Particle1, temperature )};
/* Define field information */
const char *field_names[NFIELDS] =
{ "Name","Latitude", "Longitude", "Pressure", "Temperature" };
hid_t field_type[NFIELDS];
hid_t string_type;
hid_t file_id;
hsize_t chunk_size = 10;
int compress = 0;
Particle1 fill_data[1] = { "no data",-1,-1, -99.0f, -99.0 };
int fill_data_new[1] = { -100 };
hsize_t position;
herr_t status;
hsize_t nfields_out;
hsize_t nrecords_out;
/* Define the inserted field information */
hid_t field_type_new = H5T_NATIVE_INT;
int data[NRECORDS] = { 0,1,2,3,4,5,6,7 };
/* Initialize the field type */
string_type = H5Tcopy( H5T_C_S1 );
H5Tset_size( string_type, 16 );
field_type[0] = string_type;
field_type[1] = H5T_NATIVE_INT;
field_type[2] = H5T_NATIVE_INT;
field_type[3] = H5T_NATIVE_FLOAT;
field_type[4] = H5T_NATIVE_DOUBLE;
/* Create a new file using default properties. */
file_id = H5Fcreate( "ex_table_11.h5", H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT );
/* Make the table */
status=H5TBmake_table( "Table Title",file_id,TABLE_NAME,NFIELDS,NRECORDS,
dst_size1,field_names, dst_offset1, field_type,
chunk_size, fill_data, compress, p_data );
/* Insert the new field at the end of the field list */
position = NFIELDS;
status=H5TBinsert_field( file_id, TABLE_NAME, "New Field", field_type_new, position,
fill_data_new, data );
/* Get table info */
status=H5TBget_table_info (file_id,TABLE_NAME, &nfields_out, &nrecords_out );
/* print */
printf ("Table has %d fields and %d records\n",(int)nfields_out,(int)nrecords_out);
/* Close the file. */
H5Fclose( file_id );
return 0;
}
int main(int argc, char *argv[])
{
hid_t fid = -1;
hid_t access_plist = -1;
hid_t create_plist = -1;
hid_t cparm = -1;
hid_t datatype = -1;
hid_t dataspace = -1;
hid_t dataset = -1;
hid_t memspace = -1;
hid_t groupDetector = -1;
int rank = 1;
hsize_t chunk[2] = {10,10};
hsize_t dims[2] = {1,1};
hsize_t elementSize[2] = {1,1};
hsize_t maxdims[2] = {H5S_UNLIMITED,H5S_UNLIMITED};
int ivalue[2];
int fillValue = 0;
/* Open the source file and dataset */
/* All SWMR files need to use the latest file format */
access_plist = H5Pcreate(H5P_FILE_ACCESS);
H5Pset_fclose_degree(access_plist, H5F_CLOSE_STRONG);
#if H5_VERSION_GE(1,9,178)
H5Pset_object_flush_cb(access_plist, cFlushCallback, NULL);
#endif
H5Pset_libver_bounds(access_plist, H5F_LIBVER_LATEST, H5F_LIBVER_LATEST);
create_plist = H5Pcreate(H5P_FILE_CREATE);
fid = H5Fcreate("test_string_swmr.h5", H5F_ACC_TRUNC, create_plist, access_plist);
/* Data */
rank = 2;
dims[0] = 10;
dims[1] = 10;
dataspace = H5Screate_simple(rank, dims, dims);
cparm = H5Pcreate(H5P_DATASET_CREATE);
H5Pset_chunk(cparm, rank, chunk);
datatype = H5Tcopy(H5T_NATIVE_INT8);
H5Pset_fill_value(cparm, datatype, &fillValue);
groupDetector = H5Gcreate(fid, "detector", H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
access_plist = H5Pcreate(H5P_DATASET_ACCESS);
H5Pset_chunk_cache(access_plist, 503, 100, 1.0);
dataset = H5Dcreate2(groupDetector, "data1",
datatype, dataspace,
H5P_DEFAULT, cparm, access_plist);
ivalue[0] = 1;
ivalue[1] = 1;
writeInt32Attribute(dataset, "NDArrayDimBinning", 2, ivalue);
ivalue[0] = 0;
ivalue[1] = 0;
writeInt32Attribute(dataset, "NDArrayDimOffset", 2, ivalue);
writeInt32Attribute(dataset, "NDArrayDimReverse", 2, ivalue);
ivalue[0] = 2;
writeInt32Attribute(dataset, "NDArrayNumDims", 1, ivalue);
H5Gclose(groupDetector);
dims[0] = 1;
dims[1] = 1;
chunk[0] = 1;
rank = 1;
/* Unique ID */
datatype = H5T_NATIVE_INT32;
cparm = H5Pcreate(H5P_DATASET_CREATE);
H5Pset_fill_value(cparm, datatype, &fillValue);
H5Pset_chunk(cparm, rank, chunk);
dataspace = H5Screate_simple(rank, dims, maxdims);
dataset = H5Dcreate2(fid, "NDArrayUniqueId",
datatype, dataspace,
H5P_DEFAULT, cparm, H5P_DEFAULT);
memspace = H5Screate_simple(rank, elementSize, NULL);
writeStringAttribute(dataset, "NDAttrName", "NDArrayUniqueId");
writeStringAttribute(dataset, "NDAttrDescription", "The unique ID of the NDArray");
writeStringAttribute(dataset, "NDAttrSourceType", "NDAttrSourceDriver");
writeStringAttribute(dataset, "NDAttrSource", "Driver");
/* EPICS Timestemp */
datatype = H5T_NATIVE_DOUBLE;
cparm = H5Pcreate(H5P_DATASET_CREATE);
H5Pset_fill_value(cparm, datatype, &fillValue);
H5Pset_chunk(cparm, rank, chunk);
dataspace = H5Screate_simple(rank, dims, maxdims);
dataset = H5Dcreate2(fid, "NDArrayTimeStamp",
datatype, dataspace,
H5P_DEFAULT, cparm, H5P_DEFAULT);
memspace = H5Screate_simple(rank, elementSize, NULL);
writeStringAttribute(dataset, "NDAttrName", "NDArrayTimeStamp");
writeStringAttribute(dataset, "NDAttrDescription", "The timestamp of the NDArray as float64");
writeStringAttribute(dataset, "NDAttrSourceType", "NDAttrSourceDriver");
writeStringAttribute(dataset, "NDAttrSource", "Driver");
/* EPICS TS sec */
datatype = H5T_NATIVE_UINT32;
cparm = H5Pcreate(H5P_DATASET_CREATE);
H5Pset_fill_value(cparm, datatype, &fillValue);
H5Pset_chunk(cparm, rank, chunk);
dataspace = H5Screate_simple(rank, dims, maxdims);
dataset = H5Dcreate2(fid, "NDArrayEpicsTSSec",
datatype, dataspace,
H5P_DEFAULT, cparm, H5P_DEFAULT);
memspace = H5Screate_simple(rank, elementSize, NULL);
writeStringAttribute(dataset, "NDAttrName", "NDArrayEpicsTSSec");
writeStringAttribute(dataset, "NDAttrDescription", "The NDArray EPICS timestamp seconds past epoch");
writeStringAttribute(dataset, "NDAttrSourceType", "NDAttrSourceDriver");
writeStringAttribute(dataset, "NDAttrSource", "Driver");
/* EPICS TS nsec */
datatype = H5T_NATIVE_UINT32;
cparm = H5Pcreate(H5P_DATASET_CREATE);
H5Pset_fill_value(cparm, datatype, &fillValue);
H5Pset_chunk(cparm, rank, chunk);
dataspace = H5Screate_simple(rank, dims, maxdims);
dataset = H5Dcreate2(fid, "NDArrayEpicsTSnSec",
datatype, dataspace,
H5P_DEFAULT, cparm, H5P_DEFAULT);
memspace = H5Screate_simple(rank, elementSize, NULL);
writeStringAttribute(dataset, "NDAttrName", "NDArrayEpicsTSnSec");
writeStringAttribute(dataset, "NDAttrDescription", "The NDArray EPICS timestamp nanoseconds");
writeStringAttribute(dataset, "NDAttrSourceType", "NDAttrSourceDriver");
writeStringAttribute(dataset, "NDAttrSource", "Driver");
/* Color mode */
datatype = H5T_NATIVE_INT32;
cparm = H5Pcreate(H5P_DATASET_CREATE);
H5Pset_fill_value(cparm, datatype, &fillValue);
H5Pset_chunk(cparm, rank, chunk);
dataspace = H5Screate_simple(rank, dims, maxdims);
dataset = H5Dcreate2(fid, "ColorMode",
datatype, dataspace,
H5P_DEFAULT, cparm, H5P_DEFAULT);
memspace = H5Screate_simple(rank, elementSize, NULL);
writeStringAttribute(dataset, "NDAttrName", "ColorMode");
writeStringAttribute(dataset, "NDAttrDescription", "Color mode");
writeStringAttribute(dataset, "NDAttrSourceType", "NDAttrSourceDriver");
writeStringAttribute(dataset, "NDAttrSource", "Driver");
/* Camera manufacturer */
datatype = H5Tcopy(H5T_C_S1);
H5Tset_size(datatype, 256);
cparm = H5Pcreate(H5P_DATASET_CREATE);
H5Pset_fill_value(cparm, datatype, &fillValue);
H5Pset_chunk(cparm, rank, chunk);
dataspace = H5Screate_simple(rank, dims, maxdims);
dataset = H5Dcreate2(fid, "CameraManufacturer",
datatype, dataspace,
H5P_DEFAULT, cparm, H5P_DEFAULT);
memspace = H5Screate_simple(rank, elementSize, NULL);
writeStringAttribute(dataset, "NDAttrName", "CameraManufacturer");
writeStringAttribute(dataset, "NDAttrDescription", "Camera manufacturer");
writeStringAttribute(dataset, "NDAttrSourceType", "NDAttrSourceParam");
writeStringAttribute(dataset, "NDAttrSource", "MANUFACTURER");
/* Performance data */
rank = 2;
dims[0] = 1;
dims[1] = 5;
chunk[1] = 5;
cparm = H5Pcreate(H5P_DATASET_CREATE);
H5Pset_chunk(cparm, rank, chunk);
dataspace = H5Screate_simple(rank, dims, maxdims);
dataset = H5Dcreate2(fid, "timestamp",
H5T_NATIVE_DOUBLE, dataspace,
H5P_DEFAULT, cparm, H5P_DEFAULT);
if (!H5Iis_valid(dataset)) {
printf("Error writing performance dataset");
}
H5Sclose(dataspace);
#if H5_VERSION_GE(1,9,178)
H5Fstart_swmr_write(fid);
#endif
H5Fclose(fid);
return 0;
} /* end main */
void cow_histogram_dumphdf5(cow_histogram *h, char *fn, char *gn)
// -----------------------------------------------------------------------------
// Dumps the histogram to the HDF5 file named `fn`, under the group
// `gn`/h->nickname, gn may be NULL. The function uses rank 0 to do the write.
// -----------------------------------------------------------------------------
{
#if (COW_HDF5)
if (!(h->committed && h->sealed)) {
return;
}
char gname[1024];
int rank = 0;
if (gn) {
snprintf(gname, 1024, "%s/%s", gn, h->nickname);
}
else {
snprintf(gname, 1024, "%s", h->nickname);
}
#if (COW_MPI)
if (cow_mpirunning()) {
MPI_Comm_rank(h->comm, &rank);
}
#endif
if (rank == 0) {
// -------------------------------------------------------------------------
// The write functions assume the file is already created. Have master
// create the file if it's not there already.
// -------------------------------------------------------------------------
FILE *testf = fopen(fn, "r");
hid_t fid;
if (testf == NULL) {
fid = H5Fcreate(fn, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);
}
else {
fclose(testf);
fid = H5Fopen(fn, H5F_ACC_RDWR, H5P_DEFAULT);
}
if (H5Lexists_safe(fid, gname)) {
printf("[%s] writing histogram as HDF5 to %s/%s (clobber existing)\n",
MODULE, fn, gname);
H5Gunlink(fid, gname);
}
else {
printf("[%s] writing histogram as HDF5 to %s/%s\n", MODULE, fn, gname);
}
hid_t gcpl = H5Pcreate(H5P_LINK_CREATE);
H5Pset_create_intermediate_group(gcpl, 1);
hid_t memb = H5Gcreate(fid, gname, gcpl, H5P_DEFAULT, H5P_DEFAULT);
H5Pclose(gcpl);
H5Gclose(memb);
H5Fclose(fid);
}
else {
return;
}
// Create a group to represent this histogram, and an attribute to name it
// ---------------------------------------------------------------------------
hid_t fid = H5Fopen(fn, H5F_ACC_RDWR, H5P_DEFAULT);
hid_t grp = H5Gopen(fid, gname, H5P_DEFAULT);
if (h->fullname != NULL) {
hid_t aspc = H5Screate(H5S_SCALAR);
hid_t strn = H5Tcopy(H5T_C_S1);
H5Tset_size(strn, strlen(h->fullname));
hid_t attr = H5Acreate(grp, "fullname", strn, aspc, H5P_DEFAULT, H5P_DEFAULT);
H5Awrite(attr, strn, h->fullname); // write the full name
H5Aclose(attr);
H5Tclose(strn);
H5Sclose(aspc);
}
// Create the data sets in the group: binloc (bin centers) and binval (values)
// ---------------------------------------------------------------------------
double *binlocX = h->binlocx;
double *binlocY = h->binlocy;
double *binvalV = h->binvalv;
hsize_t sizeX[1] = { h->nbinsx };
hsize_t sizeY[1] = { h->nbinsy };
hsize_t SizeX[1] = { h->nbinsx + 1 }; // to hold bin edges
hsize_t SizeY[1] = { h->nbinsy + 1 }; // below, cap S/F refers to bin edges
hsize_t sizeZ[2] = { h->nbinsx, h->nbinsy };
hid_t fspcZ = H5Screate_simple(h->n_dims, sizeZ, NULL);
if (h->n_dims >= 1) {
hid_t fspcX = H5Screate_simple(1, sizeX, NULL);
hid_t FspcX = H5Screate_simple(1, SizeX, NULL);
hid_t dsetbinX = H5Dcreate(grp, "binlocX", H5T_NATIVE_DOUBLE, fspcX,
H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
hid_t dsetedgX = H5Dcreate(grp, "binedgX", H5T_NATIVE_DOUBLE, FspcX,
H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
H5Dwrite(dsetbinX, H5T_NATIVE_DOUBLE, fspcX, fspcX, H5P_DEFAULT, binlocX);
H5Dwrite(dsetedgX, H5T_NATIVE_DOUBLE, FspcX, FspcX, H5P_DEFAULT, h->bedgesx);
H5Dclose(dsetbinX);
H5Sclose(FspcX);
H5Sclose(fspcX);
}
if (h->n_dims >= 2) {
hid_t fspcY = H5Screate_simple(1, sizeY, NULL);
hid_t FspcY = H5Screate_simple(1, SizeY, NULL);
hid_t dsetbinY = H5Dcreate(grp, "binlocY", H5T_NATIVE_DOUBLE, fspcY,
H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
hid_t dsetedgY = H5Dcreate(grp, "binedgY", H5T_NATIVE_DOUBLE, FspcY,
H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
H5Dwrite(dsetbinY, H5T_NATIVE_DOUBLE, fspcY, fspcY, H5P_DEFAULT, binlocY);
H5Dwrite(dsetedgY, H5T_NATIVE_DOUBLE, FspcY, FspcY, H5P_DEFAULT, h->bedgesy);
H5Dclose(dsetbinY);
H5Sclose(FspcY);
H5Sclose(fspcY);
}
hid_t dsetvalV = H5Dcreate(grp, "binval", H5T_NATIVE_DOUBLE, fspcZ,
H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
H5Dwrite(dsetvalV, H5T_NATIVE_DOUBLE, fspcZ, fspcZ, H5P_DEFAULT, binvalV);
H5Dclose(dsetvalV);
H5Sclose(fspcZ);
H5Gclose(grp);
H5Fclose(fid);
#endif
}
bool TChain::save(std::string fname, std::string group_name, size_t index,
std::string dim_name, int compression, int subsample,
bool converged, float lnZ) const {
if((compression<0) || (compression > 9)) {
std::cerr << "! Invalid gzip compression level: " << compression << std::endl;
return false;
}
H5::Exception::dontPrint();
H5::H5File *file = H5Utils::openFile(fname);
if(file == NULL) { return false; }
/*
try {
file->unlink(group_name);
} catch(...) {
// pass
}
*/
H5::Group *group = H5Utils::openGroup(file, group_name);
if(group == NULL) {
delete file;
return false;
}
/*
* Attributes
*/
// Datatype
H5::CompType att_type(sizeof(TChainAttribute));
hid_t tid = H5Tcopy(H5T_C_S1);
H5Tset_size(tid, H5T_VARIABLE);
att_type.insertMember("dim_name", HOFFSET(TChainAttribute, dim_name), tid);
//att_type.insertMember("total_weight", HOFFSET(TChainAttribute, total_weight), H5::PredType::NATIVE_FLOAT);
//att_type.insertMember("ndim", HOFFSET(TChainAttribute, ndim), H5::PredType::NATIVE_UINT64);
//att_type.insertMember("length", HOFFSET(TChainAttribute, length), H5::PredType::NATIVE_UINT64);
// Dataspace
int att_rank = 1;
hsize_t att_dim = 1;
H5::DataSpace att_space(att_rank, &att_dim);
// Dataset
//H5::Attribute att = group->createAttribute("parameter names", att_type, att_space);
TChainAttribute att_data;
att_data.dim_name = new char[dim_name.size()+1];
std::strcpy(att_data.dim_name, dim_name.c_str());
//att_data.total_weight = total_weight;
//att_data.ndim = N;
//att_data.length = length;
//att.write(att_type, &att_data);
delete[] att_data.dim_name;
//int att_rank = 1;
//hsize_t att_dim = 1;
H5::DataType conv_dtype = H5::PredType::NATIVE_UCHAR;
H5::DataSpace conv_dspace(att_rank, &att_dim);
//H5::Attribute conv_att = H5Utils::openAttribute(group, "converged", conv_dtype, conv_dspace);
//conv_att.write(conv_dtype, &converged);
H5::DataType lnZ_dtype = H5::PredType::NATIVE_FLOAT;
H5::DataSpace lnZ_dspace(att_rank, &att_dim);
//H5::Attribute lnZ_att = H5Utils::openAttribute(group, "ln Z", lnZ_dtype, lnZ_dspace);
//lnZ_att.write(lnZ_dtype, &lnZ);
// Creation property list to be used for all three datasets
H5::DSetCreatPropList plist;
//plist.setDeflate(compression); // gzip compression level
float fillvalue = 0;
plist.setFillValue(H5::PredType::NATIVE_FLOAT, &fillvalue);
H5D_layout_t layout = H5D_COMPACT;
plist.setLayout(layout);
/*
* Choose subsample of points in chain
*/
size_t *el_idx = NULL;
size_t *subsample_idx = NULL;
if(subsample > 0) {
size_t tot_weight_tmp = (size_t)ceil(total_weight);
el_idx = new size_t[tot_weight_tmp];
size_t unrolled_idx = 0;
size_t chain_idx = 0;
std::vector<double>::const_iterator it, it_end;
it_end = w.end();
for(it = w.begin(); it != it_end; ++it, chain_idx++) {
for(size_t n = unrolled_idx; n < unrolled_idx + (size_t)(*it); n++) {
el_idx[n] = chain_idx;
}
unrolled_idx += (size_t)(*it);
}
assert(chain_idx == length);
gsl_rng *r;
seed_gsl_rng(&r);
subsample_idx = new size_t[tot_weight_tmp];
for(size_t i=0; i<subsample; i++) {
subsample_idx[i] = el_idx[gsl_rng_uniform_int(r, tot_weight_tmp)];
}
}
/*
* Coordinates
*/
// Dataspace
hsize_t dim;
if(subsample > 0) {
dim = subsample;
} else {
dim = length;
}
// Chunking (required for compression)
int rank = 2;
hsize_t coord_dim[2] = {dim, N};
//if(dim < chunk) {
//plist.setChunk(rank, &(coord_dim[0]));
//} else {
// plist.setChunk(rank, &chunk);
//}
H5::DataSpace x_dspace(rank, &(coord_dim[0]));
// Dataset
//std::stringstream x_dset_path;
//x_dset_path << group_name << "/chain/coords";
std::stringstream coordname;
coordname << "coords " << index;
H5::DataSet* x_dataset = new H5::DataSet(group->createDataSet(coordname.str(), H5::PredType::NATIVE_FLOAT, x_dspace, plist));
// Write
float *buf = new float[N*dim];
if(subsample > 0) {
size_t tmp_idx;
for(size_t i=0; i<subsample; i++) {
tmp_idx = subsample_idx[i];
for(size_t k=0; k<N; k++) {
buf[N*i+k] = x[N*tmp_idx+k];
}
}
} else {
for(size_t i=0; i<dim; i++) { buf[i] = x[i]; }
}
x_dataset->write(buf, H5::PredType::NATIVE_FLOAT);
/*
* Weights
*/
// Dataspace
if(subsample <= 0) {
dim = w.size();
rank = 1;
H5::DataSpace w_dspace(rank, &dim);
// Dataset
//std::stringstream w_dset_path;
//w_dset_path << group_name << "/chain/weights";
H5::DataSet* w_dataset = new H5::DataSet(group->createDataSet("weights", H5::PredType::NATIVE_FLOAT, w_dspace, plist));
// Write
if(subsample > 0) {
for(size_t i=0; i<subsample; i++) { buf[i] = 1.; }
} else {
assert(w.size() < x.size());
for(size_t i=0; i<w.size(); i++) { buf[i] = w[i]; }
}
w_dataset->write(buf, H5::PredType::NATIVE_FLOAT);
delete w_dataset;
}
/*
* Probability densities
*/
// Dataspace
rank = 1;
H5::DataSpace L_dspace(rank, &dim);
// Dataset
//std::stringstream L_dset_path;
//L_dset_path << group_name << "/chain/probs";
std::stringstream lnpname;
lnpname << "ln_p " << index;
H5::DataSet* L_dataset = new H5::DataSet(group->createDataSet(lnpname.str(), H5::PredType::NATIVE_FLOAT, L_dspace, plist));
// Write
if(subsample > 0) {
for(size_t i=0; i<subsample; i++) { buf[i] = L[subsample_idx[i]]; }
} else {
assert(L.size() < x.size());
for(size_t i=0; i<L.size(); i++) { buf[i] = L[i]; }
}
L_dataset->write(buf, H5::PredType::NATIVE_FLOAT);
if(subsample > 0) {
delete[] el_idx;
delete[] subsample_idx;
}
delete[] buf;
delete x_dataset;
delete L_dataset;
delete group;
delete file;
return true;
}
// Read all optional attributes
char AH5_read_opt_attrs(hid_t loc_id, const char *path, AH5_opt_attrs_t *opt_attrs, char mandatory_attrs[][AH5_ATTR_LENGTH], size_t nb_mandatory_attrs)
{
char success = AH5_FALSE, is_mandatory;
H5O_info_t object_info;
hsize_t i, j, k = 0;
hid_t attr_id, type_id, memtype;
float buf[2];
hsize_t nb_present_mandatory_attrs = 0;
char temp_name[AH5_ATTR_LENGTH];
if (AH5_path_valid(loc_id, path))
{
// Check presence of all mandatory attributes
for (i = 0; i < (hsize_t) nb_mandatory_attrs; i++)
if (H5Aexists_by_name(loc_id, path, mandatory_attrs[i], H5P_DEFAULT) > 0)
nb_present_mandatory_attrs++;
H5Oget_info_by_name(loc_id, path, &object_info, H5P_DEFAULT);
opt_attrs->nb_instances = object_info.num_attrs - nb_present_mandatory_attrs;
if (opt_attrs->nb_instances > 0)
opt_attrs->instances = (AH5_attr_instance_t *) malloc ((size_t) opt_attrs->nb_instances * sizeof(AH5_attr_instance_t));
for (i = 0; i < object_info.num_attrs; i++)
{
is_mandatory = AH5_FALSE;
attr_id = H5Aopen_by_idx(loc_id, path, H5_INDEX_CRT_ORDER, H5_ITER_NATIVE, i, H5P_DEFAULT, H5P_DEFAULT);
H5Aget_name(attr_id, AH5_ATTR_LENGTH, temp_name);
for (j = 0; j < nb_mandatory_attrs; j++)
if (strcmp(temp_name, mandatory_attrs[j]) == 0)
is_mandatory = AH5_TRUE;
if (!is_mandatory)
{
opt_attrs->instances[k].name = strdup(temp_name);
type_id = H5Aget_type(attr_id);
opt_attrs->instances[k].type = H5Tget_class(type_id);
H5Tclose(type_id);
switch (opt_attrs->instances[k].type)
{
case H5T_INTEGER:
opt_attrs->instances[k].value.i = 0;
if (H5Aread(attr_id, H5T_NATIVE_INT, &(opt_attrs->instances[k].value.i)) >= 0)
success = AH5_TRUE;
break;
case H5T_FLOAT:
opt_attrs->instances[k].value.f = 0;
if (H5Aread(attr_id, H5T_NATIVE_FLOAT, &(opt_attrs->instances[k].value.f)) >= 0)
success = AH5_TRUE;
break;
case H5T_COMPOUND:
opt_attrs->instances[k].value.c = AH5_set_complex(0, 0);
type_id = AH5_H5Tcreate_cpx_memtype();
if (H5Aread(attr_id, type_id, buf) >= 0)
{
opt_attrs->instances[k].value.c = AH5_set_complex(buf[0], buf[1]);
success = AH5_TRUE;
}
H5Tclose(type_id);
break;
case H5T_STRING:
opt_attrs->instances[k].value.s = NULL;
memtype = H5Tcopy(H5T_C_S1);
H5Tset_size(memtype, AH5_ATTR_LENGTH);
opt_attrs->instances[k].value.s = (char *) malloc(AH5_ATTR_LENGTH * sizeof(char));
if (H5Aread(attr_id, memtype, opt_attrs->instances[k].value.s) >= 0)
success = AH5_TRUE;
H5Tclose(memtype);
break;
default:
opt_attrs->instances[k].type = H5T_NO_CLASS;
printf("***** WARNING: Unsupported type of attribute \"%s@%s\". *****\n\n", path, opt_attrs->instances[k].name);
break;
}
k++;
}
H5Aclose(attr_id);
}
}
if (!success)
{
opt_attrs->instances = NULL;
opt_attrs->nb_instances = 0;
}
return success;
}
// Author & Date: Ehsan Azar Nov 20, 2012
// Purpose: Create type for BmiTracking_t and commit
// Inputs:
// loc - where to add the type
// dim - dimension (1D, 2D or 3D)
// width - datapoint width in bytes
// Outputs:
// Returns the type id
hid_t CreateTrackingType(hid_t loc, int dim, int width)
{
herr_t ret;
hid_t tid_coords;
std::string strLabel = "BmiTracking";
// e.g. for 1D (32-bit) fixed-length, type name will be "BmiTracking32_1D_t"
// for 2D (16-bit) fixed-length, type name will be "BmiTracking16_2D_t"
switch (width)
{
case 1:
strLabel += "8";
tid_coords = H5Tcopy(H5T_NATIVE_UINT8);
break;
case 2:
strLabel += "16";
tid_coords = H5Tcopy(H5T_NATIVE_UINT16);
break;
case 4:
strLabel += "32";
tid_coords = H5Tcopy(H5T_NATIVE_UINT32);
break;
default:
return 0;
// should not happen
break;
}
switch (dim)
{
case 1:
strLabel += "_1D";
break;
case 2:
strLabel += "_2D";
break;
case 3:
strLabel += "_3D";
break;
default:
return 0;
// should not happen
break;
}
strLabel += "_t";
hid_t tid = -1;
if(H5Lexists(loc, strLabel.c_str(), H5P_DEFAULT))
{
tid = H5Topen(loc, strLabel.c_str(), H5P_DEFAULT);
} else {
tid = H5Tcreate(H5T_COMPOUND, offsetof(BmiTracking_fl_t, coords) + dim * width * 1);
ret = H5Tinsert(tid, "TimeStamp", offsetof(BmiTracking_fl_t, dwTimestamp), H5T_NATIVE_UINT32);
ret = H5Tinsert(tid, "ParentID", offsetof(BmiTracking_fl_t, parentID), H5T_NATIVE_UINT16);
ret = H5Tinsert(tid, "NodeCount", offsetof(BmiTracking_fl_t, nodeCount), H5T_NATIVE_UINT16);
ret = H5Tinsert(tid, "ElapsedTime", offsetof(BmiTracking_fl_t, etime), H5T_NATIVE_UINT32);
char corrd_labels[3][2] = {"x", "y", "z"};
for (int i = 0; i < dim; ++i)
ret = H5Tinsert(tid, corrd_labels[i], offsetof(BmiTracking_fl_t, coords) + i * width, tid_coords);
ret = H5Tcommit(loc, strLabel.c_str(), tid, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
}
H5Tclose(tid_coords);
return tid;
}
/*-------------------------------------------------------------------------
* Function: test_refresh
*
* Purpose: This function tests refresh (evict/reload) of individual
* objects' metadata from the metadata cache.
*
* Return: 0 on Success, 1 on Failure
*
* Programmer: Mike McGreevy
* August 17, 2010
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
herr_t test_refresh(void)
{
/**************************************************************************
*
* Test Description:
*
* This test will build an HDF5 file with several objects in a varying
* hierarchical layout. It will then flush the entire file to disk. Then,
* an attribute will be added to each object in the file.
*
* One by one, this process will flush each object to disk, individually.
* It will also be coordinating with another process, which will open
* the object before it is flushed by this process, and then refresh the
* object after it's been flushed, comparing the before and after object
* information to ensure that they are as expected. (i.e., most notably,
* that an attribute has been added, and is only visible after a
* successful call to a H5*refresh function).
*
* As with the flush case, the implemention is a bit tricky as it's
* dealing with signals going back and forth between the two processes
* to ensure the timing is correct, but basically, an example:
*
* Step 1. Dataset is created.
* Step 2. Dataset is flushed.
* Step 3. Attribute on Dataset is created.
* Step 4. Another process opens the dataset and verifies that it does
* not see an attribute (as the attribute hasn't been flushed yet).
* Step 5. This process flushes the dataset again (with Attribute attached).
* Step 6. The other process calls H5Drefresh, which should evict/reload
* the object's metadata, and thus pick up the attribute that's
* attached to it. Most other before/after object information is
* compared for sanity as well.
* Step 7. Rinse and Repeat for each object in the file.
*
**************************************************************************/
/**************************************************************************
* Generated Test File will look like this:
*
* GROUP "/"
* DATASET "Dataset1"
* GROUP "Group1" {
* DATASET "Dataset2"
* GROUP "Group2" {
* DATATYPE "CommittedDatatype3"
* }
* }
* GROUP "Group3" {
* DATASET "Dataset3"
* DATATYPE "CommittedDatatype2"
* }
* DATATYPE "CommittedDatatype1"
**************************************************************************/
/* Variables */
hid_t aid,fid,sid,tid1,did,dcpl,fapl = 0;
hid_t gid,gid2,gid3,tid2,tid3,did2,did3,status = 0;
hsize_t dims[2] = {50,50};
hsize_t cdims[2] = {1,1};
int fillval = 2;
/* Testing Message */
HDfprintf(stdout, "Testing individual object refresh behavior:\n");
/* Cleanup any old error or signal files */
CLEANUP_FILES;
/* ================ */
/* CREATE TEST FILE */
/* ================ */
/* Create File */
if ((fapl = H5Pcreate(H5P_FILE_ACCESS)) < 0) TEST_ERROR;
if (H5Pset_libver_bounds(fapl, H5F_LIBVER_LATEST, H5F_LIBVER_LATEST) < 0) TEST_ERROR;
if ((fid = H5Fcreate(FILENAME, H5F_ACC_TRUNC|H5F_ACC_SWMR_WRITE, H5P_DEFAULT, fapl)) < 0) TEST_ERROR;
/* Create data space and types */
if ((dcpl = H5Pcreate(H5P_DATASET_CREATE)) < 0) TEST_ERROR;
if ( H5Pset_chunk(dcpl, 2, cdims) < 0 ) TEST_ERROR;
if ( H5Pset_fill_value(dcpl, H5T_NATIVE_INT, &fillval) < 0 ) TEST_ERROR;
if ((sid = H5Screate_simple(2, dims, dims)) < 0) TEST_ERROR;
if ((tid1 = H5Tcopy(H5T_NATIVE_INT)) < 0) TEST_ERROR;
if ((tid2 = H5Tcopy(H5T_NATIVE_CHAR)) < 0) TEST_ERROR;
if ((tid3 = H5Tcopy(H5T_NATIVE_LONG)) < 0) TEST_ERROR;
/* Create Group1 */
if ((gid = H5Gcreate2(fid, "Group1", H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT)) < 0) TEST_ERROR;
/* Create Group2 */
if ((gid2 = H5Gcreate2(gid, "Group2", H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT)) < 0) TEST_ERROR;
/* Create Group3 */
if ((gid3 = H5Gcreate2(fid, "Group3", H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT)) < 0) TEST_ERROR;
/* Create Dataset1 */
if ((did = H5Dcreate2(fid, "Dataset1", tid1, sid, H5P_DEFAULT, dcpl, H5P_DEFAULT)) < 0) TEST_ERROR;
/* Create Dataset2 */
if ((did2 = H5Dcreate2(gid, "Dataset2", tid3, sid, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT)) < 0) TEST_ERROR;
/* Create Dataset3 */
if ((did3 = H5Dcreate2(gid3, "Dataset3", tid2, sid, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT)) < 0) TEST_ERROR;
/* Create CommittedDatatype1 */
if ((status = H5Tcommit2(fid, "CommittedDatatype1", tid1, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT)) < 0) TEST_ERROR;
/* Create CommittedDatatype2 */
if ((status = H5Tcommit2(gid2, "CommittedDatatype2", tid2, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT)) < 0) TEST_ERROR;
/* Create CommittedDatatype3 */
if ((status = H5Tcommit2(gid3, "CommittedDatatype3", tid3, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT)) < 0) TEST_ERROR;
/* Flush File to Disk */
if (H5Fflush(fid, H5F_SCOPE_GLOBAL) < 0) TEST_ERROR;
/* Create an attribute on each object. These will not immediately hit disk,
and thus be unavailable to another process until this process flushes
the object and the other process refreshes from disk. */
if ((aid = H5Acreate2(did, "Attribute", tid1, sid, H5P_DEFAULT, H5P_DEFAULT)) < 0) TEST_ERROR;
if (H5Aclose(aid) < 0) TEST_ERROR;
if ((aid = H5Acreate2(did2, "Attribute", tid1, sid, H5P_DEFAULT, H5P_DEFAULT)) < 0) TEST_ERROR;
if (H5Aclose(aid) < 0) TEST_ERROR;
if ((aid = H5Acreate2(did3, "Attribute", tid1, sid, H5P_DEFAULT, H5P_DEFAULT)) < 0) TEST_ERROR;
if (H5Aclose(aid) < 0) TEST_ERROR;
if ((aid = H5Acreate2(gid, "Attribute", tid1, sid, H5P_DEFAULT, H5P_DEFAULT)) < 0) TEST_ERROR;
if (H5Aclose(aid) < 0) TEST_ERROR;
if ((aid = H5Acreate2(gid2, "Attribute", tid1, sid, H5P_DEFAULT, H5P_DEFAULT)) < 0) TEST_ERROR;
if (H5Aclose(aid) < 0) TEST_ERROR;
if ((aid = H5Acreate2(gid3, "Attribute", tid1, sid, H5P_DEFAULT, H5P_DEFAULT)) < 0) TEST_ERROR;
if (H5Aclose(aid) < 0) TEST_ERROR;
if ((aid = H5Acreate2(tid1, "Attribute", tid1, sid, H5P_DEFAULT, H5P_DEFAULT)) < 0) TEST_ERROR;
if (H5Aclose(aid) < 0) TEST_ERROR;
if ((aid = H5Acreate2(tid2, "Attribute", tid1, sid, H5P_DEFAULT, H5P_DEFAULT)) < 0) TEST_ERROR;
if (H5Aclose(aid) < 0) TEST_ERROR;
if ((aid = H5Acreate2(tid3, "Attribute", tid1, sid, H5P_DEFAULT, H5P_DEFAULT)) < 0) TEST_ERROR;
if (H5Aclose(aid) < 0) TEST_ERROR;
/* ================ */
/* Refresh Datasets */
/* ================ */
TESTING("to ensure that H5Drefresh correctly refreshes single datasets");
/* Verify First Dataset can be refreshed with H5Drefresh */
if (start_refresh_verification_process(D1) != 0) TEST_ERROR;
if (H5Oflush(did) < 0) TEST_ERROR;
if (end_refresh_verification_process() != 0) TEST_ERROR;
/* Verify Second Dataset can be refreshed with H5Drefresh */
if (start_refresh_verification_process(D2) != 0) TEST_ERROR;
if (H5Oflush(did2) < 0) TEST_ERROR;
if (end_refresh_verification_process() != 0) TEST_ERROR;
PASSED();
/* ============== */
/* Refresh Groups */
/* ============== */
TESTING("to ensure that H5Grefresh correctly refreshes single groups");
/* Verify First Group can be refreshed with H5Grefresh */
if (start_refresh_verification_process(G1) != 0) TEST_ERROR;
if (H5Oflush(gid) < 0) TEST_ERROR;
if (end_refresh_verification_process() != 0) TEST_ERROR;
/* Verify Second Group can be refreshed with H5Grefresh */
if (start_refresh_verification_process(G2) != 0) TEST_ERROR;
if (H5Oflush(gid2) < 0) TEST_ERROR;
if (end_refresh_verification_process() != 0) TEST_ERROR;
PASSED();
/* ================= */
/* Refresh Datatypes */
/* ================= */
TESTING("to ensure that H5Trefresh correctly refreshes single datatypes");
/* Verify First Committed Datatype can be refreshed with H5Trefresh */
if (start_refresh_verification_process(T1) != 0) TEST_ERROR;
if (H5Oflush(tid1) < 0) TEST_ERROR;
if (end_refresh_verification_process() != 0) TEST_ERROR;
/* Verify Second Committed Datatype can be refreshed with H5Trefresh */
if (start_refresh_verification_process(T2) != 0) TEST_ERROR;
if (H5Oflush(tid2) < 0) TEST_ERROR;
if (end_refresh_verification_process() != 0) TEST_ERROR;
PASSED();
/* =============== */
/* Refresh Objects */
/* =============== */
TESTING("to ensure that H5Orefresh correctly refreshes single objects");
/* Verify Third Dataset can be refreshed with H5Orefresh */
if (start_refresh_verification_process(D3) != 0) TEST_ERROR;
if (H5Oflush(did3) < 0) TEST_ERROR;
if (end_refresh_verification_process() != 0) TEST_ERROR;
/* Verify Third Group can be refreshed with H5Orefresh */
if (start_refresh_verification_process(G3) != 0) TEST_ERROR;
if (H5Oflush(gid3) < 0) TEST_ERROR;
if (end_refresh_verification_process() != 0) TEST_ERROR;
/* Verify Third Committed Datatype can be refreshed with H5Orefresh */
if (start_refresh_verification_process(T3) != 0) TEST_ERROR;
if (H5Oflush(tid3) < 0) TEST_ERROR;
if (end_refresh_verification_process() != 0) TEST_ERROR;
PASSED();
/* ================== */
/* Cleanup and Return */
/* ================== */
/* Close Stuff */
if (H5Pclose(fapl) < 0) TEST_ERROR;
if (H5Tclose(tid1) < 0) TEST_ERROR;
if (H5Tclose(tid2) < 0) TEST_ERROR;
if (H5Tclose(tid3) < 0) TEST_ERROR;
if (H5Dclose(did) < 0) TEST_ERROR;
if (H5Dclose(did2) < 0) TEST_ERROR;
if (H5Dclose(did3) < 0) TEST_ERROR;
if (H5Gclose(gid) < 0) TEST_ERROR;
if (H5Gclose(gid2) < 0) TEST_ERROR;
if (H5Gclose(gid3) < 0) TEST_ERROR;
if (H5Sclose(sid) < 0) TEST_ERROR;
if (H5Fclose(fid) < 0) TEST_ERROR;
/* Delete Test File */
HDremove(FILENAME);
if (end_verification() < 0) TEST_ERROR;
return SUCCEED;
error:
/* Return */
return FAIL;
} /* test_refresh() */
