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;
};
/*------------------------------------------------------------------------- * Function: h5tbget_field_info_c * * Purpose: Call H5TBget_field_info * * Return: Success: 0, Failure: -1 * * Programmer: [email protected] * * Date: October 13, 2004 * * Comments: * * Modifications: * * *------------------------------------------------------------------------- */ int_f nh5tbget_field_info_c(hid_t_f *loc_id, int_f *namelen, _fcd name, hsize_t_f *nfields, size_t_f *field_sizes, size_t_f *field_offsets, size_t_f *type_size, int_f *namelen2, /* field_names lenghts */ _fcd field_names) /* field_names */ { int ret_value = -1; herr_t ret; char *c_name; int c_namelen; hsize_t num_elem; hsize_t i; int max_len=1; hid_t c_loc_id = *loc_id; hsize_t c_nfields = *nfields; size_t *c_field_sizes; size_t *c_field_offsets; size_t c_type_size; char **c_field_names; char *tmp, *tmp_p; int c_lenmax=HLTB_MAX_FIELD_LEN; size_t length = 0; num_elem = c_nfields; for (i=0; i < num_elem; i++) { if (namelen2[i] > max_len) max_len = namelen2[i]; } /* * Convert FORTRAN name to C name */ c_namelen = *namelen; c_name = (char *)HD5f2cstring(name, c_namelen); if (c_name == NULL) return ret_value; c_field_offsets = (size_t*)malloc(sizeof(size_t) * (size_t)c_nfields); if (!c_field_offsets) return ret_value; c_field_sizes = (size_t*)malloc(sizeof(size_t) * (size_t)c_nfields); if (!c_field_sizes) return ret_value; c_field_names = malloc( sizeof(char*) * (size_t)c_nfields ); if (!c_field_names) return ret_value; for ( i = 0; i < c_nfields; i++) { c_field_names[i] = malloc( sizeof(char) * HLTB_MAX_FIELD_LEN ); } /* * Call H5TBget_field_info function. */ ret = H5TBget_field_info(c_loc_id,c_name,c_field_names,c_field_sizes,c_field_offsets, &c_type_size); /* return values*/ /* names array */ tmp = (char *)malloc(c_lenmax* (size_t) c_nfields + 1); tmp_p = tmp; memset(tmp,' ', c_lenmax* (size_t) c_nfields); tmp[c_lenmax*c_nfields] = '\0'; for (i=0; i < c_nfields; i++) { memcpy(tmp_p, c_field_names[i], strlen(c_field_names[i])); namelen2[i] = (int_f)strlen(c_field_names[i]); length = MAX(length, strlen(c_field_names[i])); tmp_p = tmp_p + c_lenmax; } HD5packFstring(tmp, _fcdtocp(field_names), (int)(c_lenmax*c_nfields)); *type_size = (size_t_f)c_type_size; for (i=0; i < num_elem; i++) { field_sizes[i] = (size_t_f)c_field_sizes[i]; field_offsets[i] = (size_t_f)c_field_offsets[i]; } /* free */ for (i=0; i < num_elem; i++) { free (c_field_names[i]); } free(c_field_names); free(tmp); free(c_field_offsets); free(c_field_sizes); if (ret < 0) return ret_value; ret_value = 0; return ret_value; }
