// save the population
void logger_save_population(logger_t *logger, GString *profiles, GString *hosts) {
// create population group
hid_t group_id;
group_id = H5Gcreate1(logger->file_id, "/population", H5P_DEFAULT);
H5LTmake_dataset_string(group_id, "/population/profiles", profiles->str);
H5LTmake_dataset_string(group_id, "/population/hosts", hosts->str);
H5Gclose(group_id);
}
void hdf5_save_string(hid_t loc_id, const string& dataset_name,
const string& s) {
herr_t status = \
H5LTmake_dataset_string(loc_id, dataset_name.c_str(), s.c_str());
CHECK_GE(status, 0)
<< "Failed to save string dataset with name " << dataset_name;
}
int_f
nh5ltmake_dataset_string_c (hid_t_f *loc_id,
int_f *namelen,
_fcd name,
char *buf)
{
int ret_value = -1;
herr_t ret;
hid_t c_loc_id;
char *c_name;
int c_namelen;
/*
* Convert FORTRAN name to C name
*/
c_namelen = *namelen;
c_name = (char *)HD5f2cstring(name, c_namelen);
if (c_name == NULL) return ret_value;
/*
* Call H5LTmake_dataset_string function.
*/
c_loc_id = (hid_t)*loc_id;
ret = H5LTmake_dataset_string(c_loc_id,c_name,buf);
if (ret < 0) return ret_value;
ret_value = 0;
return ret_value;
}
/*writes properties of the current run related to implementation and command line choices*/
herr_t /*hdf5 error*/
append_meta_properties(hdf5block_t *h5block,/*hdf5 file ids*/
double *seed,/*random number seed*/
size_t *BurnInSampleSize, /*tuning iterations*/
char *h5file, /*name of hdf5 file containing the experimental data and prior set-up*/
char *lib_base)/*basename of the library file @code .so@ file*/{
herr_t status;
int omp_n,omp_np,i;
status&=H5LTset_attribute_double(h5block->file_id, "LogParameters", "seed", seed, 1);
status&=H5LTset_attribute_ulong(h5block->file_id, "LogParameters", "BurnIn", BurnInSampleSize, 1);
status&=H5LTset_attribute_string(h5block->file_id, "LogParameters", "DataFrom", h5file);
status&=H5LTmake_dataset_string(h5block->file_id,"Model",lib_base);
// here we make a short test to see what the automatic choice of the
// number of threads turns out to be.
#pragma omp parallel private(omp_n,omp_np) reduction(+:i)
{
i=1;
omp_n=omp_get_num_threads();
omp_np=omp_get_num_procs();
}
if (i!=omp_n){
fprintf(stderr,"[append_meta_properties] warning: finding out number of threads possibly failed reduction of (n×1: %i) != get_num_threads():%i.\n",i,omp_n);
} else {
h5block->size[0]=1;
h5block->size[1]=1;
status&=H5LTmake_dataset_int(h5block->file_id,"OMP_NUM_THREADS",1,h5block->size,&omp_n);
status&=H5LTmake_dataset_int(h5block->file_id,"OMP_NUM_PROCS",1,h5block->size,&omp_np);
}
return status;
}
int_f
nh5ltmake_dataset_string_c (hid_t_f *loc_id,
int_f *namelen,
_fcd name,
int_f *buflen,
char *buf)
{
int ret_value = -1;
herr_t ret;
hid_t c_loc_id;
char *c_name = NULL;
int c_namelen;
char *c_buf = NULL;
int c_buflen;
/*
* convert FORTRAN name to C name
*/
c_namelen = *namelen;
c_name = (char *)HD5f2cstring(name, c_namelen);
if (c_name == NULL)
goto done;
c_buflen = *buflen;
c_buf = (char *)HD5f2cstring(buf, c_buflen);
if (c_buf == NULL)
goto done;
/*
* call H5LTmake_dataset_string function.
*/
c_loc_id = (hid_t)*loc_id;
ret = H5LTmake_dataset_string(c_loc_id,c_name,c_buf);
if (ret < 0)
goto done;
ret_value = 0;
done:
if(c_name!=NULL)
free(c_name);
if(c_buf!=NULL)
free(c_buf);
return ret_value;
}
/** write matrix */
static void write_matrix (hid_t id, struct fclib_matrix *mat)
{
hsize_t dim = 1;
IO (H5LTmake_dataset_int (id, "nzmax", 1, &dim, &mat->nzmax));
IO (H5LTmake_dataset_int (id, "m", 1, &dim, &mat->m));
IO (H5LTmake_dataset_int (id, "n", 1, &dim, &mat->n));
IO (H5LTmake_dataset_int (id, "nz", 1, &dim, &mat->nz));
if (mat->nz >= 0) /* triplet */
{
dim = mat->nz;
IO (H5LTmake_dataset_int (id, "p", 1, &dim, mat->p));
IO (H5LTmake_dataset_int (id, "i", 1, &dim, mat->i));
}
else if (mat->nz == -1) /* csc */
{
dim = mat->n+1;
IO (H5LTmake_dataset_int (id, "p", 1, &dim, mat->p));
dim = mat->nzmax;
IO (H5LTmake_dataset_int (id, "i", 1, &dim, mat->i));
}
else if (mat->nz == -2) /* csr */
{
dim = mat->m+1;
IO (H5LTmake_dataset_int (id, "p", 1, &dim, mat->p));
dim = mat->nzmax;
IO (H5LTmake_dataset_int (id, "i", 1, &dim, mat->i));
}
else ASSERT (0, "ERROR: unkown sparse matrix type => fclib_matrix->nz = %d\n", mat->nz);
dim = mat->nzmax;
IO (H5LTmake_dataset_double (id, "x", 1, &dim, mat->x));
if (mat->info)
{
dim = 1;
if (mat->info->comment) IO (H5LTmake_dataset_string (id, "comment", mat->info->comment));
IO (H5LTmake_dataset_double (id, "conditioning", 1, &dim, &mat->info->conditioning));
IO (H5LTmake_dataset_double (id, "determinant", 1, &dim, &mat->info->determinant));
IO (H5LTmake_dataset_int (id, "rank", 1, &dim, &mat->info->rank));
}
}
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);
}
static int test_dsets( void )
{
int rank = 2;
hsize_t dims[2] = {2,3};
hid_t file_id;
hid_t dataset_id;
char data_char_in[DIM] = {1,2,3,4,5,6};
char data_char_out[DIM];
short data_short_in[DIM] = {1,2,3,4,5,6};
short data_short_out[DIM];
int data_int_in[DIM] = {1,2,3,4,5,6};
int data_int_out[DIM];
long data_long_in[DIM] = {1,2,3,4,5,6};
long data_long_out[DIM];
float data_float_in[DIM] = {1,2,3,4,5,6};
float data_float_out[DIM];
double data_double_in[DIM] = {1,2,3,4,5,6};
double data_double_out[DIM];
const char *data_string_in = "This is a string";
char data_string_out[20];
int i;
/* Create a new file using default properties. */
file_id = H5Fcreate( FILE_NAME, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT );
/*-------------------------------------------------------------------------
* H5LTmake_dataset test
*-------------------------------------------------------------------------
*/
TESTING("H5LTmake_dataset");
/* Make dataset */
if ( H5LTmake_dataset( file_id, DSET0_NAME, rank, dims, H5T_NATIVE_INT, data_int_in ) < 0 )
goto out;
/* Read dataset using the basic HDF5 API */
if ( ( dataset_id = H5Dopen2(file_id, DSET0_NAME, H5P_DEFAULT) ) < 0 )
goto out;
if ( H5Dread ( dataset_id, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, data_int_out ) < 0 )
goto out;
if ( H5Dclose( dataset_id ) < 0 )
goto out;
for (i = 0; i < DIM; i++)
{
if ( data_int_in[i] != data_int_out[i] ) {
goto out;
}
}
PASSED();
/*-------------------------------------------------------------------------
* read using the LT function H5LTread_dataset
*-------------------------------------------------------------------------
*/
TESTING("H5LTread_dataset");
if ( H5LTread_dataset( file_id, DSET0_NAME, H5T_NATIVE_INT, data_int_out ) < 0 )
goto out;
for (i = 0; i < DIM; i++)
{
if ( data_int_in[i] != data_int_out[i] ) {
goto out;
}
}
PASSED();
/*-------------------------------------------------------------------------
* test the H5LTmake_dataset_ functions
*-------------------------------------------------------------------------
*/
/*-------------------------------------------------------------------------
* H5LTmake_dataset_char
*-------------------------------------------------------------------------
*/
TESTING("H5LTmake_dataset_char");
/* Make dataset char */
if ( H5LTmake_dataset_char( file_id, DSET1_NAME, rank, dims, data_char_in ) < 0 )
goto out;
/* Read dataset */
if ( H5LTread_dataset( file_id, DSET1_NAME, H5T_NATIVE_CHAR, data_char_out ) < 0 )
goto out;
for (i = 0; i < DIM; i++)
{
if ( data_char_in[i] != data_char_out[i] ) {
goto out;
}
}
/* Read dataset */
if ( H5LTread_dataset_char( file_id, DSET1_NAME, data_char_out ) < 0 )
goto out;
for (i = 0; i < DIM; i++)
{
if ( data_char_in[i] != data_char_out[i] ) {
goto out;
}
}
PASSED();
/*-------------------------------------------------------------------------
* H5LTmake_dataset_short
*-------------------------------------------------------------------------
*/
TESTING("H5LTmake_dataset_short");
/* Make dataset short */
if ( H5LTmake_dataset_short( file_id, DSET2_NAME, rank, dims, data_short_in ) < 0 )
goto out;
/* Read dataset */
if ( H5LTread_dataset( file_id, DSET2_NAME, H5T_NATIVE_SHORT, data_short_out ) < 0 )
goto out;
for (i = 0; i < DIM; i++)
{
if ( data_short_in[i] != data_short_out[i] ) {
goto out;
}
}
/* Read dataset */
if ( H5LTread_dataset_short( file_id, DSET2_NAME, data_short_out ) < 0 )
goto out;
for (i = 0; i < DIM; i++)
{
if ( data_short_in[i] != data_short_out[i] ) {
goto out;
}
}
PASSED();
/*-------------------------------------------------------------------------
* H5LTmake_dataset_int
*-------------------------------------------------------------------------
*/
TESTING("H5LTmake_dataset_int");
/* Make dataset int */
if ( H5LTmake_dataset_int( file_id, DSET3_NAME, rank, dims, data_int_in ) < 0 )
goto out;
/* Read dataset */
if ( H5LTread_dataset( file_id, DSET3_NAME, H5T_NATIVE_INT, data_int_out ) < 0 )
goto out;
for (i = 0; i < DIM; i++)
{
if ( data_int_in[i] != data_int_out[i] ) {
goto out;
}
}
/* Read dataset */
if ( H5LTread_dataset_int( file_id, DSET3_NAME, data_int_out ) < 0 )
goto out;
for (i = 0; i < DIM; i++)
{
if ( data_int_in[i] != data_int_out[i] ) {
goto out;
}
}
PASSED();
/*-------------------------------------------------------------------------
* H5LTmake_dataset_long
*-------------------------------------------------------------------------
*/
TESTING("H5LTmake_dataset_long");
/* Make dataset long */
if ( H5LTmake_dataset_long( file_id, DSET4_NAME, rank, dims, data_long_in ) < 0 )
goto out;
/* Read dataset */
if ( H5LTread_dataset( file_id, DSET4_NAME, H5T_NATIVE_LONG, data_long_out ) < 0 )
goto out;
for (i = 0; i < DIM; i++)
{
if ( data_long_in[i] != data_long_out[i] ) {
goto out;
}
}
/* Read dataset */
if ( H5LTread_dataset_long( file_id, DSET4_NAME, data_long_out ) < 0 )
goto out;
for (i = 0; i < DIM; i++)
{
if ( data_long_in[i] != data_long_out[i] ) {
goto out;
}
}
PASSED();
/*-------------------------------------------------------------------------
* H5LTmake_dataset_float
*-------------------------------------------------------------------------
*/
TESTING("H5LTmake_dataset_float");
/* Make dataset float */
if ( H5LTmake_dataset_float( file_id, DSET5_NAME, rank, dims, data_float_in ) < 0 )
goto out;
/* Read dataset */
if ( H5LTread_dataset( file_id, DSET5_NAME, H5T_NATIVE_FLOAT, data_float_out ) < 0 )
goto out;
for (i = 0; i < DIM; i++)
{
if ( data_float_in[i] != data_float_out[i] ) {
goto out;
}
}
/* Read dataset */
if ( H5LTread_dataset_float( file_id, DSET5_NAME, data_float_out ) < 0 )
goto out;
for (i = 0; i < DIM; i++)
{
if ( data_float_in[i] != data_float_out[i] ) {
goto out;
}
}
PASSED();
/*-------------------------------------------------------------------------
* H5LTmake_dataset_double
*-------------------------------------------------------------------------
*/
TESTING("H5LTmake_dataset_double");
/* Make dataset double */
if ( H5LTmake_dataset_double( file_id, DSET6_NAME, rank, dims, data_double_in ) < 0 )
goto out;
/* Read dataset */
if ( H5LTread_dataset( file_id, DSET6_NAME, H5T_NATIVE_DOUBLE, data_double_out ) < 0 )
goto out;
for (i = 0; i < DIM; i++)
{
if ( data_double_in[i] != data_double_out[i] ) {
goto out;
}
}
/* Read dataset */
if ( H5LTread_dataset_double( file_id, DSET6_NAME, data_double_out ) < 0 )
goto out;
for (i = 0; i < DIM; i++)
{
if ( data_double_in[i] != data_double_out[i] ) {
goto out;
}
}
PASSED();
/*-------------------------------------------------------------------------
* H5LTmake_dataset_string
*-------------------------------------------------------------------------
*/
TESTING("H5LTmake_dataset_string");
/* Make dataset string */
if ( H5LTmake_dataset_string(file_id,DSET7_NAME,data_string_in) < 0 )
goto out;
/* Read dataset */
if ( H5LTread_dataset_string(file_id,DSET7_NAME,data_string_out) < 0 )
goto out;
if ( strcmp(data_string_in,data_string_out) != 0 )
goto out;
/*-------------------------------------------------------------------------
* end tests
*-------------------------------------------------------------------------
*/
/* Close the file. */
H5Fclose( file_id );
PASSED();
return 0;
out:
/* Close the file. */
H5_FAILED();
return -1;
}
/* initializes hdf5 struct and writes some of the initially known
problem properties such as state variable names into hdf5 file*/
hdf5block_t* /*freshly allocated struct with ids and size parameters*/
h5block_init(char *output_file, /*will create this file for writing*/
ode_model_parameters *omp, /*contains MCMC problem description*/
size_t Samples, /* MCMC sample size*/
const char **x_name, /*ODE model State Variable names, array of strings*/
const char **p_name, /*ODE model parameter names, array of strings*/
const char **f_name)/*ODE model output function names, array of strings*/
{
hsize_t *size=malloc(sizeof(hsize_t)*2);
hsize_t *chunk_size=malloc(sizeof(hsize_t)*2);
hid_t file_id = H5Fcreate(output_file, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);
assert(file_id>0);
int D=get_number_of_MCMC_variables(omp);
int N=get_number_of_state_variables(omp);
int P=get_number_of_model_parameters(omp);
int F=get_number_of_model_outputs(omp);
char *x_names=flatten(x_name, (size_t) N, "; ");
char *p_names=flatten(p_name, (size_t) P, "; ");
char *f_names=flatten(f_name, (size_t) F, "; ");
herr_t NameWriteError=0;
NameWriteError&=H5LTmake_dataset_string(file_id,"StateVariableNames",x_names);
NameWriteError&=H5LTmake_dataset_string(file_id,"ParameterNames",p_names);
NameWriteError&=H5LTmake_dataset_string(file_id,"OutputFunctionNames",f_names);
if (NameWriteError){
fprintf(stderr,"[h5block_init] writing (x,p,f)-names into hdf5 file failed.");
}/* else {
printf("# [main] all names have been written to file «%s».\n",output_file);
}*/
free(x_names);
free(p_names);
free(f_names);
hid_t para_property_id = H5Pcreate(H5P_DATASET_CREATE);
hid_t post_property_id = H5Pcreate(H5P_DATASET_CREATE);
/* here we set a «chunk size», which will coincide with the hyperslabs we select to write output*/
// parameter sample chunk size:
chunk_size[0]=CHUNK;
chunk_size[1]=D;
H5Pset_chunk(para_property_id, 2, chunk_size);
hid_t para_chunk_id=H5Screate_simple(2, chunk_size, NULL); // a dataspace to write chunks/hyperslabs
// posterior probability distribution chunk size:
chunk_size[0]=CHUNK;
chunk_size[1]=1;
H5Pset_chunk(post_property_id, 2, chunk_size);
hid_t post_chunk_id=H5Screate_simple(2, chunk_size, NULL);
// hyperslab selection
hsize_t *offset, *stride, *count, *block;
offset=malloc(sizeof(hsize_t)*2);
stride=malloc(sizeof(hsize_t)*2);
count=malloc(sizeof(hsize_t)*2);
block=malloc(sizeof(hsize_t)*2);
// hsize_t offset[2]={0,0}, stride[2]={1,1}, count[2]={1,1}, block[2];
int i;
for (i=0;i<2;i++) offset[i]=0;
for (i=0;i<2;i++) stride[i]=1;
for (i=0;i<2;i++) count[i]=1;
block[0]=CHUNK;
block[1]=D;
// hdf5 file setup
size[0]=Samples;
size[1]=D;
hid_t para_dataspace_id=H5Screate_simple(2, size, NULL);
size[0]=Samples;
size[1]=1;
hid_t post_dataspace_id=H5Screate_simple(2, size, NULL);
assert(post_dataspace_id>0 && para_dataspace_id>0);
hid_t parameter_set_id = H5Dcreate2(file_id, "LogParameters", H5T_NATIVE_DOUBLE, para_dataspace_id, H5P_DEFAULT, para_property_id, H5P_DEFAULT);
hid_t posterior_set_id = H5Dcreate2(file_id, "LogPosterior", H5T_NATIVE_DOUBLE, post_dataspace_id, H5P_DEFAULT, post_property_id, H5P_DEFAULT);
assert(parameter_set_id>0 && posterior_set_id>0);
//copy ids to struct
hdf5block_t *h5block;
h5block = malloc(sizeof(hdf5block_t));
h5block->file_id = file_id;
h5block->para_property_id = para_property_id;
h5block->post_property_id = post_property_id;
h5block->para_chunk_id = para_chunk_id;
h5block->post_chunk_id = post_chunk_id;
h5block->para_dataspace_id = para_dataspace_id;
h5block->post_dataspace_id = post_dataspace_id;
h5block->parameter_set_id = parameter_set_id;
h5block->posterior_set_id = posterior_set_id;
h5block->size = size;
h5block->chunk_size = chunk_size;
h5block->offset = offset;
h5block->stride = stride;
h5block->count = count;
h5block->block = block;
return h5block;
}
/** write problem info */
static void write_problem_info (hid_t id, struct fclib_info *info)
{
if (info->title) IO (H5LTmake_dataset_string (id, "title", info->title));
if (info->description) IO (H5LTmake_dataset_string (id, "description", info->description));
if (info->math_info) IO (H5LTmake_dataset_string (id, "math_info", info->math_info));
}
