int_f nh5tbread_field_name_c(hid_t_f *loc_id, int_f *namelen, _fcd name, int_f *namelen1, _fcd field_name, hsize_t_f *start, hsize_t_f *nrecords, size_t_f *type_size, void *buf) { int ret_value = -1; herr_t ret; char *c_name; int c_namelen; char *c_name1; int c_namelen1; hid_t c_loc_id = *loc_id; hsize_t c_start = *start; hsize_t c_nrecords = *nrecords; size_t c_type_size = *type_size; size_t c_type_sizes[1]; c_type_sizes[0] = c_type_size; /* * Convert FORTRAN name to C name */ c_namelen = *namelen; c_name = (char *)HD5f2cstring(name, c_namelen); if (c_name == NULL) return ret_value; c_namelen1 = *namelen1; c_name1 = (char *)HD5f2cstring(field_name, c_namelen1); if (c_name1 == NULL) return ret_value; /* * Call H5TBread_fields_name function. */ ret = H5TBread_fields_name(c_loc_id,c_name,c_name1,c_start,c_nrecords,c_type_size, 0,c_type_sizes,buf); if (ret < 0) return ret_value; ret_value = 0; return ret_value; }
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; };
/*+++++++++++++++++++++++++ SDMF version 2.4 ++++++++++++++++++++++++++++++*/ float SDMF_orbitPhaseDiff( int orbit ) { register hsize_t ni; char rsp_file[MAX_STRING_LENGTH]; hsize_t nfields, num_roe; hid_t file_id; int *orbitList = NULL; float orbitPhaseDiff = 0.092f; const char roe_flname[] = "ROE_EXC_all.h5"; const char roe_tblname[] = "roe_entry"; /* * open output HDF5-file */ (void) snprintf( rsp_file, MAX_STRING_LENGTH, "./%s", roe_flname ); H5E_BEGIN_TRY { file_id = H5Fopen( rsp_file, H5F_ACC_RDONLY, H5P_DEFAULT ); } H5E_END_TRY; if ( file_id < 0 ) { (void) snprintf( rsp_file, MAX_STRING_LENGTH, "%s/%s", DATA_DIR, roe_flname ); file_id = H5Fopen( rsp_file, H5F_ACC_RDONLY, H5P_DEFAULT ); if ( file_id < 0 ) NADC_GOTO_ERROR( NADC_ERR_HDF_FILE, rsp_file ); } /* * read info_h5 records */ (void) H5TBget_table_info( file_id, roe_tblname, &nfields, &num_roe ); /* * read Orbit column */ if ( num_roe == 0 ) return orbitPhaseDiff; orbitList = (int *) malloc( num_roe * sizeof( int )); if ( orbitList == NULL ) NADC_GOTO_ERROR( NADC_ERR_ALLOC, "orbitList" ); if ( H5LTread_dataset_int( file_id, "orbitList", orbitList ) < 0 ) NADC_GOTO_ERROR( NADC_ERR_HDF_RD, "orbitList" ); for ( ni = 0; ni < num_roe; ni++ ) { if ( orbitList[ni] == orbit ) break; } if ( ni < num_roe ) { double ECL_Exit, ECL_Entry, Period; const size_t field_offset = 0; const size_t dst_sizes = sizeof( double ); H5TBread_fields_name( file_id, roe_tblname, "ECL_EXIT", ni, 1, sizeof(double), &field_offset, &dst_sizes, &ECL_Exit ); H5TBread_fields_name( file_id, roe_tblname, "ECL_ENTRY", ni, 1, sizeof(double), &field_offset, &dst_sizes, &ECL_Entry ); H5TBread_fields_name( file_id, roe_tblname, "PERIOD", ni, 1, sizeof(double), &field_offset, &dst_sizes, &Period ); orbitPhaseDiff = (float) ((ECL_Entry - ECL_Exit) / Period - 0.5) / 2; } (void) H5Fclose( file_id ); done: if ( orbitList != NULL ) free( orbitList ); return orbitPhaseDiff; }