crp/OpenMC
1
0
Fork 0
mirror of https://github.com/openmc-dev/openmc.git synced 2026-07-28 22:26:08 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions 5

remove std:: from vector,unique_ptr,make_unique,array

Browse source
This commit is contained in:
Gavin Ridley 2021-04-22 16:46:23 -04:00
parent 2af4c9cd92
commit ad4e1c9f4a
129 changed files with 1013 additions and 1033 deletions
Download patch file Download diff file Expand all files Collapse all files

9
src/bank.cpp
View file

@ -1,8 +1,9 @@
#include "openmc/bank.h"
#include "openmc/capi.h"
#include "openmc/error.h"
#include "openmc/simulation.h"
#include "openmc/message_passing.h"
#include "openmc/simulation.h"
#include "openmc/vector.h"
#include <cstdint>
@ -15,7 +16,7 @@ namespace openmc {
namespace simulation {
std::vector<ParticleBank> source_bank;
vector<ParticleBank> source_bank;
SharedArray<ParticleBank> surf_source_bank;
@ -28,7 +29,7 @@ SharedArray<ParticleBank> fission_bank;
// Each entry in this vector corresponds to the number of progeny produced
// this generation for the particle located at that index. This vector is
// used to efficiently sort the fission bank after each iteration.
std::vector<int64_t> progeny_per_particle;
vector<int64_t> progeny_per_particle;
} // namespace simulation
@ -80,7 +81,7 @@ void sort_fission_bank()
// sorted order easy. Under normal usage conditions, the fission bank is
// over provisioned, so we can use that as scratch space.
ParticleBank* sorted_bank;
std::vector<ParticleBank> sorted_bank_holder;
vector<ParticleBank> sorted_bank_holder;
// If there is not enough space, allocate a temporary vector and point to it
if (simulation::fission_bank.size() > simulation::fission_bank.capacity() / 2) {

2
src/bremsstrahlung.cpp
View file

@ -18,7 +18,7 @@ namespace data {
xt::xtensor<double, 1> ttb_e_grid;
xt::xtensor<double, 1> ttb_k_grid;
std::vector<Bremsstrahlung> ttb;
vector<Bremsstrahlung> ttb;
} // namespace data

70
src/cell.cpp
View file

@ -33,10 +33,10 @@ namespace openmc {
namespace model {
std::unordered_map<int32_t, int32_t> cell_map;
std::vector<std::unique_ptr<Cell>> cells;
vector<unique_ptr<Cell>> cells;
std::unordered_map<int32_t, int32_t> universe_map;
std::vector<std::unique_ptr<Universe>> universes;
vector<unique_ptr<Universe>> universes;
} // namespace model
//==============================================================================
@ -46,10 +46,10 @@ namespace model {
//! operators.
//==============================================================================
std::vector<int32_t>
tokenize(const std::string region_spec) {
vector<int32_t> tokenize(const std::string region_spec)
{
// Check for an empty region_spec first.
std::vector<int32_t> tokens;
vector<int32_t> tokens;
if (region_spec.empty()) {
return tokens;
}
@ -113,11 +113,10 @@ tokenize(const std::string region_spec) {
//! This function uses the shunting-yard algorithm.
//==============================================================================
std::vector<int32_t>
generate_rpn(int32_t cell_id, std::vector<int32_t> infix)
vector<int32_t> generate_rpn(int32_t cell_id, vector<int32_t> infix)
{
std::vector<int32_t> rpn;
std::vector<int32_t> stack;
vector<int32_t> rpn;
vector<int32_t> stack;
for (int32_t token : infix) {
if (token < OP_UNION) {
@ -197,7 +196,7 @@ Universe::to_hdf5(hid_t universes_group) const
// Write the contained cells.
if (cells_.size() > 0) {
std::vector<int32_t> cell_ids;
vector<int32_t> cell_ids;
for (auto i_cell : cells_) cell_ids.push_back(model::cells[i_cell]->id_);
write_dataset(group, "cells", cell_ids);
}
@ -333,8 +332,8 @@ CSGCell::CSGCell(pugi::xml_node cell_node)
// universe), more than one material (distribmats), and some materials may
// be "void".
if (material_present) {
std::vector<std::string> mats
{get_node_array<std::string>(cell_node, "material", true)};
vector<std::string> mats {
get_node_array<std::string>(cell_node, "material", true)};
if (mats.size() > 0) {
material_.reserve(mats.size());
for (std::string mat : mats) {
@ -563,7 +562,7 @@ CSGCell::to_hdf5(hid_t cell_group) const
// Write fill information.
if (type_ == Fill::MATERIAL) {
write_dataset(group, "fill_type", "material");
std::vector<int32_t> mat_ids;
vector<int32_t> mat_ids;
for (auto i_mat : material_) {
if (i_mat != MATERIAL_VOID) {
mat_ids.push_back(model::materials[i_mat]->id_);
@ -577,7 +576,7 @@ CSGCell::to_hdf5(hid_t cell_group) const
write_dataset(group, "material", mat_ids);
}
std::vector<double> temps;
vector<double> temps;
for (auto sqrtkT_val : sqrtkT_)
temps.push_back(sqrtkT_val * sqrtkT_val / K_BOLTZMANN);
write_dataset(group, "temperature", temps);
@ -590,7 +589,7 @@ CSGCell::to_hdf5(hid_t cell_group) const
}
if (!rotation_.empty()) {
if (rotation_.size() == 12) {
std::array<double, 3> rot {rotation_[9], rotation_[10], rotation_[11]};
array<double, 3> rot {rotation_[9], rotation_[10], rotation_[11]};
write_dataset(group, "rotation", rot);
} else {
write_dataset(group, "rotation", rotation_);
@ -613,8 +612,8 @@ BoundingBox CSGCell::bounding_box_simple() const {
return bbox;
}
void CSGCell::apply_demorgan(std::vector<int32_t>::iterator start,
std::vector<int32_t>::iterator stop)
void CSGCell::apply_demorgan(
vector<int32_t>::iterator start, vector<int32_t>::iterator stop)
{
while (start < stop) {
if (*start < OP_UNION) { *start *= -1; }
@ -624,9 +623,9 @@ void CSGCell::apply_demorgan(std::vector<int32_t>::iterator start,
}
}
std::vector<int32_t>::iterator
CSGCell::find_left_parenthesis(std::vector<int32_t>::iterator start,
const std::vector<int32_t>& rpn) {
vector<int32_t>::iterator CSGCell::find_left_parenthesis(
vector<int32_t>::iterator start, const vector<int32_t>& rpn)
{
// start search at zero
int parenthesis_level = 0;
auto it = start;
@ -657,12 +656,13 @@ CSGCell::find_left_parenthesis(std::vector<int32_t>::iterator start,
return it;
}
void CSGCell::remove_complement_ops(std::vector<int32_t>& rpn) {
void CSGCell::remove_complement_ops(vector<int32_t>& rpn)
{
auto it = std::find(rpn.begin(), rpn.end(), OP_COMPLEMENT);
while (it != rpn.end()) {
// find the opening parenthesis (if any)
auto left = find_left_parenthesis(it, rpn);
std::vector<int32_t> tmp(left, it+1);
vector<int32_t> tmp(left, it + 1);
// apply DeMorgan's law to any surfaces/operators between these
// positions in the RPN
@ -674,11 +674,12 @@ void CSGCell::remove_complement_ops(std::vector<int32_t>& rpn) {
}
}
BoundingBox CSGCell::bounding_box_complex(std::vector<int32_t> rpn) {
BoundingBox CSGCell::bounding_box_complex(vector<int32_t> rpn)
{
// remove complements by adjusting surface signs and operators
remove_complement_ops(rpn);
std::vector<BoundingBox> stack(rpn.size());
vector<BoundingBox> stack(rpn.size());
int i_stack = -1;
for (auto& token : rpn) {
@ -731,7 +732,7 @@ CSGCell::contains_complex(Position r, Direction u, int32_t on_surface) const
{
// Make a stack of booleans. We don't know how big it needs to be, but we do
// know that rpn.size() is an upper-bound.
std::vector<bool> stack(rpn_.size());
vector<bool> stack(rpn_.size());
int i_stack = -1;
for (int32_t token : rpn_) {
@ -945,8 +946,8 @@ UniversePartitioner::UniversePartitioner(const Universe& univ)
}
}
const std::vector<int32_t>&
UniversePartitioner::get_cells(Position r, Direction u) const
const vector<int32_t>& UniversePartitioner::get_cells(
Position r, Direction u) const
{
// Perform a binary search for the partition containing the given coordinates.
int left = 0;
@ -1175,11 +1176,10 @@ openmc_cell_set_name(int32_t index, const char* name) {
return 0;
}
std::unordered_map<int32_t, std::vector<int32_t>>
Cell::get_contained_cells() const {
std::unordered_map<int32_t, std::vector<int32_t>> contained_cells;
std::vector<ParentCell> parent_cells;
std::unordered_map<int32_t, vector<int32_t>> Cell::get_contained_cells() const
{
std::unordered_map<int32_t, vector<int32_t>> contained_cells;
vector<ParentCell> parent_cells;
// if this cell is filled w/ a material, it contains no other cells
if (type_ != Fill::MATERIAL) {
@ -1190,9 +1190,9 @@ Cell::get_contained_cells() const {
}
//! Get all cells within this cell
void
Cell::get_contained_cells_inner(std::unordered_map<int32_t, std::vector<int32_t>>& contained_cells,
std::vector<ParentCell>& parent_cells) const
void Cell::get_contained_cells_inner(
std::unordered_map<int32_t, vector<int32_t>>& contained_cells,
vector<ParentCell>& parent_cells) const
{
// filled by material, determine instance based on parent cells

22
src/cmfd_solver.cpp
View file

@ -1,6 +1,5 @@
#include "openmc/cmfd_solver.h"
#include <vector>
#include <cmath>
#ifdef _OPENMP
@ -9,14 +8,15 @@
#include "xtensor/xtensor.hpp"
#include "openmc/bank.h"
#include "openmc/error.h"
#include "openmc/constants.h"
#include "openmc/capi.h"
#include "openmc/constants.h"
#include "openmc/error.h"
#include "openmc/mesh.h"
#include "openmc/message_passing.h"
#include "openmc/tallies/filter_energy.h"
#include "openmc/tallies/filter_mesh.h"
#include "openmc/tallies/tally.h"
#include "openmc/vector.h"
namespace openmc {
@ -26,9 +26,9 @@ namespace cmfd {
// Global variables
//==============================================================================
std::vector<int> indptr;
vector<int> indptr;
std::vector<int> indices;
vector<int> indices;
int dim;
@ -42,7 +42,7 @@ int use_all_threads;
StructuredMesh* mesh;
std::vector<double> egrid;
vector<double> egrid;
double norm;
@ -83,7 +83,7 @@ xt::xtensor<double, 1> count_bank_sites(xt::xtensor<int, 1>& bins, bool* outside
{
// Determine shape of array for counts
std::size_t cnt_size = cmfd::nx * cmfd::ny * cmfd::nz * cmfd::ng;
std::vector<std::size_t> cnt_shape = {cnt_size};
vector<std::size_t> cnt_shape = {cnt_size};
// Create array of zeros
xt::xarray<double> cnt {cnt_shape, 0.0};
@ -299,7 +299,7 @@ int cmfd_linsolver_1g(const double* A_data, const double* b, double* x,
double err = 0.0;
// Copy over x vector
std::vector<double> tmpx {x, x+cmfd::dim};
vector<double> tmpx {x, x + cmfd::dim};
// Perform red/black Gauss-Seidel iterations
for (int irb = 0; irb < 2; irb++) {
@ -366,7 +366,7 @@ int cmfd_linsolver_2g(const double* A_data, const double* b, double* x,
double err = 0.0;
// Copy over x vector
std::vector<double> tmpx {x, x+cmfd::dim};
vector<double> tmpx {x, x + cmfd::dim};
// Perform red/black Gauss-Seidel iterations
for (int irb = 0; irb < 2; irb++) {
@ -458,7 +458,7 @@ int cmfd_linsolver_ng(const double* A_data, const double* b, double* x,
double err = 0.0;
// Copy over x vector
std::vector<double> tmpx {x, x+cmfd::dim};
vector<double> tmpx {x, x + cmfd::dim};
// Loop around matrix rows
for (int irow = 0; irow < cmfd::dim; irow++) {
@ -554,7 +554,7 @@ int openmc_run_linsolver(const double* A_data, const double* b, double* x,
void free_memory_cmfd()
{
// Clear std::vectors
// Clear vectors
cmfd::indptr.clear();
cmfd::indices.clear();
cmfd::egrid.clear();

12
src/cross_sections.cpp
View file

@ -37,8 +37,7 @@ namespace openmc {
namespace data {
std::map<LibraryKey, std::size_t> library_map;
std::vector<Library> libraries;
vector<Library> libraries;
}
//==============================================================================
@ -182,16 +181,15 @@ void read_cross_sections_xml()
}
}
void
read_ce_cross_sections(const std::vector<std::vector<double>>& nuc_temps,
const std::vector<std::vector<double>>& thermal_temps)
void read_ce_cross_sections(const vector<std::vector<double>>& nuc_temps,
const vector<std::vector<double>>& thermal_temps)
{
std::unordered_set<std::string> already_read;
// Construct a vector of nuclide names because we haven't loaded nuclide data
// yet, but we need to know the name of the i-th nuclide
std::vector<std::string> nuclide_names(data::nuclide_map.size());
std::vector<std::string> thermal_names(data::thermal_scatt_map.size());
vector<std::string> nuclide_names(data::nuclide_map.size());
vector<std::string> thermal_names(data::thermal_scatt_map.size());
for (const auto& kv : data::nuclide_map) {
nuclide_names[kv.second] = kv.first;
}

2
src/dagmc.cpp
View file

@ -183,7 +183,7 @@ void load_dagmc_geometry()
dagmcMetaData DMD(model::DAG, false, false);
DMD.load_property_data();
std::vector<std::string> keywords {"temp"};
vector<std::string> keywords {"temp"};
std::map<std::string, std::string> dum;
std::string delimiters = ":/";
rval = model::DAG->parse_properties(keywords, dum, delimiters.c_str());

12
src/distribution_angle.cpp
View file

@ -1,7 +1,6 @@
#include "openmc/distribution_angle.h"
#include <cmath> // for abs, copysign
#include <vector> // for vector
#include "xtensor/xarray.hpp"
#include "xtensor/xview.hpp"
@ -10,6 +9,7 @@
#include "openmc/hdf5_interface.h"
#include "openmc/random_lcg.h"
#include "openmc/search.h"
#include "openmc/vector.h" // for vector
namespace openmc {
@ -24,8 +24,8 @@ AngleDistribution::AngleDistribution(hid_t group)
int n_energy = energy_.size();
// Get outgoing energy distribution data
std::vector<int> offsets;
std::vector<int> interp;
vector<int> offsets;
vector<int> interp;
hid_t dset = open_dataset(group, "mu");
read_attribute(dset, "offsets", offsets);
read_attribute(dset, "interpolation", interp);
@ -47,9 +47,9 @@ AngleDistribution::AngleDistribution(hid_t group)
auto xs = xt::view(temp, 0, xt::range(j, j+n));
auto ps = xt::view(temp, 1, xt::range(j, j+n));
auto cs = xt::view(temp, 2, xt::range(j, j+n));
std::vector<double> x {xs.begin(), xs.end()};
std::vector<double> p {ps.begin(), ps.end()};
std::vector<double> c {cs.begin(), cs.end()};
vector<double> x {xs.begin(), xs.end()};
vector<double> p {ps.begin(), ps.end()};
vector<double> c {cs.begin(), cs.end()};
// To get answers that match ACE data, for now we still use the tabulated
// CDF values that were passed through to the HDF5 library. At a later

6
src/distribution_energy.cpp
View file

@ -77,9 +77,9 @@ ContinuousTabular::ContinuousTabular(hid_t group)
// Get outgoing energy distribution data
dset = open_dataset(group, "distribution");
std::vector<int> offsets;
std::vector<int> interp;
std::vector<int> n_discrete;
vector<int> offsets;
vector<int> interp;
vector<int> n_discrete;
read_attribute(dset, "offsets", offsets);
read_attribute(dset, "interpolation", interp);
read_attribute(dset, "n_discrete_lines", n_discrete);

18
src/eigenvalue.cpp
View file

@ -5,6 +5,7 @@
#include "xtensor/xtensor.hpp"
#include "xtensor/xview.hpp"
#include "openmc/array.h"
#include "openmc/bank.h"
#include "openmc/capi.h"
#include "openmc/constants.h"
@ -17,11 +18,10 @@
#include "openmc/search.h"
#include "openmc/settings.h"
#include "openmc/simulation.h"
#include "openmc/timer.h"
#include "openmc/tallies/tally.h"
#include "openmc/timer.h"
#include <algorithm> // for min
#include <array>
#include <cmath> // for sqrt, abs, pow
#include <iterator> // for back_inserter
#include <string>
@ -36,8 +36,8 @@ namespace openmc {
namespace simulation {
double keff_generation;
std::array<double, 2> k_sum;
std::vector<double> entropy;
array<double, 2> k_sum;
vector<double> entropy;
xt::xtensor<double, 1> source_frac;
} // namespace simulation
@ -137,7 +137,7 @@ void synchronize_bank()
// Allocate temporary source bank -- we don't really know how many fission
// sites were created, so overallocate by a factor of 3
int64_t index_temp = 0;
std::vector<ParticleBank> temp_sites(3 * simulation::work_per_rank);
vector<ParticleBank> temp_sites(3 * simulation::work_per_rank);
for (int64_t i = 0; i < simulation::fission_bank.size(); i++ ) {
const auto& site = simulation::fission_bank[i];
@ -214,7 +214,7 @@ void synchronize_bank()
// SEND BANK SITES TO NEIGHBORS
int64_t index_local = 0;
std::vector<MPI_Request> requests;
vector<MPI_Request> requests;
if (start < settings::n_particles) {
// Determine the index of the processor which has the first part of the
@ -372,7 +372,7 @@ int openmc_get_keff(double* k_combined)
// Copy estimates of k-effective and its variance (not variance of the mean)
const auto& gt = simulation::global_tallies;
std::array<double, 3> kv {};
array<double, 3> kv {};
xt::xtensor<double, 2> cov = xt::zeros<double>({3, 3});
kv[0] = gt(GlobalTally::K_COLLISION, TallyResult::SUM) / n;
kv[1] = gt(GlobalTally::K_ABSORPTION, TallyResult::SUM) / n;
@ -427,7 +427,7 @@ int openmc_get_keff(double* k_combined)
// Initialize variables
double g = 0.0;
std::array<double, 3> S {};
array<double, 3> S {};
for (int l = 0; l < 3; ++l) {
// Permutations of estimates
@ -601,7 +601,7 @@ void write_eigenvalue_hdf5(hid_t group)
write_dataset(group, "k_col_abs", simulation::k_col_abs);
write_dataset(group, "k_col_tra", simulation::k_col_tra);
write_dataset(group, "k_abs_tra", simulation::k_abs_tra);
std::array<double, 2> k_combined;
array<double, 2> k_combined;
openmc_get_keff(k_combined.data());
write_dataset(group, "k_combined", k_combined);
}

11
src/endf.cpp
View file

@ -1,7 +1,6 @@
#include "openmc/endf.h"
#include <algorithm> // for copy
#include <array>
#include <cmath> // for log, exp
#include <iterator> // for back_inserter
#include <stdexcept> // for runtime_error
@ -9,6 +8,7 @@
#include "xtensor/xarray.hpp"
#include "xtensor/xview.hpp"
#include "openmc/array.h"
#include "openmc/constants.h"
#include "openmc/hdf5_interface.h"
#include "openmc/search.h"
@ -77,13 +77,12 @@ bool is_inelastic_scatter(int mt)
}
}
std::unique_ptr<Function1D>
read_function(hid_t group, const char* name)
unique_ptr<Function1D> read_function(hid_t group, const char* name)
{
hid_t dset = open_dataset(group, name);
std::string func_type;
read_attribute(dset, "type", func_type);
std::unique_ptr<Function1D> func;
unique_ptr<Function1D> func;
if (func_type == "Tabulated1D") {
func = std::make_unique<Tabulated1D>(dset);
} else if (func_type == "Polynomial") {
@ -133,7 +132,7 @@ Tabulated1D::Tabulated1D(hid_t dset)
// Change 1-indexing to 0-indexing
for (auto& b : nbt_) --b;
std::vector<int> int_temp;
vector<int> int_temp;
read_attribute(dset, "interpolation", int_temp);
// Convert vector of ints into Interpolation
@ -245,7 +244,7 @@ double CoherentElasticXS::operator()(double E) const
IncoherentElasticXS::IncoherentElasticXS(hid_t dset)
{
std::array<double, 2> tmp;
array<double, 2> tmp;
read_dataset(dset, nullptr, tmp);
bound_xs_ = tmp[0];
debye_waller_ = tmp[1];

2
src/event.cpp
View file

@ -17,7 +17,7 @@ SharedArray<EventQueueItem> advance_particle_queue;
SharedArray<EventQueueItem> surface_crossing_queue;
SharedArray<EventQueueItem> collision_queue;
std::vector<Particle> particles;
vector<Particle> particles;
} // namespace simulation

9
src/geometry.cpp
View file

@ -1,10 +1,9 @@
#include "openmc/geometry.h"
#include <array>
#include <fmt/core.h>
#include <fmt/ostream.h>
#include "openmc/array.h"
#include "openmc/cell.h"
#include "openmc/constants.h"
#include "openmc/error.h"
@ -27,7 +26,7 @@ namespace model {
int root_universe {-1};
int n_coord_levels;
std::vector<int64_t> overlap_check_count;
vector<int64_t> overlap_check_count;
} // namespace model
@ -371,7 +370,7 @@ BoundaryInfo distance_to_boundary(Particle& p)
double d_lat = INFINITY;
double d_surf = INFINITY;
int32_t level_surf_cross;
std::array<int, 3> level_lat_trans {};
array<int, 3> level_lat_trans {};
// Loop over each coordinate level.
for (int i = 0; i < p.n_coord(); i++) {
@ -391,7 +390,7 @@ BoundaryInfo distance_to_boundary(Particle& p)
std::array<int, 3> i_xyz {coord.lattice_x, coord.lattice_y, coord.lattice_z};
//TODO: refactor so both lattice use the same position argument (which
//also means the lat.type attribute can be removed)
std::pair<double, std::array<int, 3>> lattice_distance;
std::pair<double, array<int, 3>> lattice_distance;
switch (lat.type_) {
case LatticeType::rect:
lattice_distance = lat.distance(r, u, i_xyz);

13
src/geometry_aux.cpp
View file

@ -191,9 +191,8 @@ assign_temperatures()
//==============================================================================
void
get_temperatures(std::vector<std::vector<double>>& nuc_temps,
std::vector<std::vector<double>>& thermal_temps)
void get_temperatures(vector<std::vector<double>>& nuc_temps,
vector<std::vector<double>>& thermal_temps)
{
for (const auto& cell : model::cells) {
// Skip non-material cells.
@ -205,7 +204,7 @@ get_temperatures(std::vector<std::vector<double>>& nuc_temps,
if (i_material == MATERIAL_VOID) continue;
// Get temperature(s) of cell (rounding to nearest integer)
std::vector<double> cell_temps;
vector<double> cell_temps;
if (cell->sqrtkT_.size() == 1) {
double sqrtkT = cell->sqrtkT_[0];
cell_temps.push_back(sqrtkT*sqrtkT / K_BOLTZMANN);
@ -351,7 +350,7 @@ prepare_distribcell()
// Search through universes for material cells and assign each one a
// unique distribcell array index.
int distribcell_index = 0;
std::vector<int32_t> target_univ_ids;
vector<int32_t> target_univ_ids;
for (const auto& u : model::universes) {
for (auto idx : u->cells_) {
if (distribcells.find(idx) != distribcells.end()) {
@ -495,8 +494,8 @@ distribcell_path_inner(int32_t target_cell, int32_t map, int32_t target_offset,
// The target must be further down the geometry tree and contained in a fill
// cell or lattice cell in this universe. Find which cell contains the
// target.
std::vector<std::int32_t>::const_reverse_iterator cell_it
{search_univ.cells_.crbegin()};
vector<std::int32_t>::const_reverse_iterator cell_it {
search_univ.cells_.crbegin()};
for (; cell_it != search_univ.cells_.crend(); ++cell_it) {
Cell& c = *model::cells[*cell_it];

26
src/hdf5_interface.cpp
View file

@ -1,6 +1,5 @@
#include "openmc/hdf5_interface.h"
#include <array>
#include <cstring>
#include <stdexcept>
#include <string>
@ -16,6 +15,7 @@
#include "openmc/message_passing.h"
#endif
#include "openmc/array.h"
namespace openmc {
@ -56,16 +56,15 @@ get_shape(hid_t obj_id, hsize_t* dims)
H5Sclose(dspace);
}
std::vector<hsize_t> attribute_shape(hid_t obj_id, const char* name)
vector<hsize_t> attribute_shape(hid_t obj_id, const char* name)
{
hid_t attr = H5Aopen(obj_id, name, H5P_DEFAULT);
std::vector<hsize_t> shape = object_shape(attr);
vector<hsize_t> shape = object_shape(attr);
H5Aclose(attr);
return shape;
}
std::vector<hsize_t> object_shape(hid_t obj_id)
vector<hsize_t> object_shape(hid_t obj_id)
{
// Get number of dimensions
auto type = H5Iget_type(obj_id);
@ -81,7 +80,7 @@ std::vector<hsize_t> object_shape(hid_t obj_id)
int n = H5Sget_simple_extent_ndims(dspace);
// Get shape of array
std::vector<hsize_t> shape(n);
vector<hsize_t> shape(n);
H5Sget_simple_extent_dims(dspace, shape.data(), nullptr);
// Free resources and return
@ -337,8 +336,7 @@ get_groups(hid_t group_id, char* name[])
}
}
std::vector<std::string>
member_names(hid_t group_id, H5O_type_t type)
vector<std::string> member_names(hid_t group_id, H5O_type_t type)
{
// Determine number of links in the group
H5G_info_t info;
@ -347,7 +345,7 @@ member_names(hid_t group_id, H5O_type_t type)
// Iterate over links to get names
H5O_info_t oinfo;
size_t size;
std::vector<std::string> names;
vector<std::string> names;
for (hsize_t i = 0; i < info.nlinks; ++i) {
// Determine type of object (and skip non-group)
H5Oget_info_by_idx(group_id, ".", H5_INDEX_NAME, H5_ITER_INC, i, &oinfo,
@ -368,14 +366,12 @@ member_names(hid_t group_id, H5O_type_t type)
return names;
}
std::vector<std::string>
group_names(hid_t group_id)
vector<std::string> group_names(hid_t group_id)
{
return member_names(group_id, H5O_TYPE_GROUP);
}
std::vector<std::string>
dataset_names(hid_t group_id)
vector<std::string> dataset_names(hid_t group_id)
{
return member_names(group_id, H5O_TYPE_DATASET);
}
@ -492,13 +488,13 @@ template<>
void read_dataset(hid_t dset, xt::xarray<std::complex<double>>& arr, bool indep)
{
// Get shape of dataset
std::vector<hsize_t> shape = object_shape(dset);
vector<hsize_t> shape = object_shape(dset);
// Allocate new array to read data into
std::size_t size = 1;
for (const auto x : shape)
size *= x;
std::vector<std::complex<double>> buffer(size);
vector<std::complex<double>> buffer(size);
// Read data from attribute
read_complex(dset, nullptr, buffer.data(), indep);

4
src/initialize.cpp
View file

@ -3,9 +3,7 @@
#include <cstddef>
#include <cstdlib> // for getenv
#include <cstring>
#include <memory>
#include <string>
#include <vector>
#ifdef _OPENMP
#include <omp.h>
@ -19,6 +17,7 @@
#include "openmc/geometry_aux.h"
#include "openmc/hdf5_interface.h"
#include "openmc/material.h"
#include "openmc/memory.h"
#include "openmc/message_passing.h"
#include "openmc/mgxs_interface.h"
#include "openmc/nuclide.h"
@ -32,6 +31,7 @@
#include "openmc/tallies/tally.h"
#include "openmc/thermal.h"
#include "openmc/timer.h"
#include "openmc/vector.h"
#ifdef LIBMESH
#include "libmesh/libmesh.h"

69
src/lattice.cpp
View file

@ -2,7 +2,6 @@
#include <cmath>
#include <string>
#include <vector>
#include <fmt/core.h>
@ -12,9 +11,9 @@
#include "openmc/geometry_aux.h"
#include "openmc/hdf5_interface.h"
#include "openmc/string_utils.h"
#include "openmc/vector.h"
#include "openmc/xml_interface.h"
namespace openmc {
//==============================================================================
@ -23,7 +22,7 @@ namespace openmc {
namespace model {
std::unordered_map<int32_t, int32_t> lattice_map;
std::vector<std::unique_ptr<Lattice>> lattices;
vector<unique_ptr<Lattice>> lattices;
}
//==============================================================================
@ -142,7 +141,7 @@ RectLattice::RectLattice(pugi::xml_node lat_node)
// Read the number of lattice cells in each dimension.
std::string dimension_str {get_node_value(lat_node, "dimension")};
std::vector<std::string> dimension_words {split(dimension_str)};
vector<std::string> dimension_words {split(dimension_str)};
if (dimension_words.size() == 2) {
n_cells_[0] = std::stoi(dimension_words[0]);
n_cells_[1] = std::stoi(dimension_words[1]);
@ -159,7 +158,7 @@ RectLattice::RectLattice(pugi::xml_node lat_node)
// Read the lattice lower-left location.
std::string ll_str {get_node_value(lat_node, "lower_left")};
std::vector<std::string> ll_words {split(ll_str)};
vector<std::string> ll_words {split(ll_str)};
if (ll_words.size() != dimension_words.size()) {
fatal_error("Number of entries on <lower_left> must be the same as the "
"number of entries on <dimension>.");
@ -170,7 +169,7 @@ RectLattice::RectLattice(pugi::xml_node lat_node)
// Read the lattice pitches.
std::string pitch_str {get_node_value(lat_node, "pitch")};
std::vector<std::string> pitch_words {split(pitch_str)};
vector<std::string> pitch_words {split(pitch_str)};
if (pitch_words.size() != dimension_words.size()) {
fatal_error("Number of entries on <pitch> must be the same as the "
"number of entries on <dimension>.");
@ -181,8 +180,8 @@ RectLattice::RectLattice(pugi::xml_node lat_node)
// Read the universes and make sure the correct number was specified.
std::string univ_str {get_node_value(lat_node, "universes")};
std::vector<std::string> univ_words {split(univ_str)};
if (univ_words.size() != nx*ny*nz) {
vector<std::string> univ_words {split(univ_str)};
if (univ_words.size() != n_cells_[0] * n_cells_[1] * n_cells_[2]) {
fatal_error(fmt::format(
"Expected {} universes for a rectangular lattice of size {}x{}x{} but {} "
"were specified.", nx*ny*nz, nx, ny, nz, univ_words.size()));
@ -222,9 +221,8 @@ RectLattice::are_valid_indices(const int i_xyz[3]) const
//==============================================================================
std::pair<double, std::array<int, 3>>
RectLattice::distance(Position r, Direction u, const std::array<int, 3>& i_xyz)
const
std::pair<double, array<int, 3>> RectLattice::distance(
Position r, Direction u, const array<int, 3>& i_xyz) const
{
// Get short aliases to the coordinates.
double x = r.x;
@ -237,7 +235,7 @@ const
// Left and right sides
double d {INFTY};
std::array<int, 3> lattice_trans;
array<int, 3> lattice_trans;
if ((std::abs(x - x0) > FP_PRECISION) && u.x != 0) {
d = (x0 - x) / u.x;
if (u.x > 0) {
@ -378,11 +376,11 @@ RectLattice::to_hdf5_inner(hid_t lat_group) const
write_dataset(lat_group, "lower_left", lower_left_);
write_dataset(lat_group, "dimension", n_cells_);
} else {
std::array<double, 2> pitch_short {{pitch_[0], pitch_[1]}};
array<double, 2> pitch_short {{pitch_[0], pitch_[1]}};
write_dataset(lat_group, "pitch", pitch_short);
std::array<double, 2> ll_short {{lower_left_[0], lower_left_[1]}};
array<double, 2> ll_short {{lower_left_[0], lower_left_[1]}};
write_dataset(lat_group, "lower_left", ll_short);
std::array<int, 2> nc_short {{n_cells_[0], n_cells_[1]}};
array<int, 2> nc_short {{n_cells_[0], n_cells_[1]}};
write_dataset(lat_group, "dimension", nc_short);
}
@ -392,7 +390,7 @@ RectLattice::to_hdf5_inner(hid_t lat_group) const
hsize_t nx {static_cast<hsize_t>(n_cells_[0])};
hsize_t ny {static_cast<hsize_t>(n_cells_[1])};
hsize_t nz {static_cast<hsize_t>(n_cells_[2])};
std::vector<int> out(nx*ny*nz);
vector<int> out(nx * ny * nz);
for (int m = 0; m < nz; m++) {
for (int k = 0; k < ny; k++) {
@ -410,7 +408,7 @@ RectLattice::to_hdf5_inner(hid_t lat_group) const
} else {
hsize_t nx {static_cast<hsize_t>(n_cells_[0])};
hsize_t ny {static_cast<hsize_t>(n_cells_[1])};
std::vector<int> out(nx*ny);
vector<int> out(nx * ny);
for (int k = 0; k < ny; k++) {
for (int j = 0; j < nx; j++) {
@ -461,7 +459,7 @@ HexLattice::HexLattice(pugi::xml_node lat_node)
// Read the lattice center.
std::string center_str {get_node_value(lat_node, "center")};
std::vector<std::string> center_words {split(center_str)};
vector<std::string> center_words {split(center_str)};
if (is_3d_ && (center_words.size() != 3)) {
fatal_error("A hexagonal lattice with <n_axial> must have <center> "
"specified by 3 numbers.");
@ -475,7 +473,7 @@ HexLattice::HexLattice(pugi::xml_node lat_node)
// Read the lattice pitches.
std::string pitch_str {get_node_value(lat_node, "pitch")};
std::vector<std::string> pitch_words {split(pitch_str)};
vector<std::string> pitch_words {split(pitch_str)};
if (is_3d_ && (pitch_words.size() != 2)) {
fatal_error("A hexagonal lattice with <n_axial> must have <pitch> "
"specified by 2 numbers.");
@ -489,7 +487,7 @@ HexLattice::HexLattice(pugi::xml_node lat_node)
// Read the universes and make sure the correct number was specified.
int n_univ = (3*n_rings_*n_rings_ - 3*n_rings_ + 1) * n_axial_;
std::string univ_str {get_node_value(lat_node, "universes")};
std::vector<std::string> univ_words {split(univ_str)};
vector<std::string> univ_words {split(univ_str)};
if (univ_words.size() != n_univ) {
fatal_error(fmt::format(
"Expected {} universes for a hexagonal lattice with {} rings and {} "
@ -516,8 +514,7 @@ HexLattice::HexLattice(pugi::xml_node lat_node)
//==============================================================================
void
HexLattice::fill_lattice_x(const std::vector<std::string>& univ_words)
void HexLattice::fill_lattice_x(const vector<std::string>& univ_words)
{
int input_index = 0;
for (int m = 0; m < n_axial_; m++) {
@ -569,8 +566,7 @@ HexLattice::fill_lattice_x(const std::vector<std::string>& univ_words)
//==============================================================================
void
HexLattice::fill_lattice_y(const std::vector<std::string>& univ_words)
void HexLattice::fill_lattice_y(const vector<std::string>& univ_words)
{
int input_index = 0;
for (int m = 0; m < n_axial_; m++) {
@ -689,9 +685,8 @@ HexLattice::are_valid_indices(const int i_xyz[3]) const
//==============================================================================
std::pair<double, std::array<int, 3>>
HexLattice::distance(Position r, Direction u, const std::array<int, 3>& i_xyz)
const
std::pair<double, array<int, 3>> HexLattice::distance(
Position r, Direction u, const array<int, 3>& i_xyz) const
{
// Short description of the direction vectors used here. The beta, gamma, and
// delta vectors point towards the flat sides of each hexagonal tile.
@ -729,14 +724,14 @@ const
// beta direction
double d {INFTY};
std::array<int, 3> lattice_trans;
array<int, 3> lattice_trans;
double edge = -copysign(0.5*pitch_[0], beta_dir); // Oncoming edge
Position r_t;
if (beta_dir > 0) {
const std::array<int, 3> i_xyz_t {i_xyz[0]+1, i_xyz[1], i_xyz[2]};
const array<int, 3> i_xyz_t {i_xyz[0] + 1, i_xyz[1], i_xyz[2]};
r_t = get_local_position(r, i_xyz_t);
} else {
const std::array<int, 3> i_xyz_t {i_xyz[0]-1, i_xyz[1], i_xyz[2]};
const array<int, 3> i_xyz_t {i_xyz[0] - 1, i_xyz[1], i_xyz[2]};
r_t = get_local_position(r, i_xyz_t);
}
double beta;
@ -757,10 +752,10 @@ const
// gamma direction
edge = -copysign(0.5*pitch_[0], gamma_dir);
if (gamma_dir > 0) {
const std::array<int, 3> i_xyz_t {i_xyz[0]+1, i_xyz[1]-1, i_xyz[2]};
const array<int, 3> i_xyz_t {i_xyz[0] + 1, i_xyz[1] - 1, i_xyz[2]};
r_t = get_local_position(r, i_xyz_t);
} else {
const std::array<int, 3> i_xyz_t {i_xyz[0]-1, i_xyz[1]+1, i_xyz[2]};
const array<int, 3> i_xyz_t {i_xyz[0] - 1, i_xyz[1] + 1, i_xyz[2]};
r_t = get_local_position(r, i_xyz_t);
}
double gamma;
@ -784,10 +779,10 @@ const
// delta direction
edge = -copysign(0.5*pitch_[0], delta_dir);
if (delta_dir > 0) {
const std::array<int, 3> i_xyz_t {i_xyz[0], i_xyz[1]+1, i_xyz[2]};
const array<int, 3> i_xyz_t {i_xyz[0], i_xyz[1] + 1, i_xyz[2]};
r_t = get_local_position(r, i_xyz_t);
} else {
const std::array<int, 3> i_xyz_t {i_xyz[0], i_xyz[1]-1, i_xyz[2]};
const array<int, 3> i_xyz_t {i_xyz[0], i_xyz[1] - 1, i_xyz[2]};
r_t = get_local_position(r, i_xyz_t);
}
double delta;
@ -1028,9 +1023,9 @@ HexLattice::to_hdf5_inner(hid_t lat_group) const
write_dataset(lat_group, "pitch", pitch_);
write_dataset(lat_group, "center", center_);
} else {
std::array<double, 1> pitch_short {{pitch_[0]}};
array<double, 1> pitch_short {{pitch_[0]}};
write_dataset(lat_group, "pitch", pitch_short);
std::array<double, 2> center_short {{center_[0], center_[1]}};
array<double, 2> center_short {{center_[0], center_[1]}};
write_dataset(lat_group, "center", center_short);
}
@ -1038,7 +1033,7 @@ HexLattice::to_hdf5_inner(hid_t lat_group) const
hsize_t nx {static_cast<hsize_t>(2*n_rings_ - 1)};
hsize_t ny {static_cast<hsize_t>(2*n_rings_ - 1)};
hsize_t nz {static_cast<hsize_t>(n_axial_)};
std::vector<int> out(nx*ny*nz);
vector<int> out(nx * ny * nz);
for (int m = 0; m < nz; m++) {
for (int k = 0; k < ny; k++) {

40
src/material.cpp
View file

@ -39,7 +39,7 @@ namespace openmc {
namespace model {
std::unordered_map<int32_t, int32_t> material_map;
std::vector<std::unique_ptr<Material>> materials;
vector<unique_ptr<Material>> materials;
} // namespace model
@ -127,8 +127,8 @@ Material::Material(pugi::xml_node node)
auto node_macros = node.children("macroscopic");
int num_macros = std::distance(node_macros.begin(), node_macros.end());
std::vector<std::string> names;
std::vector<double> densities;
vector<std::string> names;
vector<double> densities;
if (settings::run_CE && num_macros > 0) {
fatal_error("Macroscopic can not be used in continuous-energy mode.");
} else if (num_macros > 1) {
@ -194,7 +194,7 @@ Material::Material(pugi::xml_node node)
// =======================================================================
// READ AND PARSE <isotropic> element
std::vector<std::string> iso_lab;
vector<std::string> iso_lab;
if (check_for_node(node, "isotropic")) {
iso_lab = get_node_array<std::string>(node, "isotropic");
}
@ -295,7 +295,7 @@ Material::Material(pugi::xml_node node)
if (settings::run_CE) {
// Loop over <sab> elements
std::vector<std::string> sab_names;
vector<std::string> sab_names;
for (auto node_sab : node.children("sab")) {
// Determine name of thermal scattering table
if (!check_for_node(node_sab, "name")) {
@ -413,7 +413,7 @@ void Material::normalize_density()
void Material::init_thermal()
{
std::vector<ThermalTable> tables;
vector<ThermalTable> tables;
std::unordered_set<int> already_checked;
for (const auto& table : thermal_tables_) {
@ -481,8 +481,8 @@ void Material::collision_stopping_power(double* s_col, bool positron)
// Oscillator strength and square of the binding energy for each oscillator
// in material
std::vector<double> f;
std::vector<double> e_b_sq;
vector<double> f;
vector<double> e_b_sq;
for (int i = 0; i < element_.size(); ++i) {
const auto& elm = *data::elements[element_[i]];
@ -936,8 +936,8 @@ void Material::set_density(double density, gsl::cstring_span units)
}
}
void Material::set_densities(const std::vector<std::string>& name,
const std::vector<double>& density)
void Material::set_densities(
const vector<std::string>& name, const vector<double>& density)
{
auto n = name.size();
Expects(n > 0);
@ -1010,9 +1010,9 @@ void Material::to_hdf5(hid_t group) const
write_dataset(material_group, "atom_density", density_);
// Copy nuclide/macro name for each nuclide to vector
std::vector<std::string> nuc_names;
std::vector<std::string> macro_names;
std::vector<double> nuc_densities;
vector<std::string> nuc_names;
vector<std::string> macro_names;
vector<double> nuc_densities;
if (settings::run_CE) {
for (int i = 0; i < nuclide_.size(); ++i) {
int i_nuc = nuclide_[i];
@ -1043,7 +1043,7 @@ void Material::to_hdf5(hid_t group) const
}
if (!thermal_tables_.empty()) {
std::vector<std::string> sab_names;
vector<std::string> sab_names;
for (const auto& table : thermal_tables_) {
sab_names.push_back(data::thermal_scatt[table.index_table]->name_);
}
@ -1099,9 +1099,9 @@ void Material::add_nuclide(const std::string& name, double density)
// Non-method functions
//==============================================================================
double sternheimer_adjustment(const std::vector<double>& f, const
std::vector<double>& e_b_sq, double e_p_sq, double n_conduction, double
log_I, double tol, int max_iter)
double sternheimer_adjustment(const vector<double>& f,
const vector<double>& e_b_sq, double e_p_sq, double n_conduction,
double log_I, double tol, int max_iter)
{
// Get the total number of oscillators
int n = f.size();
@ -1144,9 +1144,9 @@ double sternheimer_adjustment(const std::vector<double>& f, const
return rho;
}
double density_effect(const std::vector<double>& f, const std::vector<double>&
e_b_sq, double e_p_sq, double n_conduction, double rho, double E, double tol,
int max_iter)
double density_effect(const vector<double>& f,
const std::vector<double>& e_b_sq, double e_p_sq, double n_conduction,
double rho, double E, double tol, int max_iter)
{
// Get the total number of oscillators
int n = f.size();

8
src/math_functions.cpp
View file

@ -537,8 +537,8 @@ void calc_zn(int n, double rho, double phi, double zn[]) {
double sin_phi = std::sin(phi);
double cos_phi = std::cos(phi);
std::vector<double> sin_phi_vec(n + 1); // Sin[n * phi]
std::vector<double> cos_phi_vec(n + 1); // Cos[n * phi]
vector<double> sin_phi_vec(n + 1); // Sin[n * phi]
vector<double> cos_phi_vec(n + 1); // Cos[n * phi]
sin_phi_vec[0] = 1.0;
cos_phi_vec[0] = 1.0;
sin_phi_vec[1] = 2.0 * cos_phi;
@ -556,7 +556,7 @@ void calc_zn(int n, double rho, double phi, double zn[]) {
// ===========================================================================
// Calculate R_pq(rho)
// Matrix forms of the coefficients which are easier to work with
std::vector<std::vector<double>> zn_mat(n + 1, std::vector<double>(n + 1));
vector<std::vector<double>> zn_mat(n + 1, std::vector<double>(n + 1));
// Fill the main diagonal first (Eq 3.9 in Chong)
for (int p = 0; p <= n; p++) {
@ -720,7 +720,7 @@ double watt_spectrum(double a, double b, uint64_t* seed) {
void spline(int n, const double x[], const double y[], double z[])
{
std::vector<double> c_new(n-1);
vector<double> c_new(n - 1);
// Set natural boundary conditions
c_new[0] = 0.0;

113
src/mesh.cpp
View file

@ -2,7 +2,6 @@
#include <algorithm> // for copy, equal, min, min_element
#include <cstddef> // for size_t
#include <cmath> // for ceil
#include <memory> // for allocator
#include <string>
#include <gsl/gsl>
@ -25,11 +24,12 @@
#include "openmc/error.h"
#include "openmc/file_utils.h"
#include "openmc/hdf5_interface.h"
#include "openmc/memory.h"
#include "openmc/message_passing.h"
#include "openmc/search.h"
#include "openmc/settings.h"
#include "openmc/tallies/tally.h"
#include "openmc/tallies/filter.h"
#include "openmc/tallies/tally.h"
#include "openmc/xml_interface.h"
#ifdef LIBMESH
@ -53,13 +53,13 @@ const bool LIBMESH_ENABLED = false;
namespace model {
std::unordered_map<int32_t, int32_t> mesh_map;
std::vector<std::unique_ptr<Mesh>> meshes;
vector<unique_ptr<Mesh>> meshes;
} // namespace model
#ifdef LIBMESH
namespace settings {
std::unique_ptr<libMesh::LibMeshInit> libmesh_init;
unique_ptr<libMesh::LibMeshInit> libmesh_init;
const libMesh::Parallel::Communicator* libmesh_comm {nullptr};
}
#endif
@ -143,7 +143,7 @@ Mesh::set_id(int32_t id) {
std::string
StructuredMesh::bin_label(int bin) const {
std::vector<int> ijk(n_dimension_);
vector<int> ijk(n_dimension_);
get_indices_from_bin(bin, ijk.data());
if (n_dimension_ > 2) {
@ -192,7 +192,7 @@ UnstructuredMesh::UnstructuredMesh(pugi::xml_node node) : Mesh(node) {
void
UnstructuredMesh::surface_bins_crossed(Position r0,
Position r1,
std::vector<int>& bins) const {
vector<int>& bins) const {
fatal_error("Unstructured mesh surface tallies are not implemented.");
}
@ -210,7 +210,7 @@ UnstructuredMesh::to_hdf5(hid_t group) const
write_dataset(mesh_group, "filename", filename_);
write_dataset(mesh_group, "library", this->library());
// write volume of each element
std::vector<double> tet_vols;
vector<double> tet_vols;
xt::xtensor<double, 2> centroids({static_cast<size_t>(this->n_bins()), 3});
for (int i = 0; i < this->n_bins(); i++) {
tet_vols.emplace_back(this->volume(i));
@ -264,7 +264,7 @@ void StructuredMesh::get_indices_from_bin(int bin, int* ijk) const
int StructuredMesh::get_bin(Position r) const
{
// Determine indices
std::vector<int> ijk(n_dimension_);
vector<int> ijk(n_dimension_);
bool in_mesh;
get_indices(r, ijk.data(), &in_mesh);
if (!in_mesh) return -1;
@ -288,7 +288,7 @@ xt::xtensor<double, 1> StructuredMesh::count_sites(
{
// Determine shape of array for counts
std::size_t m = this->n_bins();
std::vector<std::size_t> shape = {m};
vector<std::size_t> shape = {m};
// Create array of zeros
xt::xarray<double> cnt {shape, 0.0};
@ -583,8 +583,8 @@ bool StructuredMesh::intersects_3d(Position& r0, Position r1, int* ijk) const
void StructuredMesh::bins_crossed(Position r0,
Position r1,
const Direction& u,
std::vector<int>& bins,
std::vector<double>& lengths) const
vector<int>& bins,
vector<double>& lengths) const
{
// ========================================================================
// Determine where the track intersects the mesh and if it intersects at all.
@ -600,7 +600,7 @@ void StructuredMesh::bins_crossed(Position r0,
Position r = r1 - TINY_BIT*u;
// Determine the mesh indices for the starting and ending coords. Here, we
// use arrays for ijk0 and ijk1 instead of std::vector because we obtain a
// use arrays for ijk0 and ijk1 instead of vector because we obtain a
// small performance improvement by forcing this data to live on the stack,
// rather than on the heap. We know the maximum length is 3, and by
// ensuring that all loops are only indexed up to n_dimension, we will not
@ -798,11 +798,11 @@ void
RegularMesh::surface_bins_crossed(Position r0,
Position r1,
const Direction& u,
std::vector<int>& bins) const
vector<int>& bins) const
{
// Determine indices for starting and ending location.
int n = n_dimension_;
std::vector<int> ijk0(n), ijk1(n);
vector<int> ijk0(n), ijk1(n);
bool start_in_mesh;
get_indices(r0, ijk0.data(), &start_in_mesh);
bool end_in_mesh;
@ -811,7 +811,7 @@ RegularMesh::surface_bins_crossed(Position r0,
// Check if the track intersects any part of the mesh.
if (!start_in_mesh) {
Position r0_copy = r0;
std::vector<int> ijk0_copy(ijk0);
vector<int> ijk0_copy(ijk0);
if (!intersects(r0_copy, r1, ijk0_copy.data())) return;
}
@ -938,11 +938,11 @@ RegularMesh::surface_bins_crossed(Position r0,
}
}
std::pair<std::vector<double>, std::vector<double>>
RegularMesh::plot(Position plot_ll, Position plot_ur) const
std::pair<vector<double>, std::vector<double>> RegularMesh::plot(
Position plot_ll, Position plot_ur) const
{
// Figure out which axes lie in the plane of the plot.
std::array<int, 2> axes {-1, -1};
array<int, 2> axes {-1, -1};
if (plot_ur.z == plot_ll.z) {
axes[0] = 0;
if (n_dimension_ > 1) axes[1] = 1;
@ -957,7 +957,7 @@ RegularMesh::plot(Position plot_ll, Position plot_ur) const
}
// Get the coordinates of the mesh lines along both of the axes.
std::array<std::vector<double>, 2> axis_lines;
array<vector<double>, 2> axis_lines;
for (int i_ax = 0; i_ax < 2; ++i_ax) {
int axis = axes[i_ax];
if (axis == -1) continue;
@ -992,7 +992,7 @@ xt::xtensor<double, 1> RegularMesh::count_sites(
{
// Determine shape of array for counts
std::size_t m = this->n_bins();
std::vector<std::size_t> shape = {m};
vector<std::size_t> shape = {m};
// Create array of zeros
xt::xarray<double> cnt {shape, 0.0};
@ -1100,7 +1100,7 @@ int RectilinearMesh::set_grid()
void RectilinearMesh::surface_bins_crossed(Position r0,
Position r1,
const Direction& u,
std::vector<int>& bins) const
vector<int>& bins) const
{
// Determine indices for starting and ending location.
int ijk0[3], ijk1[3];
@ -1264,11 +1264,11 @@ int RectilinearMesh::get_index_in_direction(double r, int i) const
return lower_bound_index(grid_[i].begin(), grid_[i].end(), r) + 1;
}
std::pair<std::vector<double>, std::vector<double>>
RectilinearMesh::plot(Position plot_ll, Position plot_ur) const
std::pair<vector<double>, std::vector<double>> RectilinearMesh::plot(
Position plot_ll, Position plot_ur) const
{
// Figure out which axes lie in the plane of the plot.
std::array<int, 2> axes {-1, -1};
array<int, 2> axes {-1, -1};
if (plot_ur.z == plot_ll.z) {
axes = {0, 1};
} else if (plot_ur.y == plot_ll.y) {
@ -1280,10 +1280,10 @@ RectilinearMesh::plot(Position plot_ll, Position plot_ur) const
}
// Get the coordinates of the mesh lines along both of the axes.
std::array<std::vector<double>, 2> axis_lines;
array<vector<double>, 2> axis_lines;
for (int i_ax = 0; i_ax < 2; ++i_ax) {
int axis = axes[i_ax];
std::vector<double>& lines {axis_lines[i_ax]};
vector<double>& lines {axis_lines[i_ax]};
for (auto coord : grid_[axis]) {
if (coord >= plot_ll[axis] && coord <= plot_ur[axis])
@ -1466,7 +1466,7 @@ openmc_regular_mesh_set_dimension(int32_t index, int n, const int* dims)
RegularMesh* mesh = dynamic_cast<RegularMesh*>(model::meshes[index].get());
// Copy dimension
std::vector<std::size_t> shape = {static_cast<std::size_t>(n)};
vector<std::size_t> shape = {static_cast<std::size_t>(n)};
mesh->shape_ = xt::adapt(dims, n, xt::no_ownership(), shape);
mesh->n_dimension_ = mesh->shape_.size();
return 0;
@ -1500,7 +1500,7 @@ openmc_regular_mesh_set_params(int32_t index, int n, const double* ll,
if (int err = check_mesh_type<RegularMesh>(index)) return err;
RegularMesh* m = dynamic_cast<RegularMesh*>(model::meshes[index].get());
std::vector<std::size_t> shape = {static_cast<std::size_t>(n)};
vector<std::size_t> shape = {static_cast<std::size_t>(n)};
if (ll && ur) {
m->lower_left_ = xt::adapt(ll, n, xt::no_ownership(), shape);
m->upper_right_ = xt::adapt(ur, n, xt::no_ownership(), shape);
@ -1653,15 +1653,13 @@ MOABMesh::build_kdtree(const moab::Range& all_tets)
}
}
void
MOABMesh::intersect_track(const moab::CartVect& start,
const moab::CartVect& dir,
double track_len,
std::vector<double>& hits) const {
void MOABMesh::intersect_track(const moab::CartVect& start,
const moab::CartVect& dir, double track_len, vector<double>& hits) const
{
hits.clear();
moab::ErrorCode rval;
std::vector<moab::EntityHandle> tris;
vector<moab::EntityHandle> tris;
// get all intersections with triangles in the tet mesh
// (distances are relative to the start point, not the previous intersection)
rval = kdtree_->ray_intersect_triangles(kdtree_root_,
@ -1681,15 +1679,14 @@ MOABMesh::intersect_track(const moab::CartVect& start,
// sorts by first component of std::pair by default
std::sort(hits.begin(), hits.end());
}
void
MOABMesh::bins_crossed(Position r0,
Position r1,
const Direction& u,
std::vector<int>& bins,
std::vector<double>& lengths) const
vector<int>& bins,
vector<double>& lengths) const
{
moab::CartVect start(r0.x, r0.y, r0.z);
moab::CartVect end(r1.x, r1.y, r1.z);
@ -1702,7 +1699,7 @@ MOABMesh::bins_crossed(Position r0,
start -= TINY_BIT * dir;
end += TINY_BIT * dir;
std::vector<double> hits;
vector<double> hits;
intersect_track(start, dir, track_len, hits);
bins.clear();
@ -1801,7 +1798,7 @@ std::string MOABMesh::library() const
double MOABMesh::tet_volume(moab::EntityHandle tet) const
{
std::vector<moab::EntityHandle> conn;
vector<moab::EntityHandle> conn;
moab::ErrorCode rval = mbi_->get_connectivity(&tet, 1, conn);
if (rval != moab::MB_SUCCESS) {
fatal_error("Failed to get tet connectivity");
@ -1846,7 +1843,7 @@ MOABMesh::compute_barycentric_data(const moab::Range& tets) {
// compute the barycentric data for each tet element
// and store it as a 3x3 matrix
for (auto& tet : tets) {
std::vector<moab::EntityHandle> verts;
vector<moab::EntityHandle> verts;
rval = mbi_->get_connectivity(&tet, 1, verts);
if (rval != moab::MB_SUCCESS) {
fatal_error("Failed to get connectivity of tet on umesh: " + filename_);
@ -1874,7 +1871,7 @@ MOABMesh::point_in_tet(const moab::CartVect& r,
moab::ErrorCode rval;
// get tet vertices
std::vector<moab::EntityHandle> verts;
vector<moab::EntityHandle> verts;
rval = mbi_->get_connectivity(&tet, 1, verts);
if (rval != moab::MB_SUCCESS) {
warning("Failed to get vertices of tet in umesh: " + filename_);
@ -1926,8 +1923,8 @@ int MOABMesh::get_index_from_bin(int bin) const
return bin;
}
std::pair<std::vector<double>, std::vector<double>>
MOABMesh::plot(Position plot_ll, Position plot_ur) const
std::pair<vector<double>, std::vector<double>> MOABMesh::plot(
Position plot_ll, Position plot_ur) const
{
// TODO: Implement mesh lines
return {};
@ -1978,7 +1975,7 @@ MOABMesh::centroid(int bin) const
auto tet = this->get_ent_handle_from_bin(bin);
// look up the tet connectivity
std::vector<moab::EntityHandle> conn;
vector<moab::EntityHandle> conn;
rval = mbi_->get_connectivity(&tet, 1, conn);
if (rval != moab::MB_SUCCESS) {
warning("Failed to get connectivity of a mesh element.");
@ -1986,7 +1983,7 @@ MOABMesh::centroid(int bin) const
}
// get the coordinates
std::vector<moab::CartVect> coords(conn.size());
vector<moab::CartVect> coords(conn.size());
rval = mbi_->get_coords(conn.data(), conn.size(), coords[0].array());
if (rval != moab::MB_SUCCESS) {
warning("Failed to get the coordinates of a mesh element.");
@ -2085,10 +2082,8 @@ void MOABMesh::remove_scores()
tag_names_.clear();
}
void
MOABMesh::set_score_data(const std::string& score,
const std::vector<double>& values,
const std::vector<double>& std_dev)
void MOABMesh::set_score_data(const std::string& score,
const vector<double>& values, const vector<double>& std_dev)
{
auto score_tags = this->get_score_tags(score);
@ -2259,10 +2254,8 @@ LibMesh::remove_scores()
variable_map_.clear();
}
void
LibMesh::set_score_data(const std::string& var_name,
const std::vector<double>& values,
const std::vector<double>& std_dev)
void LibMesh::set_score_data(const std::string& var_name,
const vector<double>& values, const vector<double>& std_dev)
{
auto& eqn_sys = equation_systems_->get_system(eq_system_name_);
@ -2281,13 +2274,13 @@ LibMesh::set_score_data(const std::string& var_name,
auto bin = get_bin_from_element(*it);
// set value
std::vector<libMesh::dof_id_type> value_dof_indices;
vector<libMesh::dof_id_type> value_dof_indices;
dof_map.dof_indices(*it, value_dof_indices, value_num);
Ensures(value_dof_indices.size() == 1);
eqn_sys.solution->set(value_dof_indices[0], values.at(bin));
// set std dev
std::vector<libMesh::dof_id_type> std_dev_dof_indices;
vector<libMesh::dof_id_type> std_dev_dof_indices;
dof_map.dof_indices(*it, std_dev_dof_indices, std_dev_num);
Ensures(std_dev_dof_indices.size() == 1);
eqn_sys.solution->set(std_dev_dof_indices[0], std_dev.at(bin));
@ -2306,8 +2299,8 @@ void
LibMesh::bins_crossed(Position r0,
Position r1,
const Direction& u,
std::vector<int>& bins,
std::vector<double>& lengths) const
vector<int>& bins,
vector<double>& lengths) const
{
// TODO: Implement triangle crossings here
fatal_error("Tracklength tallies on libMesh instances are not implemented.");
@ -2344,8 +2337,8 @@ LibMesh::get_bin_from_element(const libMesh::Elem* elem) const
return bin;
}
std::pair<std::vector<double>, std::vector<double>>
LibMesh::plot(Position plot_ll, Position plot_ur) const
std::pair<vector<double>, std::vector<double>> LibMesh::plot(
Position plot_ll, Position plot_ur) const
{
return {};
}
@ -2416,7 +2409,7 @@ void meshes_to_hdf5(hid_t group)
if (n_meshes > 0) {
// Write IDs of meshes
std::vector<int> ids;
vector<int> ids;
for (const auto& m : model::meshes) {
m->to_hdf5(meshes_group);
ids.push_back(m->id_);

63
src/mgxs.cpp
View file

@ -29,11 +29,10 @@ namespace openmc {
// Mgxs base-class methods
//==============================================================================
void
Mgxs::init(const std::string& in_name, double in_awr,
const std::vector<double>& in_kTs, bool in_fissionable,
AngleDistributionType in_scatter_format, bool in_is_isotropic,
const std::vector<double>& in_polar, const std::vector<double>& in_azimuthal)
void Mgxs::init(const std::string& in_name, double in_awr,
const vector<double>& in_kTs, bool in_fissionable,
AngleDistributionType in_scatter_format, bool in_is_isotropic,
const vector<double>& in_polar, const std::vector<double>& in_azimuthal)
{
// Set the metadata
name = in_name;
@ -56,14 +55,13 @@ Mgxs::init(const std::string& in_name, double in_awr,
int n_threads = 1;
#endif
cache.resize(n_threads);
// std::vector.resize() will value-initialize the members of cache[:]
// vector.resize() will value-initialize the members of cache[:]
}
//==============================================================================
void
Mgxs::metadata_from_hdf5(hid_t xs_id, const std::vector<double>& temperature,
std::vector<int>& temps_to_read, int& order_dim)
void Mgxs::metadata_from_hdf5(hid_t xs_id, const vector<double>& temperature,
vector<int>& temps_to_read, int& order_dim)
{
// get name
char char_name[MAX_WORD_LEN];
@ -88,7 +86,7 @@ Mgxs::metadata_from_hdf5(hid_t xs_id, const std::vector<double>& temperature,
dset_names[i] = new char[151];
}
get_datasets(kT_group, dset_names);
std::vector<size_t> shape = {num_temps};
vector<size_t> shape = {num_temps};
xt::xarray<double> available_temps(shape);
for (int i = 0; i < num_temps; i++) {
read_double(kT_group, dset_names[i], &available_temps[i], true);
@ -160,7 +158,7 @@ Mgxs::metadata_from_hdf5(hid_t xs_id, const std::vector<double>& temperature,
// Get the library's temperatures
int n_temperature = temps_to_read.size();
std::vector<double> in_kTs(n_temperature);
vector<double> in_kTs(n_temperature);
for (int i = 0; i < n_temperature; i++) {
std::string temp_str(std::to_string(temps_to_read[i]) + "K");
@ -254,12 +252,12 @@ Mgxs::metadata_from_hdf5(hid_t xs_id, const std::vector<double>& temperature,
}
// Set the angular bins to use equally-spaced bins
std::vector<double> in_polar(in_n_pol);
vector<double> in_polar(in_n_pol);
double dangle = PI / in_n_pol;
for (int p = 0; p < in_n_pol; p++) {
in_polar[p] = (p + 0.5) * dangle;
}
std::vector<double> in_azimuthal(in_n_azi);
vector<double> in_azimuthal(in_n_azi);
dangle = 2. * PI / in_n_azi;
for (int a = 0; a < in_n_azi; a++) {
in_azimuthal[a] = (a + 0.5) * dangle - PI;
@ -273,14 +271,13 @@ Mgxs::metadata_from_hdf5(hid_t xs_id, const std::vector<double>& temperature,
//==============================================================================
Mgxs::Mgxs(hid_t xs_id, const std::vector<double>& temperature,
int num_group, int num_delay) :
num_groups(num_group),
num_delayed_groups(num_delay)
Mgxs::Mgxs(
hid_t xs_id, const vector<double>& temperature, int num_group, int num_delay)
: num_groups(num_group), num_delayed_groups(num_delay)
{
// Call generic data gathering routine (will populate the metadata)
int order_data;
std::vector<int> temps_to_read;
vector<int> temps_to_read;
metadata_from_hdf5(xs_id, temperature, temps_to_read, order_data);
// Set number of energy and delayed groups
@ -309,11 +306,10 @@ Mgxs::Mgxs(hid_t xs_id, const std::vector<double>& temperature,
//==============================================================================
Mgxs::Mgxs(const std::string& in_name, const std::vector<double>& mat_kTs,
const std::vector<Mgxs*>& micros, const std::vector<double>& atom_densities,
int num_group, int num_delay) :
num_groups(num_group),
num_delayed_groups(num_delay)
Mgxs::Mgxs(const std::string& in_name, const vector<double>& mat_kTs,
const vector<Mgxs*>& micros, const std::vector<double>& atom_densities,
int num_group, int num_delay)
: num_groups(num_group), num_delayed_groups(num_delay)
{
// Get the minimum data needed to initialize:
// Dont need awr, but lets just initialize it anyways
@ -328,8 +324,8 @@ Mgxs::Mgxs(const std::string& in_name, const std::vector<double>& mat_kTs,
// to be true later
AngleDistributionType in_scatter_format = micros[0]->scatter_format;
bool in_is_isotropic = micros[0]->is_isotropic;
std::vector<double> in_polar = micros[0]->polar;
std::vector<double> in_azimuthal = micros[0]->azimuthal;
vector<double> in_polar = micros[0]->polar;
vector<double> in_azimuthal = micros[0]->azimuthal;
init(in_name, in_awr, mat_kTs, in_fissionable, in_scatter_format,
in_is_isotropic, in_polar, in_azimuthal);
@ -344,8 +340,8 @@ Mgxs::Mgxs(const std::string& in_name, const std::vector<double>& mat_kTs,
// Create the list of temperature indices and interpolation factors for
// each microscopic data at the material temperature
std::vector<int> micro_t(micros.size(), 0);
std::vector<double> micro_t_interp(micros.size(), 0.);
vector<int> micro_t(micros.size(), 0);
vector<double> micro_t_interp(micros.size(), 0.);
for (int m = 0; m < micros.size(); m++) {
switch(settings::temperature_method) {
case TemperatureMethod::NEAREST:
@ -383,9 +379,9 @@ Mgxs::Mgxs(const std::string& in_name, const std::vector<double>& mat_kTs,
// a different nuclide. Mathematically this just means the temperature
// interpolant is included in the number density.
// These interpolants are contained within interpolant.
std::vector<double> interpolant; // the interpolant for the Mgxs
std::vector<int> temp_indices; // the temperature index for each Mgxs
std::vector<Mgxs*> mgxs_to_combine; // The Mgxs to combine
vector<double> interpolant; // the interpolant for the Mgxs
vector<int> temp_indices; // the temperature index for each Mgxs
vector<Mgxs*> mgxs_to_combine; // The Mgxs to combine
// Now go through and build the above vectors so that we can use them to
// combine the data. We will step through each microscopic data and
// add in its lower and upper temperature points
@ -419,12 +415,11 @@ Mgxs::Mgxs(const std::string& in_name, const std::vector<double>& mat_kTs,
//==============================================================================
void
Mgxs::combine(const std::vector<Mgxs*>& micros, const std::vector<double>& scalars,
const std::vector<int>& micro_ts, int this_t)
void Mgxs::combine(const vector<Mgxs*>& micros,
const std::vector<double>& scalars, const vector<int>& micro_ts, int this_t)
{
// Build the vector of pointers to the xs objects within micros
std::vector<XsData*> those_xs(micros.size());
vector<XsData*> those_xs(micros.size());
for (int i = 0; i < micros.size(); i++) {
those_xs[i] = &(micros[i]->xs[micro_ts[i]]);
}

30
src/mgxs_interface.cpp
View file

@ -29,8 +29,8 @@ namespace data {
}
MgxsInterface::MgxsInterface(const std::string& path_cross_sections,
const std::vector<std::string> xs_to_read,
const std::vector<std::vector<double>> xs_temps)
const vector<std::string> xs_to_read,
const vector<std::vector<double>> xs_temps)
{
read_header(path_cross_sections);
set_nuclides_and_temperatures(xs_to_read, xs_temps);
@ -38,8 +38,7 @@ MgxsInterface::MgxsInterface(const std::string& path_cross_sections,
}
void MgxsInterface::set_nuclides_and_temperatures(
std::vector<std::string> xs_to_read,
std::vector<std::vector<double>> xs_temps)
vector<std::string> xs_to_read, vector<std::vector<double>> xs_temps)
{
// Check to remove all duplicates
xs_to_read_ = xs_to_read;
@ -76,7 +75,7 @@ void MgxsInterface::init()
// Read revision number for the MGXS Library file and make sure it matches
// with the current version
std::array<int, 2> array;
array<int, 2> array;
read_attribute(file_id, "version", array);
if (array != VERSION_MGXS_LIBRARY) {
fatal_error("MGXS Library file version does not match current version "
@ -95,9 +94,8 @@ void MgxsInterface::init()
//==============================================================================
void
MgxsInterface::add_mgxs(hid_t file_id, const std::string& name,
const std::vector<double>& temperature)
void MgxsInterface::add_mgxs(
hid_t file_id, const std::string& name, const vector<double>& temperature)
{
write_message(5, "Loading {} data...", name);
@ -129,12 +127,12 @@ void MgxsInterface::create_macro_xs()
if (kTs[i].size() > 0) {
// Convert atom_densities to a vector
auto& mat {model::materials[i]};
std::vector<double> atom_densities(mat->atom_density_.begin(),
mat->atom_density_.end());
vector<double> atom_densities(
mat->atom_density_.begin(), mat->atom_density_.end());
// Build array of pointers to nuclides's Mgxs objects needed for this
// material
std::vector<Mgxs*> mgxs_ptr;
vector<Mgxs*> mgxs_ptr;
for (int i_nuclide : mat->nuclide_) {
mgxs_ptr.push_back(&nuclides_[i_nuclide]);
}
@ -150,9 +148,9 @@ void MgxsInterface::create_macro_xs()
//==============================================================================
std::vector<std::vector<double>> MgxsInterface::get_mat_kTs()
vector<std::vector<double>> MgxsInterface::get_mat_kTs()
{
std::vector<std::vector<double>> kTs(model::materials.size());
vector<std::vector<double>> kTs(model::materials.size());
for (const auto& cell : model::cells) {
// Skip non-material cells
@ -248,12 +246,12 @@ void put_mgxs_header_data_to_globals()
void set_mg_interface_nuclides_and_temps()
{
// Get temperatures from global data
std::vector<std::vector<double>> nuc_temps(data::nuclide_map.size());
std::vector<std::vector<double>> dummy;
vector<std::vector<double>> nuc_temps(data::nuclide_map.size());
vector<std::vector<double>> dummy;
get_temperatures(nuc_temps, dummy);
// Build vector of nuclide names which are to be read
std::vector<std::string> nuclide_names(data::nuclide_map.size());
vector<std::string> nuclide_names(data::nuclide_map.size());
for (const auto& kv : data::nuclide_map) {
nuclide_names[kv.second] = kv.first;
}

18
src/nuclide.cpp
View file

@ -30,12 +30,12 @@ namespace openmc {
//==============================================================================
namespace data {
std::array<double, 2> energy_min {0.0, 0.0};
std::array<double, 2> energy_max {INFTY, INFTY};
array<double, 2> energy_min {0.0, 0.0};
array<double, 2> energy_max {INFTY, INFTY};
double temperature_min {INFTY};
double temperature_max {0.0};
std::unordered_map<std::string, int> nuclide_map;
std::vector<std::unique_ptr<Nuclide>> nuclides;
vector<unique_ptr<Nuclide>> nuclides;
} // namespace data
//==============================================================================
@ -48,7 +48,7 @@ int Nuclide::XS_FISSION {2};
int Nuclide::XS_NU_FISSION {3};
int Nuclide::XS_PHOTON_PROD {4};
Nuclide::Nuclide(hid_t group, const std::vector<double>& temperature)
Nuclide::Nuclide(hid_t group, const vector<double>& temperature)
{
// Set index of nuclide in global vector
index_ = data::nuclides.size();
@ -65,7 +65,7 @@ Nuclide::Nuclide(hid_t group, const std::vector<double>& temperature)
// Determine temperatures available
hid_t kT_group = open_group(group, "kTs");
auto dset_names = dataset_names(kT_group);
std::vector<double> temps_available;
vector<double> temps_available;
for (const auto& name : dset_names) {
double T;
read_dataset(kT_group, name.c_str(), T);
@ -86,7 +86,7 @@ Nuclide::Nuclide(hid_t group, const std::vector<double>& temperature)
// temperature range was given (indicated by T_max > 0), in which case all
// temperatures in the range are loaded irrespective of what temperatures
// actually appear in the model
std::vector<int> temps_to_read;
vector<int> temps_to_read;
int n = temperature.size();
double T_min = n > 0 ? settings::temperature_range[0] : 0.0;
double T_max = n > 0 ? settings::temperature_range[1] : INFTY;
@ -310,7 +310,7 @@ void Nuclide::create_derived(const Function1D* prompt_photons, const Function1D*
{
for (const auto& grid : grid_) {
// Allocate and initialize cross section
std::array<size_t, 2> shape {grid.energy.size(), 5};
array<size_t, 2> shape {grid.energy.size(), 5};
xs_.emplace_back(shape, 0.0);
}
@ -999,7 +999,7 @@ double Nuclide::collapse_rate(int MT, double temperature, gsl::span<const double
void check_data_version(hid_t file_id)
{
if (attribute_exists(file_id, "version")) {
std::vector<int> version;
vector<int> version;
read_attribute(file_id, "version", version);
if (version[0] != HDF5_VERSION[0]) {
fatal_error("HDF5 data format uses version " + std::to_string(version[0])
@ -1046,7 +1046,7 @@ extern "C" int openmc_load_nuclide(const char* name, const double* temps, int n)
// Read nuclide data from HDF5
hid_t group = open_group(file_id, name);
std::vector<double> temperature{temps, temps + n};
vector<double> temperature {temps, temps + n};
data::nuclides.push_back(std::make_unique<Nuclide>(group, temperature));
close_group(group);

13
src/output.cpp
View file

@ -269,17 +269,16 @@ void
print_overlap_check()
{
#ifdef OPENMC_MPI
std::vector<int64_t> temp(model::overlap_check_count);
MPI_Reduce(temp.data(), model::overlap_check_count.data(),
model::overlap_check_count.size(), MPI_INT64_T,
MPI_SUM, 0, mpi::intracomm);
#endif
vector<int64_t> temp(model::overlap_check_count);
MPI_Reduce(temp.data(), model::overlap_check_count.data(),
model::overlap_check_count.size(), MPI_INT64_T, MPI_SUM, 0, mpi::intracomm);
#endif
if (mpi::master) {
header("cell overlap check summary", 1);
fmt::print(" Cell ID No. Overlap Checks\n");
std::vector<int32_t> sparse_cell_ids;
vector<int32_t> sparse_cell_ids;
for (int i = 0; i < model::cells.size(); i++) {
fmt::print(" {:8} {:17}\n", model::cells[i]->id_, model::overlap_check_count[i]);
if (model::overlap_check_count[i] < 10) {
@ -606,7 +605,7 @@ write_tallies()
}
// Initialize Filter Matches Object
std::vector<FilterMatch> filter_matches;
vector<FilterMatch> filter_matches;
// Allocate space for tally filter matches
filter_matches.resize(model::tally_filters.size());

3
src/particle.cpp
View file

@ -35,8 +35,7 @@ namespace openmc {
// LocalCoord implementation
//==============================================================================
void
LocalCoord::rotate(const std::vector<double>& rotation)
void LocalCoord::rotate(const vector<double>& rotation)
{
r = r.rotate(rotation);
u = u.rotate(rotation);

2
src/particle_restart.cpp
View file

@ -1,5 +1,6 @@
#include "openmc/particle_restart.h"
#include "openmc/array.h"
#include "openmc/constants.h"
#include "openmc/hdf5_interface.h"
#include "openmc/mgxs_interface.h"
@ -15,7 +16,6 @@
#include "openmc/track_output.h"
#include <algorithm> // for copy
#include <array>
#include <stdexcept>
#include <string>

6
src/photon.cpp
View file

@ -1,5 +1,6 @@
#include "openmc/photon.h"
#include "openmc/array.h"
#include "openmc/bremsstrahlung.h"
#include "openmc/constants.h"
#include "openmc/hdf5_interface.h"
@ -13,7 +14,6 @@
#include "xtensor/xoperation.hpp"
#include "xtensor/xview.hpp"
#include <array>
#include <cmath>
#include <tuple> // for tie
@ -28,7 +28,7 @@ namespace data {
xt::xtensor<double, 1> compton_profile_pz;
std::unordered_map<std::string, int> element_map;
std::vector<std::unique_ptr<PhotonInteraction>> elements;
vector<unique_ptr<PhotonInteraction>> elements;
} // namespace data
@ -110,7 +110,7 @@ PhotonInteraction::PhotonInteraction(hid_t group)
// Read subshell photoionization cross section and atomic relaxation data
rgroup = open_group(group, "subshells");
std::vector<std::string> designators;
vector<std::string> designators;
read_attribute(rgroup, "designators", designators);
auto n_shell = designators.size();
if (n_shell == 0) {

22
src/plot.cpp
View file

@ -88,7 +88,7 @@ void PropertyData::set_overlap(size_t y, size_t x) {
namespace model {
std::unordered_map<int, int> plot_map;
std::vector<Plot> plots;
vector<Plot> plots;
uint64_t plotter_seed = 1;
} // namespace model
@ -244,7 +244,7 @@ Plot::set_output_path(pugi::xml_node plot_node)
path_plot_ = filename;
// Copy plot pixel size
std::vector<int> pxls = get_node_array<int>(plot_node, "pixels");
vector<int> pxls = get_node_array<int>(plot_node, "pixels");
if (PlotType::slice == type_) {
if (pxls.size() == 2) {
pixels_[0] = pxls[0];
@ -268,7 +268,7 @@ Plot::set_bg_color(pugi::xml_node plot_node)
{
// Copy plot background color
if (check_for_node(plot_node, "background")) {
std::vector<int> bg_rgb = get_node_array<int>(plot_node, "background");
vector<int> bg_rgb = get_node_array<int>(plot_node, "background");
if (PlotType::voxel == type_) {
if (mpi::master) {
warning(fmt::format("Background color ignored in voxel plot {}", id_));
@ -320,7 +320,7 @@ void
Plot::set_width(pugi::xml_node plot_node)
{
// Copy plotting width
std::vector<double> pl_width = get_node_array<double>(plot_node, "width");
vector<double> pl_width = get_node_array<double>(plot_node, "width");
if (PlotType::slice == type_) {
if (pl_width.size() == 2) {
width_.x = pl_width[0];
@ -391,7 +391,7 @@ Plot::set_user_colors(pugi::xml_node plot_node)
for (auto cn : plot_node.children("color")) {
// Make sure 3 values are specified for RGB
std::vector<int> user_rgb = get_node_array<int>(cn, "rgb");
vector<int> user_rgb = get_node_array<int>(cn, "rgb");
if (user_rgb.size() != 3) {
fatal_error(fmt::format("Bad RGB in plot {}", id_));
}
@ -461,7 +461,7 @@ Plot::set_meshlines(pugi::xml_node plot_node)
// Check for color
if (check_for_node(meshlines_node, "color")) {
// Check and make sure 3 values are specified for RGB
std::vector<int> ml_rgb = get_node_array<int>(meshlines_node, "color");
vector<int> ml_rgb = get_node_array<int>(meshlines_node, "color");
if (ml_rgb.size() != 3) {
fatal_error(fmt::format("Bad RGB for meshlines color in plot {}", id_));
}
@ -544,7 +544,7 @@ Plot::set_mask(pugi::xml_node plot_node)
pugi::xml_node mask_node = mask_nodes[0].node();
// Determine how many components there are and allocate
std::vector<int> iarray = get_node_array<int>(mask_node, "components");
vector<int> iarray = get_node_array<int>(mask_node, "components");
if (iarray.size() == 0) {
fatal_error(fmt::format("Missing <components> in mask of plot {}", id_));
}
@ -575,7 +575,7 @@ Plot::set_mask(pugi::xml_node plot_node)
for (int j = 0; j < colors_.size(); j++) {
if (std::find(iarray.begin(), iarray.end(), j) == iarray.end()) {
if (check_for_node(mask_node, "background")) {
std::vector<int> bg_rgb = get_node_array<int>(mask_node, "background");
vector<int> bg_rgb = get_node_array<int>(mask_node, "background");
colors_[j] = bg_rgb;
} else {
colors_[j] = WHITE;
@ -599,7 +599,7 @@ void Plot::set_overlap_color(pugi::xml_node plot_node) {
warning(fmt::format(
"Overlap color specified in plot {} but overlaps won't be shown.", id_));
}
std::vector<int> olap_clr = get_node_array<int>(plot_node, "overlap_color");
vector<int> olap_clr = get_node_array<int>(plot_node, "overlap_color");
if (olap_clr.size() == 3) {
overlap_color_ = olap_clr;
} else {
@ -778,7 +778,7 @@ void draw_mesh_lines(Plot const& pl, ImageData& data)
void create_voxel(Plot const& pl)
{
// compute voxel widths in each direction
std::array<double, 3> vox;
array<double, 3> vox;
vox[0] = pl.width_[0]/(double)pl.pixels_[0];
vox[1] = pl.width_[1]/(double)pl.pixels_[1];
vox[2] = pl.width_[2]/(double)pl.pixels_[2];
@ -803,7 +803,7 @@ void create_voxel(Plot const& pl)
// Write current date and time
write_attribute(file_id, "date_and_time", time_stamp().c_str());
std::array<int, 3> pixels;
array<int, 3> pixels;
std::copy(pl.pixels_.begin(), pl.pixels_.end(), pixels.begin());
write_attribute(file_id, "num_voxels", pixels);
write_attribute(file_id, "voxel_width", vox);

3
src/position.cpp
View file

@ -84,8 +84,7 @@ Position::operator-() const
return {-x, -y, -z};
}
Position
Position::rotate(const std::vector<double>& rotation) const
Position Position::rotate(const vector<double>& rotation) const
{
return {
x*rotation[0] + y*rotation[1] + z*rotation[2],

8
src/reaction.cpp
View file

@ -19,7 +19,7 @@ namespace openmc {
// Reaction implementation
//==============================================================================
Reaction::Reaction(hid_t group, const std::vector<int>& temperatures)
Reaction::Reaction(hid_t group, const vector<int>& temperatures)
{
read_attribute(group, "Q_value", q_value_);
read_attribute(group, "mt", mt_);
@ -84,9 +84,9 @@ Reaction::Reaction(hid_t group, const std::vector<int>& temperatures)
// <<<<<<<<<<<<<<<<<<<<<<<<<<<< REMOVE THIS <<<<<<<<<<<<<<<<<<<<<<<<<
}
double
Reaction::collapse_rate(gsl::index i_temp, gsl::span<const double> energy,
gsl::span<const double> flux, const std::vector<double>& grid) const
double Reaction::collapse_rate(gsl::index i_temp,
gsl::span<const double> energy, gsl::span<const double> flux,
const vector<double>& grid) const
{
// Find index corresponding to first energy
const auto& xs = xs_[i_temp].value;

2
src/reaction_product.cpp
View file

@ -1,6 +1,5 @@
#include "openmc/reaction_product.h"
#include <memory> // for unique_ptr
#include <string> // for string
#include <fmt/core.h>
@ -8,6 +7,7 @@
#include "openmc/endf.h"
#include "openmc/error.h"
#include "openmc/hdf5_interface.h"
#include "openmc/memory.h"
#include "openmc/particle.h"
#include "openmc/random_lcg.h"
#include "openmc/secondary_correlated.h"

25
src/scattdata.cpp
View file

@ -70,12 +70,10 @@ ScattData::base_init(int order, const xt::xtensor<int, 1>& in_gmin,
//==============================================================================
void
ScattData::base_combine(size_t max_order, size_t order_dim,
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)
void ScattData::base_combine(size_t max_order, size_t order_dim,
const vector<ScattData*>& those_scatts, const vector<double>& scalars,
xt::xtensor<int, 1>& in_gmin, xt::xtensor<int, 1>& in_gmax,
double_2dvec& sparse_mult, double_3dvec& sparse_scatter)
{
size_t groups = those_scatts[0] -> energy.size();
@ -378,9 +376,8 @@ ScattDataLegendre::sample(int gin, int& gout, double& mu, double& wgt,
//==============================================================================
void
ScattDataLegendre::combine(const std::vector<ScattData*>& those_scatts,
const std::vector<double>& scalars)
void ScattDataLegendre::combine(
const vector<ScattData*>& those_scatts, const vector<double>& scalars)
{
// Find the max order in the data set and make sure we can combine the sets
size_t max_order = 0;
@ -595,9 +592,8 @@ ScattDataHistogram::get_matrix(size_t max_order)
//==============================================================================
void
ScattDataHistogram::combine(const std::vector<ScattData*>& those_scatts,
const std::vector<double>& scalars)
void ScattDataHistogram::combine(
const vector<ScattData*>& those_scatts, const vector<double>& scalars)
{
// Find the max order in the data set and make sure we can combine the sets
size_t max_order = those_scatts[0]->get_order();
@ -814,9 +810,8 @@ ScattDataTabular::get_matrix(size_t max_order)
//==============================================================================
void
ScattDataTabular::combine(const std::vector<ScattData*>& those_scatts,
const std::vector<double>& scalars)
void ScattDataTabular::combine(
const vector<ScattData*>& those_scatts, const vector<double>& scalars)
{
// Find the max order in the data set and make sure we can combine the sets
size_t max_order = those_scatts[0]->get_order();

12
src/secondary_correlated.cpp
View file

@ -43,9 +43,9 @@ CorrelatedAngleEnergy::CorrelatedAngleEnergy(hid_t group)
// Get outgoing energy distribution data
dset = open_dataset(group, "energy_out");
std::vector<int> offsets;
std::vector<int> interp;
std::vector<int> n_discrete;
vector<int> offsets;
vector<int> interp;
vector<int> n_discrete;
read_attribute(dset, "offsets", offsets);
read_attribute(dset, "interpolation", interp);
read_attribute(dset, "n_discrete_lines", n_discrete);
@ -136,9 +136,9 @@ CorrelatedAngleEnergy::CorrelatedAngleEnergy(hid_t group)
auto ps = xt::view(mu, 1, xt::range(offset_mu, offset_mu + m));
auto cs = xt::view(mu, 2, xt::range(offset_mu, offset_mu + m));
std::vector<double> x {xs.begin(), xs.end()};
std::vector<double> p {ps.begin(), ps.end()};
std::vector<double> c {cs.begin(), cs.end()};
vector<double> x {xs.begin(), xs.end()};
vector<double> p {ps.begin(), ps.end()};
vector<double> c {cs.begin(), cs.end()};
// To get answers that match ACE data, for now we still use the tabulated
// CDF values that were passed through to the HDF5 library. At a later

8
src/secondary_kalbach.cpp
View file

@ -4,7 +4,6 @@
#include <cmath> // for log, sqrt, sinh
#include <cstddef> // for size_t
#include <iterator> // for back_inserter
#include <vector>
#include "xtensor/xarray.hpp"
#include "xtensor/xview.hpp"
@ -12,6 +11,7 @@
#include "openmc/hdf5_interface.h"
#include "openmc/random_lcg.h"
#include "openmc/search.h"
#include "openmc/vector.h"
namespace openmc {
@ -43,9 +43,9 @@ KalbachMann::KalbachMann(hid_t group)
// Get outgoing energy distribution data
dset = open_dataset(group, "distribution");
std::vector<int> offsets;
std::vector<int> interp;
std::vector<int> n_discrete;
vector<int> offsets;
vector<int> interp;
vector<int> n_discrete;
read_attribute(dset, "offsets", offsets);
read_attribute(dset, "interpolation", interp);
read_attribute(dset, "n_discrete_lines", n_discrete);

16
src/secondary_thermal.cpp
View file

@ -11,8 +11,8 @@
namespace openmc {
// Helper function to get index on incident energy grid
void
get_energy_index(const std::vector<double>& energies, double E, int& i, double& f)
void get_energy_index(
const vector<double>& energies, double E, int& i, double& f)
{
// Get index and interpolation factor for elastic grid
i = 0;
@ -81,9 +81,9 @@ IncoherentElasticAE::sample(double E_in, double& E_out, double& mu,
// IncoherentElasticAEDiscrete implementation
//==============================================================================
IncoherentElasticAEDiscrete::IncoherentElasticAEDiscrete(hid_t group,
const std::vector<double>& energy)
: energy_{energy}
IncoherentElasticAEDiscrete::IncoherentElasticAEDiscrete(
hid_t group, const vector<double>& energy)
: energy_ {energy}
{
read_dataset(group, "mu_out", mu_out_);
}
@ -135,9 +135,9 @@ IncoherentElasticAEDiscrete::sample(double E_in, double& E_out, double& mu,
// IncoherentInelasticAEDiscrete implementation
//==============================================================================
IncoherentInelasticAEDiscrete::IncoherentInelasticAEDiscrete(hid_t group,
const std::vector<double>& energy)
: energy_{energy}
IncoherentInelasticAEDiscrete::IncoherentInelasticAEDiscrete(
hid_t group, const vector<double>& energy)
: energy_ {energy}
{
read_dataset(group, "energy_out", energy_out_);
read_dataset(group, "mu_out", mu_out_);

2
src/secondary_uncorrelated.cpp
View file

@ -29,7 +29,7 @@ UncorrelatedAngleEnergy::UncorrelatedAngleEnergy(hid_t group)
std::string type;
read_attribute(energy_group, "type", type);
using UPtrEDist = std::unique_ptr<EnergyDistribution>;
using UPtrEDist = unique_ptr<EnergyDistribution>;
if (type == "discrete_photon") {
energy_ = UPtrEDist{new DiscretePhoton{energy_group}};
} else if (type == "level") {

8
src/settings.cpp
View file

@ -87,7 +87,7 @@ int64_t n_particles {-1};
int64_t max_particles_in_flight {100000};
ElectronTreatment electron_treatment {ElectronTreatment::TTB};
std::array<double, 4> energy_cutoff {0.0, 1000.0, 0.0, 0.0};
array<double, 4> energy_cutoff {0.0, 1000.0, 0.0, 0.0};
int legendre_to_tabular_points {C_NONE};
int max_order {0};
int n_log_bins {8000};
@ -96,7 +96,7 @@ int n_max_batches;
ResScatMethod res_scat_method {ResScatMethod::rvs};
double res_scat_energy_min {0.01};
double res_scat_energy_max {1000.0};
std::vector<std::string> res_scat_nuclides;
vector<std::string> res_scat_nuclides;
RunMode run_mode {RunMode::UNSET};
std::unordered_set<int> sourcepoint_batch;
std::unordered_set<int> statepoint_batch;
@ -105,11 +105,11 @@ int64_t max_surface_particles;
TemperatureMethod temperature_method {TemperatureMethod::NEAREST};
double temperature_tolerance {10.0};
double temperature_default {293.6};
std::array<double, 2> temperature_range {0.0, 0.0};
array<double, 2> temperature_range {0.0, 0.0};
int trace_batch;
int trace_gen;
int64_t trace_particle;
std::vector<std::array<int, 3>> track_identifiers;
vector<array<int, 3>> track_identifiers;
int trigger_batch_interval {1};
int verbosity {7};
double weight_cutoff {0.25};

5
src/simulation.cpp
View file

@ -267,9 +267,8 @@ int64_t work_per_rank;
const RegularMesh* entropy_mesh {nullptr};
const RegularMesh* ufs_mesh {nullptr};
std::vector<double> k_generation;
std::vector<int64_t> work_index;
vector<double> k_generation;
vector<int64_t> work_index;
} // namespace simulation

7
src/source.cpp
View file

@ -5,7 +5,6 @@
#endif
#include <algorithm> // for move
#include <memory> // for unique_ptr
#ifdef HAS_DYNAMIC_LINKING
#include <dlfcn.h> // for dlopen, dlsym, dlclose, dlerror
@ -15,15 +14,16 @@
#include "xtensor/xadapt.hpp"
#include "openmc/bank.h"
#include "openmc/capi.h"
#include "openmc/cell.h"
#include "openmc/error.h"
#include "openmc/file_utils.h"
#include "openmc/hdf5_interface.h"
#include "openmc/material.h"
#include "openmc/memory.h"
#include "openmc/message_passing.h"
#include "openmc/mgxs_interface.h"
#include "openmc/nuclide.h"
#include "openmc/capi.h"
#include "openmc/random_lcg.h"
#include "openmc/search.h"
#include "openmc/settings.h"
@ -39,8 +39,7 @@ namespace openmc {
namespace model {
std::vector<std::unique_ptr<Source>> external_sources;
vector<unique_ptr<Source>> external_sources;
}
//==============================================================================

39
src/state_point.cpp
View file

@ -3,7 +3,6 @@
#include <algorithm>
#include <cstdint> // for int64_t
#include <string>
#include <vector>
#include <fmt/core.h>
#include "xtensor/xbuilder.hpp" // for empty_like
@ -27,6 +26,7 @@
#include "openmc/tallies/filter_mesh.h"
#include "openmc/tallies/tally.h"
#include "openmc/timer.h"
#include "openmc/vector.h"
namespace openmc {
@ -141,7 +141,7 @@ openmc_statepoint_write(const char* filename, bool* write_source)
write_attribute(filters_group, "n_filters", model::tally_filters.size());
if (!model::tally_filters.empty()) {
// Write filter IDs
std::vector<int32_t> filter_ids;
vector<int32_t> filter_ids;
filter_ids.reserve(model::tally_filters.size());
for (const auto& filt : model::tally_filters)
filter_ids.push_back(filt->id());
@ -161,7 +161,7 @@ openmc_statepoint_write(const char* filename, bool* write_source)
write_attribute(tallies_group, "n_tallies", model::tallies.size());
if (!model::tallies.empty()) {
// Write tally IDs
std::vector<int32_t> tally_ids;
vector<int32_t> tally_ids;
tally_ids.reserve(model::tallies.size());
for (const auto& tally : model::tallies)
tally_ids.push_back(tally->id_);
@ -195,7 +195,7 @@ openmc_statepoint_write(const char* filename, bool* write_source)
// Write the ID of each filter attached to this tally
write_dataset(tally_group, "n_filters", tally->filters().size());
if (!tally->filters().empty()) {
std::vector<int32_t> filter_ids;
vector<int32_t> filter_ids;
filter_ids.reserve(tally->filters().size());
for (auto i_filt : tally->filters())
filter_ids.push_back(model::tally_filters[i_filt]->id());
@ -203,7 +203,7 @@ openmc_statepoint_write(const char* filename, bool* write_source)
}
// Write the nuclides this tally scores
std::vector<std::string> nuclides;
vector<std::string> nuclides;
for (auto i_nuclide : tally->nuclides_) {
if (i_nuclide == -1) {
nuclides.push_back("total");
@ -221,7 +221,7 @@ openmc_statepoint_write(const char* filename, bool* write_source)
model::tally_derivs[tally->deriv_].id);
// Write the tally score bins
std::vector<std::string> scores;
vector<std::string> scores;
for (auto sc : tally->scores_) scores.push_back(reaction_name(sc));
write_dataset(tally_group, "n_score_bins", scores.size());
write_dataset(tally_group, "score_bins", scores);
@ -351,7 +351,7 @@ void load_state_point()
// Read revision number for state point file and make sure it matches with
// current version
std::array<int, 2> array;
array<int, 2> array;
read_attribute(file_id, "version", array);
if (array != VERSION_STATEPOINT) {
fatal_error("State point version does not match current version in OpenMC.");
@ -528,14 +528,14 @@ hid_t h5banktype() {
return banktype;
}
std::vector<int64_t> calculate_surf_source_size()
vector<int64_t> calculate_surf_source_size()
{
std::vector<int64_t> surf_source_index;
vector<int64_t> surf_source_index;
surf_source_index.reserve(mpi::n_procs + 1);
#ifdef OPENMC_MPI
surf_source_index.resize(mpi::n_procs);
std::vector<int64_t> bank_size(mpi::n_procs);
vector<int64_t> bank_size(mpi::n_procs);
// Populate the surf_source_index with cumulative sum of the number of
// surface source banks per process
@ -597,10 +597,10 @@ write_source_bank(hid_t group_id, bool surf_source_bank)
int64_t count_size = simulation::work_per_rank;
// Set vectors for source bank and starting bank index of each process
std::vector<int64_t>* bank_index = &simulation::work_index;
std::vector<ParticleBank>* source_bank = &simulation::source_bank;
std::vector<int64_t> surf_source_index_vector;
std::vector<ParticleBank> surf_source_bank_vector;
vector<int64_t>* bank_index = &simulation::work_index;
vector<ParticleBank>* source_bank = &simulation::source_bank;
vector<int64_t> surf_source_index_vector;
vector<ParticleBank> surf_source_bank_vector;
// Reset dataspace sizes and vectors for surface source bank
if (surf_source_bank) {
@ -656,8 +656,7 @@ write_source_bank(hid_t group_id, bool surf_source_bank)
// Save source bank sites since the array is overwritten below
#ifdef OPENMC_MPI
std::vector<ParticleBank> temp_source {
source_bank->begin(), source_bank->end()};
vector<ParticleBank> temp_source {source_bank->begin(), source_bank->end()};
#endif
for (int i = 0; i < mpi::n_procs; ++i) {
@ -715,7 +714,7 @@ std::string dtype_member_names(hid_t dtype_id)
}
void read_source_bank(
hid_t group_id, std::vector<ParticleBank>& sites, bool distribute)
hid_t group_id, vector<ParticleBank>& sites, bool distribute)
{
hid_t banktype = h5banktype();
@ -779,7 +778,7 @@ void write_unstructured_mesh_results() {
for (auto& tally : model::tallies) {
std::vector<std::string> tally_scores;
vector<std::string> tally_scores;
for (auto filter_idx : tally->filters()) {
auto& filter = model::tally_filters[filter_idx];
if (filter->type() != "mesh") continue;
@ -829,8 +828,8 @@ void write_unstructured_mesh_results() {
int nuc_score_idx = score_idx + nuc_idx*tally->scores_.size();
// construct result vectors
std::vector<double> mean_vec(umesh->n_bins()),
std_dev_vec(umesh->n_bins());
vector<double> mean_vec(umesh->n_bins()),
std_dev_vec(umesh->n_bins());
for (int j = 0; j < tally->results_.shape()[0]; j++) {
// get the volume for this bin
double volume = umesh->volume(j);

4
src/string_utils.cpp
View file

@ -46,9 +46,9 @@ int word_count(std::string const& str)
return count;
}
std::vector<std::string> split(const std::string& in)
vector<std::string> split(const std::string& in)
{
std::vector<std::string> out;
vector<std::string> out;
for (int i = 0; i < in.size(); ) {
// Increment i until we find a non-whitespace character.

6
src/summary.cpp
View file

@ -47,9 +47,9 @@ void write_nuclides(hid_t file)
{
// Build vectors of nuclide names and awrs while only sorting nuclides from
// macroscopics
std::vector<std::string> nuc_names;
std::vector<std::string> macro_names;
std::vector<double> awrs;
vector<std::string> nuc_names;
vector<std::string> macro_names;
vector<double> awrs;
for (int i = 0; i < data::nuclides.size(); ++i) {
if (settings::run_CE) {

34
src/surface.cpp
View file

@ -1,6 +1,5 @@
#include "openmc/surface.h"
#include <array>
#include <cmath>
#include <utility>
#include <set>
@ -8,15 +7,16 @@
#include <fmt/core.h>
#include <gsl/gsl>
#include "openmc/array.h"
#include "openmc/container_util.h"
#include "openmc/error.h"
#include "openmc/dagmc.h"
#include "openmc/error.h"
#include "openmc/hdf5_interface.h"
#include "openmc/math_functions.h"
#include "openmc/random_lcg.h"
#include "openmc/settings.h"
#include "openmc/string_utils.h"
#include "openmc/xml_interface.h"
#include "openmc/random_lcg.h"
#include "openmc/math_functions.h"
namespace openmc {
@ -26,7 +26,7 @@ namespace openmc {
namespace model {
std::unordered_map<int, int> surface_map;
std::vector<std::unique_ptr<Surface>> surfaces;
vector<unique_ptr<Surface>> surfaces;
} // namespace model
//==============================================================================
@ -322,7 +322,7 @@ Direction SurfaceXPlane::normal(Position r) const
void SurfaceXPlane::to_hdf5_inner(hid_t group_id) const
{
write_string(group_id, "type", "x-plane", false);
std::array<double, 1> coeffs {{x0_}};
array<double, 1> coeffs {{x0_}};
write_dataset(group_id, "coefficients", coeffs);
}
@ -364,7 +364,7 @@ Direction SurfaceYPlane::normal(Position r) const
void SurfaceYPlane::to_hdf5_inner(hid_t group_id) const
{
write_string(group_id, "type", "y-plane", false);
std::array<double, 1> coeffs {{y0_}};
array<double, 1> coeffs {{y0_}};
write_dataset(group_id, "coefficients", coeffs);
}
@ -406,7 +406,7 @@ Direction SurfaceZPlane::normal(Position r) const
void SurfaceZPlane::to_hdf5_inner(hid_t group_id) const
{
write_string(group_id, "type", "z-plane", false);
std::array<double, 1> coeffs {{z0_}};
array<double, 1> coeffs {{z0_}};
write_dataset(group_id, "coefficients", coeffs);
}
@ -459,7 +459,7 @@ SurfacePlane::normal(Position r) const
void SurfacePlane::to_hdf5_inner(hid_t group_id) const
{
write_string(group_id, "type", "plane", false);
std::array<double, 4> coeffs {{A_, B_, C_, D_}};
array<double, 4> coeffs {{A_, B_, C_, D_}};
write_dataset(group_id, "coefficients", coeffs);
}
@ -567,7 +567,7 @@ Direction SurfaceXCylinder::normal(Position r) const
void SurfaceXCylinder::to_hdf5_inner(hid_t group_id) const
{
write_string(group_id, "type", "x-cylinder", false);
std::array<double, 3> coeffs {{y0_, z0_, radius_}};
array<double, 3> coeffs {{y0_, z0_, radius_}};
write_dataset(group_id, "coefficients", coeffs);
}
@ -607,7 +607,7 @@ Direction SurfaceYCylinder::normal(Position r) const
void SurfaceYCylinder::to_hdf5_inner(hid_t group_id) const
{
write_string(group_id, "type", "y-cylinder", false);
std::array<double, 3> coeffs {{x0_, z0_, radius_}};
array<double, 3> coeffs {{x0_, z0_, radius_}};
write_dataset(group_id, "coefficients", coeffs);
}
@ -648,7 +648,7 @@ Direction SurfaceZCylinder::normal(Position r) const
void SurfaceZCylinder::to_hdf5_inner(hid_t group_id) const
{
write_string(group_id, "type", "z-cylinder", false);
std::array<double, 3> coeffs {{x0_, y0_, radius_}};
array<double, 3> coeffs {{x0_, y0_, radius_}};
write_dataset(group_id, "coefficients", coeffs);
}
@ -725,7 +725,7 @@ Direction SurfaceSphere::normal(Position r) const
void SurfaceSphere::to_hdf5_inner(hid_t group_id) const
{
write_string(group_id, "type", "sphere", false);
std::array<double, 4> coeffs {{x0_, y0_, z0_, radius_}};
array<double, 4> coeffs {{x0_, y0_, z0_, radius_}};
write_dataset(group_id, "coefficients", coeffs);
}
@ -854,7 +854,7 @@ Direction SurfaceXCone::normal(Position r) const
void SurfaceXCone::to_hdf5_inner(hid_t group_id) const
{
write_string(group_id, "type", "x-cone", false);
std::array<double, 4> coeffs {{x0_, y0_, z0_, radius_sq_}};
array<double, 4> coeffs {{x0_, y0_, z0_, radius_sq_}};
write_dataset(group_id, "coefficients", coeffs);
}
@ -887,7 +887,7 @@ Direction SurfaceYCone::normal(Position r) const
void SurfaceYCone::to_hdf5_inner(hid_t group_id) const
{
write_string(group_id, "type", "y-cone", false);
std::array<double, 4> coeffs {{x0_, y0_, z0_, radius_sq_}};
array<double, 4> coeffs {{x0_, y0_, z0_, radius_sq_}};
write_dataset(group_id, "coefficients", coeffs);
}
@ -920,7 +920,7 @@ Direction SurfaceZCone::normal(Position r) const
void SurfaceZCone::to_hdf5_inner(hid_t group_id) const
{
write_string(group_id, "type", "z-cone", false);
std::array<double, 4> coeffs {{x0_, y0_, z0_, radius_sq_}};
array<double, 4> coeffs {{x0_, y0_, z0_, radius_sq_}};
write_dataset(group_id, "coefficients", coeffs);
}
@ -1025,7 +1025,7 @@ SurfaceQuadric::normal(Position r) const
void SurfaceQuadric::to_hdf5_inner(hid_t group_id) const
{
write_string(group_id, "type", "quadric", false);
std::array<double, 10> coeffs {{A_, B_, C_, D_, E_, F_, G_, H_, J_, K_}};
array<double, 10> coeffs {{A_, B_, C_, D_, E_, F_, G_, H_, J_, K_}};
write_dataset(group_id, "coefficients", coeffs);
}

4
src/tallies/derivative.cpp
View file

@ -9,7 +9,7 @@
#include <fmt/core.h>
template class std::vector<openmc::TallyDerivative>;
template class openmc::vector<openmc::TallyDerivative>;
namespace openmc {
@ -19,7 +19,7 @@ namespace openmc {
namespace model {
std::unordered_map<int, int> tally_deriv_map;
std::vector<TallyDerivative> tally_derivs;
vector<TallyDerivative> tally_derivs;
}
//==============================================================================

4
src/tallies/filter.cpp
View file

@ -34,7 +34,7 @@
#include "openmc/tallies/filter_zernike.h"
// explicit template instantiation definition
template class std::vector<openmc::FilterMatch>;
template class openmc::vector<openmc::FilterMatch>;
namespace openmc {
@ -44,7 +44,7 @@ namespace openmc {
namespace model {
std::unordered_map<int, int> filter_map;
std::vector<std::unique_ptr<Filter>> tally_filters;
vector<unique_ptr<Filter>> tally_filters;
}
//==============================================================================

2
src/tallies/filter_cell.cpp
View file

@ -62,7 +62,7 @@ void
CellFilter::to_statepoint(hid_t filter_group) const
{
Filter::to_statepoint(filter_group);
std::vector<int32_t> cell_ids;
vector<int32_t> cell_ids;
for (auto c : cells_) cell_ids.push_back(model::cells[c]->id_);
write_dataset(filter_group, "bins", cell_ids);
}

2
src/tallies/filter_cell_instance.cpp
View file

@ -24,7 +24,7 @@ CellInstanceFilter::from_xml(pugi::xml_node node)
Expects(cells.size() % 2 == 0);
// Convert into vector of CellInstance
std::vector<CellInstance> instances;
vector<CellInstance> instances;
for (gsl::index i = 0; i < cells.size() / 2; ++i) {
int32_t cell_id = cells[2*i];
gsl::index instance = cells[2*i + 1];

2
src/tallies/filter_legendre.cpp
View file

@ -27,7 +27,7 @@ void
LegendreFilter::get_all_bins(const Particle& p, TallyEstimator estimator,
FilterMatch& match) const
{
std::vector<double> wgt(n_bins_);
vector<double> wgt(n_bins_);
calc_pn_c(order_, p.mu(), wgt.data());
for (int i = 0; i < n_bins_; i++) {
match.bins_.push_back(i);

2
src/tallies/filter_material.cpp
View file

@ -59,7 +59,7 @@ void
MaterialFilter::to_statepoint(hid_t filter_group) const
{
Filter::to_statepoint(filter_group);
std::vector<int32_t> material_ids;
vector<int32_t> material_ids;
for (auto c : materials_) material_ids.push_back(model::materials[c]->id_);
write_dataset(filter_group, "bins", material_ids);
}

4
src/tallies/filter_particle.cpp
View file

@ -12,7 +12,7 @@ ParticleFilter::from_xml(pugi::xml_node node)
auto particles = get_node_array<std::string>(node, "bins");
// Convert to vector of ParticleType
std::vector<ParticleType> types;
vector<ParticleType> types;
for (auto& p : particles) {
types.push_back(str_to_particle_type(p));
}
@ -48,7 +48,7 @@ void
ParticleFilter::to_statepoint(hid_t filter_group) const
{
Filter::to_statepoint(filter_group);
std::vector<std::string> particles;
vector<std::string> particles;
for (auto p : particles_) {
particles.push_back(particle_type_to_str(p));
}

4
src/tallies/filter_sph_harm.cpp
View file

@ -49,7 +49,7 @@ SphericalHarmonicsFilter::get_all_bins(const Particle& p, TallyEstimator estimat
FilterMatch& match) const
{
// Determine cosine term for scatter expansion if necessary
std::vector<double> wgt(order_ + 1);
vector<double> wgt(order_ + 1);
if (cosine_ == SphericalHarmonicsCosine::scatter) {
calc_pn_c(order_, p.mu(), wgt.data());
} else {
@ -59,7 +59,7 @@ SphericalHarmonicsFilter::get_all_bins(const Particle& p, TallyEstimator estimat
}
// Find the Rn,m values
std::vector<double> rn(n_bins_);
vector<double> rn(n_bins_);
calc_rn(order_, p.u_last(), rn.data());
int j = 0;

2
src/tallies/filter_sptl_legendre.cpp
View file

@ -81,7 +81,7 @@ SpatialLegendreFilter::get_all_bins(const Particle& p, TallyEstimator estimator,
double x_norm = 2.0*(x - min_) / (max_ - min_) - 1.0;
// Compute and return the Legendre weights.
std::vector<double> wgt(order_ + 1);
vector<double> wgt(order_ + 1);
calc_pn_c(order_, x_norm, wgt.data());
for (int i = 0; i < order_ + 1; i++) {
match.bins_.push_back(i);

2
src/tallies/filter_surface.cpp
View file

@ -65,7 +65,7 @@ void
SurfaceFilter::to_statepoint(hid_t filter_group) const
{
Filter::to_statepoint(filter_group);
std::vector<int32_t> surface_ids;
vector<int32_t> surface_ids;
for (auto c : surfaces_) surface_ids.push_back(model::surfaces[c]->id_);
write_dataset(filter_group, "bins", surface_ids);
}

2
src/tallies/filter_universe.cpp
View file

@ -61,7 +61,7 @@ void
UniverseFilter::to_statepoint(hid_t filter_group) const
{
Filter::to_statepoint(filter_group);
std::vector<int32_t> universe_ids;
vector<int32_t> universe_ids;
for (auto u : universes_) universe_ids.push_back(model::universes[u]->id_);
write_dataset(filter_group, "bins", universe_ids);
}

4
src/tallies/filter_zernike.cpp
View file

@ -39,7 +39,7 @@ ZernikeFilter::get_all_bins(const Particle& p, TallyEstimator estimator,
if (r <= 1.0) {
// Compute and return the Zernike weights.
std::vector<double> zn(n_bins_);
vector<double> zn(n_bins_);
calc_zn(order_, r, theta, zn.data());
for (int i = 0; i < n_bins_; i++) {
match.bins_.push_back(i);
@ -98,7 +98,7 @@ ZernikeRadialFilter::get_all_bins(const Particle& p, TallyEstimator estimator,
if (r <= 1.0) {
// Compute and return the Zernike weights.
std::vector<double> zn(n_bins_);
vector<double> zn(n_bins_);
calc_zn_rad(order_, r, zn.data());
for (int i = 0; i < n_bins_; i++) {
match.bins_.push_back(i);

40
src/tallies/tally.cpp
View file

@ -1,11 +1,12 @@
#include "openmc/tallies/tally.h"
#include "openmc/array.h"
#include "openmc/capi.h"
#include "openmc/constants.h"
#include "openmc/error.h"
#include "openmc/file_utils.h"
#include "openmc/message_passing.h"
#include "openmc/mesh.h"
#include "openmc/message_passing.h"
#include "openmc/mgxs_interface.h"
#include "openmc/nuclide.h"
#include "openmc/particle.h"
@ -18,9 +19,9 @@
#include "openmc/tallies/filter.h"
#include "openmc/tallies/filter_cell.h"
#include "openmc/tallies/filter_cellfrom.h"
#include "openmc/tallies/filter_collision.h"
#include "openmc/tallies/filter_delayedgroup.h"
#include "openmc/tallies/filter_energy.h"
#include "openmc/tallies/filter_collision.h"
#include "openmc/tallies/filter_legendre.h"
#include "openmc/tallies/filter_mesh.h"
#include "openmc/tallies/filter_meshsurface.h"
@ -35,7 +36,6 @@
#include "xtensor/xview.hpp"
#include <algorithm> // for max
#include <array>
#include <cstddef> // for size_t
#include <string>
@ -47,13 +47,13 @@ namespace openmc {
namespace model {
std::unordered_map<int, int> tally_map;
std::vector<std::unique_ptr<Tally>> tallies;
std::vector<int> active_tallies;
std::vector<int> active_analog_tallies;
std::vector<int> active_tracklength_tallies;
std::vector<int> active_collision_tallies;
std::vector<int> active_meshsurf_tallies;
std::vector<int> active_surface_tallies;
vector<unique_ptr<Tally>> tallies;
vector<int> active_tallies;
vector<int> active_analog_tallies;
vector<int> active_tracklength_tallies;
vector<int> active_collision_tallies;
vector<int> active_meshsurf_tallies;
vector<int> active_surface_tallies;
}
namespace simulation {
@ -103,13 +103,13 @@ Tally::Tally(pugi::xml_node node)
}
// Determine number of filters
std::vector<int> filter_ids;
vector<int> filter_ids;
if (check_for_node(node, "filters")) {
filter_ids = get_node_array<int>(node, "filters");
}
// Allocate and store filter user ids
std::vector<Filter*> filters;
vector<Filter*> filters;
for (int filter_id : filter_ids) {
// Determine if filter ID is valid
auto it = model::filter_map.find(filter_id);
@ -388,8 +388,7 @@ Tally::set_scores(pugi::xml_node node)
set_scores(scores);
}
void
Tally::set_scores(const std::vector<std::string>& scores)
void Tally::set_scores(const vector<std::string>& scores)
{
// Reset state and prepare for the new scores.
scores_.clear();
@ -541,8 +540,7 @@ Tally::set_nuclides(pugi::xml_node node)
}
}
void
Tally::set_nuclides(const std::vector<std::string>& nuclides)
void Tally::set_nuclides(const vector<std::string>& nuclides)
{
nuclides_.clear();
@ -595,7 +593,7 @@ Tally::init_triggers(pugi::xml_node node)
}
// Read the trigger scores.
std::vector<std::string> trigger_scores;
vector<std::string> trigger_scores;
if (check_for_node(trigger_node, "scores")) {
trigger_scores = get_node_array<std::string>(trigger_node, "scores");
} else {
@ -1108,7 +1106,7 @@ openmc_tally_set_scores(int32_t index, int n, const char** scores)
return OPENMC_E_OUT_OF_BOUNDS;
}
std::vector<std::string> scores_str(scores, scores+n);
vector<std::string> scores_str(scores, scores + n);
try {
model::tallies[index]->set_scores(scores_str);
} catch (const std::invalid_argument& ex) {
@ -1143,8 +1141,8 @@ openmc_tally_set_nuclides(int32_t index, int n, const char** nuclides)
return OPENMC_E_OUT_OF_BOUNDS;
}
std::vector<std::string> words(nuclides, nuclides+n);
std::vector<int> nucs;
vector<std::string> words(nuclides, nuclides + n);
vector<int> nucs;
for (auto word : words){
if (word == "total") {
nucs.push_back(-1);
@ -1188,7 +1186,7 @@ openmc_tally_set_filters(int32_t index, size_t n, const int32_t* indices)
// Set the filters.
try {
// Convert indices to filter pointers
std::vector<Filter*> filters;
vector<Filter*> filters;
for (gsl::index i = 0; i < n; ++i) {
int32_t i_filt = indices[i];
filters.push_back(model::tally_filters.at(i_filt).get());

14
src/tallies/tally_scoring.cpp
View file

@ -55,9 +55,9 @@ FilterBinIter::FilterBinIter(const Tally& tally, Particle& p)
this->compute_index_weight();
}
FilterBinIter::FilterBinIter(const Tally& tally, bool end,
std::vector<FilterMatch>* particle_filter_matches)
: filter_matches_{*particle_filter_matches}, tally_{tally}
FilterBinIter::FilterBinIter(
const Tally& tally, bool end, vector<FilterMatch>* particle_filter_matches)
: filter_matches_ {*particle_filter_matches}, tally_ {tally}
{
// Handle the special case for an iterator that points to the end.
if (end) {
@ -144,9 +144,8 @@ FilterBinIter::compute_index_weight()
//! Helper function used to increment tallies with a delayed group filter.
void
score_fission_delayed_dg(int i_tally, int d_bin, double score, int score_index,
std::vector<FilterMatch>& filter_matches)
void score_fission_delayed_dg(int i_tally, int d_bin, double score,
int score_index, vector<FilterMatch>& filter_matches)
{
// Save the original delayed group bin
auto& tally {*model::tallies[i_tally]};
@ -2420,8 +2419,7 @@ void score_collision_tally(Particle& p)
match.bins_present_ = false;
}
void
score_surface_tally(Particle& p, const std::vector<int>& tallies)
void score_surface_tally(Particle& p, const vector<int>& tallies)
{
// No collision, so no weight change when survival biasing
double flux = p.wgt();

7
src/thermal.cpp
View file

@ -28,14 +28,15 @@ namespace openmc {
namespace data {
std::unordered_map<std::string, int> thermal_scatt_map;
std::vector<std::unique_ptr<ThermalScattering>> thermal_scatt;
vector<unique_ptr<ThermalScattering>> thermal_scatt;
}
//==============================================================================
// ThermalScattering implementation
//==============================================================================
ThermalScattering::ThermalScattering(hid_t group, const std::vector<double>& temperature)
ThermalScattering::ThermalScattering(
hid_t group, const vector<double>& temperature)
{
// Get name of table from group
name_ = object_name(group);
@ -65,7 +66,7 @@ ThermalScattering::ThermalScattering(hid_t group, const std::vector<double>& tem
// Determine actual temperatures to read -- start by checking whether a
// temperature range was given, in which case all temperatures in the range
// are loaded irrespective of what temperatures actually appear in the model
std::vector<int> temps_to_read;
vector<int> temps_to_read;
if (settings::temperature_range[1] > 0.0) {
for (const auto& T : temps_available) {
if (settings::temperature_range[0] <= T &&

4
src/track_output.cpp
View file

@ -5,13 +5,13 @@
#include "openmc/position.h"
#include "openmc/settings.h"
#include "openmc/simulation.h"
#include "openmc/vector.h"
#include <fmt/core.h>
#include "xtensor/xtensor.hpp"
#include <cstddef> // for size_t
#include <string>
#include <vector>
namespace openmc {
@ -40,7 +40,7 @@ void finalize_particle_track(Particle& p)
simulation::current_batch, simulation::current_gen, p.id());
// Determine number of coordinates for each particle
std::vector<int> n_coords;
vector<int> n_coords;
for (auto& coords : p.tracks()) {
n_coords.push_back(coords.size());
}

26
src/volume_calc.cpp
View file

@ -33,7 +33,7 @@ namespace openmc {
//==============================================================================
namespace model {
std::vector<VolumeCalculation> volume_calcs;
vector<VolumeCalculation> volume_calcs;
}
//==============================================================================
@ -94,12 +94,14 @@ VolumeCalculation::VolumeCalculation(pugi::xml_node node)
}
std::vector<VolumeCalculation::Result> VolumeCalculation::execute() const
vector<VolumeCalculation::Result> VolumeCalculation::execute() const
{
// Shared data that is collected from all threads
int n = domain_ids_.size();
std::vector<std::vector<int>> master_indices(n); // List of material indices for each domain
std::vector<std::vector<int>> master_hits(n); // Number of hits for each material in each domain
vector<std::vector<int>> master_indices(
n); // List of material indices for each domain
vector<std::vector<int>> master_hits(
n); // Number of hits for each material in each domain
int iterations = 0;
// Divide work over MPI processes
@ -119,8 +121,8 @@ std::vector<VolumeCalculation::Result> VolumeCalculation::execute() const
#pragma omp parallel
{
// Variables that are private to each thread
std::vector<std::vector<int>> indices(n);
std::vector<std::vector<int>> hits(n);
vector<std::vector<int>> indices(n);
vector<std::vector<int>> hits(n);
Particle p;
// Sample locations and count hits
@ -224,7 +226,7 @@ std::vector<VolumeCalculation::Result> VolumeCalculation::execute() const
double trigger_val = -INFTY;
// Set size for members of the Result struct
std::vector<Result> results(n);
vector<Result> results(n);
for (int i_domain = 0; i_domain < n; ++i_domain) {
// Get reference to result for this domain
@ -353,8 +355,8 @@ std::vector<VolumeCalculation::Result> VolumeCalculation::execute() const
} // end while
}
void VolumeCalculation::to_hdf5(const std::string& filename,
const std::vector<Result>& results) const
void VolumeCalculation::to_hdf5(
const std::string& filename, const vector<Result>& results) const
{
// Create HDF5 file
hid_t file_id = file_open(filename, 'w');
@ -418,7 +420,7 @@ void VolumeCalculation::to_hdf5(const std::string& filename,
// Create array of nuclide names from the vector
auto n_nuc = result.nuclides.size();
std::vector<std::string> nucnames;
vector<std::string> nucnames;
for (int i_nuc : result.nuclides) {
nucnames.push_back(data::nuclides[i_nuc]->name_);
}
@ -438,8 +440,8 @@ void VolumeCalculation::to_hdf5(const std::string& filename,
file_close(file_id);
}
void VolumeCalculation::check_hit(int i_material, std::vector<int>& indices,
std::vector<int>& hits) const
void VolumeCalculation::check_hit(
int i_material, vector<int>& indices, vector<int>& hits) const
{
// Check if this material was previously hit and if so, increment count

4
src/wmp.cpp
View file

@ -105,7 +105,7 @@ WindowedMultipole::evaluate(double E, double sqrtkT) const
if (sqrtkT > 0.0 && window.broaden_poly) {
// Broaden the curvefit.
double dopp = sqrt_awr_ / sqrtkT;
std::array<double, MAX_POLY_COEFFICIENTS> broadened_polynomials;
array<double, MAX_POLY_COEFFICIENTS> broadened_polynomials;
broaden_wmp_polynomials(E, dopp, fit_order_ + 1, broadened_polynomials.data());
for (int i_poly = 0; i_poly < fit_order_ + 1; ++i_poly) {
sig_s += curvefit_(i_window, i_poly, FIT_S) * broadened_polynomials[i_poly];
@ -216,7 +216,7 @@ WindowedMultipole::evaluate_deriv(double E, double sqrtkT) const
void check_wmp_version(hid_t file)
{
if (attribute_exists(file, "version")) {
std::array<int, 2> version;
array<int, 2> version;
read_attribute(file, "version", version);
if (version[0] != WMP_VERSION[0]) {
fatal_error(fmt::format(

9
src/xsdata.cpp
View file

@ -37,7 +37,7 @@ XsData::XsData(bool fissionable, AngleDistributionType scatter_format, int n_pol
fatal_error("Invalid scatter_format!");
}
// allocate all [temperature][angle][in group] quantities
std::vector<size_t> shape {n_ang, n_g_};
vector<size_t> shape {n_ang, n_g_};
total = xt::zeros<double>(shape);
absorption = xt::zeros<double>(shape);
inverse_velocity = xt::zeros<double>(shape);
@ -509,9 +509,8 @@ XsData::scatter_from_hdf5(hid_t xsdata_grp, size_t n_ang, AngleDistributionType
//==============================================================================
void
XsData::combine(const std::vector<XsData*>& those_xs,
const std::vector<double>& scalars)
void XsData::combine(
const vector<XsData*>& those_xs, const vector<double>& scalars)
{
// Combine the non-scattering data
for (size_t i = 0; i < those_xs.size(); i++) {
@ -551,7 +550,7 @@ XsData::combine(const std::vector<XsData*>& those_xs,
// Allow the ScattData object to combine itself
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());
vector<ScattData*> those_scatts(those_xs.size());
for (size_t i = 0; i < those_xs.size(); i++) {
those_scatts[i] = those_xs[i]->scatter[a].get();
}