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