H5DataSet * H5File::OpenDataSet(const std::string &name) {
size_t id = mCurrentId;
mCurrentId++;
H5DataSet *ds = new H5DataSet(id);
string groupName, dsName;
FillInGroupFromName(name, groupName, dsName);
hid_t group = GetOrCreateGroup(mHFile, groupName);
ds->SetGroup(group);
ds->SetParent(this);
ds->SetName(dsName);
/* Save old error handler */
herr_t (*old_func)(hid_t, void *);
void *old_client_data;
H5Eget_auto(H5E_DEFAULT, &old_func, &old_client_data);
/* Turn off error handling */
H5Eset_auto(H5E_DEFAULT, NULL, NULL);
if (ds->OpenDataSet()) {
mDSMap[id] = ds;
H5Eset_auto(H5E_DEFAULT, old_func, old_client_data);
return mDSMap[id];
}
/* Restore previous error handler */
H5Eset_auto(H5E_DEFAULT, old_func, old_client_data);
delete ds;
return NULL;
}
void RotatingCube::RotateMyCube ( H5File &h5_local_ref, int total_blocks, const char *cube_name, const char *cube_description )
{
char s[128];
string str;
for ( int i=0; i<total_blocks; i++ )
{
sprintf ( s,"%s/block_%04d",cube_name, i );
H5DataSet *ptr = h5_local_ref.CreateDataSet ( s, source, 3 );
sprintf ( s,"%s",cube_description );
h5_local_ref.CreateAttribute ( ptr->getDataSetId(),"description",s );
h5_local_ref.makeParamNames ( "ndx_",source.GetNumZ(),str );
h5_local_ref.CreateAttribute ( ptr->getDataSetId(),"paramNames",str.c_str() );
h5_vec.push_back ( ptr );
}
}
TEST(H5Handle_Test, WriteReadTest) {
float data[12];
for (size_t i = 0; i < ArraySize(data); i++) {
data[i] = i;
}
{
H5File file;
file.SetFile("tmp.h5");
file.Open(true);
hsize_t dims[] = {3,4};
hsize_t chunking[] = {3,4};
H5DataSet *ds = file.CreateDataSet("/tmp/here/testdata", 2, dims, chunking, 2, H5T_NATIVE_FLOAT);
size_t starts[] = {0,0};
size_t ends[] = {3,4};
//ds->WriteRangeData(starts, ends, ArraySize(data), data);
ds->WriteRangeData(starts, ends, data);
ds->Close();
}
{
H5File file;
file.SetFile("tmp.h5");
file.Open();
H5DataSet *ds = file.OpenDataSet("/tmp/here/testdata");
float query[12];
size_t starts[] = {0,0};
size_t ends[] = {3,4};
ds->ReadRangeData(starts, ends, ArraySize(query), query);
for (size_t i = 0; i < ArraySize(data); i++) {
if (data[i] != query[i]) {
EXPECT_EQ(query[i], data[i]);
}
}
{
float update[4];
size_t starts[] = {1,2};
size_t ends[] = {3,4};
size_t count = 0;
for (size_t i = 11; i >= 8; i--) {
update[count++] = i;
}
//ds->WriteRangeData(starts, ends, ArraySize(update), update);
ds->WriteRangeData(starts, ends, update);
float query[12];
size_t rstarts[] = {0,0};
size_t rends[] = {3,4};
float gold[12] = {0,1,2,3,4,5,11,10,8,9,9,8};
ds->ReadRangeData(rstarts, rends, ArraySize(query), query);
for (size_t i = 0; i < 1; i++) {
EXPECT_EQ(gold[i], query[i]);
}
}
// ds->Close();
ds = file.OpenDataSet("shouldbenull");
EXPECT_EQ(NULL,ds);
}
}
H5DataSet * H5File::CreateDataSet ( const std::string &name,
hsize_t rank,
const hsize_t dims[],
const hsize_t chunking[],
int compression,
hid_t type )
{
size_t id = mCurrentId;
mCurrentId++;
H5DataSet *ds = new H5DataSet ( id );
string groupName, dsName;
FillInGroupFromName ( name, groupName, dsName );
hid_t group = GetOrCreateGroup ( mHFile, groupName );
ds->SetGroup ( group );
ds->SetParent ( this );
ds->SetName ( dsName );
ds->SetCompression ( compression );
ds->SetDataspace ( rank, dims, chunking, type );
if ( ds->CreateDataSet() )
{
mDSMap[id] = ds;
return mDSMap[id];
}
delete ds;
return NULL;
}
TEST(H5Handle_Test, MatrixTest) {
Mat<float> mymat = ones<Mat<float> >(5,3);
Mat<float>::iterator i;
int count = 0;
for (i = mymat.begin(); i != mymat.end(); i++) {
*i = count++;
}
// mymat.raw_print(cout);
{
H5File file;
file.SetFile("tmp.h5");
file.Open(true);
H5DataSet *ds = H5Arma::CreateDataSet(file,"/tmp/fun/mat", mymat, 0);
//H5DataSet *ds = file.CreateDataSet("mat", mymat, 0);
H5Arma::WriteMatrix(*ds, mymat);
ds->Close();
}
{
H5File file;
file.SetFile("tmp.h5");
file.Open();
H5DataSet *ds = file.OpenDataSet("/tmp/fun/mat");
// H5DataSet *ds = file.OpenDataSet("mat");
Mat<float> m;
H5Arma::ReadMatrix(*ds, m);
// m.raw_print(cout);
Mat<float>::iterator gold, test;
for (gold = mymat.begin(), test = m.begin(); gold != mymat.end(); gold++, test++) {
float g = *gold;
float t = *test;
EXPECT_EQ(t, g);
}
ds->Close();
}
}
// col, row, and flow are zero-based in this function, info read out include both borders.
RcppExport SEXP readBeadParamR(SEXP RbeadParamFile,SEXP RminCol, SEXP RmaxCol, SEXP RminRow, SEXP RmaxRow,SEXP RminFlow, SEXP RmaxFlow) {
SEXP ret = R_NilValue;
char *exceptionMesg = NULL;
try {
//vector<string> beadParamFile = Rcpp::as< vector<string> > (RbeadParamFile);
//RcppStringVector tBeadParamFile(RbeadParamFile);
string beadParamFile = Rcpp::as< string > (RbeadParamFile);
int minCol = Rcpp::as< int > (RminCol);
int maxCol = Rcpp::as< int > (RmaxCol);
int minRow = Rcpp::as< int > (RminRow);
int maxRow = Rcpp::as< int > (RmaxRow);
int minFlow = Rcpp::as< int > (RminFlow);
int maxFlow = Rcpp::as< int > (RmaxFlow);
// Outputs
unsigned int nCol = maxCol - minCol+1;
unsigned int nRow = maxRow - minRow+1;
unsigned int nFlow = maxFlow - minFlow+1;
vector<unsigned int> colOut,rowOut,flowOut;
vector< double > resErr;
colOut.reserve(nCol * nRow * nFlow);
rowOut.reserve(nCol * nRow * nFlow);
// Recast int to unsigned int
vector<unsigned int> col, row, flow;
col.resize(nCol);
for(unsigned int i=0;i<col.size();++i)
col[i] = (unsigned int)(i+minCol);
row.resize(nRow);
for(unsigned int i=0;i<row.size();++i)
row[i] = (unsigned int) (i+minRow);
flow.resize(nFlow);
for(unsigned int i=0;i<flow.size();++i)
flow[i] = (unsigned int) (i+minFlow);
H5File beadParam;
beadParam.SetFile(beadParamFile);
beadParam.Open();
H5DataSet *resErrDS = beadParam.OpenDataSet("/bead/res_error");
H5DataSet *ampMulDS = beadParam.OpenDataSet("bead/ampl_multiplier");
H5DataSet *krateMulDS = beadParam.OpenDataSet("bead/k_rate_multiplier");
H5DataSet *beadInitDS = beadParam.OpenDataSet("bead/bead_init_param");
H5DataSet *beadDCDS = beadParam.OpenDataSet("bead/fg_bead_DC");
//float tresErr[nCol * nRow * nFlow];
float *tresErr;
float *tamplMul;
float *tkrateMul;
float *tbeadInit;
float *tbeadDC;
tresErr = (float *) malloc ( sizeof(float) * nCol * nRow * nFlow);
tamplMul = (float *) malloc ( sizeof(float) * nCol * nRow * nFlow);
tkrateMul = (float *) malloc ( sizeof(float) * nCol * nRow * nFlow);
tbeadInit = (float *) malloc ( sizeof(float) * nCol * nRow * 4);
tbeadDC = (float *) malloc ( sizeof(float) * nCol * nRow * nFlow);
size_t starts[3];
size_t ends[3];
starts[0] = minCol;
starts[1] = minRow;
starts[2] = minFlow;
ends[0] = maxCol;
ends[1] = maxRow;
ends[2] = maxFlow;
resErrDS->ReadRangeData(starts, ends, sizeof(tresErr),tresErr);
ampMulDS->ReadRangeData(starts, ends, sizeof(tamplMul),tamplMul);
krateMulDS->ReadRangeData(starts, ends, sizeof(tkrateMul),tkrateMul);
beadDCDS->ReadRangeData(starts, ends, sizeof(tbeadDC),tbeadDC);
starts[2] = 0;
ends[2] = 3;
beadInitDS->ReadRangeData(starts,ends,sizeof(tbeadInit),tbeadInit);
beadParam.Close();
RcppMatrix< double > resErrMat(nRow*nCol,nFlow);
RcppMatrix< double > amplMulMat(nRow*nCol,nFlow);
RcppMatrix< double > krateMulMat(nRow*nCol,nFlow);
RcppMatrix< double > beadInitMat(nRow*nCol,4);
RcppMatrix< double > beadDCMat(nRow*nCol,nFlow);
vector<int> colOutInt,rowOutInt,flowOutInt;
int count = 0;
for(size_t icol=0;icol<nCol;++icol)
for(size_t irow=0;irow<nRow;++irow) {
for(size_t iFlow=0;iFlow<nFlow;++iFlow)
{
amplMulMat(count,iFlow) = (double) tamplMul[icol * nRow * nFlow + irow * nFlow + iFlow] ;
krateMulMat(count,iFlow) = (double) tkrateMul[icol * nRow * nFlow + irow * nFlow + iFlow];
beadDCMat(count,iFlow) = (double) tbeadDC[icol * nRow *nFlow + irow * nFlow + iFlow];
}
for(size_t ip=0;ip<4;++ip)
beadInitMat(count,ip) = (double) tbeadInit[icol * nRow * ip + irow * 4 + ip];
colOutInt.push_back(minCol+icol);
rowOutInt.push_back(minRow+irow);
count++;
}
RcppResultSet rs;
rs.add("beadParamFile", beadParamFile);
rs.add("nCol", (int)nCol);
rs.add("nRow", (int)nRow);
rs.add("minFlow",minFlow);
rs.add("maxFlow",maxFlow);
rs.add("nFlow", (int)nFlow);
rs.add("col", colOutInt);
rs.add("row",rowOutInt);
rs.add("res_error",resErrMat);
rs.add("ampl_multiplier",amplMulMat);
rs.add("krate_multiplier",krateMulMat);
rs.add("bead_init",beadInitMat);
rs.add("bead_dc",beadDCMat);
ret = rs.getReturnList();
free(tresErr);
free(tamplMul);
free(tkrateMul);
free(tbeadInit);
free(tbeadDC);
}
catch(exception& ex) {
exceptionMesg = copyMessageToR(ex.what());
} catch (...) {
exceptionMesg = copyMessageToR("Unknown reason");
}
if ( exceptionMesg != NULL)
Rf_error(exceptionMesg);
return ret;
}
std::string BkgParamH5::Init(SystemContext &sys_context, SpatialContext &loc_context, int numFlows, ImageSpecClass &my_image_spec) {
//wells_output_directory is a better choice than basecaller_output_directory
//hgBgDbgFile = ToStr(sys_context.dat_source_directory) + "/bg_param.h5";
//cout << "dat_source_directory:" << sys_context.dat_source_directory << endl;
//cout << "basecaller_output_directory:" << sys_context.basecaller_output_directory << endl;
//cout << "wells_output_directory:" << sys_context.wells_output_directory << endl;
if (ToStr(sys_context.wells_output_directory)=="")
hgBgDbgFile = sys_context.experimentName;
else
hgBgDbgFile = ToStr(sys_context.wells_output_directory);
if (hgBgDbgFile[hgBgDbgFile.length()-1] != '/')
hgBgDbgFile += '/';
hgBgDbgFile += "bg_param.h5";
cout << "hgBgDbgFile:" << hgBgDbgFile << endl;
h5BgDbg.Init();
h5BgDbg.SetFile(hgBgDbgFile);
h5BgDbg.Open(true);
int blocksOfFlow = NUMFB;
int nFlowBlks = ceil(float(numFlows)/NUMFB);
//int numParam = sizeof(reg_params)/sizeof(float); // +1 not necessary
int numParam = sizeof(reg_params_H5)/sizeof(float); // +1 not necessary
hsize_t rp_dims[2], rp_chunks[2];
char s[128];
string str;
///------------------------------------------------------------------------------------------------------------
/// bead parameters
///------------------------------------------------------------------------------------------------------------
try {
beadDC.Init(loc_context.cols, loc_context.rows, numFlows);
beadDC.SetRange(0,loc_context.cols, 0, loc_context.rows, 0, blocksOfFlow);
beadDC.AllocateBuffer();
beadDCDS = h5BgDbg.CreateDataSet("/bead/fg_bead_DC", beadDC, 3);
h5BgDbg.CreateAttribute(beadDCDS->getDataSetId(),"description","bead_DC per flow");
h5BgDbg.makeParamNames("fg_beadDC_",numFlows,str);
h5BgDbg.CreateAttribute(beadDCDS->getDataSetId(),"paramNames",str.c_str());
amplMultiplier.Init(loc_context.cols, loc_context.rows, numFlows);
amplMultiplier.SetRange(0,loc_context.cols, 0, loc_context.rows, 0, blocksOfFlow);
amplMultiplier.AllocateBuffer();
amplDS = h5BgDbg.CreateDataSet("/bead/ampl_multiplier", amplMultiplier, 3);
h5BgDbg.CreateAttribute(amplDS->getDataSetId(),"description","Amplitude-multiplier per flow");
h5BgDbg.makeParamNames("ampl_",numFlows,str);
h5BgDbg.CreateAttribute(amplDS->getDataSetId(),"paramNames",str.c_str());
kRateMultiplier.Init(loc_context.cols, loc_context.rows, numFlows);
kRateMultiplier.SetRange(0,loc_context.cols, 0, loc_context.rows, 0, blocksOfFlow);
kRateMultiplier.AllocateBuffer();
kRateDS = h5BgDbg.CreateDataSet("/bead/k_rate_multiplier", kRateMultiplier, 3);
h5BgDbg.CreateAttribute(kRateDS->getDataSetId(),"description","K-rate-multiplier per flow");
h5BgDbg.makeParamNames("kRate_",numFlows,str);
h5BgDbg.CreateAttribute(kRateDS->getDataSetId(),"paramNames",str.c_str());
bgResidualError.Init(loc_context.cols, loc_context.rows, numFlows);
bgResidualError.SetRange(0,loc_context.cols, 0, loc_context.rows, 0, blocksOfFlow);
bgResidualError.AllocateBuffer();
resErrorDS = h5BgDbg.CreateDataSet("/bead/res_error", bgResidualError, 3);
h5BgDbg.CreateAttribute(resErrorDS->getDataSetId(),"description","Residual-error per flow");
h5BgDbg.makeParamNames("resErr_",numFlows,str);
h5BgDbg.CreateAttribute(resErrorDS->getDataSetId(),"paramNames",str.c_str());
beadInitParam.Init(loc_context.cols, loc_context.rows, 4);
beadInitParam.SetRange(0,loc_context.cols, 0, loc_context.rows, 0, beadInitParam.GetNumZ());
beadInitParam.AllocateBuffer();
beadInitParamDS = h5BgDbg.CreateDataSet("/bead/bead_init_param", beadInitParam, 3);
h5BgDbg.CreateAttribute(beadInitParamDS->getDataSetId(),"description","Bead-init-param, same for all flows, 4 data points: Copies, R, dmult, gain");
h5BgDbg.CreateAttribute(beadInitParamDS->getDataSetId(),"paramNames","Copies, R, dmult, gain");
beadFblk_avgErr.set_size(loc_context.cols, loc_context.rows);
beadFblk_clonal.set_size(loc_context.cols, loc_context.rows);
beadFblk_corrupt.set_size(loc_context.cols, loc_context.rows);
rp_dims[0] = rp_chunks[0] = loc_context.cols;
rp_dims[1] = rp_chunks[1] = loc_context.rows;
for (int i=0; i<nFlowBlks; i++) {
int f = (i+1)*NUMFB;
if (i==nFlowBlks-1)
f = numFlows;
sprintf(s,"/bead/flowBlkParams/avgErr/flow_%04d",f);
H5DataSet *ptr = h5BgDbg.CreateDataSet(s, 2, rp_dims, rp_chunks, 3, h5BgDbg.GetH5Type(beadFblk_avgErr.at(0,0)));
h5BgDbg.CreateAttribute(ptr->getDataSetId(),"description","avg-err per flow-block");
h5BgDbg.CreateAttribute(ptr->getDataSetId(),"paramNames","avgErr");
beadFblk_avgErrDS.push_back(ptr);
sprintf(s,"/bead/flowBlkParams/clonal/flow_%04d",f);
ptr = h5BgDbg.CreateDataSet(s, 2, rp_dims, rp_chunks, 3, h5BgDbg.GetH5Type(beadFblk_clonal.at(0,0)));
h5BgDbg.CreateAttribute(ptr->getDataSetId(),"description","clonal flag per flow-block");
h5BgDbg.CreateAttribute(ptr->getDataSetId(),"paramNames","clonal");
beadFblk_clonalDS.push_back(ptr);
sprintf(s,"/bead/flowBlkParams/corrupt/flow_%04d",f);
ptr = h5BgDbg.CreateDataSet(s, 2, rp_dims, rp_chunks, 3, h5BgDbg.GetH5Type(beadFblk_corrupt.at(0,0)));
h5BgDbg.CreateAttribute(ptr->getDataSetId(),"description","corrupt flag per flow-block");
h5BgDbg.CreateAttribute(ptr->getDataSetId(),"paramNames","corrupt");
beadFblk_corruptDS.push_back(ptr);
}
}
catch( char * str ) {
cout << "Exception raised while creating bead datasets in BkgParamH5::Init(): " << str << '\n';
}
///------------------------------------------------------------------------------------------------------------
/// region parameters
///------------------------------------------------------------------------------------------------------------
try {
//cout << "Init...regionalParams.n_rows,n_cols=" << regionalParams.n_rows << "," << regionalParams.n_cols << endl;
//rp_dims[0] = loc_context.numRegions * nFlowBlks;
char s[128];
rp_dims[0] = rp_chunks[0] = loc_context.numRegions;
rp_dims[1] = rp_chunks[1] = numFlows;
beadDC_bg.set_size(rp_dims[0], rp_dims[1]);
beadDC_bgDS = h5BgDbg.CreateDataSet("/region/bg_bead_DC", 2, rp_dims, rp_chunks, 3, h5BgDbg.GetH5Type(beadDC_bg.at(0,0)));
h5BgDbg.CreateAttribute(beadDC_bgDS->getDataSetId(),"description","bg_bead_DC");
h5BgDbg.makeParamNames("bg_beadDC_",numFlows,str);
h5BgDbg.CreateAttribute(beadDC_bgDS->getDataSetId(),"paramNames",str.c_str());
rp_dims[0] = rp_chunks[0] = loc_context.numRegions;
rp_dims[1] = rp_chunks[1] = 2;
regionOffset.set_size(rp_dims[0], rp_dims[1]);
regionOffsetDS = h5BgDbg.CreateDataSet("/region/region_offset_RowCol", 2, rp_dims, rp_chunks, 3, h5BgDbg.GetH5Type(regionOffset.at(0,0)));
h5BgDbg.CreateAttribute(regionOffsetDS->getDataSetId(),"description","region-offset-xy");
h5BgDbg.CreateAttribute(regionOffsetDS->getDataSetId(),"paramNames","row,col");
regionalParams.set_size(loc_context.numRegions, numParam);
regionalParamsExtra.set_size(loc_context.numRegions, 9);
emptyOnceParam.Init(loc_context.numRegions, my_image_spec.uncompFrames, numFlows);
emptyOnceParam.SetRange(0,loc_context.numRegions, 0, my_image_spec.uncompFrames, 0, blocksOfFlow);
emptyOnceParam.AllocateBuffer();
emptyOnceParamDS = h5BgDbg.CreateDataSet("/region/emptyTrace", emptyOnceParam, 3);
h5BgDbg.CreateAttribute(emptyOnceParamDS->getDataSetId(),"description","Empty-trace per region, per imgFrame , per flow");
h5BgDbg.makeParamNames("empty_",numFlows,str);
h5BgDbg.CreateAttribute(emptyOnceParamDS->getDataSetId(),"paramNames",str.c_str());
darkOnceParam.Init(loc_context.numRegions, NUMNUC, MAX_COMPRESSED_FRAMES);
darkOnceParam.SetRange(0,loc_context.numRegions, 0, NUMNUC, 0, darkOnceParam.GetNumZ());
darkOnceParam.AllocateBuffer();
darkOnceParamDS = h5BgDbg.CreateDataSet("/region/darkMatter/missingMass", darkOnceParam, 3);
sprintf(s,"Missing-mass per region, per nucleotide, %d data points",MAX_COMPRESSED_FRAMES);
h5BgDbg.CreateAttribute(darkOnceParamDS->getDataSetId(),"description",s);
h5BgDbg.makeParamNames("missingMass_",MAX_COMPRESSED_FRAMES,str);
h5BgDbg.CreateAttribute(darkOnceParamDS->getDataSetId(),"paramNames",str.c_str());
rp_dims[0] = rp_chunks[0] = loc_context.numRegions;
rp_dims[1] = rp_chunks[1] = NUMFB;
darknessParam.set_size(loc_context.numRegions, NUMFB);
darknessParamDS = h5BgDbg.CreateDataSet("/region/darkMatter/darkness", 2, rp_dims, rp_chunks, 3, h5BgDbg.GetH5Type(darknessParam.at(0,0)));
h5BgDbg.CreateAttribute(darknessParamDS->getDataSetId(),"description","Darkness per region, per flowBuffer");
h5BgDbg.makeParamNames("darkness_",NUMFB,str);
h5BgDbg.CreateAttribute(darknessParamDS->getDataSetId(),"paramNames",str.c_str());
rp_dims[1] = rp_chunks[1] = 2;
regionInitParam.set_size(loc_context.numRegions, 2);
regionInitParamDS = h5BgDbg.CreateDataSet("/region/region_init_param", 2, rp_dims, rp_chunks, 3, h5BgDbg.GetH5Type(regionInitParam.at(0,0)));
h5BgDbg.CreateAttribute(regionInitParamDS->getDataSetId(),"description","Region-init-param per region, 2 data points: t_mid_nuc_start & sigma_start");
h5BgDbg.CreateAttribute(regionInitParamDS->getDataSetId(),"paramNames","t_mid_nuc_start,sigma_start");
emphasisParam.Init(loc_context.numRegions, MAX_HPLEN+1, MAX_COMPRESSED_FRAMES);
emphasisParam.SetRange(0,loc_context.numRegions, 0, MAX_HPLEN+1, 0, emphasisParam.GetNumZ());
emphasisParam.AllocateBuffer();
for (int i=0; i<nFlowBlks; i++) {
int f = (i+1)*NUMFB;
if (i==nFlowBlks-1)
f = numFlows;
sprintf(s,"/region/emphasis/flow_%04d",f);
H5DataSet *ptr = h5BgDbg.CreateDataSet(s, emphasisParam, 3);
sprintf(s,"Emphasis param per region, per HP length, %d data points per flow-block",MAX_COMPRESSED_FRAMES);
h5BgDbg.CreateAttribute(ptr->getDataSetId(),"description",s);
h5BgDbg.makeParamNames("emphasis_",NUMFB,str);
h5BgDbg.CreateAttribute(ptr->getDataSetId(),"paramNames",str.c_str());
emphasisParamDS.push_back(ptr);
rp_dims[0] = rp_chunks[0] = loc_context.numRegions;
rp_dims[1] = rp_chunks[1] = numParam;
sprintf(s,"/region/region_param/flow_%04d",f);
ptr = h5BgDbg.CreateDataSet(s, 2, rp_dims, rp_chunks, 3, h5BgDbg.GetH5Type(regionalParams.at(0,0)));
sprintf(s,"Region_param per region, %d data points per flow-block",numParam);
h5BgDbg.CreateAttribute(ptr->getDataSetId(),"description",s);
h5BgDbg.makeParamNames("regionParam_",numParam,str);
h5BgDbg.CreateAttribute(ptr->getDataSetId(),"paramNames",str.c_str());
regionParamDS.push_back(ptr);
rp_dims[1] = rp_chunks[1] = regionalParamsExtra.n_cols;
sprintf(s,"/region/region_param_extra/flow_%04d",f);
ptr = h5BgDbg.CreateDataSet(s, 2, rp_dims, rp_chunks, 3, h5BgDbg.GetH5Type(regionalParamsExtra.at(0,0)));
sprintf(s,"Region_param_extra per region, %d data points per flow-block",regionalParamsExtra.n_cols);
h5BgDbg.CreateAttribute(ptr->getDataSetId(),"description",s);
h5BgDbg.CreateAttribute(ptr->getDataSetId(),"paramNames","midNucTime_0,midNucTime_1,midNucTime_2,midNucTime_3,sigma_0,sigma_1,sigma_2,sigma_3,sigma");
regionParamDSExtra.push_back(ptr);
}
}
catch( char * str ) {
cout << "Exception raised while creating region datasets in BkgParamH5::Init(): " << str << '\n';
}
///------------------------------------------------------------------------------------------------------------
/// savePointers to be passed to BkgModel::WriteBeadParameterstoDataCubes
///------------------------------------------------------------------------------------------------------------
savePointers();
return hgBgDbgFile;
}
