//-***************************************************************************** AwImpl::AwImpl( const std::string &iFileName, const AbcA::MetaData &iMetaData ) : m_fileName( iFileName ) , m_metaData( iMetaData ) , m_file( -1 ) { // add default time sampling AbcA::TimeSamplingPtr ts( new AbcA::TimeSampling() ); m_timeSamples.push_back(ts); // OPEN THE FILE! hid_t faid = H5Pcreate( H5P_FILE_ACCESS ); if ( faid < 0 ) { ABCA_THROW( "Could not create property access for fopen" ); } H5Pset_libver_bounds( faid, H5F_LIBVER_LATEST, H5F_LIBVER_LATEST ); m_file = H5Fcreate( m_fileName.c_str(), H5F_ACC_TRUNC, H5P_DEFAULT, faid ); H5Pclose( faid ); if ( m_file < 0 ) { ABCA_THROW( "Could not open file: " << m_fileName ); } // set the version using HDF5 native calls // This expresses the AbcCoreHDF5 version - how properties, // are stored within HDF5, etc. int version = ALEMBIC_HDF5_FILE_VERSION; H5LTset_attribute_int(m_file, ".", "abc_version", &version, 1); // This is the Alembic library version XXYYZZ // Where XX is the major version, YY is the minor version // and ZZ is the patch version int libraryVersion = ALEMBIC_LIBRARY_VERSION; H5LTset_attribute_int(m_file, ".", "abc_release_version", &libraryVersion, 1); m_metaData.set("_ai_AlembicVersion", AbcA::GetLibraryVersion()); // Create top explicitly. m_top = new TopOwImpl( *this, m_file, m_metaData ); }
static void psc_fields_single_write(struct psc_fields *flds, struct mrc_io *io) { int ierr; long h5_file; mrc_io_get_h5_file(io, &h5_file); hid_t group = H5Gopen(h5_file, mrc_io_obj_path(io, flds), H5P_DEFAULT); H5_CHK(group); ierr = H5LTset_attribute_int(group, ".", "p", &flds->p, 1); CE; ierr = H5LTset_attribute_int(group, ".", "ib", flds->ib, 3); CE; ierr = H5LTset_attribute_int(group, ".", "im", flds->im, 3); CE; ierr = H5LTset_attribute_int(group, ".", "nr_comp", &flds->nr_comp, 1); CE; // write components separately instead? hsize_t hdims[4] = { flds->nr_comp, flds->im[2], flds->im[1], flds->im[0] }; ierr = H5LTmake_dataset_float(group, "fields_single", 4, hdims, flds->data); CE; ierr = H5Gclose(group); CE; }
int_f nh5ltset_attribute_int_c(hid_t_f *loc_id, int_f *namelen, _fcd dsetname, int_f *attrnamelen, _fcd attrname, size_t_f *size, void *buf) { int ret_value = -1; herr_t ret; hid_t c_loc_id; char *c_name = NULL; char *c_attrname = NULL; int c_namelen; int c_attrnamelen; size_t c_size; /* * convert FORTRAN name to C name */ c_namelen = *namelen; c_name = (char *)HD5f2cstring(dsetname, c_namelen); if (c_name == NULL) goto done; c_attrnamelen = (int)*attrnamelen; c_attrname = (char *)HD5f2cstring(attrname, c_attrnamelen); if (c_attrname == NULL) goto done; /* * call H5LTset_attribute_int function. */ c_loc_id = (hid_t)*loc_id; c_size = (size_t)*size; if (sizeof(int_f) == sizeof(int)) ret = H5LTset_attribute_int(c_loc_id,c_name,c_attrname,buf,c_size); else if (sizeof(int_f) == sizeof(long)) ret = H5LTset_attribute_long(c_loc_id,c_name,c_attrname,buf,c_size); else if (sizeof(int_f) == sizeof(long long)) ret = H5LTset_attribute_long_long(c_loc_id,c_name,c_attrname,buf,c_size); else goto done; if (ret < 0) goto done; ret_value = 0; done: if(c_name!=NULL) free(c_name); if(c_attrname!=NULL) free(c_attrname); return ret_value; }
// Write int attribute <attr_name> given by address <path> char AH5_write_int_attr(hid_t loc_id, const char *path, char* attr_name, const int wdata) { char success = AH5_FALSE; if (AH5_path_valid(loc_id, path)) if (H5LTset_attribute_int(loc_id, path, attr_name, &wdata, 1) >= 0) success = AH5_TRUE; return success; }
int GWriteHDFFile::WriteHeader(gadget_header& header) { herr_t herr; for(int i=0; i<N_TYPE; i++){ header.npart[i]=npart[i]; } hid_t handle = H5Fopen(filename.c_str(), H5F_ACC_RDWR, H5P_DEFAULT); if (handle < 0) return -1*handle; // Lite interface for making simple attributes // H5LTset_attribute_int (file_id, dset_name, attr_name, data, size); // herr_t H5LTset_attribute_int( hid_t loc_id, const char *obj_name, const char *attr_name, int *buffer, size_t size) hid_t hdgrp = H5Gcreate2(handle, "Header", H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT); herr = H5LTset_attribute_uint(handle, "Header", "NumPart_ThisFile", header.npart, N_TYPE); if (herr < 0) { WARN("Could not write to header"); return -1*herr; } herr = H5LTset_attribute_uint(handle, "Header", "NumPart_Total", header.npartTotal, N_TYPE); herr = H5LTset_attribute_uint(handle, "Header", "NumPart_Total_HighWord", header.NallHW, N_TYPE); herr = H5LTset_attribute_double(handle, "Header", "MassTable", header.mass, N_TYPE); if (herr < 0) { WARN("Could not write particle numbers"); return -1*herr; } herr = H5LTset_attribute_double(handle, "Header", "Time", &header.time, 1); herr = H5LTset_attribute_double(handle, "Header", "Redshift", &header.redshift, 1); herr = H5LTset_attribute_double(handle, "Header", "BoxSize", &header.BoxSize, 1); herr = H5LTset_attribute_int(handle, "Header", "NumFilesPerSnapshot", &header.num_files, 1); herr = H5LTset_attribute_double(handle, "Header", "Omega0", &header.Omega0, 1); herr = H5LTset_attribute_double(handle, "Header", "OmegaLambda", &header.OmegaLambda, 1); herr = H5LTset_attribute_double(handle, "Header", "HubbleParam", &header.HubbleParam, 1); herr = H5LTset_attribute_int(handle, "Header", "Flag_Sfr", &header.flag_sfr, 1); herr = H5LTset_attribute_int(handle, "Header", "Flag_Cooling", &header.flag_cooling, 1); herr = H5LTset_attribute_int(handle, "Header", "Flag_StellarAge", &header.flag_stellarage, 1); herr = H5LTset_attribute_int(handle, "Header", "Flag_Metals", &header.flag_metals, 1); herr = H5LTset_attribute_int(handle, "Header", "Flag_Feedback", &header.flag_feedback, 1); herr = H5LTset_attribute_int(handle, "Header", "Flag_DoublePrecision", &header.flag_doubleprecision, 1); herr = H5LTset_attribute_int(handle, "Header", "Flag_IC_Info", &header.flag_ic_info, 1); herr = H5LTset_attribute_double(handle, "Header", "UnitLength_in_cm", &header.UnitLength_in_cm, 1); herr = H5LTset_attribute_double(handle, "Header", "UnitMass_in_g", &header.UnitMass_in_g, 1); herr = H5LTset_attribute_double(handle, "Header", "UnitVelocity_in_cm_per_s", &header.UnitVelocity_in_cm_per_s, 1); if (herr < 0) { WARN("Could not write final header flags"); return -1*herr; } H5Gclose(hdgrp); H5Fclose(handle); return 0; }
void Grid::initData(FileIO *fileIO) { hid_t gridGroup = fileIO->newGroup("/Grid"); // set lengths check(H5LTset_attribute_double(gridGroup, ".", "Lx", &Lx, 1), DMESG("HDF-5 Error")); check(H5LTset_attribute_double(gridGroup, ".", "Ly", &Ly, 1), DMESG("HDF-5 Error")); check(H5LTset_attribute_double(gridGroup, ".", "Lz", &Lz, 1), DMESG("HDF-5 Error")); check(H5LTset_attribute_double(gridGroup, ".", "Lv", &Lv, 1), DMESG("HDF-5 Error")); check(H5LTset_attribute_double(gridGroup, ".", "Lm", &Lm, 1), DMESG("HDF-5 Error")); // set grid point number check(H5LTset_attribute_int(gridGroup, ".", "Nx", &Nx , 1), DMESG("HDF-5 Error")); check(H5LTset_attribute_int(gridGroup, ".", "Nky",&Nky, 1), DMESG("HDF-5 Error")); check(H5LTset_attribute_int(gridGroup, ".", "Nz", &Nz , 1), DMESG("HDF-5 Error")); check(H5LTset_attribute_int(gridGroup, ".", "Nv", &Nv , 1), DMESG("HDF-5 Error")); check(H5LTset_attribute_int(gridGroup, ".", "Nm", &Nm , 1), DMESG("HDF-5 Error")); check(H5LTset_attribute_int(gridGroup, ".", "Ns", &Ns , 1), DMESG("HDF-5 Error")); // set grids check(H5LTset_attribute_double(gridGroup, ".", "X", &X[NxGlD], Nx), DMESG("HDF-5 Error")); check(H5LTset_attribute_double(gridGroup, ".", "Z", &Z[NzGlD], Nz), DMESG("HDF-5 Error")); check(H5LTset_attribute_double(gridGroup, ".", "V", &V[NvGlD], Nv), DMESG("HDF-5 Error")); check(H5LTset_attribute_double(gridGroup, ".", "M", &M[NmGlD], Nm), DMESG("HDF-5 Error")); check(H5LTset_attribute_string(gridGroup, ".", "MuIntegrationType", muIntegrationType.c_str()), DMESG("HDF-5 Error")); H5Gclose(gridGroup); }
int pioAddAttributeInteger(PIOObject pioObject, const char* attr_name, int attr_value) { if (pioAttributeIsProtected(attr_name)) { fprintf(stdout, "WARNING: Attribute name %s is a reserved for pinocchIO internal use.\n", attr_name); return -1; } return H5LTset_attribute_int(pioObject.identifier, ".", attr_name, &attr_value, 1); }
//-***************************************************************************** HDF5HierarchyWriter::HDF5HierarchyWriter( hid_t iFile, HDF5Hierarchy& iH5H ) : m_H5H( iH5H ) { m_H5H.build( iFile ); writeHierarchy( iFile ); // Hierarchy info is succcessfully saved. // Let's set a flag. // int enabled = 1; H5LTset_attribute_int( iFile, ".", "abc_ref_hierarchy", &enabled, 1 ); }
int incrementTimesUsed(PIOTimeline pioTimeline) { ERROR_SWITCH_INIT herr_t set_err; int times_used = getTimesUsed(pioTimeline); if (times_used < 0) return -1; times_used++; ERROR_SWITCH_OFF set_err = H5LTset_attribute_int(pioTimeline.identifier, ".", PIOAttribute_TimesUsed, ×_used, 1); ERROR_SWITCH_ON if (set_err < 0) return -1; return times_used; }
/*+++++++++++++++++++++++++ .IDENTifer PYTABLE_make_array .PURPOSE create extensible HDF5 dataset .INPUT/OUTPUT call as stat = PYTABLE_make_array( locID, dset_name, title, rank, dims, extdim, typeID, dims_chunk, fill_data, compress, shuffle, fletcher32, buff ); input: hid_t locID : HDF5 identifier of file or group char *dset_name : name of dataset char *title : int rank : number of dimensions hsize_t *dims : size of each dimension int extdim : index of expendable dimension hid_t typeID : data type (HDF5 identifier) hsize_t *dims_chunk : chunk sizes void *fill_data : Fill value for data unsigned int compress : compression level (zero for no compression) bool shuffle : shuffel data for better compression bool fletcher32 : void *buffer : buffer with data to write (or NULL) .RETURNS A negative value is returned on failure. .COMMENTS none -------------------------*/ herr_t PYTABLE_make_array( hid_t locID, const char *dset_name, const char *title, const int rank, const hsize_t *dims, int extdim, hid_t typeID, const hsize_t *dims_chunk, void *fill_data, unsigned int compress, bool shuffle, bool fletcher32, const void *buffer ) { register int ni; hid_t dataID = -1, spaceID = -1; herr_t stat; /* check if the array has to be chunked or not */ if ( dims_chunk != NULL ) { hid_t plistID; hsize_t *maxdims = (hsize_t *) malloc( rank * sizeof(hsize_t) ); if ( maxdims == NULL ) NADC_GOTO_ERROR( NADC_ERR_ALLOC, "maxdims" ); for ( ni = 0; ni < rank; ni++ ) { if ( ni == extdim ) maxdims[ni] = H5S_UNLIMITED; else maxdims[ni] = dims[ni] < dims_chunk[ni] ? dims_chunk[ni] : dims[ni]; } spaceID = H5Screate_simple( rank, dims, maxdims ); free( maxdims ); if ( spaceID < 0 ) NADC_GOTO_ERROR( NADC_ERR_HDF_SPACE, "" ); /* Modify dataset creation properties, i.e. enable chunking */ plistID = H5Pcreate( H5P_DATASET_CREATE ); if ( H5Pset_chunk( plistID, rank, dims_chunk ) < 0 ) goto done; /* set the fill value using a struct as the data type */ if ( fill_data != NULL && H5Pset_fill_value( plistID, typeID, fill_data ) < 0 ) goto done; /* dataset creation property list is modified to use */ /* fletcher must be first */ if ( fletcher32 ) { if ( H5Pset_fletcher32( plistID ) < 0 ) goto done; } /* then shuffle */ if ( shuffle ) { if ( H5Pset_shuffle( plistID ) < 0 ) goto done; } /* finally compression */ if ( compress > 0 ) { if ( H5Pset_deflate( plistID, compress ) < 0 ) goto done; } /* create the (chunked) dataset */ dataID = H5Dcreate( locID, dset_name, typeID, spaceID, H5P_DEFAULT, plistID, H5P_DEFAULT ); if ( dataID < 0 ) NADC_GOTO_ERROR( NADC_ERR_HDF_DATA, dset_name ); /* end access to the property list */ if ( H5Pclose( plistID ) < 0 ) goto done; } else { spaceID = H5Screate_simple( rank, dims, NULL ); if ( spaceID < 0 ) return -1; /* create the dataset (not chunked) */ dataID = H5Dcreate( locID, dset_name, typeID, spaceID, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT ); if ( dataID < 0 ) NADC_GOTO_ERROR( NADC_ERR_HDF_DATA, dset_name ); } /* * write the data */ stat = H5Dwrite( dataID, typeID, H5S_ALL, H5S_ALL, H5P_DEFAULT, buffer ); if ( stat < 0 ) NADC_GOTO_ERROR( NADC_ERR_HDF_WR, "" ); (void) H5Dclose( dataID ); (void) H5Sclose( spaceID ); /* * Set the conforming array attributes * * attach the CLASS attribute */ (void) H5LTset_attribute_string( locID, dset_name, "CLASS", PY_ARRAY_CLASS ); /* attach the EXTDIM attribute in case of enlargeable arrays */ (void) H5LTset_attribute_int( locID, dset_name, "EXTDIM", &extdim, 1 ); /* attach the FLAVOR attribute */ (void) H5LTset_attribute_string( locID, dset_name, "FLAVOR", PY_ARRAY_FLAVOR ); /* attach the VERSION attribute */ (void) H5LTset_attribute_string( locID, dset_name, "VERSION", PY_ARRAY_VERSION ); /* attach the TITLE attribute */ (void) H5LTset_attribute_string( locID, dset_name, "TITLE", title ); return 0; done: if ( dataID > 0 ) (void) H5Dclose( dataID ); if ( spaceID > 0 ) (void) H5Sclose( spaceID ); return -1; }
/* ------- begin -------------------------- init_hdf5_indata.c --- */ void init_hdf5_indata_new(void) /* Creates the netCDF file for the input data */ { const char routineName[] = "init_hdf5_indata_new"; int i, PRD_angle_dep; double *eweight, *eabund, *x, *y; /* This value is harcoded for efficiency. Maximum number of iterations ever needed */ int NMaxIter = 1500; hid_t plist, ncid, file_dspace, ncid_input, ncid_atmos, ncid_mpi; hsize_t dims[4]; bool_t XRD; char startJ[MAX_LINE_SIZE], StokesMode[MAX_LINE_SIZE], angleSet[MAX_LINE_SIZE]; /* Create the file */ if (( plist = H5Pcreate(H5P_FILE_ACCESS )) < 0) HERR(routineName); if (( H5Pset_fapl_mpio(plist, mpi.comm, mpi.info) ) < 0) HERR(routineName); if (( ncid = H5Fcreate(INPUTDATA_FILE, H5F_ACC_TRUNC, H5P_DEFAULT, plist) ) < 0) HERR(routineName); if (( H5Pclose(plist) ) < 0) HERR(routineName); /* Create groups */ if (( ncid_input = H5Gcreate(ncid, "/input", H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT) ) < 0) HERR(routineName); if (( ncid_atmos = H5Gcreate(ncid, "/atmos", H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT) ) < 0) HERR(routineName); if (( ncid_mpi = H5Gcreate(ncid, "/mpi", H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT) ) < 0) HERR(routineName); /* --- Definitions for the root group --- */ /* dimensions as attributes */ if (( H5LTset_attribute_int(ncid, "/", "nx", &mpi.nx, 1) ) < 0) HERR(routineName); if (( H5LTset_attribute_int(ncid, "/", "ny", &mpi.ny, 1) ) < 0) HERR(routineName); if (( H5LTset_attribute_int(ncid, "/", "nz", (int *) &infile.nz, 1 )) < 0) HERR(routineName); /* attributes */ if (( H5LTset_attribute_string(ncid, "/", "atmosID", atmos.ID)) < 0) HERR(routineName); if (( H5LTset_attribute_string(ncid, "/", "rev_id", mpi.rev_id) ) < 0) HERR(routineName); /* --- Definitions for the INPUT group --- */ /* attributes */ if ( atmos.NPRDactive > 0) PRD_angle_dep = input.PRD_angle_dep; else PRD_angle_dep=0; XRD = (input.XRD && atmos.NPRDactive > 0); if (( H5LTset_attribute_uchar(ncid_input, ".", "Magneto_optical", (unsigned char *) &input.magneto_optical, 1)) < 0) HERR(routineName); if (( H5LTset_attribute_uchar(ncid_input, ".", "PRD_angle_dep", (unsigned char *) &PRD_angle_dep, 1)) < 0) HERR(routineName); if (( H5LTset_attribute_uchar(ncid_input, ".", "XRD", (unsigned char *) &XRD, 1)) < 0) HERR(routineName); if (( H5LTset_attribute_uchar(ncid_input, ".", "Background_polarization", (unsigned char *) &input.backgr_pol, 1)) < 0) HERR(routineName); switch (input.startJ) { case UNKNOWN: strcpy(startJ, "Unknown"); break; case LTE_POPULATIONS: strcpy(startJ, "LTE_POPULATIONS"); break; case ZERO_RADIATION: strcpy(startJ, "ZERO_RADIATION"); break; case OLD_POPULATIONS: strcpy(startJ, "OLD_POPULATIONS"); break; case ESCAPE_PROBABILITY: strcpy(startJ, "ESCAPE_PROBABILITY"); break; case NEW_J: strcpy(startJ, "NEW_J"); break; case OLD_J: strcpy(startJ, "OLD_J"); break; } if (( H5LTset_attribute_string(ncid_input, ".", "Start_J", startJ)) < 0) HERR(routineName); switch (input.StokesMode) { case NO_STOKES: strcpy(StokesMode, "NO_STOKES"); break; case FIELD_FREE: strcpy(StokesMode, "FIELD_FREE"); break; case POLARIZATION_FREE: strcpy(StokesMode, "POLARIZATION_FREE"); break; case FULL_STOKES: strcpy(StokesMode, "FULL_STOKES"); break; } if (( H5LTset_attribute_string(ncid_input, ".", "Stokes_mode", StokesMode) ) < 0) HERR(routineName); switch (atmos.angleSet.set) { case SET_VERTICAL: strcpy(angleSet, "SET_VERTICAL"); break; case SET_GL: strcpy(angleSet, "SET_GL"); break; case SET_A2: strcpy(angleSet, "SET_A2"); break; case SET_A4: strcpy(angleSet, "SET_A4"); break; case SET_A6: strcpy(angleSet, "SET_A6"); break; case SET_A8: strcpy(angleSet, "SET_A8"); break; case SET_B4: strcpy(angleSet, "SET_B4"); break; case SET_B6: strcpy(angleSet, "SET_B6"); break; case SET_B8: strcpy(angleSet, "SET_B8"); break; case NO_SET: strcpy(angleSet, "NO_SET"); break; } if (( H5LTset_attribute_string(ncid_input, ".", "Angle_set", angleSet) ) < 0) HERR(routineName); if (( H5LTset_attribute_string(ncid_input, ".", "Atmos_file", input.atmos_input) ) < 0) HERR(routineName); if (( H5LTset_attribute_string(ncid_input, ".", "Abundances_file", input.abund_input) ) < 0) HERR(routineName); if (( H5LTset_attribute_string(ncid_input, ".", "Kurucz_PF_data", input.pfData) ) < 0) HERR(routineName); if (( H5LTset_attribute_double(ncid_input, ".", "Iteration_limit", &input.iterLimit, 1) ) < 0) HERR(routineName); if (( H5LTset_attribute_double(ncid_input, ".", "PRD_Iteration_limit", &input.PRDiterLimit, 1) ) < 0) HERR(routineName); if (( H5LTset_attribute_int(ncid_input, ".", "N_max_iter", &input.NmaxIter, 1) ) < 0) HERR(routineName); if (( H5LTset_attribute_int(ncid_input, ".", "Ng_delay", &input.Ngdelay, 1) ) < 0) HERR(routineName); if (( H5LTset_attribute_int(ncid_input, ".", "Ng_order", &input.Ngorder, 1) ) < 0) HERR(routineName); if (( H5LTset_attribute_int(ncid_input, ".", "Ng_period", &input.Ngperiod, 1) ) < 0) HERR(routineName); if (( H5LTset_attribute_int(ncid_input, ".", "PRD_N_max_iter", &input.PRD_NmaxIter, 1) ) < 0) HERR(routineName); if (( H5LTset_attribute_int(ncid_input, ".", "PRD_Ng_delay", &input.PRD_Ngdelay, 1) ) < 0) HERR(routineName); if (( H5LTset_attribute_int(ncid_input, ".", "PRD_Ng_order", &input.PRD_Ngorder, 1) ) < 0) HERR(routineName); if (( H5LTset_attribute_int(ncid_input, ".", "PRD_Ng_period", &input.PRD_Ngperiod, 1) ) < 0) HERR(routineName); if (( H5LTset_attribute_double(ncid_input, ".", "Metallicity", &input.metallicity, 1) ) < 0) HERR(routineName); if (( H5LTset_attribute_double(ncid_input, ".", "Lambda_reference", &atmos.lambda_ref, 1) ) < 0) HERR(routineName); /* --- Definitions for the ATMOS group --- */ /* dimensions */ if (( H5LTset_attribute_int(ncid_atmos, ".", "nhydr", &atmos.H->Nlevel, 1) ) < 0) HERR(routineName); if (( H5LTset_attribute_int(ncid_atmos, ".", "nelements", &atmos.Nelem, 1) ) < 0) HERR(routineName); if (( H5LTset_attribute_int(ncid_atmos, ".", "nrays", &geometry.Nrays, 1) ) < 0) HERR(routineName); /* variables*/ dims[0] = mpi.nx; dims[1] = mpi.ny; dims[2] = infile.nz; if (( file_dspace = H5Screate_simple(3, dims, NULL) ) < 0) HERR(routineName); if (( plist = H5Pcreate(H5P_DATASET_CREATE) ) < 0) HERR(routineName); if (( H5Pset_fill_value(plist, H5T_NATIVE_FLOAT, &FILLVALUE) ) < 0) HERR(routineName); if (( H5Pset_alloc_time(plist, H5D_ALLOC_TIME_EARLY) ) < 0) HERR(routineName); if (( H5Pset_fill_time(plist, H5D_FILL_TIME_ALLOC) ) < 0) HERR(routineName); if (( io.in_atmos_T = H5Dcreate(ncid_atmos, "temperature", H5T_NATIVE_FLOAT, file_dspace, H5P_DEFAULT, plist, H5P_DEFAULT)) < 0) HERR(routineName); if (( io.in_atmos_vz = H5Dcreate(ncid_atmos, "velocity_z", H5T_NATIVE_FLOAT, file_dspace, H5P_DEFAULT, plist, H5P_DEFAULT)) < 0) HERR(routineName); if (( io.in_atmos_z = H5Dcreate(ncid_atmos, "height", H5T_NATIVE_FLOAT, file_dspace, H5P_DEFAULT, plist, H5P_DEFAULT)) < 0) HERR(routineName); if (( H5Pclose(plist) ) < 0) HERR(routineName); if (( H5Sclose(file_dspace) ) < 0) HERR(routineName); /* --- Write some data that does not depend on xi, yi, ATMOS group --- */ /* arrays of number of elements */ eweight = (double *) malloc(atmos.Nelem * sizeof(double)); eabund = (double *) malloc(atmos.Nelem * sizeof(double)); for (i=0; i < atmos.Nelem; i++) { eweight[i] = atmos.elements[i].weight; eabund[i] = atmos.elements[i].abund; } dims[0] = atmos.Nelem; if (( H5LTmake_dataset(ncid_atmos, "element_weight", 1, dims, H5T_NATIVE_DOUBLE, eweight) ) < 0) HERR(routineName); if (( H5LTmake_dataset(ncid_atmos, "element_abundance", 1, dims, H5T_NATIVE_DOUBLE, eabund) ) < 0) HERR(routineName); /* Not writing element_id for now dims[1] = strlen; if (( H5LTmake_dataset(ncid_atmos, "element_id", 2, dims, H5T_C_S1, eID) ) < 0) HERR(routineName); */ free(eweight); free(eabund); dims[0] = geometry.Nrays; if (( H5LTmake_dataset(ncid_atmos, "muz", 1, dims, H5T_NATIVE_DOUBLE, geometry.muz) ) < 0) HERR(routineName); if (( H5LTmake_dataset(ncid_atmos, "wmu", 1, dims, H5T_NATIVE_DOUBLE, geometry.wmu) ) < 0) HERR(routineName); x = (double *) malloc(mpi.nx * sizeof(double)); y = (double *) malloc(mpi.ny * sizeof(double)); for (i=0; i < mpi.nx; i++) x[i] = infile.x[mpi.xnum[i]]; for (i=0; i < mpi.ny; i++) y[i] = infile.y[mpi.ynum[i]]; dims[0] = mpi.nx; if (( H5LTmake_dataset(ncid_atmos, "x", 1, dims, H5T_NATIVE_DOUBLE, x) ) < 0) HERR(routineName); dims[0] = mpi.ny; if (( H5LTmake_dataset(ncid_atmos, "y", 1, dims, H5T_NATIVE_DOUBLE, y) ) < 0) HERR(routineName); free(x); free(y); /* attributes */ if (( H5LTset_attribute_uchar(ncid_atmos, ".", "moving", (unsigned char *) &atmos.moving, 1)) < 0) HERR(routineName); if (( H5LTset_attribute_uchar(ncid_atmos, ".", "stokes", (unsigned char *) &atmos.Stokes, 1)) < 0) HERR(routineName); if (( H5LTset_attribute_string(ncid_atmos, "temperature", "units", "K") ) < 0) HERR(routineName); if (( H5LTset_attribute_string(ncid_atmos, "velocity_z", "units", "m s^-1") ) < 0) HERR(routineName); if (( H5LTset_attribute_string(ncid_atmos, "height", "units", "m") ) < 0) HERR(routineName); if (( H5LTset_attribute_string(ncid_atmos, "element_weight", "units", "atomic_mass_units") ) < 0) HERR(routineName); if (( H5LTset_attribute_string(ncid_atmos, "x", "units", "m") ) < 0) HERR(routineName); if (( H5LTset_attribute_string(ncid_atmos, "y", "units", "m") ) < 0) HERR(routineName); /* --- Definitions for the MPI group --- */ /* dimensions */ if (( H5LTset_attribute_int(ncid_mpi, ".", "nprocesses", &mpi.size, 1) ) < 0) HERR(routineName); if (( H5LTset_attribute_int(ncid_mpi, ".", "niterations", &NMaxIter, 1) ) < 0) HERR(routineName); /* variables*/ dims[0] = mpi.nx; if (( H5LTmake_dataset(ncid_mpi, XNUM_NAME, 1, dims, H5T_NATIVE_INT, mpi.xnum) ) < 0) HERR(routineName); dims[0] = mpi.ny; if (( H5LTmake_dataset(ncid_mpi, YNUM_NAME, 1, dims, H5T_NATIVE_INT, mpi.ynum) ) < 0) HERR(routineName); dims[0] = mpi.nx; dims[1] = mpi.ny; if (( file_dspace = H5Screate_simple(2, dims, NULL) ) < 0) HERR(routineName); if (( plist = H5Pcreate(H5P_DATASET_CREATE) ) < 0) HERR(routineName); if (( H5Pset_fill_value(plist, H5T_NATIVE_FLOAT, &FILLVALUE) ) < 0) HERR(routineName); if (( H5Pset_alloc_time(plist, H5D_ALLOC_TIME_EARLY) ) < 0) HERR(routineName); if (( H5Pset_fill_time(plist, H5D_FILL_TIME_ALLOC) ) < 0) HERR(routineName); if (( io.in_mpi_tm = H5Dcreate(ncid_mpi, TASK_MAP, H5T_NATIVE_LONG, file_dspace, H5P_DEFAULT, plist, H5P_DEFAULT)) < 0) HERR(routineName); if (( io.in_mpi_tn = H5Dcreate(ncid_mpi, TASK_NUMBER, H5T_NATIVE_LONG, file_dspace, H5P_DEFAULT, plist, H5P_DEFAULT)) < 0) HERR(routineName); if (( io.in_mpi_it = H5Dcreate(ncid_mpi, ITER_NAME, H5T_NATIVE_LONG, file_dspace, H5P_DEFAULT, plist, H5P_DEFAULT)) < 0) HERR(routineName); if (( io.in_mpi_conv = H5Dcreate(ncid_mpi, CONV_NAME, H5T_NATIVE_LONG, file_dspace, H5P_DEFAULT, plist, H5P_DEFAULT)) < 0) HERR(routineName); if (( io.in_mpi_dm = H5Dcreate(ncid_mpi, DM_NAME, H5T_NATIVE_FLOAT, file_dspace, H5P_DEFAULT, plist, H5P_DEFAULT)) < 0) HERR(routineName); if (( io.in_mpi_zc = H5Dcreate(ncid_mpi, ZC_NAME, H5T_NATIVE_INT, file_dspace, H5P_DEFAULT, plist, H5P_DEFAULT)) < 0) HERR(routineName); if (( H5Pclose(plist) ) < 0) HERR(routineName); if (( H5Sclose(file_dspace) ) < 0) HERR(routineName); dims[0] = mpi.nx; dims[1] = mpi.ny; dims[2] = NMaxIter; if (( file_dspace = H5Screate_simple(3, dims, NULL) ) < 0) HERR(routineName); if (( plist = H5Pcreate(H5P_DATASET_CREATE) ) < 0) HERR(routineName); if (( H5Pset_fill_value(plist, H5T_NATIVE_FLOAT, &FILLVALUE) ) < 0) HERR(routineName); if (( H5Pset_alloc_time(plist, H5D_ALLOC_TIME_EARLY) ) < 0) HERR(routineName); if (( H5Pset_fill_time(plist, H5D_FILL_TIME_ALLOC) ) < 0) HERR(routineName); if (( io.in_mpi_dmh = H5Dcreate(ncid_mpi, DMH_NAME, H5T_NATIVE_FLOAT, file_dspace, H5P_DEFAULT, plist, H5P_DEFAULT)) < 0) HERR(routineName); if (( H5Pclose(plist) ) < 0) HERR(routineName); if (( H5Sclose(file_dspace) ) < 0) HERR(routineName); /* attributes */ if (( H5LTset_attribute_int(ncid_mpi, ".", "x_start", &input.p15d_x0, 1) ) < 0) HERR(routineName); if (( H5LTset_attribute_int(ncid_mpi, ".", "x_end", &input.p15d_x1, 1) ) < 0) HERR(routineName); if (( H5LTset_attribute_int(ncid_mpi, ".", "x_step", &input.p15d_xst, 1) ) < 0) HERR(routineName); if (( H5LTset_attribute_int(ncid_mpi, ".", "y_start", &input.p15d_y0, 1) ) < 0) HERR(routineName); if (( H5LTset_attribute_int(ncid_mpi, ".", "y_end", &input.p15d_y1, 1) ) < 0) HERR(routineName); if (( H5LTset_attribute_int(ncid_mpi, ".", "y_step", &input.p15d_yst, 1) ) < 0) HERR(routineName); /* Tiago: most of the arrays involving Ntasks or rank as index are not currently being written. They should eventually be migrated into arrays of [ix, iy] and be written for each task. This is to avoid causing problems with pool mode, where these quantities are not known from the start. */ /* Flush ensures file is created in case of crash */ if (( H5Fflush(ncid, H5F_SCOPE_LOCAL) ) < 0) HERR(routineName); /* --- Copy stuff to the IO data struct --- */ io.in_ncid = ncid; io.in_input_ncid = ncid_input; io.in_atmos_ncid = ncid_atmos; io.in_mpi_ncid = ncid_mpi; return; }
static herr_t make_attributes( hid_t loc_id, const char* obj_name ) { int rank_out; hsize_t *dims_out = 0; H5T_class_t type_class; size_t type_size; int i; char attr_str_in[] = {"My attribute"}; char attr_str_out[20]; char attr_char_in[5] = {1,2,3,4,5}; char attr_char_out[5]; short attr_short_in[5] = {1,2,3,4,5}; short attr_short_out[5]; int attr_int_in[5] = {1,2,3,4,5}; int attr_int_out[5]; long attr_long_in[5] = {1,2,3,4,5}; long attr_long_out[5]; float attr_float_in[5] = {1,2,3,4,5}; float attr_float_out[5]; double attr_double_in[5] = {1,2,3,4,5}; double attr_double_out[5]; unsigned char attr_uchar_in[5] = {1,2,3,4,5}; unsigned char attr_uchar_out[5]; unsigned short attr_ushort_in[5] = {1,2,3,4,5}; unsigned short attr_ushort_out[5]; unsigned int attr_uint_in[5] = {1,2,3,4,5}; unsigned int attr_uint_out[5]; unsigned long attr_ulong_in[5] = {1,2,3,4,5}; unsigned long attr_ulong_out[5]; /*------------------------------------------------------------------------- * H5LTset_attribute_string test *------------------------------------------------------------------------- */ TESTING("H5LTset_attribute_string"); /* Set the attribute */ if ( H5LTset_attribute_string( loc_id, obj_name, ATTR1_NAME, attr_str_in ) < 0 ) return -1; PASSED(); /*------------------------------------------------------------------------- * H5LTset_attribute_string test *------------------------------------------------------------------------- */ TESTING("H5LTget_attribute_string"); /* Get the attribute */ if ( H5LTget_attribute_string( loc_id, obj_name, ATTR1_NAME, attr_str_out ) < 0 ) return -1; if ( strcmp( attr_str_in, attr_str_out ) != 0 ) { return -1; } PASSED(); /*------------------------------------------------------------------------- * H5LTset_attribute_char test *------------------------------------------------------------------------- */ TESTING("H5LTset_attribute_char"); /* Set the attribute */ if ( H5LTset_attribute_char( loc_id, obj_name, ATTR2_NAME, attr_char_in, (size_t)5 ) < 0 ) return -1; PASSED(); /*------------------------------------------------------------------------- * H5LTget_attribute_char test *------------------------------------------------------------------------- */ TESTING("H5LTget_attribute_char"); /* Get the attribute */ if ( H5LTget_attribute_char( loc_id, obj_name, ATTR2_NAME, attr_char_out ) < 0 ) return -1; for (i = 0; i < 5; i++) { if ( attr_char_in[i] != attr_char_out[i] ) { return -1; } } /* Get the attribute */ if ( H5LTget_attribute( loc_id, obj_name, ATTR2_NAME, H5T_NATIVE_CHAR, attr_char_out ) < 0 ) return -1; for (i = 0; i < 5; i++) { if ( attr_char_in[i] != attr_char_out[i] ) { return -1; } } PASSED(); /*------------------------------------------------------------------------- * H5LTset_attribute_short test *------------------------------------------------------------------------- */ TESTING("H5LTset_attribute_short"); /* Set the attribute */ if ( H5LTset_attribute_short( loc_id, obj_name, ATTR3_NAME, attr_short_in, (size_t)5 ) < 0 ) return -1; PASSED(); /*------------------------------------------------------------------------- * H5LTget_attribute_short test *------------------------------------------------------------------------- */ TESTING("H5LTget_attribute_short"); /* Get the attribute */ if ( H5LTget_attribute_short( loc_id, obj_name, ATTR3_NAME, attr_short_out ) < 0 ) return -1; for (i = 0; i < 5; i++) { if ( attr_short_in[i] != attr_short_out[i] ) { return -1; } } /* Get the attribute */ if ( H5LTget_attribute( loc_id, obj_name, ATTR3_NAME, H5T_NATIVE_SHORT, attr_short_out ) < 0 ) return -1; for (i = 0; i < 5; i++) { if ( attr_short_in[i] != attr_short_out[i] ) { return -1; } } PASSED(); /*------------------------------------------------------------------------- * H5LTset_attribute_int test *------------------------------------------------------------------------- */ TESTING("H5LTset_attribute_int"); /* Set the attribute */ if ( H5LTset_attribute_int( loc_id, obj_name, ATTR4_NAME, attr_int_in, (size_t)5 ) < 0 ) return -1; PASSED(); /*------------------------------------------------------------------------- * H5LTget_attribute_int test *------------------------------------------------------------------------- */ TESTING("H5LTget_attribute_int"); /* Get the attribute */ if ( H5LTget_attribute_int( loc_id, obj_name, ATTR4_NAME, attr_int_out ) < 0 ) return -1; for (i = 0; i < 5; i++) { if ( attr_int_in[i] != attr_int_out[i] ) { return -1; } } /* Get the attribute */ if ( H5LTget_attribute( loc_id, obj_name, ATTR4_NAME, H5T_NATIVE_INT, attr_int_out ) < 0 ) return -1; for (i = 0; i < 5; i++) { if ( attr_int_in[i] != attr_int_out[i] ) { return -1; } } PASSED(); /*------------------------------------------------------------------------- * H5LTset_attribute_long test *------------------------------------------------------------------------- */ TESTING("H5LTset_attribute_long"); /* Set the attribute */ if ( H5LTset_attribute_long( loc_id, obj_name, ATTR5_NAME, attr_long_in, (size_t)5 ) < 0 ) return -1; PASSED(); /*------------------------------------------------------------------------- * H5LTget_attribute_long test *------------------------------------------------------------------------- */ TESTING("H5LTget_attribute_long"); /* Get the attribute */ if ( H5LTget_attribute_long( loc_id, obj_name, ATTR5_NAME, attr_long_out ) < 0 ) return -1; for (i = 0; i < 5; i++) { if ( attr_long_in[i] != attr_long_out[i] ) { return -1; } } /* Get the attribute */ if ( H5LTget_attribute( loc_id, obj_name, ATTR5_NAME, H5T_NATIVE_LONG, attr_long_out ) < 0 ) return -1; for (i = 0; i < 5; i++) { if ( attr_long_in[i] != attr_long_out[i] ) { return -1; } } PASSED(); /*------------------------------------------------------------------------- * H5LTset_attribute_uchar test *------------------------------------------------------------------------- */ TESTING("H5LTset_attribute_uchar"); /* Set the attribute */ if ( H5LTset_attribute_uchar( loc_id, obj_name, ATTR6_NAME, attr_uchar_in, (size_t)5 ) < 0 ) return -1; PASSED(); /*------------------------------------------------------------------------- * H5LTget_attribute_uchar test *------------------------------------------------------------------------- */ TESTING("H5LTget_attribute_uchar"); /* Get the attribute */ if ( H5LTget_attribute_uchar( loc_id, obj_name, ATTR6_NAME, attr_uchar_out ) < 0 ) return -1; for (i = 0; i < 5; i++) { if ( attr_uchar_in[i] != attr_uchar_out[i] ) { return -1; } } /* Get the attribute */ if ( H5LTget_attribute( loc_id, obj_name, ATTR6_NAME, H5T_NATIVE_UCHAR, attr_uchar_out ) < 0 ) return -1; for (i = 0; i < 5; i++) { if ( attr_uchar_in[i] != attr_uchar_out[i] ) { return -1; } } PASSED(); /*------------------------------------------------------------------------- * H5LTset_attribute_ushort test *------------------------------------------------------------------------- */ TESTING("H5LTset_attribute_ushort"); /* Set the attribute */ if ( H5LTset_attribute_ushort( loc_id, obj_name, ATTR7_NAME, attr_ushort_in, (size_t)5 ) < 0 ) return -1; PASSED(); /*------------------------------------------------------------------------- * H5LTget_attribute_ushort test *------------------------------------------------------------------------- */ TESTING("H5LTget_attribute_ushort"); /* Get the attribute */ if ( H5LTget_attribute_ushort( loc_id, obj_name, ATTR7_NAME, attr_ushort_out ) < 0 ) return -1; for (i = 0; i < 5; i++) { if ( attr_ushort_in[i] != attr_ushort_out[i] ) { return -1; } } /* Get the attribute */ if ( H5LTget_attribute( loc_id, obj_name, ATTR7_NAME, H5T_NATIVE_USHORT, attr_ushort_out ) < 0 ) return -1; for (i = 0; i < 5; i++) { if ( attr_ushort_in[i] != attr_ushort_out[i] ) { return -1; } } PASSED(); /*------------------------------------------------------------------------- * H5LTset_attribute_int test *------------------------------------------------------------------------- */ TESTING("H5LTset_attribute_uint"); /* Set the attribute */ if ( H5LTset_attribute_uint( loc_id, obj_name, ATTR8_NAME, attr_uint_in, (size_t)5 ) < 0 ) return -1; PASSED(); /*------------------------------------------------------------------------- * H5LTget_attribute_int test *------------------------------------------------------------------------- */ TESTING("H5LTget_attribute_uint"); /* Get the attribute */ if ( H5LTget_attribute_uint( loc_id, obj_name, ATTR8_NAME, attr_uint_out ) < 0 ) return -1; for (i = 0; i < 5; i++) { if ( attr_uint_in[i] != attr_uint_out[i] ) { return -1; } } /* Get the attribute */ if ( H5LTget_attribute( loc_id, obj_name, ATTR8_NAME, H5T_NATIVE_UINT, attr_uint_out ) < 0 ) return -1; for (i = 0; i < 5; i++) { if ( attr_uint_in[i] != attr_uint_out[i] ) { return -1; } } PASSED(); /*------------------------------------------------------------------------- * H5LTset_attribute_ulong test *------------------------------------------------------------------------- */ TESTING("H5LTset_attribute_ulong"); /* Set the attribute */ if ( H5LTset_attribute_ulong( loc_id, obj_name, ATTR9_NAME, attr_ulong_in, (size_t)5 ) < 0 ) return -1; PASSED(); /*------------------------------------------------------------------------- * H5LTget_attribute_long test *------------------------------------------------------------------------- */ TESTING("H5LTget_attribute_ulong"); /* Get the attribute */ if ( H5LTget_attribute_ulong( loc_id, obj_name, ATTR9_NAME, attr_ulong_out ) < 0 ) return -1; for (i = 0; i < 5; i++) { if ( attr_ulong_in[i] != attr_ulong_out[i] ) { return -1; } } /* Get the attribute */ if ( H5LTget_attribute( loc_id, obj_name, ATTR9_NAME, H5T_NATIVE_ULONG, attr_ulong_out ) < 0 ) return -1; for (i = 0; i < 5; i++) { if ( attr_ulong_in[i] != attr_ulong_out[i] ) { return -1; } } PASSED(); /*------------------------------------------------------------------------- * H5LTset_attribute_float test *------------------------------------------------------------------------- */ TESTING("H5LTset_attribute_float"); /* Set the attribute */ if ( H5LTset_attribute_float( loc_id, obj_name, ATTR10_NAME, attr_float_in, (size_t)5 ) < 0 ) return -1; PASSED(); /*------------------------------------------------------------------------- * H5LTget_attribute_float test *------------------------------------------------------------------------- */ TESTING("H5LTget_attribute_float"); /* Get the attribute */ if ( H5LTget_attribute_float( loc_id, obj_name, ATTR10_NAME, attr_float_out ) < 0 ) return -1; for (i = 0; i < 5; i++) { if ( attr_float_in[i] != attr_float_out[i] ) { return -1; } } /* Get the attribute */ if ( H5LTget_attribute( loc_id, obj_name, ATTR10_NAME, H5T_NATIVE_FLOAT, attr_float_out ) < 0 ) return -1; for (i = 0; i < 5; i++) { if ( attr_float_in[i] != attr_float_out[i] ) { return -1; } } PASSED(); /*------------------------------------------------------------------------- * H5LTset_attribute_double test *------------------------------------------------------------------------- */ TESTING("H5LTset_attribute_double"); /* Set the attribute */ if ( H5LTset_attribute_double( loc_id, obj_name, ATTR11_NAME, attr_double_in, (size_t)5 ) < 0 ) return -1; PASSED(); /*------------------------------------------------------------------------- * H5LTget_attribute_double test *------------------------------------------------------------------------- */ TESTING("H5LTget_attribute_double"); /* Get the attribute */ if ( H5LTget_attribute_double( loc_id, obj_name, ATTR11_NAME, attr_double_out ) < 0 ) return -1; for (i = 0; i < 5; i++) { if ( attr_double_in[i] != attr_double_out[i] ) { return -1; } } /* Get the attribute */ if ( H5LTget_attribute( loc_id, obj_name, ATTR11_NAME, H5T_NATIVE_DOUBLE, attr_double_out ) < 0 ) return -1; for (i = 0; i < 5; i++) { if ( attr_double_in[i] != attr_double_out[i] ) { return -1; } } PASSED(); /*------------------------------------------------------------------------- * H5LTget_attribute_ndims test *------------------------------------------------------------------------- */ TESTING("H5LTget_attribute_ndims"); if ( H5LTget_attribute_ndims( loc_id, obj_name, ATTR2_NAME, &rank_out ) < 0 ) return -1; if ( rank_out != 1 ) { return -1; } PASSED(); /*------------------------------------------------------------------------- * H5LTget_attribute_info test *------------------------------------------------------------------------- */ TESTING("H5LTget_attribute_info"); dims_out = (hsize_t*) malloc( sizeof(hsize_t) * rank_out ); if ( H5LTget_attribute_info( loc_id, obj_name, ATTR2_NAME, dims_out, &type_class, &type_size) < 0 ) return -1; for (i = 0; i < rank_out; i++) { if ( dims_out[i] != 5 ) { return -1; } } if ( type_class != H5T_INTEGER ) { return -1; } if ( dims_out ) free( dims_out ); PASSED(); return 0; }
/*main mcmc loop, records sampled values, performs no tuning of the step size.*/ int /*always returns success*/ mcmc_foreach(int rank, /*MPI rank*/ int R, /*MPI Comm size*/ size_t SampleSize, /*number of iterations of MCMC*/ ode_model_parameters *omp, /*ODE problem cpecification and pre-allocated space*/ mcmc_kernel *kernel, /* MCMC kernel sturct, holds MCMC-algorithm's parameters*/ hdf5block_t *h5block, /*defines the hdf5 file to write into, holds ids and sizes*/ void *buffer, /* for MPI communication, similar to kernel*/ main_options *option)/*options from defaults, files and command line*/{ clock_t ct=clock(); gsl_matrix *log_para_chunk; gsl_vector *log_post_chunk; int D=get_number_of_MCMC_variables(omp); log_para_chunk=gsl_matrix_alloc(CHUNK,D); log_post_chunk=gsl_vector_alloc(CHUNK); gsl_vector_view current; gsl_vector_view x_state; int swaps = 0; // swap success counter int acc=no; // acceptance flag int acc_c=0; // acceptance counter double acc_rate=0.0; size_t it; int master=no; int DEST; double beta=mcmc_get_beta(kernel); herr_t status; int resume_EC; int last_chunk=no, not_written_yet=yes; for (it = 0; it < SampleSize; it++) { mcmc_sample(kernel, &acc); last_chunk=SampleSize-it<CHUNK; if (acc && last_chunk && not_written_yet){ resume_EC=write_resume_state(option->resume_file, rank, R, kernel); if (resume_EC==EXIT_SUCCESS){ not_written_yet=no; } } acc_c += acc; master=(it%2==rank%2); if (master){ DEST=(rank+1)%R; // this process is the master process for swap decisions } else { DEST=(R+rank-1)%R; // this process has to accept swap decisions from DEST } //their_beta=BETA(DEST,R); // the other proc's if (R>1){ mcmc_exchange_information(kernel,DEST,buffer); swaps+=mcmc_swap_chains(kernel,master,rank,DEST,buffer); } /* save sampled point for writing */ current=gsl_matrix_row(log_para_chunk,it%CHUNK); x_state=gsl_vector_view_array(kernel->x,D); gsl_vector_memcpy(&(current.vector),&(x_state.vector)); gsl_vector_set(log_post_chunk,it%CHUNK,kernel->fx[0]); /* print sample log and statistics every 100 samples */ if ( ((it + 1) % CHUNK) == 0 ) { acc_rate = ((double) acc_c) / ((double) CHUNK); fprintf(stdout, "# [rank % 2i/% 2i; β=%5f; %3li%% done] (it %5li)\tacc. rate: %3.2f;\t%3i %% swap success\t",rank,R,beta,(100*it)/SampleSize,it,acc_rate,swaps); mcmc_print_stats(kernel, stdout); acc_c = 0; // print chunk to hdf5 file status=h5write_current_chunk(h5block,log_para_chunk,log_post_chunk); h5block->offset[0]=it+1; swaps=0; } } assert(status==0); // write remaining data to the output hdf5 file int Rest=SampleSize % CHUNK; printf("[main] last iteration done %i points remain to write.\n",Rest); if (Rest > 0){ h5block->chunk_size[0]=Rest; h5block->chunk_size[1]=D; h5block->para_chunk_id=H5Screate_simple(2, h5block->chunk_size, NULL); h5block->chunk_size[0]=Rest; h5block->chunk_size[1]=1; h5block->post_chunk_id=H5Screate_simple(2, h5block->chunk_size, NULL); printf("[main] writing the remaining %i sampled parametrisations to file.\n",Rest); h5block->block[0]=Rest; h5block->block[1]=D; display_chunk_properties(h5block); status = H5Sselect_hyperslab(h5block->para_dataspace_id, H5S_SELECT_SET, h5block->offset, h5block->stride, h5block->count, h5block->block); H5Dwrite(h5block->parameter_set_id, H5T_NATIVE_DOUBLE, h5block->para_chunk_id, h5block->para_dataspace_id, H5P_DEFAULT, log_para_chunk->data); h5block->block[1]=1; printf("[main] writing their %i log-posterior values to file.\n",Rest); display_chunk_properties(h5block); status &= H5Sselect_hyperslab(h5block->post_dataspace_id, H5S_SELECT_SET, h5block->offset, h5block->stride, h5block->count, h5block->block); H5Dwrite(h5block->posterior_set_id, H5T_NATIVE_DOUBLE, h5block->post_chunk_id, h5block->post_dataspace_id, H5P_DEFAULT, log_post_chunk->data); assert(status>=0); } // annotate written sample with all necessary information //printf("[main] writing some annotation about the sampled points as hdf5 attributes.\n"); status&=H5LTset_attribute_int(h5block->file_id, "LogParameters", "MPI_RANK", &rank, 1); status&=H5LTset_attribute_ulong(h5block->file_id, "LogParameters", "SampleSize", &SampleSize, 1); status&=H5LTset_attribute_double(h5block->file_id, "LogParameters", "InverseTemperature_Beta", &beta, 1); ct=clock()-ct; double sampling_time=((double) ct)/((double) CLOCKS_PER_SEC); int ts=round(sampling_time); int hms[3]; // hours, minutes, seconds hms[0]=ts/3600; hms[1]=(ts%3600)/60; hms[2]=(ts%60); printf("# computation time spend sampling: %i:%i:%i\n",hms[0],hms[1],hms[2]); h5block->size[0]=1; status&=H5LTmake_dataset_double (h5block->file_id, "SamplingTime_s", 1, h5block->size, &sampling_time); h5block->size[0]=3; status&=H5LTmake_dataset_int(h5block->file_id, "SamplingTime_hms", 1, h5block->size, hms); if(status){ printf("[rank %i] statistics written to file.\n",rank); } return EXIT_SUCCESS; }
/*+++++++++++++++++++++++++ Main Program or Function +++++++++++++++*/ void SCIA_WR_H5_MPH( struct param_record param, const struct mph_envi *mph ) { register unsigned short ni = 0; hid_t mph_type[NFIELDS]; const int compress = 0; const char *mph_names[NFIELDS] = { "product_name", "proc_stage", "ref_doc", "acquisition_station", "proc_center", "proc_time", "software_version", "sensing_start", "sensing_stop", "phase", "cycle", "rel_orbit", "abs_orbit", "state_vector_time", "delta_ut1", "x_position", "y_position", "z_position", "x_velocity", "y_velocity", "z_velocity", "vector_source", "utc_sbt_time", "sat_binary_time", "clock_step", "leap_utc", "leap_sign", "leap_err", "product_err", "tot_size", "sph_size", "num_dsd", "dsd_size", "num_data_sets" }; /* * define user-defined data types of the Table-fields */ mph_type[0] = H5Tcopy( H5T_C_S1 ); (void) H5Tset_size( mph_type[0], (size_t) ENVI_FILENAME_SIZE ); mph_type[1] = H5Tcopy( H5T_C_S1 ); (void) H5Tset_size( mph_type[1], (size_t) 2 ); mph_type[2] = H5Tcopy( H5T_C_S1 ); (void) H5Tset_size( mph_type[2], (size_t) 24 ); mph_type[3] = H5Tcopy( H5T_C_S1 ); (void) H5Tset_size( mph_type[3], (size_t) 21 ); mph_type[4] = H5Tcopy( H5T_C_S1 ); (void) H5Tset_size( mph_type[4], (size_t) 7 ); mph_type[5] = H5Tcopy( H5T_C_S1 ); (void) H5Tset_size( mph_type[5], (size_t) UTC_STRING_LENGTH ); mph_type[6] = H5Tcopy( H5T_C_S1 ); (void) H5Tset_size( mph_type[6], (size_t) 15 ); mph_type[7] = H5Tcopy( H5T_C_S1 ); (void) H5Tset_size( mph_type[7], (size_t) UTC_STRING_LENGTH ); mph_type[8] = H5Tcopy( H5T_C_S1 ); (void) H5Tset_size( mph_type[8], (size_t) UTC_STRING_LENGTH ); mph_type[9] = H5Tcopy( H5T_C_S1 ); (void) H5Tset_size( mph_type[9], (size_t) 2 ); mph_type[10] = H5Tcopy( H5T_NATIVE_SHORT ); mph_type[11] = H5Tcopy( H5T_NATIVE_INT ); mph_type[12] = H5Tcopy( H5T_NATIVE_INT ); mph_type[13] = H5Tcopy( H5T_C_S1 ); (void) H5Tset_size( mph_type[13], (size_t) UTC_STRING_LENGTH ); mph_type[14] = H5Tcopy( H5T_NATIVE_DOUBLE ); mph_type[15] = H5Tcopy( H5T_NATIVE_DOUBLE ); mph_type[16] = H5Tcopy( H5T_NATIVE_DOUBLE ); mph_type[17] = H5Tcopy( H5T_NATIVE_DOUBLE ); mph_type[18] = H5Tcopy( H5T_NATIVE_DOUBLE ); mph_type[19] = H5Tcopy( H5T_NATIVE_DOUBLE ); mph_type[20] = H5Tcopy( H5T_NATIVE_DOUBLE ); mph_type[21] = H5Tcopy( H5T_C_S1 ); (void) H5Tset_size( mph_type[21], (size_t) 3 ); mph_type[22] = H5Tcopy( H5T_C_S1 ); (void) H5Tset_size( mph_type[22], (size_t) UTC_STRING_LENGTH ); mph_type[23] = H5Tcopy( H5T_NATIVE_UINT ); mph_type[24] = H5Tcopy( H5T_NATIVE_UINT ); mph_type[25] = H5Tcopy( H5T_C_S1 ); (void) H5Tset_size( mph_type[25], (size_t) UTC_STRING_LENGTH ); mph_type[26] = H5Tcopy( H5T_NATIVE_SHORT ); mph_type[27] = H5Tcopy( H5T_C_S1 ); (void) H5Tset_size( mph_type[27], (size_t) 2 ); mph_type[28] = H5Tcopy( H5T_C_S1 ); (void) H5Tset_size( mph_type[28], (size_t) 2 ); mph_type[29] = H5Tcopy( H5T_NATIVE_UINT ); mph_type[30] = H5Tcopy( H5T_NATIVE_UINT ); mph_type[31] = H5Tcopy( H5T_NATIVE_UINT ); mph_type[32] = H5Tcopy( H5T_NATIVE_UINT ); mph_type[33] = H5Tcopy( H5T_NATIVE_UINT ); /* * create table */ (void) H5TBmake_table( "Main Product Header", param.hdf_file_id, "MPH", NFIELDS, 1, mph_size, mph_names, mph_offs, mph_type, 1, NULL, compress, mph ); /* * create some attributes for quick access */ (void) H5LTset_attribute_int( param.hdf_file_id, "/", "abs_orbit", &mph->abs_orbit, 1 ); /* * close interface */ do { (void) H5Tclose( mph_type[ni] ); } while ( ++ni < NFIELDS ); }
int SpIO_FwriteModel(SpFile *sfp, SpModel model) { int status = 0; herr_t hstatus; /* Write the version of format */ if(!status) { hstatus = H5LTset_attribute_string(sfp->h5f_id, "/", "format", "SPARX format v3"); if(hstatus < 0) status = 1; } /* Write the type of coordinat system */ if(!status) { DatINode *geom = Dat_IList_IdxLookup(GEOM_TYPES, model.parms.geom); Deb_ASSERT(geom != NULL); hstatus = H5LTset_attribute_string(sfp->h5f_id, "/", "geom", geom->name); if(hstatus < 0) status = 1; } /* Write T_cmb */ if(!status) { hstatus = H5LTset_attribute_double(sfp->h5f_id, "/", "T_cmb", &model.parms.T_cmb, (size_t)1); if(hstatus < 0) status = 1; } /* Write T_in */ if(!status) { hstatus = H5LTset_attribute_double(sfp->h5f_id, "/", "T_in", &model.parms.T_in, (size_t)1); if(hstatus < 0) status = 1; } /* Write molecule name */ if(!status) { Molec *mol = model.parms.mol; hstatus = H5LTset_attribute_string(sfp->h5f_id, "/", "molec", mol ? mol->name : ""); if(hstatus < 0) status = 1; } /* Write pops-switch */ if(!status) { hstatus = H5LTset_attribute_int(sfp->h5f_id, "/", "pops", &model.parms.pops, (size_t)1); if(hstatus < 0) status = 1; } /* Write dust-switch */ if(!status) { hstatus = H5LTset_attribute_int(sfp->h5f_id, "/", "dust", &model.parms.dust, (size_t)1); if(hstatus < 0) status = 1; } /* Write polariz-switch */ if(!status) { hstatus = H5LTset_attribute_int(sfp->h5f_id, "/", "polariz", &model.parms.polariz, (size_t)1); if(hstatus < 0) status = 1; } /* Write polariz-switch */ if(!status) { hstatus = H5LTset_attribute_double(sfp->h5f_id, "/", "z", &model.parms.z, (size_t)1); if(hstatus < 0) status = 1; } /* Write grid */ if(!status) status = SpIO_H5WriteGrid(sfp->h5f_id, model.grid, &model.parms); if(status) status = Err_SETSTRING("Error writing model to file `%s'", sfp->name); return status; }
/* ------- begin -------------------------- init_aux_new.c -- --- */ void init_aux_new(void) { /* Creates the HDF5 file for the auxiliary data */ const char routineName[] = "init_aux_new"; unsigned int *tmp; double *tmp_double; int i; hid_t plist, ncid, file_dspace, ncid_atom, ncid_mol; hid_t id_x, id_y, id_z, id_n, id_tmp; hsize_t dims[4]; char group_name[ARR_STRLEN]; Atom *atom; Molecule *molecule; /* Create the file */ if (( plist = H5Pcreate(H5P_FILE_ACCESS) ) < 0) HERR(routineName); if (( H5Pset_fapl_mpio(plist, mpi.comm, mpi.info) ) < 0) HERR(routineName); if (( ncid = H5Fcreate(AUX_FILE, H5F_ACC_TRUNC, H5P_DEFAULT, plist) ) < 0) HERR(routineName); if (( H5Pclose(plist) ) < 0) HERR(routineName); /* --- Definitions for the root group --- */ /* dimensions as attributes */ if (( H5LTset_attribute_int(ncid, "/", "nx", &mpi.nx, 1) ) < 0) HERR(routineName); if (( H5LTset_attribute_int(ncid, "/", "ny", &mpi.ny, 1) ) < 0) HERR(routineName); if (( H5LTset_attribute_int(ncid, "/", "nz", (int *) &infile.nz, 1 )) < 0) HERR(routineName); /* attributes */ if (( H5LTset_attribute_string(ncid, "/", "atmosID", atmos.ID)) < 0) HERR(routineName); if (( H5LTset_attribute_string(ncid, "/", "rev_id", mpi.rev_id) ) < 0) HERR(routineName); /* Create arrays for multiple-atom/molecule output */ io.aux_atom_ncid = (hid_t *) malloc(atmos.Nactiveatom * sizeof(hid_t)); io.aux_mol_ncid = (hid_t *) malloc(atmos.Nactivemol * sizeof(hid_t)); if (input.p15d_wpop) { io.aux_atom_pop = (hid_t *) malloc(atmos.Nactiveatom * sizeof(hid_t)); io.aux_atom_poplte = (hid_t *) malloc(atmos.Nactiveatom * sizeof(hid_t)); io.aux_mol_pop = (hid_t *) malloc(atmos.Nactivemol * sizeof(hid_t)); io.aux_mol_poplte = (hid_t *) malloc(atmos.Nactivemol * sizeof(hid_t)); } if (input.p15d_wrates) { io.aux_atom_RijL = (hid_t *) malloc(atmos.Nactiveatom * sizeof(hid_t)); io.aux_atom_RjiL = (hid_t *) malloc(atmos.Nactiveatom * sizeof(hid_t)); io.aux_atom_RijC = (hid_t *) malloc(atmos.Nactiveatom * sizeof(hid_t)); io.aux_atom_RjiC = (hid_t *) malloc(atmos.Nactiveatom * sizeof(hid_t)); } /* Fill value */ if (( plist = H5Pcreate(H5P_DATASET_CREATE) ) < 0) HERR(routineName); if (( H5Pset_fill_value(plist, H5T_NATIVE_FLOAT, &FILLVALUE) ) < 0) HERR(routineName); if (( H5Pset_alloc_time(plist, H5D_ALLOC_TIME_EARLY) ) < 0) HERR(routineName); if (( H5Pset_fill_time(plist, H5D_FILL_TIME_ALLOC) ) < 0) HERR(routineName); /* --- Group loop over active ATOMS --- */ for (i=0; i < atmos.Nactiveatom; i++) { atom = atmos.activeatoms[i]; /* Get group name */ sprintf(group_name, (atom->ID[1] == ' ') ? "atom_%.1s" : "atom_%.2s", atom->ID); if (( ncid_atom = H5Gcreate(ncid, group_name, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT) ) < 0) HERR(routineName); io.aux_atom_ncid[i] = ncid_atom; /* --- dimensions as attributes --- */ if (( H5LTset_attribute_int(ncid_atom, ".", "nlevel", &atom->Nlevel, 1)) < 0) HERR(routineName); if (( H5LTset_attribute_int(ncid_atom, ".", "nline", &atom->Nline, 1)) < 0) HERR(routineName); if (( H5LTset_attribute_int(ncid_atom, ".", "ncontinuum", &atom->Ncont, 1)) < 0) HERR(routineName); /* --- dimension datasets --- */ dims[0] = mpi.nx; if (( H5LTmake_dataset(ncid_atom, X_NAME, 1, dims, H5T_NATIVE_DOUBLE, geometry.xscale) ) < 0) HERR(routineName); if (( id_x = H5Dopen2(ncid_atom, X_NAME, H5P_DEFAULT)) < 0) HERR(routineName); dims[0] = mpi.ny; if (( H5LTmake_dataset(ncid_atom, Y_NAME, 1, dims, H5T_NATIVE_DOUBLE, geometry.yscale) ) < 0) HERR(routineName); if (( id_y = H5Dopen2(ncid_atom, Y_NAME, H5P_DEFAULT)) < 0) HERR(routineName); dims[0] = infile.nz; tmp_double = (double *) calloc(infile.nz , sizeof(double)); if (( H5LTmake_dataset(ncid_atom, ZOUT_NAME, 1, dims, H5T_NATIVE_DOUBLE, tmp_double) ) < 0) HERR(routineName); free(tmp_double); if (( id_z = H5Dopen2(ncid_atom, ZOUT_NAME, H5P_DEFAULT)) < 0) HERR(routineName); dims[0] = atom->Nlevel; tmp = (unsigned int *) calloc(atom->Nlevel , sizeof(unsigned int)); if (( H5LTmake_dataset(ncid_atom, LEVEL_NAME, 1, dims, H5T_NATIVE_UINT, tmp) ) < 0) HERR(routineName); free(tmp); dims[0] = atom->Nline; tmp = (unsigned int *) calloc(atom->Nline , sizeof(unsigned int)); if (( H5LTmake_dataset(ncid_atom, LINE_NAME, 1, dims, H5T_NATIVE_UINT, tmp) ) < 0) HERR(routineName); free(tmp); if (atom->Ncont > 0) { dims[0] = atom->Ncont; tmp = (unsigned int *) calloc(atom->Ncont , sizeof(unsigned int)); if (( H5LTmake_dataset(ncid_atom, CONT_NAME, 1, dims, H5T_NATIVE_UINT, tmp) ) < 0) HERR(routineName); free(tmp); } /* For compatibility with netCDF readers, only use dataset as dimension */ if (( H5LTset_attribute_string(ncid_atom, ZOUT_NAME, "NAME", NETCDF_COMPAT) ) < 0) HERR(routineName); if (( H5LTset_attribute_string(ncid_atom, LEVEL_NAME, "NAME", NETCDF_COMPAT) ) < 0) HERR(routineName); if (( H5LTset_attribute_string(ncid_atom, LINE_NAME, "NAME", NETCDF_COMPAT) ) < 0) HERR(routineName); if (atom->Ncont > 0) { if (( H5LTset_attribute_string(ncid_atom, CONT_NAME, "NAME", NETCDF_COMPAT) ) < 0) HERR(routineName); } /* --- variables --- */ dims[0] = atom->Nlevel; dims[1] = mpi.nx; dims[2] = mpi.ny; dims[3] = infile.nz; /* Populations */ if (input.p15d_wpop) { if (( file_dspace = H5Screate_simple(4, dims, NULL) ) < 0) HERR(routineName); if (( id_n = H5Dopen2(ncid_atom, LEVEL_NAME, H5P_DEFAULT)) < 0) HERR(routineName); if (atom->n != NULL) { if (( id_tmp = H5Dcreate(ncid_atom, POP_NAME, H5T_NATIVE_FLOAT, file_dspace, H5P_DEFAULT, plist, H5P_DEFAULT)) < 0) HERR(routineName); if (( H5DSattach_scale(id_tmp, id_n, 0)) < 0) HERR(routineName); if (( H5DSattach_scale(id_tmp, id_x, 1)) < 0) HERR(routineName); if (( H5DSattach_scale(id_tmp, id_y, 2)) < 0) HERR(routineName); if (( H5DSattach_scale(id_tmp, id_z, 3)) < 0) HERR(routineName); if (( H5LTset_attribute_float(ncid_atom, POP_NAME, "_FillValue", &FILLVALUE, 1) ) < 0) HERR(routineName); io.aux_atom_pop[i] = id_tmp; } if (atom->nstar != NULL) { if (( id_tmp = H5Dcreate(ncid_atom, POPLTE_NAME, H5T_NATIVE_FLOAT, file_dspace, H5P_DEFAULT, plist, H5P_DEFAULT)) < 0) HERR(routineName); if (( H5DSattach_scale(id_tmp, id_n, 0)) < 0) HERR(routineName); if (( H5DSattach_scale(id_tmp, id_x, 1)) < 0) HERR(routineName); if (( H5DSattach_scale(id_tmp, id_y, 2)) < 0) HERR(routineName); if (( H5DSattach_scale(id_tmp, id_z, 3)) < 0) HERR(routineName); if (( H5LTset_attribute_float(ncid_atom, POPLTE_NAME, "_FillValue", &FILLVALUE, 1) ) < 0) HERR(routineName); io.aux_atom_poplte[i] = id_tmp; } if (( H5Dclose(id_n) ) < 0) HERR(routineName); if (( H5Sclose(file_dspace) ) < 0) HERR(routineName); } if (input.p15d_wrates) { /* Radiative rates */ dims[0] = atom->Nline; dims[1] = mpi.nx; dims[2] = mpi.ny; dims[3] = infile.nz; if (( file_dspace = H5Screate_simple(4, dims, NULL) ) < 0) HERR(routineName); if (( id_n = H5Dopen2(ncid_atom, LINE_NAME, H5P_DEFAULT)) < 0) HERR(routineName); if (( id_tmp = H5Dcreate(ncid_atom, RIJ_L_NAME, H5T_NATIVE_FLOAT, file_dspace, H5P_DEFAULT, plist, H5P_DEFAULT)) < 0) HERR(routineName); if (( H5DSattach_scale(id_tmp, id_n, 0)) < 0) HERR(routineName); if (( H5DSattach_scale(id_tmp, id_x, 1)) < 0) HERR(routineName); if (( H5DSattach_scale(id_tmp, id_y, 2)) < 0) HERR(routineName); if (( H5DSattach_scale(id_tmp, id_z, 3)) < 0) HERR(routineName); if (( H5LTset_attribute_float(ncid_atom, RIJ_L_NAME, "_FillValue", &FILLVALUE, 1) ) < 0) HERR(routineName); io.aux_atom_RijL[i] = id_tmp; if (( id_tmp = H5Dcreate(ncid_atom, RJI_L_NAME, H5T_NATIVE_FLOAT, file_dspace, H5P_DEFAULT, plist, H5P_DEFAULT)) < 0) HERR(routineName); if (( H5DSattach_scale(id_tmp, id_n, 0)) < 0) HERR(routineName); if (( H5DSattach_scale(id_tmp, id_x, 1)) < 0) HERR(routineName); if (( H5DSattach_scale(id_tmp, id_y, 2)) < 0) HERR(routineName); if (( H5DSattach_scale(id_tmp, id_z, 3)) < 0) HERR(routineName); if (( H5LTset_attribute_float(ncid_atom, RJI_L_NAME, "_FillValue", &FILLVALUE, 1) ) < 0) HERR(routineName); io.aux_atom_RjiL[i] = id_tmp; if (( H5Dclose(id_n) ) < 0) HERR(routineName); if (( H5Sclose(file_dspace) ) < 0) HERR(routineName); if (atom->Ncont > 0) { dims[0] = atom->Ncont; if (( file_dspace = H5Screate_simple(4, dims, NULL) ) < 0) HERR(routineName); if (( id_n = H5Dopen2(ncid_atom, CONT_NAME, H5P_DEFAULT)) < 0) HERR(routineName); if (( id_tmp = H5Dcreate(ncid_atom, RIJ_C_NAME, H5T_NATIVE_FLOAT, file_dspace, H5P_DEFAULT, plist, H5P_DEFAULT)) < 0) HERR(routineName); if (( H5DSattach_scale(id_tmp, id_n, 0)) < 0) HERR(routineName); if (( H5DSattach_scale(id_tmp, id_x, 1)) < 0) HERR(routineName); if (( H5DSattach_scale(id_tmp, id_y, 2)) < 0) HERR(routineName); if (( H5DSattach_scale(id_tmp, id_z, 3)) < 0) HERR(routineName); if (( H5LTset_attribute_float(ncid_atom, RIJ_C_NAME, "_FillValue", &FILLVALUE, 1) ) < 0) HERR(routineName); io.aux_atom_RijC[i] = id_tmp; if (( id_tmp = H5Dcreate(ncid_atom, RJI_C_NAME, H5T_NATIVE_FLOAT, file_dspace, H5P_DEFAULT, plist, H5P_DEFAULT)) < 0) HERR(routineName); if (( H5DSattach_scale(id_tmp, id_n, 0)) < 0) HERR(routineName); if (( H5DSattach_scale(id_tmp, id_x, 1)) < 0) HERR(routineName); if (( H5DSattach_scale(id_tmp, id_y, 2)) < 0) HERR(routineName); if (( H5DSattach_scale(id_tmp, id_z, 3)) < 0) HERR(routineName); if (( H5LTset_attribute_float(ncid_atom, RJI_C_NAME, "_FillValue", &FILLVALUE, 1) ) < 0) HERR(routineName); io.aux_atom_RjiC[i] = id_tmp; if (( H5Dclose(id_n) ) < 0) HERR(routineName); if (( H5Sclose(file_dspace) ) < 0) HERR(routineName); } } if (( H5Dclose(id_x) ) < 0) HERR(routineName); if (( H5Dclose(id_y) ) < 0) HERR(routineName); if (( H5Dclose(id_z) ) < 0) HERR(routineName); } /* end active ATOMS loop */ /* --- Group loop over active MOLECULES --- */ for (i=0; i < atmos.Nactivemol; i++) { molecule = atmos.activemols[i]; /* Get group name */ sprintf( group_name, "molecule_%s", molecule->ID); if (( ncid_mol = H5Gcreate(ncid, group_name, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT) ) < 0) HERR(routineName); io.aux_mol_ncid[i] = ncid_mol; /* --- dimensions as attributes --- */ if (( H5LTset_attribute_int(ncid_mol, ".", "nlevel_vibr", &molecule->Nv, 1)) < 0) HERR(routineName); if (( H5LTset_attribute_int(ncid_mol, ".", "nline_molecule", &molecule->Nrt, 1)) < 0) HERR(routineName); if (( H5LTset_attribute_int(ncid_mol, ".", "nJ", &molecule->NJ, 1)) < 0) HERR(routineName); /* --- dimension datasets --- */ dims[0] = mpi.nx; if (( H5LTmake_dataset(ncid_mol, X_NAME, 1, dims, H5T_NATIVE_DOUBLE, geometry.xscale) ) < 0) HERR(routineName); if (( id_x = H5Dopen2(ncid_mol, X_NAME, H5P_DEFAULT)) < 0) HERR(routineName); dims[0] = mpi.ny; if (( H5LTmake_dataset(ncid_mol, Y_NAME, 1, dims, H5T_NATIVE_DOUBLE, geometry.yscale) ) < 0) HERR(routineName); if (( id_y = H5Dopen2(ncid_mol, Y_NAME, H5P_DEFAULT)) < 0) HERR(routineName); dims[0] = infile.nz; tmp_double = (double *) calloc(infile.nz , sizeof(double)); if (( H5LTmake_dataset(ncid_mol, ZOUT_NAME, 1, dims, H5T_NATIVE_DOUBLE, tmp_double) ) < 0) HERR(routineName); free(tmp_double); if (( id_z = H5Dopen2(ncid_mol, ZOUT_NAME, H5P_DEFAULT)) < 0) HERR(routineName); dims[0] = molecule->Nv; tmp = (unsigned int *) calloc(molecule->Nv, sizeof(unsigned int)); if (( H5LTmake_dataset(ncid_mol, VLEVEL_NAME, 1, dims, H5T_NATIVE_UINT, tmp) ) < 0) HERR(routineName); free(tmp); dims[0] = molecule->Nrt; tmp = (unsigned int *) calloc(molecule->Nrt, sizeof(unsigned int)); if (( H5LTmake_dataset(ncid_mol, VLINE_NAME, 1, dims, H5T_NATIVE_UINT, tmp) ) < 0) HERR(routineName); free(tmp); dims[0] = molecule->NJ; tmp = (unsigned int *) calloc(molecule->NJ, sizeof(unsigned int)); if (( H5LTmake_dataset(ncid_mol, NJ_NAME, 1, dims, H5T_NATIVE_UINT, tmp) ) < 0) HERR(routineName); free(tmp); /* For compatibility with netCDF readers, only use dataset as dimension */ if (( H5LTset_attribute_string(ncid_mol, ZOUT_NAME, "NAME", NETCDF_COMPAT) ) < 0) HERR(routineName); if (( H5LTset_attribute_string(ncid_mol, VLEVEL_NAME, "NAME", NETCDF_COMPAT) ) < 0) HERR(routineName); if (( H5LTset_attribute_string(ncid_mol, VLINE_NAME, "NAME", NETCDF_COMPAT) ) < 0) HERR(routineName); if (( H5LTset_attribute_string(ncid_mol, NJ_NAME, "NAME", NETCDF_COMPAT) ) < 0) HERR(routineName); /* --- variables --- */ dims[0] = molecule->Nv; dims[1] = mpi.nx; dims[2] = mpi.ny; dims[3] = infile.nz; /* Populations */ if (input.p15d_wpop) { if (( file_dspace = H5Screate_simple(4, dims, NULL) ) < 0) HERR(routineName); if (( id_n = H5Dopen2(ncid_mol, VLEVEL_NAME, H5P_DEFAULT)) < 0) HERR(routineName); if (molecule->nv != NULL) { if (( id_tmp = H5Dcreate(ncid_mol, POP_NAME, H5T_NATIVE_FLOAT, file_dspace, H5P_DEFAULT, plist, H5P_DEFAULT)) < 0) HERR(routineName); if (( H5DSattach_scale(id_tmp, id_n, 0)) < 0) HERR(routineName); if (( H5DSattach_scale(id_tmp, id_x, 1)) < 0) HERR(routineName); if (( H5DSattach_scale(id_tmp, id_y, 2)) < 0) HERR(routineName); if (( H5DSattach_scale(id_tmp, id_z, 3)) < 0) HERR(routineName); io.aux_mol_pop[i] = id_tmp; } if (molecule->nvstar != NULL) { if (( id_tmp = H5Dcreate(ncid_mol, POPLTE_NAME, H5T_NATIVE_FLOAT, file_dspace, H5P_DEFAULT, plist, H5P_DEFAULT)) < 0) HERR(routineName); if (( H5DSattach_scale(id_tmp, id_n, 0)) < 0) HERR(routineName); if (( H5DSattach_scale(id_tmp, id_x, 1)) < 0) HERR(routineName); if (( H5DSattach_scale(id_tmp, id_y, 2)) < 0) HERR(routineName); if (( H5DSattach_scale(id_tmp, id_z, 3)) < 0) HERR(routineName); io.aux_mol_poplte[i] = id_tmp; } if (( H5Dclose(id_n) ) < 0) HERR(routineName); if (( H5Sclose(file_dspace) ) < 0) HERR(routineName); // TODO: molecule->Ediss, molecule->Tmin, molecule->Tmax } if (( H5Dclose(id_x) ) < 0) HERR(routineName); if (( H5Dclose(id_y) ) < 0) HERR(routineName); if (( H5Dclose(id_z) ) < 0) HERR(routineName); } /* end active MOLECULES loop */ io.aux_ncid = ncid; /* Copy stuff to the IO data struct */ if (( H5Pclose(plist) ) < 0) HERR(routineName); /* Free hdf5 resources */ /* Flush ensures file is created in case of crash */ if (( H5Fflush(ncid, H5F_SCOPE_LOCAL) ) < 0) HERR(routineName); return; }
//! Export data to HDF5 file. DO NOT include 'output/' in string 'file'. void Surface::ExportHDF(const char* file, double xmin, double xmax, int Nx, double ymin, double ymax, int Ny, Interpolator* intpl) { char fname[strlen(file)+11]; strcpy(fname, "output/"); // Automatically export to directory 'output/' strcat(fname, file); // Allocate memory for output data double *x; x = new double[Nx]; double *y; y = new double[Ny]; double *data; data = new double[Ny*Nx]; // Generate output data double stepx = (xmax-xmin)/Nx; double stepy = (ymax-ymin)/Ny; herr_t status; for( int i = 0; i < Nx; i++) { x[i] = xmin + stepx * i; } for( int j = 0; j < Ny; j++) { y[j] = ymin + stepy * j; for( int i = 0; i < Nx; i++) { // The indexing is meant for consistency with python, VisIt, etc. data[i + j*Nx] = (*this)(x[i], y[j], intpl); } } // Create file and save data hid_t file_id; hsize_t dims[Dim2]; dims[0] = Ny; dims[1] = Nx; hsize_t dimx[Dim1]; dimx[0] = Nx; hsize_t dimy[Dim1]; dimy[0] = Ny; file_id = H5Fcreate(fname, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT); // Number of grids saved as attributes. Coodrinates saved as 1D arrays since the mesh is rectilinear. Data saved as 2D array. status = H5LTmake_dataset_double(file_id,"/x",Dim1,dimx,x); status = H5LTmake_dataset_double(file_id,"/y",Dim1,dimy,y); status = H5LTmake_dataset_double(file_id,"/data",Dim2,dims,data); status = H5LTset_attribute_int(file_id,"/x","size of x",&Nx,1); status = H5LTset_attribute_int(file_id,"/y","size of y",&Ny,1); status = H5Fclose(file_id); // Clear up memory delete [] x; delete [] y; delete [] data; // Create XMDF file that accompanies HDF5 file so as to enable VisIt reading. strcat(fname, ".xmf"); FILE *xmf = 0; xmf = fopen(fname, "w"); fprintf(xmf, "<?xml version=\"1.0\" ?>\n"); fprintf(xmf, "<!DOCTYPE Xdmf SYSTEM \"Xdmf.dtd\" []>\n"); fprintf(xmf, "<Xdmf Version=\"2.0\">\n"); fprintf(xmf, " <Domain>\n"); fprintf(xmf, " <Grid Name=\"mesh\" GridType=\"Uniform\">\n"); fprintf(xmf, " <Topology TopologyType=\"2DRectMesh\" NumberOfElements=\"%d %d\"/>\n", Ny, Nx); fprintf(xmf, " <Geometry GeometryType=\"VXVY\">\n"); fprintf(xmf, " <DataItem Dimensions=\"%d\" NumberType=\"Float\" Precision=\"4\" Format=\"HDF\">\n", Nx); fprintf(xmf, " %s:/x\n", file); fprintf(xmf, " </DataItem>\n"); fprintf(xmf, " <DataItem Dimensions=\"%d\" NumberType=\"Float\" Precision=\"4\" Format=\"HDF\">\n", Ny); fprintf(xmf, " %s:/y\n", file); fprintf(xmf, " </DataItem>\n"); fprintf(xmf, " </Geometry>\n"); fprintf(xmf, " <Attribute Name=\"data\" AttributeType=\"Scalar\" Center=\"Node\">\n"); fprintf(xmf, " <DataItem Dimensions=\"%d %d\" NumberType=\"Float\" Precision=\"4\" Format=\"HDF\">\n", Ny, Nx); fprintf(xmf, " %s:/data\n", file); fprintf(xmf, " </DataItem>\n"); fprintf(xmf, " </Attribute>\n"); fprintf(xmf, " </Grid>\n"); fprintf(xmf, " </Domain>\n"); fprintf(xmf, "</Xdmf>\n"); fclose(xmf); }