void hdf5_load_nd_dataset<float>(hid_t file_id, const char* dataset_name_, int min_dim, int max_dim, Blob<float>* blob) { hdf5_load_nd_dataset_helper(file_id, dataset_name_, min_dim, max_dim, blob); herr_t status = H5LTread_dataset_float( file_id, dataset_name_, blob->mutable_cpu_data()); CHECK_GE(status, 0) << "Failed to read float dataset " << dataset_name_; }
float hdf5_load_float<float>(hid_t loc_id, const string& dataset_name) { float val; herr_t status = H5LTread_dataset_float(loc_id, dataset_name.c_str(), &val); CHECK_GE(status, 0) << "Failed to load int dataset with name " << dataset_name; return val; }
/** * Read data from the dataset. * * @param [in] DatasetName * @param [in] DimensionSizes * @param [out] Data * @throw ios::failure */ void THDF5_File::ReadCompleteDataset (const char * DatasetName, const TDimensionSizes & DimensionSizes, float * Data){ if (GetDatasetDimensionSizes(DatasetName).GetElementCount() != DimensionSizes.GetElementCount()) { char ErrorMessage[256]; sprintf(ErrorMessage,HDF5_ERR_FMT_WrongDimensionSizes,DatasetName); throw ios::failure(ErrorMessage); } /* read dataset */ herr_t status = H5LTread_dataset_float(HDF5_FileId,DatasetName,Data); if (status < 0) { char ErrorMessage[256]; sprintf(ErrorMessage,HDF5_ERR_FMT_CouldNotReadFrom,DatasetName); throw ios::failure(ErrorMessage); } }// end of ReadDataset (float)
static void psc_fields_single_read(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); int ib[3], im[3], nr_comp; ierr = H5LTget_attribute_int(group, ".", "p", &flds->p); CE; ierr = H5LTget_attribute_int(group, ".", "ib", ib); CE; ierr = H5LTget_attribute_int(group, ".", "im", im); CE; ierr = H5LTget_attribute_int(group, ".", "nr_comp", &nr_comp); CE; for (int d = 0; d < 3; d++) { assert(ib[d] == flds->ib[d]); assert(im[d] == flds->im[d]); } assert(nr_comp == flds->nr_comp); psc_fields_setup(flds); ierr = H5LTread_dataset_float(group, "fields_single", flds->data); CE; ierr = H5Gclose(group); CE; }
void read_saghdf5(char *fname, sagobj *SnapGal, float *wlambda, long id_arr, int icount) { hid_t file_id = H5Fopen(fname, H5F_ACC_RDONLY, H5P_DEFAULT); hsize_t dims[2]; int ng,i,j,id,k; float *DiscMass, *BulgeMass; float SMass; if (file_id < 0) { printf("ERROR (read_saghdf5) : Unable to open file %s\n",fname); exit(1); } if (H5LTget_dataset_info(file_id,"/SFR",dims,NULL,NULL) < 0) { printf("ERROR (read_saghdf5): Unable to read dimensions from SFR.\n"); exit(1); } NGals = (size_t) (dims[0]*dims[1]); printf("INFO (read_saghdf5): Reading %d galaxies from file %s\n",NGals,fname); if (icount == 0) { if (H5LTread_dataset_float(file_id,"/SED/Magnitudes/lambda",wlambda) < 0) { printf("ERROR (read_saghdf5): unable to read lambda array. Exiting\n"); exit(1); } NBinSed = sizeof(wlambda)/sizeof(wlambda[0]); } Prop = (float *) malloc(NGals * sizeof(float)); // Read variables with conditions. Get ID list for galaxies satisfying conditions. for (ic = 0; ic< nconditions; ic++) { vars_in_subdirs(conditions[ic].prop,buf); if (H5LTread_dataset_float(file_id,buf,Prop) < 0) { printf("ERROR (read_saghdf5): Unable to read %s\n",Dump[k].Name); exit(1); } for (ig = 0; ig < NGals; ig++) { if (conditions[k].type == 1) { if (Prop[ig] < conditions[k].val) gflag[ig]++; } else { if (Prop[ig] > conditions[k].val) gflag[ig]++; } } // In the end, any galaxy with gflag > 0 is not recorded. } NGals = 0; for (k = 0; k< CopyDump; k++) { sprintf(location,"/%s%s",Dump[k].Dir,Dump[k].Name); if (H5LTread_dataset_float(file_id,location,Prop) < 0) { printf("ERROR (read_saghdf5): Unable to read %s\n",Dump[k].Name); exit(1); } for (i = 0;i<NGals;i++) { if (gflag[i] == 0) SnapGal[i+id_arr].Props[k] = Prop[i]; NGals++; } } // Read SED only if magnitudes are requested if (Magdump > 0) { float * sed_arr = malloc(NGals * NBinSed * sizeof(float)); if (H5LTread_dataset_float(file_id,"/SED/Magnitudes/Sed",sed_arr) < 0) { printf("ERROR (read_saghdf5): Unable to read sed.\n"); exit(1); } // float *dust_ext = malloc(NGals*NBinSed * sizeof(float)); // if (H5LTread_dataset_float(file_id,"/SED/Magnitudes/dust_ext",dust_ext) < 0) // { // printf("ERROR (read_saghdf5): Unable to read dust_ext.\n"); // exit(1); // } } // No idea if this works... it must be tested. /* k = 0; for (i = 0;i < NGals; i++) { SMass = DiscMass[i] + BulgeMass[i]; if( SMass >= Hubble_h * MinStellarMass/1.0e10) { SnapGal[id_arr+k].StellarMass = SMass; SnapGal[id_arr+k].Sed = (float *) malloc(NBinSed*sizeof(float)); for (j = 0; j<NBinSed; j++) { id = j + i*NBinSed; SnapGal[id_arr+k].Sed[j] = dust_ext[id] * sed_arr[id]; } k++; } } */ NGals = k; free(dust_ext); free(sed_arr); free(Prop); if (H5Fclose(file_id) < 0) { printf("ERROR (read_saghdf5): Error while closing file %s\n",fname); exit(1); } }
/*+++++++++++++++++++++++++ Main Program or Function +++++++++++++++*/ void SCIA_RD_IMAP_CH4( bool qflag, const char *flname, struct imap_hdr *hdr, struct imap_rec **imap_out ) { register unsigned int ni, nr; char *cpntr, ctemp[SHORT_STRING_LENGTH]; float *rbuff; double *dbuff; hid_t fid = -1; hsize_t dims[2]; struct imap_rec *rec = NULL; /* * strip path of file-name */ if ( (cpntr = strrchr( flname, '/' )) != NULL ) { (void) nadc_strlcpy( ctemp, ++cpntr, SHORT_STRING_LENGTH ); } else { (void) nadc_strlcpy( ctemp, flname, SHORT_STRING_LENGTH ); } /* * initialize IMAP header structure */ (void) nadc_strlcpy( hdr->product, ctemp, ENVI_FILENAME_SIZE ); NADC_RECEIVEDATE( flname, hdr->receive_date ); (void) strcpy( hdr->creation_date, hdr->receive_date ); (void) strcpy( hdr->l1b_product, "" ); (void) strcpy( hdr->validity_start, "" ); (void) strcpy( hdr->validity_stop, "" ); (void) nadc_strlcpy( hdr->software_version, ctemp+9, 4 ); if ( (cpntr = strrchr( ctemp, '_' )) != NULL ) { char str_magic[5], str_orbit[6]; (void) nadc_strlcpy( str_magic, cpntr+1, 5 ); while ( --cpntr > ctemp ) if ( *cpntr == '_' ) break; (void) nadc_strlcpy( str_orbit, cpntr+1, 6 ); hdr->counter[0] = (unsigned short) strtoul( str_magic, (char **) NULL, 10 ); hdr->orbit[0] = (unsigned int) strtoul( str_orbit, (char **) NULL, 10 ); } else { hdr->counter[0] = 0u; hdr->orbit[0] = 0u; } hdr->numProd = 1u; hdr->numRec = 0u; hdr->file_size = nadc_file_size( flname ); imap_out[0] = NULL; /* * open IMAP product in original HDF5 format */ H5E_BEGIN_TRY { fid = H5Fopen( flname, H5F_ACC_RDONLY, H5P_DEFAULT ); } H5E_END_TRY; if ( fid < 0 ) NADC_RETURN_ERROR( NADC_ERR_HDF_FILE, flname ); (void) H5LTget_dataset_info( fid, "/Data/Geolocation/time", dims, NULL, NULL ); if ( dims[0] == 0 ) return; hdr->numRec = (unsigned int) dims[0]; /* * allocate enough space to store all records */ rec = (struct imap_rec *) malloc( hdr->numRec * sizeof( struct imap_rec )); if ( rec == NULL ) NADC_RETURN_ERROR( NADC_ERR_ALLOC, "rec" ); if ( (dbuff = (double *) malloc( hdr->numRec * sizeof(double) )) == NULL ) NADC_RETURN_ERROR( NADC_ERR_ALLOC, "rbuff" ); (void) H5LTread_dataset_double( fid, "/Data/Geolocation/time", dbuff ); for ( ni = 0; ni < hdr->numRec; ni++ ) rec[ni].jday = dbuff[ni]; free( dbuff ); if ( (rbuff = (float *) malloc( hdr->numRec * sizeof(float) )) == NULL ) NADC_RETURN_ERROR( NADC_ERR_ALLOC, "rbuff" ); (void) H5LTread_dataset_float( fid, "/Data/Geolocation/Longitude", rbuff ); for ( ni = 0; ni < hdr->numRec; ni++ ) rec[ni].lon_center = LON_IN_RANGE( rbuff[ni] ); (void) H5LTread_dataset_float( fid, "/Data/Geolocation/Latitude", rbuff ); for ( ni = 0; ni < hdr->numRec; ni++ ) rec[ni].lat_center = rbuff[ni]; (void) H5LTread_dataset_float( fid, "/Data/FitResults/VCD_CH4", rbuff ); for ( ni = 0; ni < hdr->numRec; ni++ ) rec[ni].ch4_vcd = rbuff[ni]; (void) H5LTread_dataset_float( fid, "/Data/FitResults/VCD_CH4_ERROR", rbuff ); for ( ni = 0; ni < hdr->numRec; ni++ ) rec[ni].ch4_error = rbuff[ni]; (void) H5LTread_dataset_float( fid, "/Data/FitResults/VCD_CH4_MODEL", rbuff ); for ( ni = 0; ni < hdr->numRec; ni++ ) rec[ni].ch4_model = rbuff[ni]; (void) H5LTread_dataset_float( fid, "/Data/FitResults/xVMR_CH4", rbuff ); for ( ni = 0; ni < hdr->numRec; ni++ ) rec[ni].ch4_vmr = rbuff[ni]; (void) H5LTread_dataset_float( fid, "/Data/FitResults/VCD_CO2", rbuff ); for ( ni = 0; ni < hdr->numRec; ni++ ) rec[ni].co2_vcd = rbuff[ni]; (void) H5LTread_dataset_float( fid, "/Data/FitResults/VCD_CO2_ERROR", rbuff ); for ( ni = 0; ni < hdr->numRec; ni++ ) rec[ni].co2_error = rbuff[ni]; (void) H5LTread_dataset_float( fid, "/Data/FitResults/VCD_CO2_MODEL", rbuff ); for ( ni = 0; ni < hdr->numRec; ni++ ) rec[ni].co2_model = rbuff[ni]; /* * read auxiliary/geolocation data */ (void) H5LTread_dataset_float( fid, "/Data/Geolocation/state_id", rbuff ); for ( ni = 0; ni < hdr->numRec; ni++ ) rec[ni].meta.stateID = (unsigned char) rbuff[ni]; (void) H5LTread_dataset_float( fid, "/Data/Geolocation/IntegrationTime", rbuff ); for ( ni = 0; ni < hdr->numRec; ni++ ) { if ( rbuff[ni] == 0.12f ) rec[ni].meta.intg_time = 0.125f; else rec[ni].meta.intg_time = rbuff[ni]; } (void) H5LTread_dataset_float( fid, "/Data/Auxiliary/pixels_ch4", rbuff ); for ( ni = 0; ni < hdr->numRec; ni++ ) rec[ni].meta.pixels_ch4 = (unsigned short) rbuff[ni]; (void) H5LTread_dataset_float( fid, "/Data/Auxiliary/pixels_co2", rbuff ); for ( ni = 0; ni < hdr->numRec; ni++ ) rec[ni].meta.pixels_co2 = (unsigned short) rbuff[ni]; (void) H5LTread_dataset_float( fid, "/Data/Geolocation/AirMassFactor", rbuff ); for ( ni = 0; ni < hdr->numRec; ni++ ) rec[ni].meta.amf = rbuff[ni]; (void) H5LTread_dataset_float( fid, "/Data/Geolocation/LineOfSightZenithAngle", rbuff ); for ( ni = 0; ni < hdr->numRec; ni++ ) rec[ni].meta.lza = rbuff[ni]; (void) H5LTread_dataset_float( fid, "/Data/Geolocation/SolarZenithAngle", rbuff ); for ( ni = 0; ni < hdr->numRec; ni++ ) rec[ni].meta.sza = rbuff[ni]; (void) H5LTread_dataset_float( fid, "/Data/Geolocation/ScanRange", rbuff ); for ( ni = 0; ni < hdr->numRec; ni++ ) rec[ni].meta.scanRange = rbuff[ni]; SET_IMAP_BS_FLAG( rbuff, hdr->numRec, rec); (void) H5LTread_dataset_float( fid, "/Data/Geolocation/SurfaceElevation", rbuff ); for ( ni = 0; ni < hdr->numRec; ni++ ) rec[ni].meta.elev = rbuff[ni]; (void) H5LTread_dataset_float( fid, "/Data/Auxiliary/BU_ch4_window", rbuff ); for ( ni = 0; ni < hdr->numRec; ni++ ) rec[ni].meta.bu_ch4 = rbuff[ni]; (void) H5LTread_dataset_float( fid, "/Data/Auxiliary/residual_ch4", rbuff ); for ( ni = 0; ni < hdr->numRec; ni++ ) rec[ni].meta.resi_ch4 = rbuff[ni]; (void) H5LTread_dataset_float( fid, "/Data/Auxiliary/BU_co2_window", rbuff ); for ( ni = 0; ni < hdr->numRec; ni++ ) rec[ni].meta.bu_co2 = rbuff[ni]; (void) H5LTread_dataset_float( fid, "/Data/Auxiliary/residual_co2", rbuff ); for ( ni = 0; ni < hdr->numRec; ni++ ) rec[ni].meta.resi_co2 = rbuff[ni]; /* * read corners of the tiles */ rbuff = (float *) realloc( rbuff, NUM_CORNERS * hdr->numRec * sizeof(float) ); if ( rbuff == NULL ) NADC_RETURN_ERROR( NADC_ERR_ALLOC, "rbuff" ); (void) H5LTread_dataset_float( fid, "/Data/Geolocation/CornerLongitudes", rbuff ); for ( ni = nr = 0; ni < hdr->numRec; ni++ ) { register unsigned short nc = 0; rec[ni].lon_corner[1] = LON_IN_RANGE( rbuff[nr] ); nr++; rec[ni].lon_corner[0] = LON_IN_RANGE( rbuff[nr] ); nr++; rec[ni].lon_corner[2] = LON_IN_RANGE( rbuff[nr] ); nr++; rec[ni].lon_corner[3] = LON_IN_RANGE( rbuff[nr] ); nr++; do { if ( fabsf(rec[ni].lon_center-rec[ni].lon_corner[nc]) > 180.f ) { if ( rec[ni].lon_center > 0.f ) rec[ni].lon_corner[nc] += 360.f; else rec[ni].lon_corner[nc] -= 360.f; } } while ( ++nc < NUM_CORNERS ); } (void) H5LTread_dataset_float( fid, "/Data/Geolocation/CornerLatitudes", rbuff ); for ( ni = nr = 0; ni < hdr->numRec; ni++ ) { rec[ni].lat_corner[1] = rbuff[nr++]; rec[ni].lat_corner[0] = rbuff[nr++]; rec[ni].lat_corner[2] = rbuff[nr++]; rec[ni].lat_corner[3] = rbuff[nr++]; } free( rbuff ); /* * select IMAP records */ if ( qflag ) hdr->numRec = SELECT_IMAP_RECORDS( hdr->numRec, rec ); /* obtain validity period from data records */ if ( hdr->numRec > 0 ) { SciaJDAY2adaguc( rec->jday, hdr->validity_start ); SciaJDAY2adaguc( rec[hdr->numRec-1].jday, hdr->validity_stop ); imap_out[0] = rec; } else free( rec ); }
void bright::Reactor1G::loadlib(std::string lib) { // Loads Apporiate Libraries for Reactor and makes them into Burnup Parameters [F, pi(F), di(F), BUi(F), Tij(F)]. // HDF5 types hid_t rlib; herr_t rstat; rlib = H5Fopen (lib.c_str(), H5F_ACC_RDONLY, H5P_DEFAULT); //Recator Library // Initializes Burnup Parameters... hsize_t dimFromIso[1]; hsize_t dimToIso[1]; rstat = H5LTget_dataset_info(rlib, "/FromIso_zz", dimFromIso, NULL, NULL); rstat = H5LTget_dataset_info(rlib, "/ToIso_zz", dimToIso, NULL, NULL); #ifdef _WIN32 int * FromIso; int * ToIso; FromIso = new int [dimFromIso[0]]; ToIso = new int [dimToIso[0]]; #else int FromIso [dimFromIso[0]]; int ToIso [dimToIso[0]]; #endif rstat = H5LTread_dataset_int(rlib, "/FromIso_zz", FromIso); rstat = H5LTread_dataset_int(rlib, "/ToIso_zz", ToIso); I.clear(); I.insert(&FromIso[0], &FromIso[dimFromIso[0]]); J.clear(); J.insert(&ToIso[0], &ToIso[dimToIso[0]]); // Get Fluence Vector hsize_t dimsF[1]; // Read in number of data points rstat = H5LTget_dataset_info(rlib, "/Fluence", dimsF, NULL, NULL); int lenF = dimsF[0]; // Make temp array #ifdef _WIN32 float * tempF; tempF = new float [lenF]; #else float tempF [lenF]; #endif rstat = H5LTread_dataset_float(rlib, "/Fluence", tempF); F.assign(&tempF[0], &tempF[lenF]); // Fluence in [n/kb] for (nuc_iter i = I.begin(); i != I.end(); i++ ) { std::string iso = pyne::nucname::name(*i); // Build BUi_F_ #ifdef _WIN32 float * tempBUi; tempBUi = new float [lenF]; #else float tempBUi [lenF]; #endif rstat = H5LTread_dataset_float(rlib, ("/Burnup/" + iso).c_str(), tempBUi); BUi_F_[*i].assign(&tempBUi[0], &tempBUi[lenF]); // Build pi_F_ #ifdef _WIN32 float * temppi; temppi = new float [lenF]; #else float temppi [lenF]; #endif rstat = H5LTread_dataset_float(rlib, ("/Production/" + iso).c_str(), temppi); pi_F_[*i].assign(&temppi[0], &temppi[lenF]); pi_F_[*i][0] = pyne::solve_line(0.0, F[2], pi_F_[*i][2], F[1], pi_F_[*i][1]); // Build di_F_ #ifdef _WIN32 float * tempdi; tempdi = new float [lenF]; #else float tempdi [lenF]; #endif rstat = H5LTread_dataset_float(rlib, ("/Destruction/" + iso).c_str(), tempdi); di_F_[*i].assign(&tempdi[0], &tempdi[lenF]); di_F_[*i][0] = pyne::solve_line(0.0, F[2], di_F_[*i][2], F[1], di_F_[*i][1]); // Build Tij_F_ for (int jn = 0; jn < dimToIso[0] ; jn++) { int j = ToIso[jn]; std::string jso = pyne::nucname::name(j); #ifdef _WIN32 float * tempTij; tempTij = new float [lenF]; #else float tempTij [lenF]; #endif rstat = H5LTread_dataset_float(rlib, ("/Transmutation/" + iso + "/" + jso).c_str(), tempTij); Tij_F_[*i][j].assign(&tempTij[0], &tempTij[lenF]); }; }; rstat = H5Fclose(rlib); // Now get microscopic XS data from KAERI... // ...But only if the disadvantage factor is used. if (!use_zeta) return; // HDF5 types hid_t kdblib; // KaeriData.h5 file reference herr_t kdbstat; // File status hsize_t xs_nfields, xs_nrows; // Number of rows and fields (named columns) in XS table // open the file kdblib = H5Fopen ( (bright::BRIGHT_DATA + "/KaeriData.h5").c_str(), H5F_ACC_RDONLY, H5P_DEFAULT); // KAERI Data Library // Get Thermal Mawell Average Table & Field Data Dimensions kdbstat = H5TBget_table_info(kdblib, "/XS/ThermalMaxwellAve", &xs_nfields, &xs_nrows); // Creating an empy array of character strings is tricky, // because character strings are arrays themselves! char ** xs_field_names = new char * [xs_nfields]; for (int n = 0; n < xs_nfields; n++) xs_field_names[n] = new char [50]; #ifdef _WIN32 size_t * xs_field_sizes; size_t * xs_field_offsets; xs_field_sizes = new size_t [xs_nfields]; xs_field_offsets = new size_t [xs_nfields]; #else size_t xs_field_sizes [xs_nfields]; size_t xs_field_offsets [xs_nfields]; #endif size_t xs_type_size; kdbstat = H5TBget_field_info(kdblib, "/XS/ThermalMaxwellAve", xs_field_names, xs_field_sizes, xs_field_offsets, &xs_type_size); // Read the "isozz" column so that we can inteligently pick out our data int isozz_n = bright::find_index_char( (char *) "isozz", xs_field_names, xs_nfields); int * isozz = new int [xs_nrows]; const size_t temp_xs_field_sizes_isozz_n [1] = {xs_field_sizes[isozz_n]}; kdbstat = H5TBread_fields_name(kdblib, "/XS/ThermalMaxwellAve", xs_field_names[isozz_n], 0, xs_nrows, sizeof(int), 0, temp_xs_field_sizes_isozz_n, isozz); // Now, load the XS that we need. // NOTE: This maps metastable isotopes to their stable versions if they can't be found! int sigma_a_n = bright::find_index_char( (char *) "sigma_a", xs_field_names, xs_nfields); int sigma_s_n = bright::find_index_char( (char *) "sigma_s", xs_field_names, xs_nfields); for (std::set<int>::iterator i = bright::track_nucs.begin(); i != bright::track_nucs.end(); i++) { int iso_n = bright::find_index<int>(*i, isozz, xs_nrows); if (iso_n < 0) iso_n = bright::find_index<int>(10*((*i)/10), isozz); if (iso_n < 0) { sigma_a_therm[*i] = 0.0; sigma_s_therm[*i] = 0.0; continue; }; double * iso_sig_a = new double [1]; double * iso_sig_s = new double [1]; const size_t temp_xs_field_sizes_sigma_a_n [1] = {xs_field_sizes[sigma_a_n]}; const size_t temp_xs_field_sizes_sigma_s_n [1] = {xs_field_sizes[sigma_s_n]}; kdbstat = H5TBread_fields_name(kdblib, "/XS/ThermalMaxwellAve", xs_field_names[sigma_a_n], iso_n, 1, sizeof(double), 0, temp_xs_field_sizes_sigma_a_n, iso_sig_a); kdbstat = H5TBread_fields_name(kdblib, "/XS/ThermalMaxwellAve", xs_field_names[sigma_s_n], iso_n, 1, sizeof(double), 0, temp_xs_field_sizes_sigma_s_n, iso_sig_s); sigma_a_therm[*i] = iso_sig_a[0]; sigma_s_therm[*i] = iso_sig_s[0]; }; kdbstat = H5Fclose(kdblib); return; };
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; }
void rdiff(const char *name, hid_t f1, hid_t f2) { hid_t g1 = H5Gopen(f1, name, H5P_DEFAULT); hid_t g2 = H5Gopen(f2, name, H5P_DEFAULT); if (g1 >= 0 && g2 >= 0) { int n1 = H5Aget_num_attrs(g1); for (int i = 0; i < n1; i++) { char aname[MAXNAME]; hid_t a1 = H5Aopen_idx(g1, i); assert(H5Aget_name(a1, MAXNAME, aname) < MAXNAME); H5Aclose(a1); if (!H5LTfind_attribute(g2, aname)) { printf("Only in %s[%s%s]\n", file1, name, aname); continue; } int d1, d2; H5LTget_attribute_ndims(f1, name, aname, &d1); H5LTget_attribute_ndims(f2, name, aname, &d2); assert(d1 <= 1 && d2 <= 1); hsize_t dims1, dims2; H5T_class_t t1, t2; size_t ts1, ts2; H5LTget_attribute_info(f1, name, aname, &dims1, &t1, &ts1); H5LTget_attribute_info(f2, name, aname, &dims2, &t2, &ts2); assert(t1 == t2); assert(t1 == H5T_INTEGER || t1 == H5T_FLOAT || t1 == H5T_STRING); if (t1 == H5T_INTEGER) { assert(d1==0 || (dims1 == 1 && dims2 == 1)); assert(ts1 == 4 && ts2 == 4); int v1, v2; H5LTget_attribute_int(f1, name, aname, &v1); H5LTget_attribute_int(f2, name, aname, &v2); if (v1 != v2) { printf("%s[%s%s]=%d %s[%s%s]=%d\n", file1, name, aname, v1, file2, name, aname, v2); } } if (t1 == H5T_FLOAT) { assert(d1==0 || (dims1 == 1 && dims2 == 1)); assert(ts1 == 4 && ts2 == 4); float v1, v2; H5LTget_attribute_float(f1, name, aname, &v1); H5LTget_attribute_float(f2, name, aname, &v2); if (v1 != v2) { printf("%s[%s%s]=%g %s[%s%s]=%g\n", file1, name, aname, v1, file2, name, aname, v2); } } if (t1 == H5T_STRING) { assert(ts1 < 256 && ts2 < 256); char buf1[256]; char buf2[256]; H5LTget_attribute_string(f1, name, aname, buf1); H5LTget_attribute_string(f2, name, aname, buf2); if (strcmp(buf1, buf2)) { printf("%s[%s%s]=%s %s[%s%s]=%s\n", file1, name, aname, buf1, file2, name, aname, buf2); } } } int n2 = H5Aget_num_attrs(g2); for (int i = 0; i < n2; i++) { char aname[MAXNAME]; hid_t a2 = H5Aopen_idx(g2, i); assert(H5Aget_name(a2, MAXNAME, aname) < MAXNAME); H5Aclose(a2); if (!H5LTfind_attribute(g1, aname)) { printf("Only in %s[%s%s]\n", file2, name, aname); continue; } } hsize_t nobj; H5Gget_num_objs(g1, &nobj); for (int i = 0; i < nobj; i++) { char oname[MAXNAME]; assert(H5Gget_objname_by_idx(g1, i, oname, MAXNAME) < MAXNAME); int otype = H5Gget_objtype_by_idx(g1, i); assert(otype == H5G_DATASET); if (!H5LTfind_dataset(g2, oname)) { printf("Only in %s[%s%s]\n", file1, name, oname); continue; } hsize_t dims1[2], dims2[2]; H5T_class_t t1, t2; size_t ts1, ts2; H5LTget_dataset_info(g1, oname, dims1, &t1, &ts1); H5LTget_dataset_info(g2, oname, dims2, &t2, &ts2); if (dims1[0] != dims2[0] || dims1[1] != dims2[1]) { printf("%s[%s%s](%d,%d) != %s[%s%s](%d,%d)\n", file1, name, oname, dims1[1], dims1[0], file2, name, oname, dims2[1], dims2[0]); continue; } float *data1 = malloc(dims1[0]*dims1[1]*sizeof(float)); float *data2 = malloc(dims1[0]*dims1[1]*sizeof(float)); H5LTread_dataset_float(g1, oname, data1); H5LTread_dataset_float(g2, oname, data2); float maxdiff = 0; for (int i = dims1[0]*dims1[1]-1; i >= 0; i--) { float d = data1[i] - data2[i]; if (d < 0) d = -d; if (d > maxdiff) maxdiff = d; } printf("max |%s[%s%s] - %s[%s%s]| = %g\n", file1, name, oname, file2, name, oname, maxdiff); free(data1); free(data2); } H5Gget_num_objs(g2, &nobj); for (int i = 0; i < nobj; i++) { char oname[MAXNAME]; assert(H5Gget_objname_by_idx(g2, i, oname, MAXNAME) < MAXNAME); int otype = H5Gget_objtype_by_idx(g2, i); assert(otype == H5G_DATASET); if (!H5LTfind_dataset(g1, oname)) { printf("Only in %s[%s%s]\n", file2, name, oname); continue; } } H5Gclose(g1); H5Gclose(g2); } else if (g1 >= 0) { printf("Only in %s:%s\n", file1, name); H5Gclose(g1); } else if (g2 >= 0) { printf("Only in %s:%s\n", file2, name); H5Gclose(g2); } else { printf("Group %s does not exist in either file.\n", name); } }