crp/OpenMC
1
0
Fork 0
mirror of https://github.com/openmc-dev/openmc.git synced 2026-07-27 21:55:41 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions 5

Got it all working, next would like to take advantage of the xtensor features to reduce lines of code

Browse source
This commit is contained in:
Adam G Nelson 2018-09-01 11:01:56 -04:00
parent 4e92988433
commit 35def7aac2
9 changed files with 200 additions and 332 deletions
Download patch file Download diff file Expand all files Collapse all files

2
include/openmc/constants.h
View file

@ -11,8 +11,6 @@
namespace openmc {
// TODO: Replace with xtensor/other library?
typedef std::vector<double> double_1dvec;
typedef std::vector<std::vector<double> > double_2dvec;
typedef std::vector<std::vector<std::vector<double> > > double_3dvec;
typedef std::vector<std::vector<std::vector<std::vector<double> > > > double_4dvec;

4
include/openmc/hdf5_interface.h
View file

@ -50,10 +50,6 @@ void
read_nd_vector(hid_t obj_id, const char* name, xt::xtensor<double, 1>& result,
bool must_have = false);
void
read_nd_vector(hid_t obj_id, const char* name, std::vector<double>& result,
bool must_have = false);
void
read_nd_vector(hid_t obj_id, const char* name, xt::xtensor<double, 2>& result,
bool must_have = false);

29
include/openmc/scattdata.h
View file

@ -33,8 +33,8 @@ class ScattData {
//! \brief Combines microscopic ScattDatas into a macroscopic one.
void
base_combine(int max_order, const std::vector<ScattData*>& those_scatts,
const double_1dvec& scalars, xt::xtensor<int, 1>& in_gmin,
base_combine(size_t max_order, const std::vector<ScattData*>& those_scatts,
const std::vector<double>& scalars, xt::xtensor<int, 1>& in_gmin,
xt::xtensor<int, 1>& in_gmax, double_2dvec& sparse_mult,
double_3dvec& sparse_scatter);
@ -85,7 +85,7 @@ class ScattData {
//! @param scalars Scalars to multiply the microscopic data by.
virtual void
combine(const std::vector<ScattData*>& those_scatts,
const double_1dvec& scalars) = 0;
const std::vector<double>& scalars) = 0;
//! \brief Getter for the dimensionality of the scattering order.
//!
@ -93,7 +93,7 @@ class ScattData {
//! of points, and for Histogram this is the number of bins.
//!
//! @return The order.
virtual int
virtual size_t
get_order() = 0;
//! \brief Builds a dense scattering matrix from the constituent parts
@ -102,7 +102,7 @@ class ScattData {
//! requested; ignored otherwise.
//! @return The dense scattering matrix.
virtual xt::xtensor<double, 3>
get_matrix(int max_order) = 0;
get_matrix(size_t max_order) = 0;
//! \brief Samples the outgoing energy from the ScattData info.
//!
@ -151,7 +151,7 @@ class ScattDataLegendre: public ScattData {
void
combine(const std::vector<ScattData*>& those_scatts,
const double_1dvec& scalars);
const std::vector<double>& scalars);
//! \brief Find the maximal value of the angular distribution to use as a
// bounding box with rejection sampling.
@ -164,11 +164,11 @@ class ScattDataLegendre: public ScattData {
void
sample(int gin, int& gout, double& mu, double& wgt);
int
size_t
get_order() {return dist[0][0].size() - 1;};
xt::xtensor<double, 3>
get_matrix(int max_order);
get_matrix(size_t max_order);
};
//==============================================================================
@ -192,7 +192,7 @@ class ScattDataHistogram: public ScattData {
void
combine(const std::vector<ScattData*>& those_scatts,
const double_1dvec& scalars);
const std::vector<double>& scalars);
double
calc_f(int gin, int gout, double mu);
@ -200,11 +200,11 @@ class ScattDataHistogram: public ScattData {
void
sample(int gin, int& gout, double& mu, double& wgt);
int
size_t
get_order() {return dist[0][0].size();};
xt::xtensor<double, 3>
get_matrix(int max_order);
get_matrix(size_t max_order);
};
//==============================================================================
@ -234,7 +234,7 @@ class ScattDataTabular: public ScattData {
void
combine(const std::vector<ScattData*>& those_scatts,
const double_1dvec& scalars);
const std::vector<double>& scalars);
double
calc_f(int gin, int gout, double mu);
@ -242,10 +242,11 @@ class ScattDataTabular: public ScattData {
void
sample(int gin, int& gout, double& mu, double& wgt);
int
size_t
get_order() {return dist[0][0].size();};
xt::xtensor<double, 3> get_matrix(int max_order);
xt::xtensor<double, 3>
get_matrix(size_t max_order);
};
//==============================================================================

10
include/openmc/xsdata.h
View file

@ -24,14 +24,14 @@ class XsData {
private:
//! \brief Reads scattering data from the HDF5 file
void
scatter_from_hdf5(hid_t xsdata_grp, int n_pol, int n_azi, int energy_groups,
scatter_from_hdf5(hid_t xsdata_grp, size_t n_ang, size_t energy_groups,
int scatter_format, int final_scatter_format, int order_data,
int max_order, int legendre_to_tabular_points);
//! \brief Reads fission data from the HDF5 file
void
fission_from_hdf5(hid_t xsdata_grp, int n_pol, int n_azi, int energy_groups,
int delayed_groups, bool is_isotropic);
fission_from_hdf5(hid_t xsdata_grp, size_t n_ang, size_t energy_groups,
size_t delayed_groups, bool is_isotropic);
public:
@ -70,7 +70,7 @@ class XsData {
//! @param scatter_format The scattering representation of the file.
//! @param n_pol Number of polar angles.
//! @param n_azi Number of azimuthal angles.
XsData(int num_groups, int num_delayed_groups, bool fissionable,
XsData(size_t num_groups, size_t num_delayed_groups, bool fissionable,
int scatter_format, int n_pol, int n_azi);
//! \brief Loads the XsData object from the HDF5 file
@ -103,7 +103,7 @@ class XsData {
//! @param micros Microscopic objects to combine.
//! @param scalars Scalars to multiply the microscopic data by.
void
combine(const std::vector<XsData*>& those_xs, const double_1dvec& scalars);
combine(const std::vector<XsData*>& those_xs, const std::vector<double>& scalars);
//! \brief Checks to see if this and that are able to be combined
//!

112
src/hdf5_interface.cpp
View file

@ -477,106 +477,6 @@ read_dataset(hid_t obj_id, const char* name, hid_t mem_type_id,
if (name) H5Dclose(dset);
}
// //*****************************************************************************
// void
// read_nd_vector(hid_t obj_id, const char* name, xt::xtensor<double, 1>& result,
// bool must_have)
// {
// if (object_exists(obj_id, name)) {
// read_double(obj_id, name, result.data(), true);
// } else if (must_have) {
// fatal_error(std::string("Must provide " + std::string(name) + "!"));
// }
// }
// void
// read_nd_vector(hid_t obj_id, const char* name, xt::xtensor<double, 2>& result,
// bool must_have)
// {
// if (object_exists(obj_id, name)) {
// xt::xarray<double> temp;
// read_double(obj_id, name, temp.data(), true);
// result = xt::adapt(temp, result.shape());
// } else if (must_have) {
// fatal_error(std::string("Must provide " + std::string(name) + "!"));
// }
// }
// void
// read_nd_vector(hid_t obj_id, const char* name, xt::xtensor<double, 3>& result,
// bool must_have)
// {
// if (object_exists(obj_id, name)) {
// xt::xarray<double> temp;
// read_double(obj_id, name, temp.data(), true);
// result = xt::adapt(temp, result.shape());
// } else if (must_have) {
// fatal_error(std::string("Must provide " + std::string(name) + "!"));
// }
// }
// void
// read_nd_vector(hid_t obj_id, const char* name, xt::xtensor<double, 4>& result,
// bool must_have)
// {
// if (object_exists(obj_id, name)) {
// xt::xarray<double> temp;
// read_double(obj_id, name, temp.data(), true);
// result = xt::adapt(temp, result.shape());
// } else if (must_have) {
// fatal_error(std::string("Must provide " + std::string(name) + "!"));
// }
// }
// void
// read_nd_vector(hid_t obj_id, const char* name, xt::xtensor<double, 5>& result,
// bool must_have)
// {
// if (object_exists(obj_id, name)) {
// xt::xarray<double> temp;
// read_double(obj_id, name, temp.data(), true);
// result = xt::adapt(temp, result.shape());
// } else if (must_have) {
// fatal_error(std::string("Must provide " + std::string(name) + "!"));
// }
// }
// void
// read_nd_vector(hid_t obj_id, const char* name, xt::xtensor<int, 2>& result,
// bool must_have)
// {
// if (object_exists(obj_id, name)) {
// xt::xarray<int> temp;
// read_int(obj_id, name, temp.data(), true);
// result = xt::adapt(temp, result.shape());
// } else if (must_have) {
// fatal_error(std::string("Must provide " + std::string(name) + "!"));
// }
// }
// void
// read_nd_vector(hid_t obj_id, const char* name, xt::xtensor<int, 3>& result,
// bool must_have)
// {
// if (object_exists(obj_id, name)) {
// xt::xarray<int> temp;
// read_int(obj_id, name, temp.data(), true);
// result = xt::adapt(temp, result.shape());
// } else if (must_have) {
// fatal_error(std::string("Must provide " + std::string(name) + "!"));
// }
// }
//*****************************************************************************
void
read_double(hid_t obj_id, const char* name, double* buffer, bool indep)
@ -635,18 +535,6 @@ read_complex(hid_t obj_id, const char* name, std::complex<double>* buffer, bool
}
void
read_nd_vector(hid_t obj_id, const char* name, std::vector<double>& result,
bool must_have)
{
if (object_exists(obj_id, name)) {
read_double(obj_id, name, result.data(), true);
} else if (must_have) {
fatal_error(std::string("Must provide " + std::string(name) + "!"));
}
}
void
read_nd_vector(hid_t obj_id, const char* name, xt::xtensor<double, 1>& result,
bool must_have)

6
src/mgxs_interface.cpp
View file

@ -19,7 +19,7 @@ add_mgxs_c(hid_t file_id, const char* name, int energy_groups,
int& method)
{
// Convert temps to a vector for the from_hdf5 function
double_1dvec temperature(temps, temps + n_temps);
std::vector<double> temperature(temps, temps + n_temps);
write_message("Loading " + std::string(name) + " data...", 6);
@ -60,10 +60,10 @@ create_macro_xs_c(const char* mat_name, int n_nuclides, const int i_nuclides[],
{
if (n_temps > 0) {
// // Convert temps to a vector
double_1dvec temperature(temps, temps + n_temps);
std::vector<double> temperature(temps, temps + n_temps);
// Convert atom_densities to a vector
double_1dvec atom_densities_vec(atom_densities,
std::vector<double> atom_densities_vec(atom_densities,
atom_densities + n_nuclides);
// Build array of pointers to nuclides_MG's Mgxs objects needed for this

78
src/scattdata.cpp
View file

@ -22,7 +22,7 @@ ScattData::base_init(int order, const xt::xtensor<int, 1>& in_gmin,
const xt::xtensor<int, 1>& in_gmax, const double_2dvec& in_energy,
const double_2dvec& in_mult)
{
int groups = in_energy.size();
size_t groups = in_energy.size();
gmin = in_gmin;
gmax = in_gmax;
@ -53,12 +53,12 @@ ScattData::base_init(int order, const xt::xtensor<int, 1>& in_gmin,
//==============================================================================
void
ScattData::base_combine(int max_order,
const std::vector<ScattData*>& those_scatts, const double_1dvec& scalars,
ScattData::base_combine(size_t max_order,
const std::vector<ScattData*>& those_scatts, const std::vector<double>& scalars,
xt::xtensor<int, 1>& in_gmin, xt::xtensor<int, 1>& in_gmax, double_2dvec& sparse_mult,
double_3dvec& sparse_scatter)
{
int groups = those_scatts[0] -> energy.size();
size_t groups = those_scatts[0] -> energy.size();
// Now allocate and zero our storage spaces
xt::xtensor<double, 3> this_matrix({groups, groups, max_order}, 0.);
@ -108,7 +108,7 @@ ScattData::base_combine(int max_order,
}
// Combine mult_numer and mult_denom into the combined multiplicity matrix
xt::xtensor<double, 2> this_mult = xt::ones<double>({groups, groups});
xt::xtensor<double, 2> this_mult({groups, groups}, 1.);
for (int gin = 0; gin < groups; gin++) {
for (int gout = 0; gout < groups; gout++) {
if (mult_denom(gin, gout) > 0.) {
@ -247,8 +247,8 @@ ScattDataLegendre::init(const xt::xtensor<int, 1>& in_gmin,
const xt::xtensor<int, 1>& in_gmax, const double_2dvec& in_mult,
const double_3dvec& coeffs)
{
int groups = coeffs.size();
int order = coeffs[0][0].size();
size_t groups = coeffs.size();
size_t order = coeffs[0][0].size();
// make a copy of coeffs that we can use to both extract data and normalize
double_3dvec matrix = coeffs;
@ -303,7 +303,7 @@ ScattDataLegendre::init(const xt::xtensor<int, 1>& in_gmin,
void
ScattDataLegendre::update_max_val()
{
int groups = max_val.size();
size_t groups = max_val.size();
// Step through the polynomial with fixed number of points to identify the
// maximal value
int Nmu = 1001;
@ -386,25 +386,25 @@ ScattDataLegendre::sample(int gin, int& gout, double& mu, double& wgt)
void
ScattDataLegendre::combine(const std::vector<ScattData*>& those_scatts,
const double_1dvec& scalars)
const std::vector<double>& scalars)
{
// Find the max order in the data set and make sure we can combine the sets
int max_order = 0;
size_t max_order = 0;
for (int i = 0; i < those_scatts.size(); i++) {
// Lets also make sure these items are combineable
ScattDataLegendre* that = dynamic_cast<ScattDataLegendre*>(those_scatts[i]);
if (!that) {
fatal_error("Cannot combine the ScattData objects!");
}
int that_order = that->get_order();
size_t that_order = that->get_order();
if (that_order > max_order) max_order = that_order;
}
max_order++; // Add one since this is a Legendre
int groups = those_scatts[0] -> energy.size();
size_t groups = those_scatts[0] -> energy.size();
xt::xtensor<int, 1> in_gmin({groups});
xt::xtensor<int, 1> in_gmax({groups});
xt::xtensor<int, 1> in_gmin({groups}, 0);
xt::xtensor<int, 1> in_gmax({groups}, 0);
double_3dvec sparse_scatter(groups);
double_2dvec sparse_mult(groups);
@ -421,11 +421,11 @@ ScattDataLegendre::combine(const std::vector<ScattData*>& those_scatts,
//==============================================================================
xt::xtensor<double, 3>
ScattDataLegendre::get_matrix(int max_order)
ScattDataLegendre::get_matrix(size_t max_order)
{
// Get the sizes and initialize the data to 0
int groups = energy.size();
int order_dim = max_order + 1;
size_t groups = energy.size();
size_t order_dim = max_order + 1;
xt::xtensor<double, 3> matrix({groups, groups, order_dim}, 0.);
for (int gin = 0; gin < groups; gin++) {
@ -449,8 +449,8 @@ ScattDataHistogram::init(const xt::xtensor<int, 1>& in_gmin,
const xt::xtensor<int, 1>& in_gmax, const double_2dvec& in_mult,
const double_3dvec& coeffs)
{
int groups = coeffs.size();
int order = coeffs[0][0].size();
size_t groups = coeffs.size();
size_t order = coeffs[0][0].size();
// make a copy of coeffs that we can use to both extract data and normalize
double_3dvec matrix = coeffs;
@ -579,13 +579,13 @@ ScattDataHistogram::sample(int gin, int& gout, double& mu, double& wgt)
//==============================================================================
xt::xtensor<double, 3>
ScattDataHistogram::get_matrix(int max_order)
ScattDataHistogram::get_matrix(size_t max_order)
{
// Get the sizes and initialize the data to 0
int groups = energy.size();
size_t groups = energy.size();
// We ignore the requested order for Histogram and Tabular representations
int order_dim = get_order();
xt::xtensor<double, 3> matrix = xt::zeros<double>({groups, groups, order_dim});
size_t order_dim = get_order();
xt::xtensor<double, 3> matrix({groups, groups, order_dim}, 0);
for (int gin = 0; gin < groups; gin++) {
for (int i_gout = 0; i_gout < energy[gin].size(); i_gout++) {
@ -603,10 +603,10 @@ ScattDataHistogram::get_matrix(int max_order)
void
ScattDataHistogram::combine(const std::vector<ScattData*>& those_scatts,
const double_1dvec& scalars)
const std::vector<double>& scalars)
{
// Find the max order in the data set and make sure we can combine the sets
int max_order = those_scatts[0]->get_order();
size_t max_order = those_scatts[0]->get_order();
for (int i = 0; i < those_scatts.size(); i++) {
// Lets also make sure these items are combineable
ScattDataHistogram* that = dynamic_cast<ScattDataHistogram*>(those_scatts[i]);
@ -618,10 +618,10 @@ ScattDataHistogram::combine(const std::vector<ScattData*>& those_scatts,
}
}
int groups = those_scatts[0] -> energy.size();
size_t groups = those_scatts[0] -> energy.size();
xt::xtensor<int, 1> in_gmin({groups});
xt::xtensor<int, 1> in_gmax({groups});
xt::xtensor<int, 1> in_gmin({groups}, 0);
xt::xtensor<int, 1> in_gmax({groups}, 0);
double_3dvec sparse_scatter(groups);
double_2dvec sparse_mult(groups);
@ -644,8 +644,8 @@ ScattDataTabular::init(const xt::xtensor<int, 1>& in_gmin,
const xt::xtensor<int, 1>& in_gmax, const double_2dvec& in_mult,
const double_3dvec& coeffs)
{
int groups = coeffs.size();
int order = coeffs[0][0].size();
size_t groups = coeffs.size();
size_t order = coeffs[0][0].size();
// make a copy of coeffs that we can use to both extract data and normalize
double_3dvec matrix = coeffs;
@ -796,12 +796,12 @@ ScattDataTabular::sample(int gin, int& gout, double& mu, double& wgt)
//==============================================================================
xt::xtensor<double, 3>
ScattDataTabular::get_matrix(int max_order)
ScattDataTabular::get_matrix(size_t max_order)
{
// Get the sizes and initialize the data to 0
int groups = energy.size();
size_t groups = energy.size();
// We ignore the requested order for Histogram and Tabular representations
int order_dim = get_order();
size_t order_dim = get_order();
xt::xtensor<double, 3> matrix({groups, groups, order_dim}, 0.);
for (int gin = 0; gin < groups; gin++) {
@ -820,10 +820,10 @@ ScattDataTabular::get_matrix(int max_order)
void
ScattDataTabular::combine(const std::vector<ScattData*>& those_scatts,
const double_1dvec& scalars)
const std::vector<double>& scalars)
{
// Find the max order in the data set and make sure we can combine the sets
int max_order = those_scatts[0]->get_order();
size_t max_order = those_scatts[0]->get_order();
for (int i = 0; i < those_scatts.size(); i++) {
// Lets also make sure these items are combineable
ScattDataTabular* that = dynamic_cast<ScattDataTabular*>(those_scatts[i]);
@ -835,10 +835,10 @@ ScattDataTabular::combine(const std::vector<ScattData*>& those_scatts,
}
}
int groups = those_scatts[0] -> energy.size();
size_t groups = those_scatts[0] -> energy.size();
xt::xtensor<int, 1> in_gmin({groups});
xt::xtensor<int, 1> in_gmax({groups});
xt::xtensor<int, 1> in_gmin({groups}, 0);
xt::xtensor<int, 1> in_gmax({groups}, 0);
double_3dvec sparse_scatter(groups);
double_2dvec sparse_mult(groups);
@ -879,7 +879,7 @@ convert_legendre_to_tabular(ScattDataLegendre& leg, ScattDataTabular& tab,
tab.dmu = 2. / (n_mu - 1);
// Calculate f(mu) and integrate it so we can avoid rejection sampling
int groups = tab.energy.size();
size_t groups = tab.energy.size();
tab.fmu.resize(groups);
for (int gin = 0; gin < groups; gin++) {
int num_groups = tab.gmax[gin] - tab.gmin[gin] + 1;

282
src/xsdata.cpp
View file

@ -5,8 +5,10 @@
#include <algorithm>
#include <numeric>
#include "xtensor/xbuilder.hpp"
#include "xtensor/xview.hpp"
#include "xtensor/xindex_view.hpp"
#include "xtensor/xmath.hpp"
#include "xtensor/xbuilder.hpp"
#include "openmc/constants.h"
#include "openmc/error.h"
@ -20,7 +22,7 @@ namespace openmc {
// XsData class methods
//==============================================================================
XsData::XsData(int energy_groups, int num_delayed_groups, bool fissionable,
XsData::XsData(size_t energy_groups, size_t num_delayed_groups, bool fissionable,
int scatter_format, int n_pol, int n_azi)
{
size_t n_ang = n_pol * n_azi;
@ -63,13 +65,10 @@ XsData::XsData(int energy_groups, int num_delayed_groups, bool fissionable,
for (int a = 0; a < n_ang; a++) {
if (scatter_format == ANGLE_HISTOGRAM) {
// scatter[a] = std::make_unique(ScattDataHistogram);
scatter.emplace_back(new ScattDataHistogram);
} else if (scatter_format == ANGLE_TABULAR) {
// scatter[a] = std::make_unique(ScattDataTabular);
scatter.emplace_back(new ScattDataTabular);
} else if (scatter_format == ANGLE_LEGENDRE) {
// scatter[a] = std::make_unique(ScattDataLegendre);
scatter.emplace_back(new ScattDataLegendre);
}
}
@ -83,13 +82,13 @@ XsData::from_hdf5(hid_t xsdata_grp, bool fissionable, int scatter_format,
int legendre_to_tabular_points, bool is_isotropic, int n_pol, int n_azi)
{
// Reconstruct the dimension information so it doesn't need to be passed
int n_ang = n_pol * n_azi;
int energy_groups = total.shape()[1];
int delayed_groups = decay_rate.shape()[1];
size_t n_ang = n_pol * n_azi;
size_t energy_groups = total.shape()[1];
size_t delayed_groups = decay_rate.shape()[1];
// Set the fissionable-specific data
if (fissionable) {
fission_from_hdf5(xsdata_grp, n_pol, n_azi, energy_groups, delayed_groups,
fission_from_hdf5(xsdata_grp, n_ang, energy_groups, delayed_groups,
is_isotropic);
}
// Get the non-fission-specific data
@ -98,43 +97,34 @@ XsData::from_hdf5(hid_t xsdata_grp, bool fissionable, int scatter_format,
read_nd_vector(xsdata_grp, "inverse-velocity", inverse_velocity);
// Get scattering data
scatter_from_hdf5(xsdata_grp, n_pol, n_azi, energy_groups, scatter_format,
scatter_from_hdf5(xsdata_grp, n_ang, energy_groups, scatter_format,
final_scatter_format, order_data, max_order, legendre_to_tabular_points);
// Check absorption to ensure it is not 0 since it is often the
// denominator in tally methods
for (int a = 0; a < n_ang; a++) {
for (int gin = 0; gin < energy_groups; gin++) {
if (absorption(a, gin) == 0.) absorption(a, gin) = 1.e-10;
}
}
xt::filtration(absorption, xt::equal(absorption, 0.)) = 1.e-10;
// Get or calculate the total x/s
if (object_exists(xsdata_grp, "total")) {
read_nd_vector(xsdata_grp, "total", total);
} else {
for (int a = 0; a < n_ang; a++) {
for (int gin = 0; gin < energy_groups; gin++) {
for (size_t a = 0; a < n_ang; a++) {
for (size_t gin = 0; gin < energy_groups; gin++) {
total(a, gin) = absorption(a, gin) + scatter[a]->scattxs[gin];
}
}
}
// Fix if total is 0, since it is in the denominator when tallying
for (int a = 0; a < n_ang; a++) {
for (int gin = 0; gin < energy_groups; gin++) {
if (total(a, gin) == 0.) total(a, gin) = 1.e-10;
}
}
xt::filtration(total, xt::equal(total, 0.)) = 1.e-10;
}
//==============================================================================
void
XsData::fission_from_hdf5(hid_t xsdata_grp, int n_pol, int n_azi,
int energy_groups, int delayed_groups, bool is_isotropic)
XsData::fission_from_hdf5(hid_t xsdata_grp, size_t n_ang, size_t energy_groups,
size_t delayed_groups, bool is_isotropic)
{
size_t n_ang = n_pol * n_azi;
// Get the fission and kappa_fission data xs; these are optional
read_nd_vector(xsdata_grp, "fission", fission);
read_nd_vector(xsdata_grp, "kappa-fission", kappa_fission);
@ -143,23 +133,23 @@ XsData::fission_from_hdf5(hid_t xsdata_grp, int n_pol, int n_azi,
xt::xtensor<double, 3> temp_beta({n_ang, energy_groups, delayed_groups}, 0.);
if (object_exists(xsdata_grp, "beta")) {
hid_t xsdata = open_dataset(xsdata_grp, "beta");
int ndims = dataset_ndims(xsdata);
size_t ndims = dataset_ndims(xsdata);
// raise ndims to make the isotropic ndims the same as angular
if (is_isotropic) ndims += 2;
if (ndims == 3) {
// Beta is input as [delayed group]
std::vector<double> temp_arr({n_pol * n_azi * delayed_groups});
xt::xtensor<double, 1> temp_arr({n_ang * delayed_groups}, 0.);
read_nd_vector(xsdata_grp, "beta", temp_arr);
// Broadcast to all incoming groups
int temp_idx = 0;
for (int a = 0; a < n_ang; a++) {
for (int dg = 0; dg < delayed_groups; dg++) {
size_t temp_idx = 0;
for (size_t a = 0; a < n_ang; a++) {
for (size_t dg = 0; dg < delayed_groups; dg++) {
// Set the first group index and copy the rest
temp_beta(a, 0, dg) = temp_arr[temp_idx++];
for (int gin = 1; gin < energy_groups; gin++) {
for (size_t gin = 1; gin < energy_groups; gin++) {
temp_beta(a, gin, dg) = temp_beta(a, 0, dg);
}
}
@ -174,40 +164,40 @@ XsData::fission_from_hdf5(hid_t xsdata_grp, int n_pol, int n_azi,
// If chi is provided, set chi-prompt and chi-delayed
if (object_exists(xsdata_grp, "chi")) {
xt::xtensor<double, 2> temp_arr ({n_ang, energy_groups});
xt::xtensor<double, 2> temp_arr ({n_ang, energy_groups}, 0.);
read_nd_vector(xsdata_grp, "chi", temp_arr);
for (int a = 0; a < n_ang; a++) {
for (size_t a = 0; a < n_ang; a++) {
// First set the first group
for (int gout = 0; gout < energy_groups; gout++) {
for (size_t gout = 0; gout < energy_groups; gout++) {
chi_prompt(a, 0, gout) = temp_arr(a, gout);
}
// Now normalize this data
double chi_sum = 0.;
for (int gout = 0; gout < energy_groups; gout++) {
for (size_t gout = 0; gout < energy_groups; gout++) {
chi_sum += chi_prompt(a, 0, gout);
}
if (chi_sum <= 0.) {
fatal_error("Encountered chi for a group that is <= 0!");
}
for (int gout = 0; gout < energy_groups; gout++) {
for (size_t gout = 0; gout < energy_groups; gout++) {
chi_prompt(a, 0, gout) /= chi_sum;
}
// And extend to the remaining incoming groups
for (int gin = 1; gin < energy_groups; gin++) {
for (int gout = 0; gout < energy_groups; gout++) {
for (size_t gin = 1; gin < energy_groups; gin++) {
for (size_t gout = 0; gout < energy_groups; gout++) {
chi_prompt(a, gin, gout) = chi_prompt(a, 0, gout);
}
}
// Finally set chi-delayed equal to chi-prompt
// Set chi-delayed to chi-prompt
for(int gin = 0; gin < energy_groups; gin++) {
for (int gout = 0; gout < energy_groups; gout++) {
for (int dg = 0; dg < delayed_groups; dg++) {
for(size_t gin = 0; gin < energy_groups; gin++) {
for (size_t gout = 0; gout < energy_groups; gout++) {
for (size_t dg = 0; dg < delayed_groups; dg++) {
chi_delayed(a, gin, gout, dg) = chi_prompt(a, gin, gout);
}
}
@ -219,7 +209,7 @@ XsData::fission_from_hdf5(hid_t xsdata_grp, int n_pol, int n_azi,
// if nu-fission is a matrix, set chi-prompt and chi-delayed.
if (object_exists(xsdata_grp, "nu-fission")) {
hid_t xsdata = open_dataset(xsdata_grp, "nu-fission");
int ndims = dataset_ndims(xsdata);
size_t ndims = dataset_ndims(xsdata);
// raise ndims to make the isotropic ndims the same as angular
if (is_isotropic) ndims += 2;
@ -228,9 +218,9 @@ XsData::fission_from_hdf5(hid_t xsdata_grp, int n_pol, int n_azi,
read_nd_vector(xsdata_grp, "nu-fission", prompt_nu_fission);
// set delayed-nu-fission and correct prompt-nu-fission with beta
for (int a = 0; a < n_ang; a++) {
for (int gin = 0; gin < energy_groups; gin++) {
for (int dg = 0; dg < delayed_groups; dg++) {
for (size_t a = 0; a < n_ang; a++) {
for (size_t gin = 0; gin < energy_groups; gin++) {
for (size_t dg = 0; dg < delayed_groups; dg++) {
delayed_nu_fission(a, gin, dg) =
temp_beta(a, gin, dg) * prompt_nu_fission(a, gin);
}
@ -238,7 +228,7 @@ XsData::fission_from_hdf5(hid_t xsdata_grp, int n_pol, int n_azi,
// Correct the prompt-nu-fission using the delayed neutron fraction
if (delayed_groups > 0) {
double beta_sum = 0.;
for (int gin = 0; gin < energy_groups; gin++) {
for (size_t gin = 0; gin < energy_groups; gin++) {
beta_sum += temp_beta(a, gin);
}
@ -252,10 +242,10 @@ XsData::fission_from_hdf5(hid_t xsdata_grp, int n_pol, int n_azi,
read_nd_vector(xsdata_grp, "nu-fission", chi_prompt);
// Normalize the chi info so the CDF is 1.
for (int a = 0; a < n_ang; a++) {
for (int gin = 0; gin < energy_groups; gin++) {
for (size_t a = 0; a < n_ang; a++) {
for (size_t gin = 0; gin < energy_groups; gin++) {
double chi_sum = 0.;
for (int gout = 0; gout < energy_groups; gout++) {
for (size_t gout = 0; gout < energy_groups; gout++) {
chi_sum += chi_prompt(a, gin, gout);
}
@ -263,7 +253,7 @@ XsData::fission_from_hdf5(hid_t xsdata_grp, int n_pol, int n_azi,
prompt_nu_fission(a, gin) = chi_sum;
if (chi_sum >= 0.) {
for (int gout = 0; gout < energy_groups; gout++) {
for (size_t gout = 0; gout < energy_groups; gout++) {
chi_prompt(a, gin, gout) /= chi_sum;
}
} else {
@ -271,18 +261,18 @@ XsData::fission_from_hdf5(hid_t xsdata_grp, int n_pol, int n_azi,
}
}
// set chi-delayed to chi-prompt
for (int gin = 0; gin < energy_groups; gin++) {
for (int gout = 0; gout < energy_groups; gout++) {
for (int dg = 0; dg < delayed_groups; dg++) {
// set all of chi-delayed to chi-prompt
for (size_t gin = 0; gin < energy_groups; gin++) {
for (size_t gout = 0; gout < energy_groups; gout++) {
for (size_t dg = 0; dg < delayed_groups; dg++) {
chi_delayed(a, gin, gout, dg) = chi_prompt(a, gin, gout);
}
}
}
// Set the delayed-nu-fission and correct prompt-nu-fission with beta
for (int gin = 0; gin < energy_groups; gin++) {
for (int dg = 0; dg < delayed_groups; dg++) {
for (size_t gin = 0; gin < energy_groups; gin++) {
for (size_t dg = 0; dg < delayed_groups; dg++) {
delayed_nu_fission(a, gin, dg) = temp_beta(a, gin, dg) *
prompt_nu_fission(a, gin);
}
@ -290,7 +280,7 @@ XsData::fission_from_hdf5(hid_t xsdata_grp, int n_pol, int n_azi,
// Correct prompt-nu-fission using the delayed neutron fraction
if (delayed_groups > 0) {
double beta_sum = 0.;
for (int dg = 0; dg < delayed_groups; dg++) {
for (size_t dg = 0; dg < delayed_groups; dg++) {
beta_sum += temp_beta(a, gin, dg);
}
prompt_nu_fission(a, gin) *= (1. - beta_sum);
@ -306,23 +296,23 @@ XsData::fission_from_hdf5(hid_t xsdata_grp, int n_pol, int n_azi,
// If chi-prompt is provided, set chi-prompt
if (object_exists(xsdata_grp, "chi-prompt")) {
xt::xtensor<double, 2> temp_arr({n_ang, energy_groups});
xt::xtensor<double, 2> temp_arr({n_ang, energy_groups}, 0.);
read_nd_vector(xsdata_grp, "chi-prompt", temp_arr);
for (int a = 0; a < n_ang; a++) {
for (int gin = 0; gin < energy_groups; gin++) {
for (int gout = 0; gout < energy_groups; gout++) {
for (size_t a = 0; a < n_ang; a++) {
for (size_t gin = 0; gin < energy_groups; gin++) {
for (size_t gout = 0; gout < energy_groups; gout++) {
chi_prompt(a, gin, gout) = temp_arr(a, gout);
}
// Normalize chi so its CDF goes to 1
double chi_sum = 0.;
for (int gout = 0; gout < energy_groups; gout++) {
for (size_t gout = 0; gout < energy_groups; gout++) {
chi_sum += chi_prompt(a, gin, gout);
}
if (chi_sum >= 0.) {
for (int gout = 0; gout < energy_groups; gout++) {
for (size_t gout = 0; gout < energy_groups; gout++) {
chi_prompt(a, gin, gout) /= chi_sum;
}
} else {
@ -335,20 +325,20 @@ XsData::fission_from_hdf5(hid_t xsdata_grp, int n_pol, int n_azi,
// If chi-delayed is provided, set chi-delayed
if (object_exists(xsdata_grp, "chi-delayed")) {
hid_t xsdata = open_dataset(xsdata_grp, "chi-delayed");
int ndims = dataset_ndims(xsdata);
size_t ndims = dataset_ndims(xsdata);
// raise ndims to make the isotropic ndims the same as angular
if (is_isotropic) ndims += 2;
close_dataset(xsdata);
if (ndims == 3) {
// chi-delayed is a [in group] vector
xt::xtensor<double, 2> temp_arr({n_ang, energy_groups});
xt::xtensor<double, 2> temp_arr({n_ang, energy_groups}, 0.);
read_nd_vector(xsdata_grp, "chi-delayed", temp_arr);
for (int a = 0; a < n_ang; a++) {
for (size_t a = 0; a < n_ang; a++) {
// normalize the chi CDF to 1
double chi_sum = 0.;
for (int gout = 0; gout < energy_groups; gout++) {
for (size_t gout = 0; gout < energy_groups; gout++) {
chi_sum += temp_arr(a, gout);
}
@ -357,9 +347,9 @@ XsData::fission_from_hdf5(hid_t xsdata_grp, int n_pol, int n_azi,
}
// set chi-delayed
for (int gin = 0; gin < energy_groups; gin++) {
for (int gout = 0; gout < energy_groups; gout++) {
for (int dg = 0; dg < delayed_groups; dg++) {
for (size_t gin = 0; gin < energy_groups; gin++) {
for (size_t gout = 0; gout < energy_groups; gout++) {
for (size_t dg = 0; dg < delayed_groups; dg++) {
chi_delayed(a, gin, gout, dg) = temp_arr(a, gout) / chi_sum;
}
}
@ -370,16 +360,16 @@ XsData::fission_from_hdf5(hid_t xsdata_grp, int n_pol, int n_azi,
read_nd_vector(xsdata_grp, "chi-delayed", chi_delayed);
// Normalize the chi info so the CDF is 1.
for (int a = 0; a < n_ang; a++) {
for (int dg = 0; dg < delayed_groups; dg++) {
for (int gin = 0; gin < energy_groups; gin++) {
for (size_t a = 0; a < n_ang; a++) {
for (size_t dg = 0; dg < delayed_groups; dg++) {
for (size_t gin = 0; gin < energy_groups; gin++) {
double chi_sum = 0.;
for (int gout = 0; gout < energy_groups; gout++) {
for (size_t gout = 0; gout < energy_groups; gout++) {
chi_sum += chi_delayed(a, gin, gout, dg);
}
if (chi_sum > 0.) {
for (int gout = 0; gout < energy_groups; gout++) {
for (size_t gout = 0; gout < energy_groups; gout++) {
chi_delayed(a, gin, gout, dg) /= chi_sum;
}
} else {
@ -396,7 +386,7 @@ XsData::fission_from_hdf5(hid_t xsdata_grp, int n_pol, int n_azi,
// Get prompt-nu-fission, if present
if (object_exists(xsdata_grp, "prompt-nu-fission")) {
hid_t xsdata = open_dataset(xsdata_grp, "prompt-nu-fission");
int ndims = dataset_ndims(xsdata);
size_t ndims = dataset_ndims(xsdata);
// raise ndims to make the isotropic ndims the same as angular
if (is_isotropic) ndims += 2;
close_dataset(xsdata);
@ -407,14 +397,14 @@ XsData::fission_from_hdf5(hid_t xsdata_grp, int n_pol, int n_azi,
} else if (ndims == 4) {
// prompt nu fission is a matrix,
// so set prompt_nu_fiss & chi_prompt
xt::xtensor<double, 3> temp_arr({n_ang, energy_groups, energy_groups});
xt::xtensor<double, 3> temp_arr({n_ang, energy_groups, energy_groups}, 0.);
read_nd_vector(xsdata_grp, "prompt-nu-fission", temp_arr);
// The prompt_nu_fission vector from the matrix form
for (int a = 0; a < n_ang; a++) {
for (int gin = 0; gin < energy_groups; gin++) {
for (size_t a = 0; a < n_ang; a++) {
for (size_t gin = 0; gin < energy_groups; gin++) {
double prompt_sum = 0.;
for (int gout = 0; gout < energy_groups; gout++) {
for (size_t gout = 0; gout < energy_groups; gout++) {
prompt_sum += temp_arr(a, gin, gout);
}
@ -422,9 +412,9 @@ XsData::fission_from_hdf5(hid_t xsdata_grp, int n_pol, int n_azi,
}
// The chi_prompt data is just the normalized fission matrix
for (int gin= 0; gin < energy_groups; gin++) {
for (size_t gin= 0; gin < energy_groups; gin++) {
if (prompt_nu_fission(a, gin) > 0.) {
for (int gout = 0; gout < energy_groups; gout++) {
for (size_t gout = 0; gout < energy_groups; gout++) {
chi_prompt(a, gin, gout) =
temp_arr(a, gin, gout) / prompt_nu_fission(a, gin);
}
@ -442,7 +432,7 @@ XsData::fission_from_hdf5(hid_t xsdata_grp, int n_pol, int n_azi,
// Get delayed-nu-fission, if present
if (object_exists(xsdata_grp, "delayed-nu-fission")) {
hid_t xsdata = open_dataset(xsdata_grp, "delayed-nu-fission");
int ndims = dataset_ndims(xsdata);
size_t ndims = dataset_ndims(xsdata);
close_dataset(xsdata);
// raise ndims to make the isotropic ndims the same as angular
if (is_isotropic) ndims += 2;
@ -453,12 +443,12 @@ XsData::fission_from_hdf5(hid_t xsdata_grp, int n_pol, int n_azi,
fatal_error("cannot set delayed-nu-fission with a 1D array if "
"beta is not provided");
}
xt::xtensor<double, 2> temp_arr({n_ang, energy_groups});
xt::xtensor<double, 2> temp_arr({n_ang, energy_groups}, 0.);
read_nd_vector(xsdata_grp, "delayed-nu-fission", temp_arr);
for (int a = 0; a < n_ang; a++) {
for (int gin = 0; gin < energy_groups; gin++) {
for (int dg = 0; dg < delayed_groups; dg++) {
for (size_t a = 0; a < n_ang; a++) {
for (size_t gin = 0; gin < energy_groups; gin++) {
for (size_t dg = 0; dg < delayed_groups; dg++) {
// Set delayed-nu-fission using beta
delayed_nu_fission(a, gin, dg) =
temp_beta(a, gin, dg) * temp_arr(a, gin);
@ -473,23 +463,23 @@ XsData::fission_from_hdf5(hid_t xsdata_grp, int n_pol, int n_azi,
} else if (ndims == 5) {
// This will contain delayed-nu-fission and chi-delayed data
xt::xtensor<double, 4> temp_arr({n_ang, energy_groups, energy_groups,
delayed_groups});
delayed_groups}, 0.);
read_nd_vector(xsdata_grp, "delayed-nu-fission", temp_arr);
// Set the 3D delayed-nu-fission matrix and 4D chi-delayed matrix
// from the 4D delayed-nu-fission matrix
for (int a = 0; a < n_ang; a++) {
for (int dg = 0; dg < delayed_groups; dg++) {
for (int gin = 0; gin < energy_groups; gin++) {
for (size_t a = 0; a < n_ang; a++) {
for (size_t dg = 0; dg < delayed_groups; dg++) {
for (size_t gin = 0; gin < energy_groups; gin++) {
double gout_sum = 0.;
for (int gout = 0; gout < energy_groups; gout++) {
for (size_t gout = 0; gout < energy_groups; gout++) {
gout_sum += temp_arr(a, gin, gout, dg);
chi_delayed(a, gin, gout, dg) = temp_arr(a, gin, gout, dg);
}
delayed_nu_fission(a, gin, dg) = gout_sum;
// Normalize chi-delayed
if (gout_sum > 0.) {
for (int gout = 0; gout < energy_groups; gout++) {
for (size_t gout = 0; gout < energy_groups; gout++) {
chi_delayed(a, gin, gout, dg) /= gout_sum;
}
} else {
@ -506,10 +496,10 @@ XsData::fission_from_hdf5(hid_t xsdata_grp, int n_pol, int n_azi,
}
// Combine prompt_nu_fission and delayed_nu_fission into nu_fission
for (int a = 0; a < n_ang; a++) {
for (int gin = 0; gin < energy_groups; gin++) {
for (size_t a = 0; a < n_ang; a++) {
for (size_t gin = 0; gin < energy_groups; gin++) {
nu_fission(a, gin) = prompt_nu_fission(a, gin);
for (int dg = 0; dg < delayed_groups; dg++) {
for (size_t dg = 0; dg < delayed_groups; dg++) {
nu_fission(a, gin) += delayed_nu_fission(a, gin, dg);
}
}
@ -519,20 +509,19 @@ XsData::fission_from_hdf5(hid_t xsdata_grp, int n_pol, int n_azi,
//==============================================================================
void
XsData::scatter_from_hdf5(hid_t xsdata_grp, int n_pol, int n_azi,
int energy_groups, int scatter_format, int final_scatter_format,
int order_data, int max_order, int legendre_to_tabular_points)
XsData::scatter_from_hdf5(hid_t xsdata_grp, size_t n_ang, size_t energy_groups,
int scatter_format, int final_scatter_format, int order_data,
int max_order, int legendre_to_tabular_points)
{
size_t n_ang = n_pol * n_azi;
if (!object_exists(xsdata_grp, "scatter_data")) {
fatal_error("Must provide scatter_data group!");
}
hid_t scatt_grp = open_group(xsdata_grp, "scatter_data");
// Get the outgoing group boundary indices
xt::xtensor<int, 2> gmin({n_ang, energy_groups});
xt::xtensor<int, 2> gmin({n_ang, energy_groups}, 0.);
read_nd_vector(scatt_grp, "g_min", gmin, true);
xt::xtensor<int, 2> gmax({n_ang, energy_groups});
xt::xtensor<int, 2> gmax({n_ang, energy_groups}, 0.);
read_nd_vector(scatt_grp, "g_max", gmax, true);
// Make gmin and gmax start from 0 vice 1 as they do in the library
@ -541,42 +530,39 @@ XsData::scatter_from_hdf5(hid_t xsdata_grp, int n_pol, int n_azi,
// Now use this info to find the length of a vector to hold the flattened
// data.
int length = 0;
for (int a = 0; a < n_ang; a++) {
for (int gin = 0; gin < energy_groups; gin++) {
size_t length = 0;
for (size_t a = 0; a < n_ang; a++) {
for (size_t gin = 0; gin < energy_groups; gin++) {
length += order_data * (gmax(a, gin) - gmin(a, gin) + 1);
}
}
double_4dvec input_scatt(n_ang, double_3dvec(energy_groups));
//temp_arr scope
{
std::vector<double> temp_arr(length);
read_nd_vector(scatt_grp, "scatter_matrix", temp_arr, true);
xt::xtensor<double, 1> temp_arr({length}, 0.);
read_nd_vector(scatt_grp, "scatter_matrix", temp_arr, true);
// Compare the number of orders given with the max order of the problem;
// strip off the superfluous orders if needed
int order_dim;
if (scatter_format == ANGLE_LEGENDRE) {
order_dim = std::min(order_data - 1, max_order) + 1;
} else {
order_dim = order_data;
}
// Compare the number of orders given with the max order of the problem;
// strip off the superfluous orders if needed
int order_dim;
if (scatter_format == ANGLE_LEGENDRE) {
order_dim = std::min(order_data - 1, max_order) + 1;
} else {
order_dim = order_data;
}
// convert the flattened temp_arr to a jagged array for passing to
// scatt data
int temp_idx = 0;
for (int a = 0; a < n_ang; a++) {
for (int gin = 0; gin < energy_groups; gin++) {
input_scatt[a][gin].resize(gmax(a, gin) - gmin(a, gin) + 1);
for (int i_gout = 0; i_gout < input_scatt[a][gin].size(); i_gout++) {
input_scatt[a][gin][i_gout].resize(order_dim);
for (int l = 0; l < order_dim; l++) {
input_scatt[a][gin][i_gout][l] = temp_arr[temp_idx++];
}
// Adjust index for the orders we didnt take
temp_idx += (order_data - order_dim);
// convert the flattened temp_arr to a jagged array for passing to
// scatt data
size_t temp_idx = 0;
for (size_t a = 0; a < n_ang; a++) {
for (size_t gin = 0; gin < energy_groups; gin++) {
input_scatt[a][gin].resize(gmax(a, gin) - gmin(a, gin) + 1);
for (size_t i_gout = 0; i_gout < input_scatt[a][gin].size(); i_gout++) {
input_scatt[a][gin][i_gout].resize(order_dim);
for (size_t l = 0; l < order_dim; l++) {
input_scatt[a][gin][i_gout][l] = temp_arr[temp_idx++];
}
// Adjust index for the orders we didnt take
temp_idx += (order_data - order_dim);
}
}
}
@ -584,26 +570,25 @@ XsData::scatter_from_hdf5(hid_t xsdata_grp, int n_pol, int n_azi,
// Get multiplication matrix
double_3dvec temp_mult(n_ang, double_2dvec(energy_groups));
if (object_exists(scatt_grp, "multiplicity_matrix")) {
std::vector<double> temp_arr(length / order_data);
temp_arr.resize({length / order_data});
read_nd_vector(scatt_grp, "multiplicity_matrix", temp_arr);
// convert the flat temp_arr to a jagged array for passing to scatt data
int temp_idx = 0;
for (int a = 0; a < n_ang; a++) {
for (int gin = 0; gin < energy_groups; gin++) {
size_t temp_idx = 0;
for (size_t a = 0; a < n_ang; a++) {
for (size_t gin = 0; gin < energy_groups; gin++) {
temp_mult[a][gin].resize(gmax(a, gin) - gmin(a, gin) + 1);
for (int i_gout = 0; i_gout < temp_mult[a][gin].size(); i_gout++) {
for (size_t i_gout = 0; i_gout < temp_mult[a][gin].size(); i_gout++) {
temp_mult[a][gin][i_gout] = temp_arr[temp_idx++];
}
}
}
temp_arr.clear();
} else {
// Use a default: multiplicities are 1.0.
for (int a = 0; a < n_ang; a++) {
for (int gin = 0; gin < energy_groups; gin++) {
for (size_t a = 0; a < n_ang; a++) {
for (size_t gin = 0; gin < energy_groups; gin++) {
temp_mult[a][gin].resize(gmax(a, gin) - gmin(a, gin) + 1);
for (int i_gout = 0; i_gout < temp_mult[a][gin].size(); i_gout++) {
for (size_t i_gout = 0; i_gout < temp_mult[a][gin].size(); i_gout++) {
temp_mult[a][gin][i_gout] = 1.;
}
}
@ -614,10 +599,11 @@ XsData::scatter_from_hdf5(hid_t xsdata_grp, int n_pol, int n_azi,
// Finally, convert the Legendre data to tabular, if needed
if (scatter_format == ANGLE_LEGENDRE &&
final_scatter_format == ANGLE_TABULAR) {
for (int a = 0; a < n_ang; a++) {
for (size_t a = 0; a < n_ang; a++) {
ScattDataLegendre legendre_scatt;
xt::xtensor<int, 1> in_gmin = xt::view(gmin, a, xt::all());
xt::xtensor<int, 1> in_gmax = xt::view(gmax, a, xt::all());
legendre_scatt.init(in_gmin, in_gmax,
temp_mult[a], input_scatt[a]);
@ -631,10 +617,10 @@ XsData::scatter_from_hdf5(hid_t xsdata_grp, int n_pol, int n_azi,
} else {
// We are sticking with the current representation
// Initialize the ScattData object with this data
for (int a = 0; a < n_ang; a++) {
scatter[a]->init(xt::view(gmin, a, xt::all()),
xt::view(gmax, a, xt::all()),
temp_mult[a], input_scatt[a]);
for (size_t a = 0; a < n_ang; a++) {
xt::xtensor<int, 1> in_gmin = xt::view(gmin, a, xt::all());
xt::xtensor<int, 1> in_gmax = xt::view(gmax, a, xt::all());
scatter[a]->init(in_gmin, in_gmax, temp_mult[a], input_scatt[a]);
}
}
}
@ -643,10 +629,10 @@ XsData::scatter_from_hdf5(hid_t xsdata_grp, int n_pol, int n_azi,
void
XsData::combine(const std::vector<XsData*>& those_xs,
const double_1dvec& scalars)
const std::vector<double>& scalars)
{
// Combine the non-scattering data
for (int i = 0; i < those_xs.size(); i++) {
for (size_t i = 0; i < those_xs.size(); i++) {
XsData* that = those_xs[i];
if (!equiv(*that)) fatal_error("Cannot combine the XsData objects!");
double scalar = scalars[i];
@ -668,10 +654,10 @@ XsData::combine(const std::vector<XsData*>& those_xs,
}
// Allow the ScattData object to combine itself
for (int a = 0; a < total.shape()[0]; a++) {
for (size_t a = 0; a < total.shape()[0]; a++) {
// Build vector of the scattering objects to incorporate
std::vector<ScattData*> those_scatts(those_xs.size());
for (int i = 0; i < those_xs.size(); i++) {
for (size_t i = 0; i < those_xs.size(); i++) {
those_scatts[i] = those_xs[i]->scatter[a].get();
}

9
tests/regression_tests/mgxs_library_ce_to_mg/test.py
View file

@ -71,11 +71,10 @@ class MGXSTestHarness(PyAPITestHarness):
openmc.run(openmc_exec=config['exe'])
def _cleanup(self):
pass
# super()._cleanup()
# f = 'mgxs.h5'
# if os.path.exists(f):
# os.remove(f)
super()._cleanup()
f = 'mgxs.h5'
if os.path.exists(f):
os.remove(f)
def test_mgxs_library_ce_to_mg():