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);
}
}
