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

Merge pull request #1868 from paulromano/clang-format

Browse source 
Apply clang-format to all C++ source files
This commit is contained in:
shikhar413 2021-08-14 09:51:12 -04:00 • committed by GitHub
commit 2efe223404
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
187 changed files with 7479 additions and 7051 deletions
Download patch file Download diff file Expand all files Collapse all files

2
.git-blame-ignore-revs Normal file
View file

@ -0,0 +1,2 @@
# Applied clang-format to all source files
1bc2bd84600c8d2ca9253339c167401127f6a9f3

114
docs/source/devguide/styleguide.rst
View file

@ -12,18 +12,22 @@ adding new code in OpenMC.
C++
---
.. important:: To ensure consistent styling with little effort, this project
uses `clang-format <https://clang.llvm.org/docs/ClangFormat.html>`_. The
repository contains a ``.clang-format`` file that can be used to
automatically apply the style rules that are described below. The easiest
way to use clang-format is through a plugin/extension for your editor/IDE
that automatically runs clang-format using the ``.clang-format`` file
whenever a file is saved.
.. _styleguide_formatting:
Indentation
-----------
Automatic Formatting
--------------------
Use two spaces per indentation level.
To ensure consistent styling with little effort, this project uses `clang-format
<https://clang.llvm.org/docs/ClangFormat.html>`_. The repository contains a
``.clang-format`` file that can be used to automatically apply a consistent
format. The easiest way to use clang-format is to run
``tools/dev/install-commit-hooks.sh`` to install a post-commit hook that gets
executed each time a commit is made. Note that this script requires that you
already have clang-format installed. In addition, you may want to configure your
editor/IDE to automatically runs clang-format using the ``.clang-format`` file
whenever a file is saved. For example, `Visual Studio Code
<https://code.visualstudio.com/docs/cpp/cpp-ide#_code-formatting>`_ includes
support for running clang-format.
Miscellaneous
-------------
@ -123,94 +127,6 @@ Variables declared constexpr or const that have static storage duration (exist
for the duration of the program) should be upper-case with underscores,
e.g., ``SQRT_PI``.
Use C++-style declarator layout (see `NL.18
<http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#nl18-use-c-style-declarator-layout>`_):
pointer and reference operators in declarations should be placed adject to the
base type rather than the variable name. Avoid declaring multiple names in a
single declaration to avoid confusion:
.. code-block:: C++
T* p; // good
T& p; // good
T *p; // bad
T* p, q; // misleading
Curly braces
------------
For a class declaration, the opening brace should be on the same line that
lists the name of the class.
.. code-block:: C++
class Matrix {
...
};
For a function definition, the opening and closing braces should each be on
their own lines. This helps distinguish function code from the argument list.
If the entire function fits on one or two lines, then the braces can be on the
same line. e.g.:
.. code-block:: C++
return_type function(type1 arg1, type2 arg2)
{
content();
}
return_type
function_with_many_args(type1 arg1, type2 arg2, type3 arg3,
type4 arg4)
{
content();
}
int return_one() {return 1;}
int return_one()
{return 1;}
For a conditional, the opening brace should be on the same line as the end of
the conditional statement. If there is a following ``else if`` or ``else``
statement, the closing brace should be on the same line as that following
statement. Otherwise, the closing brace should be on its own line. A one-line
conditional can have the closing brace on the same line or it can omit the
braces entirely e.g.:
.. code-block:: C++
if (condition) {
content();
}
if (condition1) {
content();
} else if (condition 2) {
more_content();
} else {
further_content();
}
if (condition) {content()};
if (condition) content();
For loops similarly have an opening brace on the same line as the statement and
a closing brace on its own line. One-line loops may have the closing brace on
the same line or omit the braces entirely.
.. code-block:: C++
for (int i = 0; i < 5; i++) {
content();
}
for (int i = 0; i < 5; i++) {content();}
for (int i = 0; i < 5; i++) content();
Documentation
-------------
@ -226,7 +142,7 @@ Style for Python code should follow PEP8_.
Docstrings for functions and methods should follow numpydoc_ style.
Python code should work with Python 3.4+.
Python code should work with Python 3.6+.
Use of third-party Python packages should be limited to numpy_, scipy_,
matplotlib_, pandas_, and h5py_. Use of other third-party packages must be

6
docs/source/devguide/workflow.rst
View file

@ -67,6 +67,12 @@ features and bug fixes. The general steps for contributing are as follows:
cd openmc
git checkout -b newbranch develop
3. Run ``tools/dev/install-commit-hooks.sh`` to install a post-commit hook that
runs clang-format on C++ files to apply :ref:`automatic code formatting
<styleguide_formatting>` (requires that clang-format already be installed).
In addition, you may want to configure your text editor to automatically run
clang-format when saving C++ files.
3. Make your changes on the new branch that you intend to have included in
*develop*. If you have made other changes that should not be merged back,
ensure that those changes are made on a different branch.

6
include/openmc/angle_energy.h
View file

@ -14,11 +14,11 @@ namespace openmc {
class AngleEnergy {
public:
virtual void sample(double E_in, double& E_out, double& mu,
uint64_t* seed) const = 0;
virtual void sample(
double E_in, double& E_out, double& mu, uint64_t* seed) const = 0;
virtual ~AngleEnergy() = default;
};
}
} // namespace openmc
#endif // OPENMC_ANGLE_ENERGY_H

30
include/openmc/boundary_condition.h
View file

@ -20,8 +20,7 @@ public:
//! to directly modify anything about the particle, but it will do so
//! indirectly by calling the particle's appropriate cross_*_bc function.
//! \param surf The specific surface on the boundary the particle struck.
virtual void
handle_particle(Particle& p, const Surface& surf) const = 0;
virtual void handle_particle(Particle& p, const Surface& surf) const = 0;
//! Return a string classification of this BC.
virtual std::string type() const = 0;
@ -33,10 +32,9 @@ public:
class VacuumBC : public BoundaryCondition {
public:
void
handle_particle(Particle& p, const Surface& surf) const override;
void handle_particle(Particle& p, const Surface& surf) const override;
std::string type() const override {return "vacuum";}
std::string type() const override { return "vacuum"; }
};
//==============================================================================
@ -45,10 +43,9 @@ public:
class ReflectiveBC : public BoundaryCondition {
public:
void
handle_particle(Particle& p, const Surface& surf) const override;
void handle_particle(Particle& p, const Surface& surf) const override;
std::string type() const override {return "reflective";}
std::string type() const override { return "reflective"; }
};
//==============================================================================
@ -57,10 +54,9 @@ public:
class WhiteBC : public BoundaryCondition {
public:
void
handle_particle(Particle& p, const Surface& surf) const override;
void handle_particle(Particle& p, const Surface& surf) const override;
std::string type() const override {return "white";}
std::string type() const override { return "white"; }
};
//==============================================================================
@ -69,11 +65,9 @@ public:
class PeriodicBC : public BoundaryCondition {
public:
PeriodicBC(int i_surf, int j_surf)
: i_surf_(i_surf), j_surf_(j_surf)
{};
PeriodicBC(int i_surf, int j_surf) : i_surf_(i_surf), j_surf_(j_surf) {};
std::string type() const override {return "periodic";}
std::string type() const override { return "periodic"; }
protected:
int i_surf_;
@ -88,8 +82,7 @@ class TranslationalPeriodicBC : public PeriodicBC {
public:
TranslationalPeriodicBC(int i_surf, int j_surf);
void
handle_particle(Particle& p, const Surface& surf) const override;
void handle_particle(Particle& p, const Surface& surf) const override;
protected:
//! Vector along which incident particles will be moved
@ -106,8 +99,7 @@ class RotationalPeriodicBC : public PeriodicBC {
public:
RotationalPeriodicBC(int i_surf, int j_surf);
void
handle_particle(Particle& p, const Surface& surf) const override;
void handle_particle(Particle& p, const Surface& surf) const override;
protected:
//! Angle about the axis by which particle coordinates will be rotated

10
include/openmc/bremsstrahlung.h
View file

@ -14,8 +14,8 @@ namespace openmc {
class BremsstrahlungData {
public:
// Data
xt::xtensor<double, 2> pdf; //!< Bremsstrahlung energy PDF
xt::xtensor<double, 2> cdf; //!< Bremsstrahlung energy CDF
xt::xtensor<double, 2> pdf; //!< Bremsstrahlung energy PDF
xt::xtensor<double, 2> cdf; //!< Bremsstrahlung energy CDF
xt::xtensor<double, 1> yield; //!< Photon yield
};
@ -32,8 +32,10 @@ public:
namespace data {
extern xt::xtensor<double, 1> ttb_e_grid; //! energy T of incident electron in [eV]
extern xt::xtensor<double, 1> ttb_k_grid; //! reduced energy W/T of emitted photon
extern xt::xtensor<double, 1>
ttb_e_grid; //! energy T of incident electron in [eV]
extern xt::xtensor<double, 1>
ttb_k_grid; //! reduced energy W/T of emitted photon
} // namespace data

400
include/openmc/capi.h
View file

@ -1,211 +1,231 @@
#ifndef OPENMC_CAPI_H
#define OPENMC_CAPI_H
#include <stdint.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#ifdef __cplusplus
extern "C" {
#endif
int openmc_calculate_volumes();
int openmc_cell_filter_get_bins(int32_t index, const int32_t** cells, int32_t* n);
int openmc_cell_get_fill(int32_t index, int* type, int32_t** indices, int32_t* n);
int openmc_cell_get_id(int32_t index, int32_t* id);
int openmc_cell_get_temperature(int32_t index, const int32_t* instance, double* T);
int openmc_cell_get_translation(int32_t index, double xyz[]);
int openmc_cell_get_rotation(int32_t index, double rot[], size_t* n);
int openmc_cell_get_name(int32_t index, const char** name);
int openmc_cell_get_num_instances(int32_t index, int32_t* num_instances);
int openmc_cell_set_name(int32_t index, const char* name);
int openmc_cell_set_fill(int32_t index, int type, int32_t n, const int32_t* indices);
int openmc_cell_set_id(int32_t index, int32_t id);
int openmc_cell_set_temperature(int32_t index, double T, const int32_t* instance, bool set_contained = false);
int openmc_cell_set_translation(int32_t index, const double xyz[]);
int openmc_cell_set_rotation(int32_t index, const double rot[], size_t rot_len);
int openmc_energy_filter_get_bins(int32_t index, const double** energies, size_t* n);
int openmc_energy_filter_set_bins(int32_t index, size_t n, const double* energies);
int openmc_energyfunc_filter_get_energy(int32_t index, size_t* n, const double** energy);
int openmc_energyfunc_filter_get_y(int32_t index, size_t* n, const double** y);
int openmc_energyfunc_filter_set_data(int32_t index, size_t n,
const double* energies, const double* y);
int openmc_extend_cells(int32_t n, int32_t* index_start, int32_t* index_end);
int openmc_extend_filters(int32_t n, int32_t* index_start, int32_t* index_end);
int openmc_extend_materials(int32_t n, int32_t* index_start, int32_t* index_end);
int openmc_extend_meshes(int32_t n, const char* type, int32_t* index_start,
int32_t* index_end);
int openmc_extend_tallies(int32_t n, int32_t* index_start, int32_t* index_end);
int openmc_filter_get_id(int32_t index, int32_t* id);
int openmc_filter_get_type(int32_t index, char* type);
int openmc_filter_set_id(int32_t index, int32_t id);
int openmc_finalize();
int openmc_find_cell(const double* xyz, int32_t* index, int32_t* instance);
int openmc_cell_bounding_box(const int32_t index, double* llc, double* urc);
int openmc_global_bounding_box(double* llc, double* urc);
int openmc_fission_bank(void** ptr, int64_t* n);
int openmc_get_cell_index(int32_t id, int32_t* index);
int openmc_get_filter_index(int32_t id, int32_t* index);
void openmc_get_filter_next_id(int32_t* id);
int openmc_get_keff(double k_combined[]);
int openmc_get_material_index(int32_t id, int32_t* index);
int openmc_get_mesh_index(int32_t id, int32_t* index);
int openmc_get_n_batches(int* n_batches, bool get_max_batches);
int openmc_get_nuclide_index(const char name[], int* index);
int openmc_add_unstructured_mesh(const char filename[], const char library[], int* id);
int64_t openmc_get_seed();
int openmc_get_tally_index(int32_t id, int32_t* index);
void openmc_get_tally_next_id(int32_t* id);
int openmc_global_tallies(double** ptr);
int openmc_hard_reset();
int openmc_init(int argc, char* argv[], const void* intracomm);
bool openmc_is_statepoint_batch();
int openmc_legendre_filter_get_order(int32_t index, int* order);
int openmc_legendre_filter_set_order(int32_t index, int order);
int openmc_load_nuclide(const char* name, const double* temps, int n);
int openmc_material_add_nuclide(int32_t index, const char name[], double density);
int openmc_material_get_densities(int32_t index, const int** nuclides, const double** densities, int* n);
int openmc_material_get_id(int32_t index, int32_t* id);
int openmc_material_get_fissionable(int32_t index, bool* fissionable);
int openmc_material_get_density(int32_t index, double* density);
int openmc_material_get_volume(int32_t index, double* volume);
int openmc_material_set_density(int32_t index, double density, const char* units);
int openmc_material_set_densities(int32_t index, int n, const char** name, const double* density);
int openmc_material_set_id(int32_t index, int32_t id);
int openmc_material_get_name(int32_t index, const char** name);
int openmc_material_set_name(int32_t index, const char* name);
int openmc_material_set_volume(int32_t index, double volume);
int openmc_material_filter_get_bins(int32_t index, const int32_t** bins, size_t* n);
int openmc_material_filter_set_bins(int32_t index, size_t n, const int32_t* bins);
int openmc_mesh_filter_get_mesh(int32_t index, int32_t* index_mesh);
int openmc_mesh_filter_set_mesh(int32_t index, int32_t index_mesh);
int openmc_mesh_filter_get_translation(int32_t index, double translation[3]);
int openmc_mesh_filter_set_translation(int32_t index, double translation[3]);
int openmc_mesh_get_id(int32_t index, int32_t* id);
int openmc_mesh_set_id(int32_t index, int32_t id);
int openmc_meshsurface_filter_get_mesh(int32_t index, int32_t* index_mesh);
int openmc_meshsurface_filter_set_mesh(int32_t index, int32_t index_mesh);
int openmc_new_filter(const char* type, int32_t* index);
int openmc_next_batch(int* status);
int openmc_nuclide_name(int index, const char** name);
int openmc_plot_geometry();
int openmc_id_map(const void* slice, int32_t* data_out);
int openmc_property_map(const void* slice, double* data_out);
int openmc_rectilinear_mesh_get_grid(int32_t index, double** grid_x, int* nx,
double** grid_y, int* ny, double** grid_z, int* nz);
int openmc_rectilinear_mesh_set_grid(int32_t index, const double* grid_x,
const int nx, const double* grid_y, const int ny,
const double* grid_z, const int nz);
int openmc_regular_mesh_get_dimension(int32_t index, int** id, int* n);
int openmc_regular_mesh_get_params(int32_t index, double** ll, double** ur, double** width, int* n);
int openmc_regular_mesh_set_dimension(int32_t index, int n, const int* dims);
int openmc_regular_mesh_set_params(int32_t index, int n, const double* ll, const double* ur, const double* width);
int openmc_reset();
int openmc_reset_timers();
int openmc_run();
void openmc_set_seed(int64_t new_seed);
int openmc_set_n_batches(int32_t n_batches, bool set_max_batches,
bool add_statepoint_batch);
int openmc_simulation_finalize();
int openmc_simulation_init();
int openmc_source_bank(void** ptr, int64_t* n);
int openmc_spatial_legendre_filter_get_order(int32_t index, int* order);
int openmc_spatial_legendre_filter_get_params(int32_t index, int* axis, double* min, double* max);
int openmc_spatial_legendre_filter_set_order(int32_t index, int order);
int openmc_spatial_legendre_filter_set_params(int32_t index, const int* axis,
const double* min, const double* max);
int openmc_sphharm_filter_get_order(int32_t index, int* order);
int openmc_sphharm_filter_get_cosine(int32_t index, char cosine[]);
int openmc_sphharm_filter_set_order(int32_t index, int order);
int openmc_sphharm_filter_set_cosine(int32_t index, const char cosine[]);
int openmc_statepoint_write(const char* filename, bool* write_source);
int openmc_tally_allocate(int32_t index, const char* type);
int openmc_tally_get_active(int32_t index, bool* active);
int openmc_tally_get_estimator(int32_t index, int* estimator);
int openmc_tally_get_id(int32_t index, int32_t* id);
int openmc_tally_get_filters(int32_t index, const int32_t** indices, size_t* n);
int openmc_tally_get_n_realizations(int32_t index, int32_t* n);
int openmc_tally_get_nuclides(int32_t index, int** nuclides, int* n);
int openmc_tally_get_scores(int32_t index, int** scores, int* n);
int openmc_tally_get_type(int32_t index, int32_t* type);
int openmc_tally_get_writable(int32_t index, bool* writable);
int openmc_tally_reset(int32_t index);
int openmc_tally_results(int32_t index, double** ptr, size_t shape_[3]);
int openmc_tally_set_active(int32_t index, bool active);
int openmc_tally_set_estimator(int32_t index, const char* estimator);
int openmc_tally_set_filters(int32_t index, size_t n, const int32_t* indices);
int openmc_tally_set_id(int32_t index, int32_t id);
int openmc_tally_set_nuclides(int32_t index, int n, const char** nuclides);
int openmc_tally_set_scores(int32_t index, int n, const char** scores);
int openmc_tally_set_type(int32_t index, const char* type);
int openmc_tally_set_writable(int32_t index, bool writable);
int openmc_zernike_filter_get_order(int32_t index, int* order);
int openmc_zernike_filter_get_params(int32_t index, double* x, double* y, double* r);
int openmc_zernike_filter_set_order(int32_t index, int order);
int openmc_zernike_filter_set_params(int32_t index, const double* x,
const double* y, const double* r);
int openmc_calculate_volumes();
int openmc_cell_filter_get_bins(
int32_t index, const int32_t** cells, int32_t* n);
int openmc_cell_get_fill(
int32_t index, int* type, int32_t** indices, int32_t* n);
int openmc_cell_get_id(int32_t index, int32_t* id);
int openmc_cell_get_temperature(
int32_t index, const int32_t* instance, double* T);
int openmc_cell_get_translation(int32_t index, double xyz[]);
int openmc_cell_get_rotation(int32_t index, double rot[], size_t* n);
int openmc_cell_get_name(int32_t index, const char** name);
int openmc_cell_get_num_instances(int32_t index, int32_t* num_instances);
int openmc_cell_set_name(int32_t index, const char* name);
int openmc_cell_set_fill(
int32_t index, int type, int32_t n, const int32_t* indices);
int openmc_cell_set_id(int32_t index, int32_t id);
int openmc_cell_set_temperature(
int32_t index, double T, const int32_t* instance, bool set_contained = false);
int openmc_cell_set_translation(int32_t index, const double xyz[]);
int openmc_cell_set_rotation(int32_t index, const double rot[], size_t rot_len);
int openmc_energy_filter_get_bins(
int32_t index, const double** energies, size_t* n);
int openmc_energy_filter_set_bins(
int32_t index, size_t n, const double* energies);
int openmc_energyfunc_filter_get_energy(
int32_t index, size_t* n, const double** energy);
int openmc_energyfunc_filter_get_y(int32_t index, size_t* n, const double** y);
int openmc_energyfunc_filter_set_data(
int32_t index, size_t n, const double* energies, const double* y);
int openmc_extend_cells(int32_t n, int32_t* index_start, int32_t* index_end);
int openmc_extend_filters(int32_t n, int32_t* index_start, int32_t* index_end);
int openmc_extend_materials(
int32_t n, int32_t* index_start, int32_t* index_end);
int openmc_extend_meshes(
int32_t n, const char* type, int32_t* index_start, int32_t* index_end);
int openmc_extend_tallies(int32_t n, int32_t* index_start, int32_t* index_end);
int openmc_filter_get_id(int32_t index, int32_t* id);
int openmc_filter_get_type(int32_t index, char* type);
int openmc_filter_set_id(int32_t index, int32_t id);
int openmc_finalize();
int openmc_find_cell(const double* xyz, int32_t* index, int32_t* instance);
int openmc_cell_bounding_box(const int32_t index, double* llc, double* urc);
int openmc_global_bounding_box(double* llc, double* urc);
int openmc_fission_bank(void** ptr, int64_t* n);
int openmc_get_cell_index(int32_t id, int32_t* index);
int openmc_get_filter_index(int32_t id, int32_t* index);
void openmc_get_filter_next_id(int32_t* id);
int openmc_get_keff(double k_combined[]);
int openmc_get_material_index(int32_t id, int32_t* index);
int openmc_get_mesh_index(int32_t id, int32_t* index);
int openmc_get_n_batches(int* n_batches, bool get_max_batches);
int openmc_get_nuclide_index(const char name[], int* index);
int openmc_add_unstructured_mesh(
const char filename[], const char library[], int* id);
int64_t openmc_get_seed();
int openmc_get_tally_index(int32_t id, int32_t* index);
void openmc_get_tally_next_id(int32_t* id);
int openmc_global_tallies(double** ptr);
int openmc_hard_reset();
int openmc_init(int argc, char* argv[], const void* intracomm);
bool openmc_is_statepoint_batch();
int openmc_legendre_filter_get_order(int32_t index, int* order);
int openmc_legendre_filter_set_order(int32_t index, int order);
int openmc_load_nuclide(const char* name, const double* temps, int n);
int openmc_material_add_nuclide(
int32_t index, const char name[], double density);
int openmc_material_get_densities(
int32_t index, const int** nuclides, const double** densities, int* n);
int openmc_material_get_id(int32_t index, int32_t* id);
int openmc_material_get_fissionable(int32_t index, bool* fissionable);
int openmc_material_get_density(int32_t index, double* density);
int openmc_material_get_volume(int32_t index, double* volume);
int openmc_material_set_density(
int32_t index, double density, const char* units);
int openmc_material_set_densities(
int32_t index, int n, const char** name, const double* density);
int openmc_material_set_id(int32_t index, int32_t id);
int openmc_material_get_name(int32_t index, const char** name);
int openmc_material_set_name(int32_t index, const char* name);
int openmc_material_set_volume(int32_t index, double volume);
int openmc_material_filter_get_bins(
int32_t index, const int32_t** bins, size_t* n);
int openmc_material_filter_set_bins(
int32_t index, size_t n, const int32_t* bins);
int openmc_mesh_filter_get_mesh(int32_t index, int32_t* index_mesh);
int openmc_mesh_filter_set_mesh(int32_t index, int32_t index_mesh);
int openmc_mesh_filter_get_translation(int32_t index, double translation[3]);
int openmc_mesh_filter_set_translation(int32_t index, double translation[3]);
int openmc_mesh_get_id(int32_t index, int32_t* id);
int openmc_mesh_set_id(int32_t index, int32_t id);
int openmc_meshsurface_filter_get_mesh(int32_t index, int32_t* index_mesh);
int openmc_meshsurface_filter_set_mesh(int32_t index, int32_t index_mesh);
int openmc_new_filter(const char* type, int32_t* index);
int openmc_next_batch(int* status);
int openmc_nuclide_name(int index, const char** name);
int openmc_plot_geometry();
int openmc_id_map(const void* slice, int32_t* data_out);
int openmc_property_map(const void* slice, double* data_out);
int openmc_rectilinear_mesh_get_grid(int32_t index, double** grid_x, int* nx,
double** grid_y, int* ny, double** grid_z, int* nz);
int openmc_rectilinear_mesh_set_grid(int32_t index, const double* grid_x,
const int nx, const double* grid_y, const int ny, const double* grid_z,
const int nz);
int openmc_regular_mesh_get_dimension(int32_t index, int** id, int* n);
int openmc_regular_mesh_get_params(
int32_t index, double** ll, double** ur, double** width, int* n);
int openmc_regular_mesh_set_dimension(int32_t index, int n, const int* dims);
int openmc_regular_mesh_set_params(int32_t index, int n, const double* ll,
const double* ur, const double* width);
int openmc_reset();
int openmc_reset_timers();
int openmc_run();
void openmc_set_seed(int64_t new_seed);
int openmc_set_n_batches(
int32_t n_batches, bool set_max_batches, bool add_statepoint_batch);
int openmc_simulation_finalize();
int openmc_simulation_init();
int openmc_source_bank(void** ptr, int64_t* n);
int openmc_spatial_legendre_filter_get_order(int32_t index, int* order);
int openmc_spatial_legendre_filter_get_params(
int32_t index, int* axis, double* min, double* max);
int openmc_spatial_legendre_filter_set_order(int32_t index, int order);
int openmc_spatial_legendre_filter_set_params(
int32_t index, const int* axis, const double* min, const double* max);
int openmc_sphharm_filter_get_order(int32_t index, int* order);
int openmc_sphharm_filter_get_cosine(int32_t index, char cosine[]);
int openmc_sphharm_filter_set_order(int32_t index, int order);
int openmc_sphharm_filter_set_cosine(int32_t index, const char cosine[]);
int openmc_statepoint_write(const char* filename, bool* write_source);
int openmc_tally_allocate(int32_t index, const char* type);
int openmc_tally_get_active(int32_t index, bool* active);
int openmc_tally_get_estimator(int32_t index, int* estimator);
int openmc_tally_get_id(int32_t index, int32_t* id);
int openmc_tally_get_filters(int32_t index, const int32_t** indices, size_t* n);
int openmc_tally_get_n_realizations(int32_t index, int32_t* n);
int openmc_tally_get_nuclides(int32_t index, int** nuclides, int* n);
int openmc_tally_get_scores(int32_t index, int** scores, int* n);
int openmc_tally_get_type(int32_t index, int32_t* type);
int openmc_tally_get_writable(int32_t index, bool* writable);
int openmc_tally_reset(int32_t index);
int openmc_tally_results(int32_t index, double** ptr, size_t shape_[3]);
int openmc_tally_set_active(int32_t index, bool active);
int openmc_tally_set_estimator(int32_t index, const char* estimator);
int openmc_tally_set_filters(int32_t index, size_t n, const int32_t* indices);
int openmc_tally_set_id(int32_t index, int32_t id);
int openmc_tally_set_nuclides(int32_t index, int n, const char** nuclides);
int openmc_tally_set_scores(int32_t index, int n, const char** scores);
int openmc_tally_set_type(int32_t index, const char* type);
int openmc_tally_set_writable(int32_t index, bool writable);
int openmc_zernike_filter_get_order(int32_t index, int* order);
int openmc_zernike_filter_get_params(
int32_t index, double* x, double* y, double* r);
int openmc_zernike_filter_set_order(int32_t index, int order);
int openmc_zernike_filter_set_params(
int32_t index, const double* x, const double* y, const double* r);
//! Sets the mesh and energy grid for CMFD reweight
//! \param[in] meshtyally_id id of CMFD Mesh Tally
//! \param[in] cmfd_indices indices storing spatial and energy dimensions of CMFD problem
//! \param[in] norm CMFD normalization factor
void openmc_initialize_mesh_egrid(const int meshtally_id, const int* cmfd_indices,
const double norm);
//! Sets the mesh and energy grid for CMFD reweight
//! \param[in] meshtyally_id id of CMFD Mesh Tally
//! \param[in] cmfd_indices indices storing spatial and energy dimensions of
//! CMFD problem \param[in] norm CMFD normalization factor
void openmc_initialize_mesh_egrid(
const int meshtally_id, const int* cmfd_indices, const double norm);
//! Sets the mesh and energy grid for CMFD reweight
//! \param[in] feedback whether or not to run CMFD feedback
//! \param[in] cmfd_src computed CMFD source
void openmc_cmfd_reweight(const bool feedback, const double* cmfd_src);
//! Sets the mesh and energy grid for CMFD reweight
//! \param[in] feedback whether or not to run CMFD feedback
//! \param[in] cmfd_src computed CMFD source
void openmc_cmfd_reweight(const bool feedback, const double* cmfd_src);
//! Sets the fixed variables that are used for CMFD linear solver
//! \param[in] indptr CSR format index pointer array of loss matrix
//! \param[in] len_indptr length of indptr
//! \param[in] indices CSR format index array of loss matrix
//! \param[in] n_elements number of non-zero elements in CMFD loss matrix
//! \param[in] dim dimension n of nxn CMFD loss matrix
//! \param[in] spectral spectral radius of CMFD matrices and tolerances
//! \param[in] map coremap for problem, storing accelerated regions
//! \param[in] use_all_threads whether to use all threads when running CMFD solver
void openmc_initialize_linsolver(const int* indptr, int len_indptr,
const int* indices, int n_elements,
int dim, double spectral,
const int* map, bool use_all_threads);
//! Sets the fixed variables that are used for CMFD linear solver
//! \param[in] indptr CSR format index pointer array of loss matrix
//! \param[in] len_indptr length of indptr
//! \param[in] indices CSR format index array of loss matrix
//! \param[in] n_elements number of non-zero elements in CMFD loss matrix
//! \param[in] dim dimension n of nxn CMFD loss matrix
//! \param[in] spectral spectral radius of CMFD matrices and tolerances
//! \param[in] map coremap for problem, storing accelerated regions
//! \param[in] use_all_threads whether to use all threads when running CMFD
//! solver
void openmc_initialize_linsolver(const int* indptr, int len_indptr,
const int* indices, int n_elements, int dim, double spectral, const int* map,
bool use_all_threads);
//! Runs a Gauss Seidel linear solver to solve CMFD matrix equations
//! linear solver
//! \param[in] A_data CSR format data array of coefficient matrix
//! \param[in] b right hand side vector
//! \param[out] x unknown vector
//! \param[in] tol tolerance on final error
//! \return number of inner iterations required to reach convergence
int openmc_run_linsolver(const double* A_data, const double* b,
double* x, double tol);
//! Runs a Gauss Seidel linear solver to solve CMFD matrix equations
//! linear solver
//! \param[in] A_data CSR format data array of coefficient matrix
//! \param[in] b right hand side vector
//! \param[out] x unknown vector
//! \param[in] tol tolerance on final error
//! \return number of inner iterations required to reach convergence
int openmc_run_linsolver(
const double* A_data, const double* b, double* x, double tol);
//! Export physical properties for model
//! \param[in] filename Filename to write to
//! \return Error code
int openmc_properties_export(const char* filename);
//! Export physical properties for model
//! \param[in] filename Filename to write to
//! \return Error code
int openmc_properties_export(const char* filename);
//! Import physical properties for model
//! \param[in] filename Filename to read from
// \return Error code
int openmc_properties_import(const char* filename);
//! Import physical properties for model
//! \param[in] filename Filename to read from
// \return Error code
int openmc_properties_import(const char* filename);
// Error codes
extern int OPENMC_E_UNASSIGNED;
extern int OPENMC_E_ALLOCATE;
extern int OPENMC_E_OUT_OF_BOUNDS;
extern int OPENMC_E_INVALID_SIZE;
extern int OPENMC_E_INVALID_ARGUMENT;
extern int OPENMC_E_INVALID_TYPE;
extern int OPENMC_E_INVALID_ID;
extern int OPENMC_E_GEOMETRY;
extern int OPENMC_E_DATA;
extern int OPENMC_E_PHYSICS;
extern int OPENMC_E_WARNING;
// Error codes
extern int OPENMC_E_UNASSIGNED;
extern int OPENMC_E_ALLOCATE;
extern int OPENMC_E_OUT_OF_BOUNDS;
extern int OPENMC_E_INVALID_SIZE;
extern int OPENMC_E_INVALID_ARGUMENT;
extern int OPENMC_E_INVALID_TYPE;
extern int OPENMC_E_INVALID_ID;
extern int OPENMC_E_GEOMETRY;
extern int OPENMC_E_DATA;
extern int OPENMC_E_PHYSICS;
extern int OPENMC_E_WARNING;
// Global variables
extern char openmc_err_msg[256];
// Global variables
extern char openmc_err_msg[256];
#ifdef __cplusplus
}

87
include/openmc/cell.h
View file

@ -7,9 +7,9 @@
#include <string>
#include <unordered_map>
#include <gsl/gsl>
#include "hdf5.h"
#include "pugixml.hpp"
#include <gsl/gsl>
#include "openmc/constants.h"
#include "openmc/memory.h" // for unique_ptr
@ -24,18 +24,14 @@ namespace openmc {
// Constants
//==============================================================================
enum class Fill {
MATERIAL,
UNIVERSE,
LATTICE
};
enum class Fill { MATERIAL, UNIVERSE, LATTICE };
// TODO: Convert to enum
constexpr int32_t OP_LEFT_PAREN {std::numeric_limits<int32_t>::max()};
constexpr int32_t OP_RIGHT_PAREN {std::numeric_limits<int32_t>::max() - 1};
constexpr int32_t OP_COMPLEMENT {std::numeric_limits<int32_t>::max() - 2};
constexpr int32_t OP_LEFT_PAREN {std::numeric_limits<int32_t>::max()};
constexpr int32_t OP_RIGHT_PAREN {std::numeric_limits<int32_t>::max() - 1};
constexpr int32_t OP_COMPLEMENT {std::numeric_limits<int32_t>::max() - 2};
constexpr int32_t OP_INTERSECTION {std::numeric_limits<int32_t>::max() - 3};
constexpr int32_t OP_UNION {std::numeric_limits<int32_t>::max() - 4};
constexpr int32_t OP_UNION {std::numeric_limits<int32_t>::max() - 4};
//==============================================================================
// Global variables
@ -48,29 +44,27 @@ class Universe;
class UniversePartitioner;
namespace model {
extern std::unordered_map<int32_t, int32_t> cell_map;
extern vector<unique_ptr<Cell>> cells;
extern std::unordered_map<int32_t, int32_t> cell_map;
extern vector<unique_ptr<Cell>> cells;
extern std::unordered_map<int32_t, int32_t> universe_map;
extern vector<unique_ptr<Universe>> universes;
extern std::unordered_map<int32_t, int32_t> universe_map;
extern vector<unique_ptr<Universe>> universes;
} // namespace model
//==============================================================================
//! A geometry primitive that fills all space and contains cells.
//==============================================================================
class Universe
{
class Universe {
public:
int32_t id_; //!< Unique ID
vector<int32_t> cells_; //!< Cells within this universe
int32_t id_; //!< Unique ID
vector<int32_t> cells_; //!< Cells within this universe
//! \brief Write universe information to an HDF5 group.
//! \param group_id An HDF5 group id.
virtual void to_hdf5(hid_t group_id) const;
virtual bool find_cell(Particle &p) const;
virtual bool find_cell(Particle& p) const;
BoundingBox bounding_box() const;
@ -117,12 +111,11 @@ public:
//! \param on_surface The signed index of a surface that the coordinate is
//! known to be on. This index takes precedence over surface sense
//! calculations.
virtual bool
contains(Position r, Direction u, int32_t on_surface) const = 0;
virtual bool contains(Position r, Direction u, int32_t on_surface) const = 0;
//! Find the oncoming boundary of this cell.
virtual std::pair<double, int32_t>
distance(Position r, Direction u, int32_t on_surface, Particle* p) const = 0;
virtual std::pair<double, int32_t> distance(
Position r, Direction u, int32_t on_surface, Particle* p) const = 0;
//! Write all information needed to reconstruct the cell to an HDF5 group.
//! \param group_id An HDF5 group id.
@ -157,7 +150,8 @@ public:
//! \param[in] set_contained If this cell is not filled with a material,
//! collect all contained cells with material fills and set their
//! temperatures.
void set_temperature(double T, int32_t instance = -1, bool set_contained = false);
void set_temperature(
double T, int32_t instance = -1, bool set_contained = false);
//! Set the rotation matrix of a cell instance
//! \param[in] rot The rotation matrix of length 3 or 9
@ -184,16 +178,16 @@ public:
//----------------------------------------------------------------------------
// Data members
int32_t id_; //!< Unique ID
std::string name_; //!< User-defined name
Fill type_; //!< Material, universe, or lattice
int32_t universe_; //!< Universe # this cell is in
int32_t fill_; //!< Universe # filling this cell
int32_t n_instances_{0}; //!< Number of instances of this cell
GeometryType geom_type_; //!< Geometric representation type (CSG, DAGMC)
int32_t id_; //!< Unique ID
std::string name_; //!< User-defined name
Fill type_; //!< Material, universe, or lattice
int32_t universe_; //!< Universe # this cell is in
int32_t fill_; //!< Universe # filling this cell
int32_t n_instances_ {0}; //!< Number of instances of this cell
GeometryType geom_type_; //!< Geometric representation type (CSG, DAGMC)
//! \brief Index corresponding to this cell in distribcell arrays
int distribcell_index_{C_NONE};
int distribcell_index_ {C_NONE};
//! \brief Material(s) within this cell.
//!
@ -210,7 +204,7 @@ public:
vector<std::int32_t> region_;
//! Reverse Polish notation for region expression
vector<std::int32_t> rpn_;
bool simple_; //!< Does the region contain only intersections?
bool simple_; //!< Does the region contain only intersections?
//! \brief Neighboring cells in the same universe.
NeighborList neighbors_;
@ -229,24 +223,22 @@ public:
};
struct CellInstanceItem {
int32_t index {-1}; //! Index into global cells array
int lattice_indx{-1}; //! Flat index value of the lattice cell
int32_t index {-1}; //! Index into global cells array
int lattice_indx {-1}; //! Flat index value of the lattice cell
};
//==============================================================================
class CSGCell : public Cell
{
class CSGCell : public Cell {
public:
CSGCell();
explicit CSGCell(pugi::xml_node cell_node);
bool
contains(Position r, Direction u, int32_t on_surface) const;
bool contains(Position r, Direction u, int32_t on_surface) const;
std::pair<double, int32_t>
distance(Position r, Direction u, int32_t on_surface, Particle* p) const;
std::pair<double, int32_t> distance(
Position r, Direction u, int32_t on_surface, Particle* p) const;
void to_hdf5_inner(hid_t group_id) const override;
@ -285,8 +277,7 @@ protected:
//! and spheres.
//==============================================================================
class UniversePartitioner
{
class UniversePartitioner {
public:
explicit UniversePartitioner(const Universe& univ);
@ -307,7 +298,6 @@ private:
vector<vector<int32_t>> partitions_;
};
//==============================================================================
//! Define a containing (parent) cell
//==============================================================================
@ -324,7 +314,9 @@ struct ParentCell {
struct CellInstance {
//! Check for equality
bool operator==(const CellInstance& other) const
{ return index_cell == other.index_cell && instance == other.instance; }
{
return index_cell == other.index_cell && instance == other.instance;
}
gsl::index index_cell;
gsl::index instance;
@ -333,7 +325,7 @@ struct CellInstance {
struct CellInstanceHash {
std::size_t operator()(const CellInstance& k) const
{
return 4096*k.index_cell + k.instance;
return 4096 * k.index_cell + k.instance;
}
};
@ -343,7 +335,6 @@ struct CellInstanceHash {
void read_cells(pugi::xml_node node);
#ifdef DAGMC
class DAGUniverse;
#endif

314
include/openmc/constants.h
View file

@ -79,16 +79,20 @@ constexpr double INFTY {std::numeric_limits<double>::max()};
// (CODATA) 2018 recommendation (https://physics.nist.gov/cuu/Constants/).
// Physical constants
constexpr double MASS_NEUTRON {1.00866491595}; // mass of a neutron in amu
constexpr double MASS_NEUTRON_EV {939.56542052e6}; // mass of a neutron in eV/c^2
constexpr double MASS_PROTON {1.007276466621}; // mass of a proton in amu
constexpr double MASS_ELECTRON_EV {0.51099895000e6}; // electron mass energy equivalent in eV/c^2
constexpr double FINE_STRUCTURE {137.035999084}; // inverse fine structure constant
constexpr double PLANCK_C {1.2398419839593942e4}; // Planck's constant times c in eV-Angstroms
constexpr double AMU {1.66053906660e-27}; // 1 amu in kg
constexpr double C_LIGHT {2.99792458e8}; // speed of light in m/s
constexpr double N_AVOGADRO {0.602214076}; // Avogadro's number in 10^24/mol
constexpr double K_BOLTZMANN {8.617333262e-5}; // Boltzmann constant in eV/K
constexpr double MASS_NEUTRON {1.00866491595}; // mass of a neutron in amu
constexpr double MASS_NEUTRON_EV {
939.56542052e6}; // mass of a neutron in eV/c^2
constexpr double MASS_PROTON {1.007276466621}; // mass of a proton in amu
constexpr double MASS_ELECTRON_EV {
0.51099895000e6}; // electron mass energy equivalent in eV/c^2
constexpr double FINE_STRUCTURE {
137.035999084}; // inverse fine structure constant
constexpr double PLANCK_C {
1.2398419839593942e4}; // Planck's constant times c in eV-Angstroms
constexpr double AMU {1.66053906660e-27}; // 1 amu in kg
constexpr double C_LIGHT {2.99792458e8}; // speed of light in m/s
constexpr double N_AVOGADRO {0.602214076}; // Avogadro's number in 10^24/mol
constexpr double K_BOLTZMANN {8.617333262e-5}; // Boltzmann constant in eV/K
// Electron subshell labels
constexpr array<const char*, 39> SUBSHELLS = {"K", "L1", "L2", "L3", "M1", "M2",
@ -99,16 +103,13 @@ constexpr array<const char*, 39> SUBSHELLS = {"K", "L1", "L2", "L3", "M1", "M2",
// Void material and nuclide
// TODO: refactor and remove
constexpr int MATERIAL_VOID {-1};
constexpr int NUCLIDE_NONE {-1};
constexpr int NUCLIDE_NONE {-1};
// ============================================================================
// CROSS SECTION RELATED CONSTANTS
// Temperature treatment method
enum class TemperatureMethod {
NEAREST,
INTERPOLATION
};
enum class TemperatureMethod { NEAREST, INTERPOLATION };
// Reaction types
enum ReactionType {
@ -117,105 +118,105 @@ enum ReactionType {
ELASTIC = 2,
N_NONELASTIC = 3,
N_LEVEL = 4,
MISC = 5,
N_2ND = 11,
N_2N = 16,
N_3N = 17,
MISC = 5,
N_2ND = 11,
N_2N = 16,
N_3N = 17,
N_FISSION = 18,
N_F = 19,
N_NF = 20,
N_2NF = 21,
N_NA = 22,
N_N3A = 23,
N_2NA = 24,
N_3NA = 25,
N_NP = 28,
N_N2A = 29,
N_2N2A = 30,
N_ND = 32,
N_NT = 33,
N_N3HE = 34,
N_ND2A = 35,
N_NT2A = 36,
N_4N = 37,
N_3NF = 38,
N_2NP = 41,
N_3NP = 42,
N_N2P = 44,
N_NPA = 45,
N_N1 = 51,
N_N40 = 90,
N_NC = 91,
N_F = 19,
N_NF = 20,
N_2NF = 21,
N_NA = 22,
N_N3A = 23,
N_2NA = 24,
N_3NA = 25,
N_NP = 28,
N_N2A = 29,
N_2N2A = 30,
N_ND = 32,
N_NT = 33,
N_N3HE = 34,
N_ND2A = 35,
N_NT2A = 36,
N_4N = 37,
N_3NF = 38,
N_2NP = 41,
N_3NP = 42,
N_N2P = 44,
N_NPA = 45,
N_N1 = 51,
N_N40 = 90,
N_NC = 91,
N_DISAPPEAR = 101,
N_GAMMA = 102,
N_P = 103,
N_D = 104,
N_T = 105,
N_3HE = 106,
N_A = 107,
N_2A = 108,
N_3A = 109,
N_2P = 111,
N_PA = 112,
N_T2A = 113,
N_D2A = 114,
N_PD = 115,
N_PT = 116,
N_DA = 117,
N_5N = 152,
N_6N = 153,
N_2NT = 154,
N_TA = 155,
N_4NP = 156,
N_3ND = 157,
N_NDA = 158,
N_2NPA = 159,
N_7N = 160,
N_8N = 161,
N_5NP = 162,
N_6NP = 163,
N_7NP = 164,
N_4NA = 165,
N_5NA = 166,
N_6NA = 167,
N_7NA = 168,
N_4ND = 169,
N_5ND = 170,
N_6ND = 171,
N_3NT = 172,
N_4NT = 173,
N_5NT = 174,
N_6NT = 175,
N_P = 103,
N_D = 104,
N_T = 105,
N_3HE = 106,
N_A = 107,
N_2A = 108,
N_3A = 109,
N_2P = 111,
N_PA = 112,
N_T2A = 113,
N_D2A = 114,
N_PD = 115,
N_PT = 116,
N_DA = 117,
N_5N = 152,
N_6N = 153,
N_2NT = 154,
N_TA = 155,
N_4NP = 156,
N_3ND = 157,
N_NDA = 158,
N_2NPA = 159,
N_7N = 160,
N_8N = 161,
N_5NP = 162,
N_6NP = 163,
N_7NP = 164,
N_4NA = 165,
N_5NA = 166,
N_6NA = 167,
N_7NA = 168,
N_4ND = 169,
N_5ND = 170,
N_6ND = 171,
N_3NT = 172,
N_4NT = 173,
N_5NT = 174,
N_6NT = 175,
N_2N3HE = 176,
N_3N3HE = 177,
N_4N3HE = 178,
N_3N2P = 179,
N_3N2A = 180,
N_3NPA = 181,
N_DT = 182,
N_NPD = 183,
N_NPT = 184,
N_NDT = 185,
N_3N2P = 179,
N_3N2A = 180,
N_3NPA = 181,
N_DT = 182,
N_NPD = 183,
N_NPT = 184,
N_NDT = 185,
N_NP3HE = 186,
N_ND3HE = 187,
N_NT3HE = 188,
N_NTA = 189,
N_2N2P = 190,
N_P3HE = 191,
N_D3HE = 192,
N_3HEA = 193,
N_4N2P = 194,
N_4N2A = 195,
N_4NPA = 196,
N_3P = 197,
N_N3P = 198,
N_NTA = 189,
N_2N2P = 190,
N_P3HE = 191,
N_D3HE = 192,
N_3HEA = 193,
N_4N2P = 194,
N_4N2A = 195,
N_4NPA = 196,
N_3P = 197,
N_N3P = 198,
N_3N2PA = 199,
N_5N2P = 200,
N_XP = 203,
N_XD = 204,
N_XT = 205,
N_X3HE = 206,
N_XA = 207,
N_5N2P = 200,
N_XP = 203,
N_XD = 204,
N_XT = 205,
N_X3HE = 206,
N_XA = 207,
HEATING = 301,
DAMAGE_ENERGY = 444,
COHERENT = 502,
@ -224,18 +225,18 @@ enum ReactionType {
PAIR_PROD = 516,
PAIR_PROD_NUC = 517,
PHOTOELECTRIC = 522,
N_P0 = 600,
N_PC = 649,
N_D0 = 650,
N_DC = 699,
N_T0 = 700,
N_TC = 749,
N_3HE0 = 750,
N_3HEC = 799,
N_A0 = 800,
N_AC = 849,
N_2N0 = 875,
N_2NC = 891,
N_P0 = 600,
N_PC = 649,
N_D0 = 650,
N_DC = 699,
N_T0 = 700,
N_TC = 749,
N_3HE0 = 750,
N_3HEC = 799,
N_A0 = 800,
N_AC = 849,
N_2N0 = 875,
N_2NC = 891,
HEATING_LOCAL = 901
};
@ -255,9 +256,9 @@ constexpr int PARTIAL_FISSION_MAX {4};
// Resonance elastic scattering methods
enum class ResScatMethod {
rvs, // Relative velocity sampling
rvs, // Relative velocity sampling
dbrc, // Doppler broadening rejection correction
cxs // Constant cross section
cxs // Constant cross section
};
enum class ElectronTreatment {
@ -296,31 +297,13 @@ enum class MgxsType {
// ============================================================================
// TALLY-RELATED CONSTANTS
enum class TallyResult {
VALUE,
SUM,
SUM_SQ
};
enum class TallyResult { VALUE, SUM, SUM_SQ };
enum class TallyType {
VOLUME,
MESH_SURFACE,
SURFACE
};
enum class TallyType { VOLUME, MESH_SURFACE, SURFACE };
enum class TallyEstimator {
ANALOG,
TRACKLENGTH,
COLLISION
};
enum class TallyEstimator { ANALOG, TRACKLENGTH, COLLISION };
enum class TallyEvent {
SURFACE,
LATTICE,
KILL,
SCATTER,
ABSORB
};
enum class TallyEvent { SURFACE, LATTICE, KILL, SCATTER, ABSORB };
// Tally score type -- if you change these, make sure you also update the
// _SCORES dictionary in openmc/capi/tally.py
@ -329,40 +312,39 @@ enum class TallyEvent {
// store one of these enum values usually also may be responsible for storing
// MT numbers from the long enum above.
enum TallyScore {
SCORE_FLUX = -1, // flux
SCORE_TOTAL = -2, // total reaction rate
SCORE_SCATTER = -3, // scattering rate
SCORE_NU_SCATTER = -4, // scattering production rate
SCORE_ABSORPTION = -5, // absorption rate
SCORE_FISSION = -6, // fission rate
SCORE_NU_FISSION = -7, // neutron production rate
SCORE_KAPPA_FISSION = -8, // fission energy production rate
SCORE_CURRENT = -9, // current
SCORE_EVENTS = -10, // number of events
SCORE_FLUX = -1, // flux
SCORE_TOTAL = -2, // total reaction rate
SCORE_SCATTER = -3, // scattering rate
SCORE_NU_SCATTER = -4, // scattering production rate
SCORE_ABSORPTION = -5, // absorption rate
SCORE_FISSION = -6, // fission rate
SCORE_NU_FISSION = -7, // neutron production rate
SCORE_KAPPA_FISSION = -8, // fission energy production rate
SCORE_CURRENT = -9, // current
SCORE_EVENTS = -10, // number of events
SCORE_DELAYED_NU_FISSION = -11, // delayed neutron production rate
SCORE_PROMPT_NU_FISSION = -12, // prompt neutron production rate
SCORE_INVERSE_VELOCITY = -13, // flux-weighted inverse velocity
SCORE_FISS_Q_PROMPT = -14, // prompt fission Q-value
SCORE_FISS_Q_RECOV = -15, // recoverable fission Q-value
SCORE_DECAY_RATE = -16 // delayed neutron precursor decay rate
SCORE_PROMPT_NU_FISSION = -12, // prompt neutron production rate
SCORE_INVERSE_VELOCITY = -13, // flux-weighted inverse velocity
SCORE_FISS_Q_PROMPT = -14, // prompt fission Q-value
SCORE_FISS_Q_RECOV = -15, // recoverable fission Q-value
SCORE_DECAY_RATE = -16 // delayed neutron precursor decay rate
};
// Global tally parameters
constexpr int N_GLOBAL_TALLIES {4};
enum class GlobalTally {
K_COLLISION,
K_ABSORPTION,
K_TRACKLENGTH,
LEAKAGE
};
enum class GlobalTally { K_COLLISION, K_ABSORPTION, K_TRACKLENGTH, LEAKAGE };
// Miscellaneous
constexpr int C_NONE {-1};
constexpr int F90_NONE {0}; //TODO: replace usage of this with C_NONE
constexpr int F90_NONE {0}; // TODO: replace usage of this with C_NONE
// Interpolation rules
enum class Interpolation {
histogram = 1, lin_lin = 2, lin_log = 3, log_lin = 4, log_log = 5
histogram = 1,
lin_lin = 2,
lin_log = 3,
log_lin = 4,
log_log = 5
};
enum class RunMode {
@ -383,11 +365,7 @@ constexpr int CMFD_NOACCEL {-1};
//==============================================================================
// Geometry Constants
enum class GeometryType {
CSG,
DAG
};
enum class GeometryType { CSG, DAG };
} // namespace openmc

4
include/openmc/container_util.h
View file

@ -2,7 +2,7 @@
#define OPENMC_CONTAINER_UTIL_H
#include <algorithm> // for find
#include <iterator> // for begin, end
#include <iterator> // for begin, end
namespace openmc {
@ -12,6 +12,6 @@ inline bool contains(const C& v, const T& x)
return std::end(v) != std::find(std::begin(v), std::end(v), x);
}
}
} // namespace openmc
#endif // OPENMC_CONTAINER_UTIL_H

22
include/openmc/cross_sections.h
View file

@ -3,8 +3,8 @@
#include "pugixml.hpp"
#include <string>
#include <map>
#include <string>
#include "openmc/vector.h"
@ -18,22 +18,24 @@ class Library {
public:
// Types, enums
enum class Type {
neutron = 1, photon = 3, thermal = 2, multigroup = 4, wmp = 5
neutron = 1,
photon = 3,
thermal = 2,
multigroup = 4,
wmp = 5
};
// Constructors
Library() { };
Library() {};
Library(pugi::xml_node node, const std::string& directory);
// Comparison operator (for using in map)
bool operator<(const Library& other) {
return path_ < other.path_;
}
bool operator<(const Library& other) { return path_ < other.path_; }
// Data members
Type type_; //!< Type of data library
Type type_; //!< Type of data library
vector<std::string> materials_; //!< Materials contained in library
std::string path_; //!< File path to library
std::string path_; //!< File path to library
};
using LibraryKey = std::pair<Library::Type, std::string>;
@ -60,11 +62,11 @@ extern vector<Library> libraries;
//! libraries
void read_cross_sections_xml();
//! Load nuclide and thermal scattering data from HDF5 files
//
//! \param[in] nuc_temps Temperatures for each nuclide in [K]
//! \param[in] thermal_temps Temperatures for each thermal scattering table in [K]
//! \param[in] thermal_temps Temperatures for each thermal scattering table in
//! [K]
void read_ce_cross_sections(const vector<vector<double>>& nuc_temps,
const vector<vector<double>>& thermal_temps);

77
include/openmc/dagmc.h
View file

@ -17,7 +17,7 @@ namespace openmc {
void read_dagmc_universes(pugi::xml_node node);
void check_dagmc_root_univ();
}
} // namespace openmc
#ifdef DAGMC
@ -49,7 +49,7 @@ public:
private:
std::shared_ptr<moab::DagMC> dagmc_ptr_; //!< Pointer to DagMC instance
int32_t dag_index_; //!< DagMC index of surface
int32_t dag_index_; //!< DagMC index of surface
};
class DAGCell : public Cell {
@ -58,8 +58,8 @@ public:
bool contains(Position r, Direction u, int32_t on_surface) const override;
std::pair<double, int32_t>
distance(Position r, Direction u, int32_t on_surface, Particle* p) const override;
std::pair<double, int32_t> distance(
Position r, Direction u, int32_t on_surface, Particle* p) const override;
BoundingBox bounding_box() const override;
@ -71,24 +71,24 @@ public:
private:
std::shared_ptr<moab::DagMC> dagmc_ptr_; //!< Pointer to DagMC instance
int32_t dag_index_; //!< DagMC index of cell
int32_t dag_index_; //!< DagMC index of cell
};
class DAGUniverse : public Universe {
public:
explicit DAGUniverse(pugi::xml_node node);
//! Create a new DAGMC universe
//! \param[in] filename Name of the DAGMC file
//! \param[in] auto_geom_ids Whether or not to automatically assign cell and surface IDs
//! \param[in] auto_mat_ids Whether or not to automatically assign material IDs
explicit DAGUniverse(const std::string& filename,
bool auto_geom_ids = false,
bool auto_mat_ids = false);
//! \param[in] auto_geom_ids Whether or not to automatically assign cell and
//! surface IDs \param[in] auto_mat_ids Whether or not to automatically assign
//! material IDs
explicit DAGUniverse(const std::string& filename, bool auto_geom_ids = false,
bool auto_mat_ids = false);
//! Initialize the DAGMC accel. data structures, indices, material assignments, etc.
//! Initialize the DAGMC accel. data structures, indices, material
//! assignments, etc.
void initialize();
//! Reads UWUW materials and returns an ID map
@ -97,54 +97,67 @@ public:
//! \return True if UWUW materials are present, False if not
bool uses_uwuw() const;
//! Returns the index to the implicit complement's index in OpenMC for this DAGMC universe
//! Returns the index to the implicit complement's index in OpenMC for this
//! DAGMC universe
int32_t implicit_complement_idx() const;
//! Transform UWUW materials into an OpenMC-readable XML format
//! \return A string representing a materials.xml file of the UWUW materials in this universe
//! \return A string representing a materials.xml file of the UWUW materials
//! in this universe
std::string get_uwuw_materials_xml() const;
//! Writes the UWUW material file to XML (for debugging purposes)
void write_uwuw_materials_xml(const std::string& outfile = "uwuw_materials.xml") const;
void write_uwuw_materials_xml(
const std::string& outfile = "uwuw_materials.xml") const;
//! Assign a material to a cell based
//! \param[in] mat_string The DAGMC material assignment string
//! \param[in] c The OpenMC cell to which the material is assigned
void legacy_assign_material(std::string mat_string,
std::unique_ptr<DAGCell>& c) const;
void legacy_assign_material(
std::string mat_string, std::unique_ptr<DAGCell>& c) const;
//! Generate a string representing the ranges of IDs present in the DAGMC model.
//! Contiguous chunks of IDs are represented as a range (i.e. 1-10). If there is
//! a single ID a chunk, it will be represented as a single number (i.e. 2, 4, 6, 8).
//! \param[in] dim Dimension of the entities
//! \return A string of the ID ranges for entities of dimension \p dim
//! Generate a string representing the ranges of IDs present in the DAGMC
//! model. Contiguous chunks of IDs are represented as a range (i.e. 1-10). If
//! there is a single ID a chunk, it will be represented as a single number
//! (i.e. 2, 4, 6, 8). \param[in] dim Dimension of the entities \return A
//! string of the ID ranges for entities of dimension \p dim
std::string dagmc_ids_for_dim(int dim) const;
bool find_cell(Particle &p) const override;
bool find_cell(Particle& p) const override;
void to_hdf5(hid_t universes_group) const override;
// Data Members
std::shared_ptr<moab::DagMC> dagmc_instance_; //!< DAGMC Instance for this universe
int32_t cell_idx_offset_; //!< An offset to the start of the cells in this universe in OpenMC's cell vector
int32_t surf_idx_offset_; //!< An offset to the start of the surfaces in this universe in OpenMC's surface vector
std::shared_ptr<moab::DagMC>
dagmc_instance_; //!< DAGMC Instance for this universe
int32_t cell_idx_offset_; //!< An offset to the start of the cells in this
//!< universe in OpenMC's cell vector
int32_t surf_idx_offset_; //!< An offset to the start of the surfaces in this
//!< universe in OpenMC's surface vector
// Accessors
bool has_graveyard() const { return has_graveyard_; }
private:
std::string filename_; //!< Name of the DAGMC file used to create this universe
std::shared_ptr<UWUW> uwuw_; //!< Pointer to the UWUW instance for this universe
bool adjust_geometry_ids_; //!< Indicates whether or not to automatically generate new cell and surface IDs for the universe
bool adjust_material_ids_; //!< Indicates whether or not to automatically generate new material IDs for the universe
bool has_graveyard_; //!< Indicates if the DAGMC geometry has a "graveyard" volume
std::string
filename_; //!< Name of the DAGMC file used to create this universe
std::shared_ptr<UWUW>
uwuw_; //!< Pointer to the UWUW instance for this universe
bool adjust_geometry_ids_; //!< Indicates whether or not to automatically
//!< generate new cell and surface IDs for the
//!< universe
bool adjust_material_ids_; //!< Indicates whether or not to automatically
//!< generate new material IDs for the universe
bool has_graveyard_; //!< Indicates if the DAGMC geometry has a "graveyard"
//!< volume
};
//==============================================================================
// Non-member functions
//==============================================================================
int32_t next_cell(DAGUniverse* dag_univ, DAGCell* cur_cell, DAGSurface* surf_xed);
int32_t next_cell(
DAGUniverse* dag_univ, DAGCell* cur_cell, DAGSurface* surf_xed);
} // namespace openmc

41
include/openmc/distribution.h
View file

@ -57,7 +57,7 @@ private:
class Uniform : public Distribution {
public:
explicit Uniform(pugi::xml_node node);
Uniform(double a, double b) : a_{a}, b_{b} {};
Uniform(double a, double b) : a_ {a}, b_ {b} {};
//! Sample a value from the distribution
//! \param seed Pseudorandom number seed pointer
@ -66,6 +66,7 @@ public:
double a() const { return a_; }
double b() const { return b_; }
private:
double a_; //!< Lower bound of distribution
double b_; //!< Upper bound of distribution
@ -78,7 +79,7 @@ private:
class Maxwell : public Distribution {
public:
explicit Maxwell(pugi::xml_node node);
Maxwell(double theta) : theta_{theta} { };
Maxwell(double theta) : theta_ {theta} {};
//! Sample a value from the distribution
//! \param seed Pseudorandom number seed pointer
@ -86,6 +87,7 @@ public:
double sample(uint64_t* seed) const;
double theta() const { return theta_; }
private:
double theta_; //!< Factor in exponential [eV]
};
@ -97,7 +99,7 @@ private:
class Watt : public Distribution {
public:
explicit Watt(pugi::xml_node node);
Watt(double a, double b) : a_{a}, b_{b} { };
Watt(double a, double b) : a_ {a}, b_ {b} {};
//! Sample a value from the distribution
//! \param seed Pseudorandom number seed pointer
@ -106,19 +108,22 @@ public:
double a() const { return a_; }
double b() const { return b_; }
private:
double a_; //!< Factor in exponential [eV]
double b_; //!< Factor in square root [1/eV]
};
//==============================================================================
//! Normal distributions with form 1/2*std_dev*sqrt(pi) exp (-(e-E0)/2*std_dev)^2
//! Normal distributions with form 1/2*std_dev*sqrt(pi) exp
//! (-(e-E0)/2*std_dev)^2
//==============================================================================
class Normal : public Distribution {
public:
explicit Normal(pugi::xml_node node);
Normal(double mean_value, double std_dev) : mean_value_{mean_value}, std_dev_{std_dev} { };
Normal(double mean_value, double std_dev)
: mean_value_ {mean_value}, std_dev_ {std_dev} {};
//! Sample a value from the distribution
//! \param seed Pseudorandom number seed pointer
@ -127,9 +132,10 @@ public:
double mean_value() const { return mean_value_; }
double std_dev() const { return std_dev_; }
private:
double mean_value_; //!< middle of distribution [eV]
double std_dev_; //!< standard deviation [eV]
double mean_value_; //!< middle of distribution [eV]
double std_dev_; //!< standard deviation [eV]
};
//==============================================================================
@ -140,7 +146,8 @@ private:
class Muir : public Distribution {
public:
explicit Muir(pugi::xml_node node);
Muir(double e0, double m_rat, double kt) : e0_{e0}, m_rat_{m_rat}, kt_{kt} { };
Muir(double e0, double m_rat, double kt)
: e0_ {e0}, m_rat_ {m_rat}, kt_ {kt} {};
//! Sample a value from the distribution
//! \param seed Pseudorandom number seed pointer
@ -150,6 +157,7 @@ public:
double e0() const { return e0_; }
double m_rat() const { return m_rat_; }
double kt() const { return kt_; }
private:
// example DT fusion m_rat = 5 (D = 2 + T = 3)
// ion temp = 20000 eV
@ -167,7 +175,7 @@ class Tabular : public Distribution {
public:
explicit Tabular(pugi::xml_node node);
Tabular(const double* x, const double* p, int n, Interpolation interp,
const double* c=nullptr);
const double* c = nullptr);
//! Sample a value from the distribution
//! \param seed Pseudorandom number seed pointer
@ -179,18 +187,19 @@ public:
const vector<double>& x() const { return x_; }
const vector<double>& p() const { return p_; }
Interpolation interp() const { return interp_; }
private:
vector<double> x_; //!< tabulated independent variable
vector<double> p_; //!< tabulated probability density
vector<double> c_; //!< cumulative distribution at tabulated values
Interpolation interp_; //!< interpolation rule
vector<double> x_; //!< tabulated independent variable
vector<double> p_; //!< tabulated probability density
vector<double> c_; //!< cumulative distribution at tabulated values
Interpolation interp_; //!< interpolation rule
//! Initialize tabulated probability density function
//! \param x Array of values for independent variable
//! \param p Array of tabulated probabilities
//! \param n Number of tabulated values
void init(const double* x, const double* p, std::size_t n,
const double* c=nullptr);
void init(
const double* x, const double* p, std::size_t n, const double* c = nullptr);
};
//==============================================================================
@ -200,7 +209,7 @@ private:
class Equiprobable : public Distribution {
public:
explicit Equiprobable(pugi::xml_node node);
Equiprobable(const double* x, int n) : x_{x, x+n} { };
Equiprobable(const double* x, int n) : x_ {x, x + n} {};
//! Sample a value from the distribution
//! \param seed Pseudorandom number seed pointer

30
include/openmc/distribution_energy.h
View file

@ -4,8 +4,8 @@
#ifndef OPENMC_DISTRIBUTION_ENERGY_H
#define OPENMC_DISTRIBUTION_ENERGY_H
#include "xtensor/xtensor.hpp"
#include "hdf5.h"
#include "xtensor/xtensor.hpp"
#include "openmc/constants.h"
#include "openmc/endf.h"
@ -38,11 +38,12 @@ public:
//! \param[inout] seed Pseudorandom number seed pointer
//! \return Sampled energy in [eV]
double sample(double E, uint64_t* seed) const;
private:
int primary_flag_; //!< Indicator of whether the photon is a primary or
//!< non-primary photon.
double energy_; //!< Photon energy or binding energy
double A_; //!< Atomic weight ratio of the target nuclide
double energy_; //!< Photon energy or binding energy
double A_; //!< Atomic weight ratio of the target nuclide
};
//===============================================================================
@ -58,8 +59,9 @@ public:
//! \param[inout] seed Pseudorandom number seed pointer
//! \return Sampled energy in [eV]
double sample(double E, uint64_t* seed) const;
private:
double threshold_; //!< Energy threshold in lab, (A + 1)/A * |Q|
double threshold_; //!< Energy threshold in lab, (A + 1)/A * |Q|
double mass_ratio_; //!< (A/(A+1))^2
};
@ -78,17 +80,18 @@ public:
//! \param[inout] seed Pseudorandom number seed pointer
//! \return Sampled energy in [eV]
double sample(double E, uint64_t* seed) const;
private:
//! Outgoing energy for a single incoming energy
struct CTTable {
Interpolation interpolation; //!< Interpolation law
int n_discrete; //!< Number of of discrete energies
Interpolation interpolation; //!< Interpolation law
int n_discrete; //!< Number of of discrete energies
xt::xtensor<double, 1> e_out; //!< Outgoing energies in [eV]
xt::xtensor<double, 1> p; //!< Probability density
xt::xtensor<double, 1> c; //!< Cumulative distribution
xt::xtensor<double, 1> p; //!< Probability density
xt::xtensor<double, 1> c; //!< Cumulative distribution
};
int n_region_; //!< Number of inteprolation regions
int n_region_; //!< Number of inteprolation regions
vector<int> breakpoints_; //!< Breakpoints between regions
vector<Interpolation> interpolation_; //!< Interpolation laws
vector<double> energy_; //!< Incident energy in [eV]
@ -108,9 +111,10 @@ public:
//! \param[inout] seed Pseudorandom number seed pointer
//! \return Sampled energy in [eV]
double sample(double E, uint64_t* seed) const;
private:
Tabulated1D theta_; //!< Incoming energy dependent parameter
double u_; //!< Restriction energy
double u_; //!< Restriction energy
};
//===============================================================================
@ -127,9 +131,10 @@ public:
//! \param[inout] seed Pseudorandom number seed pointer
//! \return Sampled energy in [eV]
double sample(double E, uint64_t* seed) const;
private:
Tabulated1D theta_; //!< Incoming energy dependent parameter
double u_; //!< Restriction energy
double u_; //!< Restriction energy
};
//===============================================================================
@ -146,10 +151,11 @@ public:
//! \param[inout] seed Pseudorandom number seed pointer
//! \return Sampled energy in [eV]
double sample(double E, uint64_t* seed) const;
private:
Tabulated1D a_; //!< Energy-dependent 'a' parameter
Tabulated1D b_; //!< Energy-dependent 'b' parameter
double u_; //!< Restriction energy
double u_; //!< Restriction energy
};
} // namespace openmc

13
include/openmc/distribution_multi.h
View file

@ -17,8 +17,8 @@ namespace openmc {
class UnitSphereDistribution {
public:
UnitSphereDistribution() { };
explicit UnitSphereDistribution(Direction u) : u_ref_{u} { };
UnitSphereDistribution() {};
explicit UnitSphereDistribution(Direction u) : u_ref_ {u} {};
explicit UnitSphereDistribution(pugi::xml_node node);
virtual ~UnitSphereDistribution() = default;
@ -27,7 +27,7 @@ public:
//! \return Direction sampled
virtual Direction sample(uint64_t* seed) const = 0;
Direction u_ref_ {0.0, 0.0, 1.0}; //!< reference direction
Direction u_ref_ {0.0, 0.0, 1.0}; //!< reference direction
};
//==============================================================================
@ -61,7 +61,7 @@ Direction isotropic_direction(uint64_t* seed);
class Isotropic : public UnitSphereDistribution {
public:
Isotropic() { };
Isotropic() {};
//! Sample a direction from the distribution
//! \param seed Pseudorandom number seed pointer
@ -75,8 +75,9 @@ public:
class Monodirectional : public UnitSphereDistribution {
public:
Monodirectional(Direction u) : UnitSphereDistribution{u} { };
explicit Monodirectional(pugi::xml_node node) : UnitSphereDistribution{node} { };
Monodirectional(Direction u) : UnitSphereDistribution {u} {};
explicit Monodirectional(pugi::xml_node node)
: UnitSphereDistribution {node} {};
//! Sample a direction from the distribution
//! \param seed Pseudorandom number seed pointer

32
include/openmc/distribution_spatial.h
View file

@ -37,6 +37,7 @@ public:
Distribution* x() const { return x_.get(); }
Distribution* y() const { return y_.get(); }
Distribution* z() const { return z_.get(); }
private:
UPtrDist x_; //!< Distribution of x coordinates
UPtrDist y_; //!< Distribution of y coordinates
@ -55,19 +56,19 @@ public:
//! \param seed Pseudorandom number seed pointer
//! \return Sampled position
Position sample(uint64_t* seed) const;
Distribution* r() const { return r_.get(); }
Distribution* phi() const { return phi_.get(); }
Distribution* z() const { return z_.get(); }
Position origin() const { return origin_; }
private:
UPtrDist r_; //!< Distribution of r coordinates
UPtrDist phi_; //!< Distribution of phi coordinates
UPtrDist z_; //!< Distribution of z coordinates
UPtrDist r_; //!< Distribution of r coordinates
UPtrDist phi_; //!< Distribution of phi coordinates
UPtrDist z_; //!< Distribution of z coordinates
Position origin_; //!< Cartesian coordinates of the cylinder center
};
//==============================================================================
//! Distribution of points specified by spherical coordinates r,theta,phi
//==============================================================================
@ -84,11 +85,12 @@ public:
Distribution* r() const { return r_.get(); }
Distribution* theta() const { return theta_.get(); }
Distribution* phi() const { return phi_.get(); }
Position origin () const { return origin_; }
Position origin() const { return origin_; }
private:
UPtrDist r_; //!< Distribution of r coordinates
UPtrDist theta_; //!< Distribution of theta coordinates
UPtrDist phi_; //!< Distribution of phi coordinates
UPtrDist r_; //!< Distribution of r coordinates
UPtrDist theta_; //!< Distribution of theta coordinates
UPtrDist phi_; //!< Distribution of phi coordinates
Position origin_; //!< Cartesian coordinates of the sphere center
};
@ -98,7 +100,7 @@ private:
class SpatialBox : public SpatialDistribution {
public:
explicit SpatialBox(pugi::xml_node node, bool fission=false);
explicit SpatialBox(pugi::xml_node node, bool fission = false);
//! Sample a position from the distribution
//! \param seed Pseudorandom number seed pointer
@ -109,9 +111,10 @@ public:
bool only_fissionable() const { return only_fissionable_; }
Position lower_left() const { return lower_left_; }
Position upper_right() const { return upper_right_; }
private:
Position lower_left_; //!< Lower-left coordinates of box
Position upper_right_; //!< Upper-right coordinates of box
Position lower_left_; //!< Lower-left coordinates of box
Position upper_right_; //!< Upper-right coordinates of box
bool only_fissionable_ {false}; //!< Only accept sites in fissionable region?
};
@ -121,8 +124,8 @@ private:
class SpatialPoint : public SpatialDistribution {
public:
SpatialPoint() : r_{} { };
SpatialPoint(Position r) : r_{r} { };
SpatialPoint() : r_ {} {};
SpatialPoint(Position r) : r_ {r} {};
explicit SpatialPoint(pugi::xml_node node);
//! Sample a position from the distribution
@ -131,6 +134,7 @@ public:
Position sample(uint64_t* seed) const;
Position r() const { return r_; }
private:
Position r_; //!< Single position at which sites are generated
};

11
include/openmc/endf.h
View file

@ -57,6 +57,7 @@ public:
//! \param[in] x independent variable
//! \return Polynomial evaluated at x
double operator()(double x) const override;
private:
vector<double> coef_; //!< Polynomial coefficients
};
@ -86,9 +87,9 @@ private:
std::size_t n_regions_ {0}; //!< number of interpolation regions
vector<int> nbt_; //!< values separating interpolation regions
vector<Interpolation> int_; //!< interpolation schemes
std::size_t n_pairs_; //!< number of (x,y) pairs
vector<double> x_; //!< values of abscissa
vector<double> y_; //!< values of ordinate
std::size_t n_pairs_; //!< number of (x,y) pairs
vector<double> x_; //!< values of abscissa
vector<double> y_; //!< values of ordinate
};
//==============================================================================
@ -118,9 +119,11 @@ public:
explicit IncoherentElasticXS(hid_t dset);
double operator()(double E) const override;
private:
double bound_xs_; //!< Characteristic bound xs in [b]
double debye_waller_; //!< Debye-Waller integral divided by atomic mass in [eV^-1]
double
debye_waller_; //!< Debye-Waller integral divided by atomic mass in [eV^-1]
};
//! Read 1D function from HDF5 dataset

29
include/openmc/error.h
View file

@ -2,8 +2,8 @@
#define OPENMC_ERROR_H
#include <cstring>
#include <string>
#include <sstream>
#include <string>
#include <fmt/format.h>
@ -18,50 +18,43 @@
namespace openmc {
inline void
set_errmsg(const char* message)
inline void set_errmsg(const char* message)
{
std::strcpy(openmc_err_msg, message);
}
inline void
set_errmsg(const std::string& message)
inline void set_errmsg(const std::string& message)
{
std::strcpy(openmc_err_msg, message.c_str());
}
inline void
set_errmsg(const std::stringstream& message)
inline void set_errmsg(const std::stringstream& message)
{
std::strcpy(openmc_err_msg, message.str().c_str());
}
[[noreturn]] void fatal_error(const std::string& message, int err=-1);
[[noreturn]] void fatal_error(const std::string& message, int err = -1);
[[noreturn]] inline
void fatal_error(const std::stringstream& message)
[[noreturn]] inline void fatal_error(const std::stringstream& message)
{
fatal_error(message.str());
}
[[noreturn]] inline
void fatal_error(const char* message)
[[noreturn]] inline void fatal_error(const char* message)
{
fatal_error(std::string{message, std::strlen(message)});
fatal_error(std::string {message, std::strlen(message)});
}
void warning(const std::string& message);
inline
void warning(const std::stringstream& message)
inline void warning(const std::stringstream& message)
{
warning(message.str());
}
void write_message(const std::string& message, int level=0);
void write_message(const std::string& message, int level = 0);
inline
void write_message(const std::stringstream& message, int level)
inline void write_message(const std::stringstream& message, int level)
{
write_message(message.str(), level);
}

41
include/openmc/event.h
View file

@ -7,7 +7,6 @@
#include "openmc/particle.h"
#include "openmc/shared_array.h"
namespace openmc {
//==============================================================================
@ -17,17 +16,17 @@ namespace openmc {
// In the event-based model, instead of moving or sorting the particles
// themselves based on which event they need, a queue is used to store the
// index (and other useful info) for each event type.
// The EventQueueItem struct holds the relevant information about a particle needed
// for sorting the queue. For very high particle counts, a sorted queue has the
// potential to result in greatly improved cache efficiency. However, sorting
// will introduce some overhead due to the sorting process itself, and may not
// result in any benefits if not enough particles are present for them to achieve
// consistent locality improvements.
struct EventQueueItem{
int64_t idx; //!< particle index in event-based particle buffer
ParticleType type; //!< particle type
int64_t material; //!< material that particle is in
double E; //!< particle energy
// The EventQueueItem struct holds the relevant information about a particle
// needed for sorting the queue. For very high particle counts, a sorted queue
// has the potential to result in greatly improved cache efficiency. However,
// sorting will introduce some overhead due to the sorting process itself, and
// may not result in any benefits if not enough particles are present for them
// to achieve consistent locality improvements.
struct EventQueueItem {
int64_t idx; //!< particle index in event-based particle buffer
ParticleType type; //!< particle type
int64_t material; //!< material that particle is in
double E; //!< particle energy
// Constructors
EventQueueItem() = default;
@ -35,16 +34,18 @@ struct EventQueueItem{
: idx(buffer_idx), type(p.type()), material(p.material()), E(p.E())
{}
// Compare by particle type, then by material type (4.5% fuel/7.0% fuel/cladding/etc),
// then by energy.
// TODO: Currently in OpenMC, the material ID corresponds not only to a general
// type, but also specific isotopic densities. Ideally we would
// like to be able to just sort by general material type, regardless of densities.
// A more general material type ID may be added in the future, in which case we
// can update the material field of this struct to contain the more general id.
// Compare by particle type, then by material type (4.5% fuel/7.0%
// fuel/cladding/etc), then by energy.
// TODO: Currently in OpenMC, the material ID corresponds not only to a
// general type, but also specific isotopic densities. Ideally we would like
// to be able to just sort by general material type, regardless of densities.
// A more general material type ID may be added in the future, in which case
// we can update the material field of this struct to contain the more general
// id.
bool operator<(const EventQueueItem& rhs) const
{
return std::tie(type, material, E) < std::tie(rhs.type, rhs.material, rhs.E);
return std::tie(type, material, E) <
std::tie(rhs.type, rhs.material, rhs.E);
}
};

4
include/openmc/finalize.h
View file

@ -1,8 +1,6 @@
#ifndef OPENMC_FINALIZE_H
#define OPENMC_FINALIZE_H
namespace openmc {
} // namespace openmc
namespace openmc {} // namespace openmc
#endif // OPENMC_FINALIZE_H

11
include/openmc/geometry.h
View file

@ -19,7 +19,7 @@ class Particle;
namespace model {
extern int root_universe; //!< Index of root universe
extern int root_universe; //!< Index of root universe
extern "C" int n_coord_levels; //!< Number of CSG coordinate levels
extern vector<int64_t> overlap_check_count;
@ -30,7 +30,8 @@ extern vector<int64_t> overlap_check_count;
//! Check two distances by coincidence tolerance
//==============================================================================
inline bool coincident(double d1, double d2) {
inline bool coincident(double d1, double d2)
{
return std::abs(d1 - d2) < FP_COINCIDENT;
}
@ -38,15 +39,15 @@ inline bool coincident(double d1, double d2) {
//! Check for overlapping cells at a particle's position.
//==============================================================================
bool check_cell_overlap(Particle& p, bool error=true);
bool check_cell_overlap(Particle& p, bool error = true);
//==============================================================================
//! Get the cell instance for a particle at the specified universe level
//!
//! \param p A particle for which to compute the instance using
//! its coordinates
//! \param level The level (zero indexed) of the geometry where the instance should be computed.
//! \return The instance of the cell at the specified level.
//! \param level The level (zero indexed) of the geometry where the instance
//! should be computed. \return The instance of the cell at the specified level.
//==============================================================================
int cell_instance_at_level(const Particle& p, int level);

12
include/openmc/geometry_aux.h
View file

@ -14,8 +14,9 @@
namespace openmc {
namespace model {
extern std::unordered_map<int32_t, std::unordered_map<int32_t, int32_t>> universe_cell_counts;
extern std::unordered_map<int32_t, int32_t> universe_level_counts;
extern std::unordered_map<int32_t, std::unordered_map<int32_t, int32_t>>
universe_cell_counts;
extern std::unordered_map<int32_t, int32_t> universe_level_counts;
} // namespace model
void read_geometry_xml();
@ -69,7 +70,8 @@ int32_t find_root_universe();
//! filter.
//==============================================================================
void prepare_distribcell(const std::vector<int32_t>* user_distribcells = nullptr);
void prepare_distribcell(
const std::vector<int32_t>* user_distribcells = nullptr);
//==============================================================================
//! Recursively search through the geometry and count cell instances.
@ -106,8 +108,8 @@ int count_universe_instances(int32_t search_univ, int32_t target_univ_id,
//! desired instance of the target cell.
//==============================================================================
std::string
distribcell_path(int32_t target_cell, int32_t map, int32_t target_offset);
std::string distribcell_path(
int32_t target_cell, int32_t map, int32_t target_offset);
//==============================================================================
//! Determine the maximum number of nested coordinate levels in the geometry.

255
include/openmc/hdf5_interface.h
View file

@ -5,8 +5,8 @@
#include <complex>
#include <cstddef>
#include <cstring> // for strlen
#include <string>
#include <sstream>
#include <string>
#include <type_traits>
#include "hdf5.h"
@ -25,8 +25,7 @@ namespace openmc {
// Low-level internal functions
//==============================================================================
void read_attr(hid_t obj_id, const char* name, hid_t mem_type_id,
void* buffer);
void read_attr(hid_t obj_id, const char* name, hid_t mem_type_id, void* buffer);
void write_attr(hid_t obj_id, int ndim, const hsize_t* dims, const char* name,
hid_t mem_type_id, const void* buffer);
@ -47,17 +46,18 @@ bool using_mpio_device(hid_t obj_id);
hid_t create_group(hid_t parent_id, const std::string& name);
inline hid_t create_group(hid_t parent_id, const std::stringstream& name)
{return create_group(parent_id, name.str());}
{
return create_group(parent_id, name.str());
}
hid_t file_open(const std::string& filename, char mode, bool parallel=false);
hid_t file_open(const std::string& filename, char mode, bool parallel = false);
hid_t open_group(hid_t group_id, const std::string& name);
void write_string(hid_t group_id, const char* name, const std::string& buffer,
bool indep);
void write_string(
hid_t group_id, const char* name, const std::string& buffer, bool indep);
vector<hsize_t> attribute_shape(hid_t obj_id, const char* name);
vector<std::string> dataset_names(hid_t group_id);
void ensure_exists(hid_t obj_id, const char* name, bool attribute=false);
void ensure_exists(hid_t obj_id, const char* name, bool attribute = false);
vector<std::string> group_names(hid_t group_id);
vector<hsize_t> object_shape(hid_t obj_id);
std::string object_name(hid_t obj_id);
@ -67,56 +67,54 @@ std::string object_name(hid_t obj_id);
//==============================================================================
extern "C" {
bool attribute_exists(hid_t obj_id, const char* name);
size_t attribute_typesize(hid_t obj_id, const char* name);
hid_t create_group(hid_t parent_id, const char* name);
void close_dataset(hid_t dataset_id);
void close_group(hid_t group_id);
int dataset_ndims(hid_t dset);
size_t dataset_typesize(hid_t obj_id, const char* name);
hid_t file_open(const char* filename, char mode, bool parallel);
void file_close(hid_t file_id);
void get_name(hid_t obj_id, char* name);
int get_num_datasets(hid_t group_id);
int get_num_groups(hid_t group_id);
void get_datasets(hid_t group_id, char* name[]);
void get_groups(hid_t group_id, char* name[]);
void get_shape(hid_t obj_id, hsize_t* dims);
void get_shape_attr(hid_t obj_id, const char* name, hsize_t* dims);
bool object_exists(hid_t object_id, const char* name);
hid_t open_dataset(hid_t group_id, const char* name);
hid_t open_group(hid_t group_id, const char* name);
void read_attr_double(hid_t obj_id, const char* name, double* buffer);
void read_attr_int(hid_t obj_id, const char* name, int* buffer);
void read_attr_string(hid_t obj_id, const char* name, size_t slen,
char* buffer);
void read_complex(hid_t obj_id, const char* name,
std::complex<double>* buffer, bool indep);
void read_double(hid_t obj_id, const char* name, double* buffer, bool indep);
void read_int(hid_t obj_id, const char* name, int* buffer, bool indep);
void read_llong(hid_t obj_id, const char* name, long long* buffer,
bool indep);
void read_string(hid_t obj_id, const char* name, size_t slen, char* buffer,
bool indep);
bool attribute_exists(hid_t obj_id, const char* name);
size_t attribute_typesize(hid_t obj_id, const char* name);
hid_t create_group(hid_t parent_id, const char* name);
void close_dataset(hid_t dataset_id);
void close_group(hid_t group_id);
int dataset_ndims(hid_t dset);
size_t dataset_typesize(hid_t obj_id, const char* name);
hid_t file_open(const char* filename, char mode, bool parallel);
void file_close(hid_t file_id);
void get_name(hid_t obj_id, char* name);
int get_num_datasets(hid_t group_id);
int get_num_groups(hid_t group_id);
void get_datasets(hid_t group_id, char* name[]);
void get_groups(hid_t group_id, char* name[]);
void get_shape(hid_t obj_id, hsize_t* dims);
void get_shape_attr(hid_t obj_id, const char* name, hsize_t* dims);
bool object_exists(hid_t object_id, const char* name);
hid_t open_dataset(hid_t group_id, const char* name);
hid_t open_group(hid_t group_id, const char* name);
void read_attr_double(hid_t obj_id, const char* name, double* buffer);
void read_attr_int(hid_t obj_id, const char* name, int* buffer);
void read_attr_string(
hid_t obj_id, const char* name, size_t slen, char* buffer);
void read_complex(
hid_t obj_id, const char* name, std::complex<double>* buffer, bool indep);
void read_double(hid_t obj_id, const char* name, double* buffer, bool indep);
void read_int(hid_t obj_id, const char* name, int* buffer, bool indep);
void read_llong(hid_t obj_id, const char* name, long long* buffer, bool indep);
void read_string(
hid_t obj_id, const char* name, size_t slen, char* buffer, bool indep);
void read_tally_results(hid_t group_id, hsize_t n_filter, hsize_t n_score,
double* results);
void write_attr_double(hid_t obj_id, int ndim, const hsize_t* dims,
const char* name, const double* buffer);
void write_attr_int(hid_t obj_id, int ndim, const hsize_t* dims,
const char* name, const int* buffer);
void write_attr_string(hid_t obj_id, const char* name, const char* buffer);
void write_double(hid_t group_id, int ndim, const hsize_t* dims,
const char* name, const double* buffer, bool indep);
void write_int(hid_t group_id, int ndim, const hsize_t* dims,
const char* name, const int* buffer, bool indep);
void write_llong(hid_t group_id, int ndim, const hsize_t* dims,
const char* name, const long long* buffer, bool indep);
void write_string(hid_t group_id, int ndim, const hsize_t* dims, size_t slen,
const char* name, char const* buffer, bool indep);
void write_tally_results(hid_t group_id, hsize_t n_filter, hsize_t n_score,
const double* results);
void read_tally_results(
hid_t group_id, hsize_t n_filter, hsize_t n_score, double* results);
void write_attr_double(hid_t obj_id, int ndim, const hsize_t* dims,
const char* name, const double* buffer);
void write_attr_int(hid_t obj_id, int ndim, const hsize_t* dims,
const char* name, const int* buffer);
void write_attr_string(hid_t obj_id, const char* name, const char* buffer);
void write_double(hid_t group_id, int ndim, const hsize_t* dims,
const char* name, const double* buffer, bool indep);
void write_int(hid_t group_id, int ndim, const hsize_t* dims, const char* name,
const int* buffer, bool indep);
void write_llong(hid_t group_id, int ndim, const hsize_t* dims,
const char* name, const long long* buffer, bool indep);
void write_string(hid_t group_id, int ndim, const hsize_t* dims, size_t slen,
const char* name, char const* buffer, bool indep);
void write_tally_results(
hid_t group_id, hsize_t n_filter, hsize_t n_score, const double* results);
} // extern "C"
//==============================================================================
@ -127,7 +125,9 @@ extern "C" {
//==============================================================================
template<typename T>
struct H5TypeMap { static const hid_t type_id; };
struct H5TypeMap {
static const hid_t type_id;
};
//==============================================================================
// Templates/overloads for read_attribute
@ -185,8 +185,7 @@ void read_attribute(hid_t obj_id, const char* name, xt::xarray<T>& arr)
}
// overload for std::string
inline void
read_attribute(hid_t obj_id, const char* name, std::string& str)
inline void read_attribute(hid_t obj_id, const char* name, std::string& str)
{
// Create buffer to read data into
auto n = attribute_typesize(obj_id, name);
@ -194,7 +193,7 @@ read_attribute(hid_t obj_id, const char* name, std::string& str)
// Read attribute and set string
read_attr_string(obj_id, name, n, buffer);
str = std::string{buffer, n};
str = std::string {buffer, n};
delete[] buffer;
}
@ -207,7 +206,7 @@ inline void read_attribute(
// Allocate a C char array to get strings
auto n = attribute_typesize(obj_id, name);
char* buffer = new char[m*n];
char* buffer = new char[m * n];
// Read char data in attribute
read_attr_string(obj_id, name, n, buffer);
@ -216,10 +215,12 @@ inline void read_attribute(
// Determine proper length of string -- strlen doesn't work because
// buffer[i] might not have any null characters
std::size_t k = 0;
for (; k < n; ++k) if (buffer[i*n + k] == '\0') break;
for (; k < n; ++k)
if (buffer[i * n + k] == '\0')
break;
// Create string based on (char*, size_t) constructor
vec.emplace_back(&buffer[i*n], k);
vec.emplace_back(&buffer[i * n], k);
}
delete[] buffer;
}
@ -232,17 +233,17 @@ inline void read_attribute(
// this version of read_dataset for vectors, arrays, or other non-scalar types.
// enable_if_t allows us to conditionally remove the function from overload
// resolution when the type T doesn't meet a certain criterion.
template<typename T> inline
std::enable_if_t<std::is_scalar<std::decay_t<T>>::value>
read_dataset(hid_t obj_id, const char* name, T& buffer, bool indep=false)
template<typename T>
inline std::enable_if_t<std::is_scalar<std::decay_t<T>>::value> read_dataset(
hid_t obj_id, const char* name, T& buffer, bool indep = false)
{
read_dataset_lowlevel(obj_id, name, H5TypeMap<T>::type_id, H5S_ALL, indep,
&buffer);
read_dataset_lowlevel(
obj_id, name, H5TypeMap<T>::type_id, H5S_ALL, indep, &buffer);
}
// overload for std::string
inline void
read_dataset(hid_t obj_id, const char* name, std::string& str, bool indep=false)
inline void read_dataset(
hid_t obj_id, const char* name, std::string& str, bool indep = false)
{
// Create buffer to read data into
auto n = dataset_typesize(obj_id, name);
@ -250,7 +251,7 @@ read_dataset(hid_t obj_id, const char* name, std::string& str, bool indep=false)
// Read attribute and set string
read_string(obj_id, name, n, buffer, indep);
str = std::string{buffer, n};
str = std::string {buffer, n};
}
// array version
@ -258,8 +259,8 @@ template<typename T, std::size_t N>
inline void read_dataset(
hid_t dset, const char* name, array<T, N>& buffer, bool indep = false)
{
read_dataset_lowlevel(dset, name, H5TypeMap<T>::type_id, H5S_ALL, indep,
buffer.data());
read_dataset_lowlevel(
dset, name, H5TypeMap<T>::type_id, H5S_ALL, indep, buffer.data());
}
// vector version
@ -273,8 +274,8 @@ void read_dataset(hid_t dset, vector<T>& vec, bool indep = false)
vec.resize(shape[0]);
// Read data into vector
read_dataset_lowlevel(dset, nullptr, H5TypeMap<T>::type_id, H5S_ALL, indep,
vec.data());
read_dataset_lowlevel(
dset, nullptr, H5TypeMap<T>::type_id, H5S_ALL, indep, vec.data());
}
template<typename T>
@ -286,8 +287,8 @@ void read_dataset(
close_dataset(dset);
}
template <typename T>
void read_dataset(hid_t dset, xt::xarray<T>& arr, bool indep=false)
template<typename T>
void read_dataset(hid_t dset, xt::xarray<T>& arr, bool indep = false)
{
// Get shape of dataset
vector<hsize_t> shape = object_shape(dset);
@ -299,17 +300,17 @@ void read_dataset(hid_t dset, xt::xarray<T>& arr, bool indep=false)
arr.resize(shape);
// Read data from attribute
read_dataset_lowlevel(dset, nullptr, H5TypeMap<T>::type_id, H5S_ALL, indep,
arr.data());
read_dataset_lowlevel(
dset, nullptr, H5TypeMap<T>::type_id, H5S_ALL, indep, arr.data());
}
template<>
void read_dataset(hid_t dset, xt::xarray<std::complex<double>>& arr,
bool indep);
void read_dataset(
hid_t dset, xt::xarray<std::complex<double>>& arr, bool indep);
template <typename T>
void read_dataset(hid_t obj_id, const char* name, xt::xarray<T>& arr,
bool indep=false)
template<typename T>
void read_dataset(
hid_t obj_id, const char* name, xt::xarray<T>& arr, bool indep = false)
{
// Open dataset and read array
hid_t dset = open_dataset(obj_id, name);
@ -317,10 +318,9 @@ void read_dataset(hid_t obj_id, const char* name, xt::xarray<T>& arr,
close_dataset(dset);
}
template <typename T, std::size_t N>
void read_dataset(hid_t obj_id, const char* name, xt::xtensor<T, N>& arr,
bool indep=false)
template<typename T, std::size_t N>
void read_dataset(
hid_t obj_id, const char* name, xt::xtensor<T, N>& arr, bool indep = false)
{
// Open dataset and read array
hid_t dset = open_dataset(obj_id, name);
@ -346,8 +346,8 @@ void read_dataset(hid_t obj_id, const char* name, xt::xtensor<T, N>& arr,
}
// overload for Position
inline void
read_dataset(hid_t obj_id, const char* name, Position& r, bool indep=false)
inline void read_dataset(
hid_t obj_id, const char* name, Position& r, bool indep = false)
{
array<double, 3> x;
read_dataset(obj_id, name, x, indep);
@ -356,9 +356,9 @@ read_dataset(hid_t obj_id, const char* name, Position& r, bool indep=false)
r.z = x[2];
}
template <typename T, std::size_t N>
inline void read_dataset_as_shape(hid_t obj_id, const char* name,
xt::xtensor<T, N>& arr, bool indep=false)
template<typename T, std::size_t N>
inline void read_dataset_as_shape(
hid_t obj_id, const char* name, xt::xtensor<T, N>& arr, bool indep = false)
{
hid_t dset = open_dataset(obj_id, name);
@ -369,8 +369,8 @@ inline void read_dataset_as_shape(hid_t obj_id, const char* name,
vector<T> buffer(size);
// Read data from attribute
read_dataset_lowlevel(dset, nullptr, H5TypeMap<T>::type_id, H5S_ALL, indep,
buffer.data());
read_dataset_lowlevel(
dset, nullptr, H5TypeMap<T>::type_id, H5S_ALL, indep, buffer.data());
// Adapt into xarray
arr = xt::adapt(buffer, arr.shape());
@ -378,10 +378,9 @@ inline void read_dataset_as_shape(hid_t obj_id, const char* name,
close_dataset(dset);
}
template <typename T, std::size_t N>
template<typename T, std::size_t N>
inline void read_nd_vector(hid_t obj_id, const char* name,
xt::xtensor<T, N>& result, bool must_have=false)
xt::xtensor<T, N>& result, bool must_have = false)
{
if (object_exists(obj_id, name)) {
read_dataset_as_shape(obj_id, name, result, true);
@ -394,20 +393,19 @@ inline void read_nd_vector(hid_t obj_id, const char* name,
// Templates/overloads for write_attribute
//==============================================================================
template<typename T> inline void
write_attribute(hid_t obj_id, const char* name, T buffer)
template<typename T>
inline void write_attribute(hid_t obj_id, const char* name, T buffer)
{
write_attr(obj_id, 0, nullptr, name, H5TypeMap<T>::type_id, &buffer);
}
inline void
write_attribute(hid_t obj_id, const char* name, const char* buffer)
inline void write_attribute(hid_t obj_id, const char* name, const char* buffer)
{
write_attr_string(obj_id, name, buffer);
}
inline void
write_attribute(hid_t obj_id, const char* name, const std::string& buffer)
inline void write_attribute(
hid_t obj_id, const char* name, const std::string& buffer)
{
write_attr_string(obj_id, name, buffer.c_str());
}
@ -428,30 +426,26 @@ inline void write_attribute(
write_attr(obj_id, 1, dims, name, H5TypeMap<T>::type_id, buffer.data());
}
inline void
write_attribute(hid_t obj_id, const char* name, Position r)
inline void write_attribute(hid_t obj_id, const char* name, Position r)
{
array<double, 3> buffer {r.x, r.y, r.z};
write_attribute(obj_id, name, buffer);
}
//==============================================================================
// Templates/overloads for write_dataset
//==============================================================================
// Template for scalars (ensured by SFINAE)
template<typename T> inline
std::enable_if_t<std::is_scalar<std::decay_t<T>>::value>
write_dataset(hid_t obj_id, const char* name, T buffer)
template<typename T>
inline std::enable_if_t<std::is_scalar<std::decay_t<T>>::value> write_dataset(
hid_t obj_id, const char* name, T buffer)
{
write_dataset_lowlevel(obj_id, 0, nullptr, name, H5TypeMap<T>::type_id,
H5S_ALL, false, &buffer);
write_dataset_lowlevel(
obj_id, 0, nullptr, name, H5TypeMap<T>::type_id, H5S_ALL, false, &buffer);
}
inline void
write_dataset(hid_t obj_id, const char* name, const char* buffer)
inline void write_dataset(hid_t obj_id, const char* name, const char* buffer)
{
write_string(obj_id, name, buffer, false);
}
@ -461,8 +455,8 @@ inline void write_dataset(
hid_t obj_id, const char* name, const array<T, N>& buffer)
{
hsize_t dims[] {N};
write_dataset_lowlevel(obj_id, 1, dims, name, H5TypeMap<T>::type_id,
H5S_ALL, false, buffer.data());
write_dataset_lowlevel(obj_id, 1, dims, name, H5TypeMap<T>::type_id, H5S_ALL,
false, buffer.data());
}
inline void write_dataset(
@ -478,10 +472,10 @@ inline void write_dataset(
}
// Copy data into contiguous buffer
char* temp = new char[n*m];
std::fill(temp, temp + n*m, '\0');
char* temp = new char[n * m];
std::fill(temp, temp + n * m, '\0');
for (decltype(n) i = 0; i < n; ++i) {
std::copy(buffer[i].begin(), buffer[i].end(), temp + i*m);
std::copy(buffer[i].begin(), buffer[i].end(), temp + i * m);
}
// Write 2D data
@ -496,30 +490,29 @@ inline void write_dataset(
hid_t obj_id, const char* name, const vector<T>& buffer)
{
hsize_t dims[] {buffer.size()};
write_dataset_lowlevel(obj_id, 1, dims, name, H5TypeMap<T>::type_id,
H5S_ALL, false, buffer.data());
write_dataset_lowlevel(obj_id, 1, dims, name, H5TypeMap<T>::type_id, H5S_ALL,
false, buffer.data());
}
// Template for xarray, xtensor, etc.
template<typename D> inline void
write_dataset(hid_t obj_id, const char* name, const xt::xcontainer<D>& arr)
template<typename D>
inline void write_dataset(
hid_t obj_id, const char* name, const xt::xcontainer<D>& arr)
{
using T = typename D::value_type;
auto s = arr.shape();
vector<hsize_t> dims {s.cbegin(), s.cend()};
write_dataset_lowlevel(obj_id, dims.size(), dims.data(), name,
H5TypeMap<T>::type_id, H5S_ALL, false, arr.data());
H5TypeMap<T>::type_id, H5S_ALL, false, arr.data());
}
inline void
write_dataset(hid_t obj_id, const char* name, Position r)
inline void write_dataset(hid_t obj_id, const char* name, Position r)
{
array<double, 3> buffer {r.x, r.y, r.z};
write_dataset(obj_id, name, buffer);
}
inline void
write_dataset(hid_t obj_id, const char* name, std::string buffer)
inline void write_dataset(hid_t obj_id, const char* name, std::string buffer)
{
write_string(obj_id, name, buffer.c_str(), false);
}

2
include/openmc/initialize.h
View file

@ -13,6 +13,6 @@ void initialize_mpi(MPI_Comm intracomm);
#endif
void read_input_xml();
}
} // namespace openmc
#endif // OPENMC_INITIALIZE_H

87
include/openmc/lattice.h
View file

@ -20,11 +20,9 @@ namespace openmc {
// Module constants
//==============================================================================
constexpr int32_t NO_OUTER_UNIVERSE{-1};
constexpr int32_t NO_OUTER_UNIVERSE {-1};
enum class LatticeType {
rect, hex
};
enum class LatticeType { rect, hex };
//==============================================================================
// Global variables
@ -33,8 +31,8 @@ enum class LatticeType {
class Lattice;
namespace model {
extern std::unordered_map<int32_t, int32_t> lattice_map;
extern vector<unique_ptr<Lattice>> lattices;
extern std::unordered_map<int32_t, int32_t> lattice_map;
extern vector<unique_ptr<Lattice>> lattices;
} // namespace model
//==============================================================================
@ -45,15 +43,14 @@ namespace model {
class LatticeIter;
class ReverseLatticeIter;
class Lattice
{
class Lattice {
public:
int32_t id_; //!< Universe ID number
std::string name_; //!< User-defined name
int32_t id_; //!< Universe ID number
std::string name_; //!< User-defined name
LatticeType type_;
vector<int32_t> universes_; //!< Universes filling each lattice tile
int32_t outer_ {NO_OUTER_UNIVERSE}; //!< Universe tiled outside the lattice
vector<int32_t> offsets_; //!< Distribcell offset table
vector<int32_t> universes_; //!< Universes filling each lattice tile
int32_t outer_ {NO_OUTER_UNIVERSE}; //!< Universe tiled outside the lattice
vector<int32_t> offsets_; //!< Distribcell offset table
explicit Lattice(pugi::xml_node lat_node);
@ -72,7 +69,9 @@ public:
//! Allocate offset table for distribcell.
void allocate_offset_table(int n_maps)
{offsets_.resize(n_maps * universes_.size(), C_NONE);}
{
offsets_.resize(n_maps * universes_.size(), C_NONE);
}
//! Populate the distribcell offset tables.
int32_t fill_offset_table(int32_t offset, int32_t target_univ_id, int map,
@ -112,7 +111,9 @@ public:
//! \return true if the given index fit within the lattice bounds. False
//! otherwise.
virtual bool is_valid_index(int indx) const
{return (indx >= 0) && (indx < universes_.size());}
{
return (indx >= 0) && (indx < universes_.size());
}
//! \brief Get the distribcell offset for a lattice tile.
//! \param The map index for the target cell.
@ -138,7 +139,7 @@ public:
void to_hdf5(hid_t group_id) const;
protected:
bool is_3d_; //!< Has divisions along the z-axis?
bool is_3d_; //!< Has divisions along the z-axis?
virtual void to_hdf5_inner(hid_t group_id) const = 0;
};
@ -147,26 +148,24 @@ protected:
//! An iterator over lattice universes.
//==============================================================================
class LatticeIter
{
class LatticeIter {
public:
int indx_; //!< An index to a Lattice universes or offsets array.
int indx_; //!< An index to a Lattice universes or offsets array.
LatticeIter(Lattice &lat, int indx)
: indx_(indx), lat_(lat)
{}
LatticeIter(Lattice& lat, int indx) : indx_(indx), lat_(lat) {}
bool operator==(const LatticeIter &rhs) {return (indx_ == rhs.indx_);}
bool operator==(const LatticeIter& rhs) { return (indx_ == rhs.indx_); }
bool operator!=(const LatticeIter &rhs) {return !(*this == rhs);}
bool operator!=(const LatticeIter& rhs) { return !(*this == rhs); }
int32_t& operator*() {return lat_.universes_[indx_];}
int32_t& operator*() { return lat_.universes_[indx_]; }
LatticeIter& operator++()
{
while (indx_ < lat_.universes_.size()) {
++indx_;
if (lat_.is_valid_index(indx_)) return *this;
if (lat_.is_valid_index(indx_))
return *this;
}
indx_ = lat_.universes_.size();
return *this;
@ -180,18 +179,16 @@ protected:
//! A reverse iterator over lattice universes.
//==============================================================================
class ReverseLatticeIter : public LatticeIter
{
class ReverseLatticeIter : public LatticeIter {
public:
ReverseLatticeIter(Lattice &lat, int indx)
: LatticeIter {lat, indx}
{}
ReverseLatticeIter(Lattice& lat, int indx) : LatticeIter {lat, indx} {}
ReverseLatticeIter& operator++()
{
while (indx_ > -1) {
--indx_;
if (lat_.is_valid_index(indx_)) return *this;
if (lat_.is_valid_index(indx_))
return *this;
}
indx_ = -1;
return *this;
@ -200,8 +197,7 @@ public:
//==============================================================================
class RectLattice : public Lattice
{
class RectLattice : public Lattice {
public:
explicit RectLattice(pugi::xml_node lat_node);
@ -225,15 +221,14 @@ public:
void to_hdf5_inner(hid_t group_id) const;
private:
array<int, 3> n_cells_; //!< Number of cells along each axis
Position lower_left_; //!< Global lower-left corner of the lattice
Position pitch_; //!< Lattice tile width along each axis
array<int, 3> n_cells_; //!< Number of cells along each axis
Position lower_left_; //!< Global lower-left corner of the lattice
Position pitch_; //!< Lattice tile width along each axis
};
//==============================================================================
class HexLattice : public Lattice
{
class HexLattice : public Lattice {
public:
explicit HexLattice(pugi::xml_node lat_node);
@ -264,8 +259,8 @@ public:
private:
enum class Orientation {
y, //!< Flat side of lattice parallel to y-axis
x //!< Flat side of lattice parallel to x-axis
y, //!< Flat side of lattice parallel to y-axis
x //!< Flat side of lattice parallel to x-axis
};
//! Fill universes_ vector for 'y' orientation
@ -274,11 +269,11 @@ private:
//! Fill universes_ vector for 'x' orientation
void fill_lattice_x(const vector<std::string>& univ_words);
int n_rings_; //!< Number of radial tile positions
int n_axial_; //!< Number of axial tile positions
Orientation orientation_; //!< Orientation of lattice
Position center_; //!< Global center of lattice
array<double, 2> pitch_; //!< Lattice tile width and height
int n_rings_; //!< Number of radial tile positions
int n_axial_; //!< Number of axial tile positions
Orientation orientation_; //!< Orientation of lattice
Position center_; //!< Global center of lattice
array<double, 2> pitch_; //!< Lattice tile width and height
};
//==============================================================================

34
include/openmc/material.h
View file

@ -4,10 +4,10 @@
#include <string>
#include <unordered_map>
#include <gsl/gsl>
#include <hdf5.h>
#include "pugixml.hpp"
#include "xtensor/xtensor.hpp"
#include <gsl/gsl>
#include <hdf5.h>
#include "openmc/bremsstrahlung.h"
#include "openmc/constants.h"
@ -34,15 +34,14 @@ extern vector<unique_ptr<Material>> materials;
//! A substance with constituent nuclides and thermal scattering data
//==============================================================================
class Material
{
class Material {
public:
//----------------------------------------------------------------------------
// Types
struct ThermalTable {
int index_table; //!< Index of table in data::thermal_scatt
int index_table; //!< Index of table in data::thermal_scatt
int index_nuclide; //!< Index in nuclide_
double fraction; //!< How often to use table
double fraction; //!< How often to use table
};
//----------------------------------------------------------------------------
@ -116,11 +115,17 @@ public:
//! Get nuclides in material
//! \return Indices into the global nuclides vector
gsl::span<const int> nuclides() const { return {nuclide_.data(), nuclide_.size()}; }
gsl::span<const int> nuclides() const
{
return {nuclide_.data(), nuclide_.size()};
}
//! Get densities of each nuclide in material
//! \return Densities in [atom/b-cm]
gsl::span<const double> densities() const { return {atom_density_.data(), atom_density_.size()}; }
gsl::span<const double> densities() const
{
return {atom_density_.data(), atom_density_.size()};
}
//! Get ID of material
//! \return ID of material
@ -145,15 +150,16 @@ public:
//----------------------------------------------------------------------------
// Data
int32_t id_ {C_NONE}; //!< Unique ID
std::string name_; //!< Name of material
int32_t id_ {C_NONE}; //!< Unique ID
std::string name_; //!< Name of material
vector<int> nuclide_; //!< Indices in nuclides vector
vector<int> element_; //!< Indices in elements vector
xt::xtensor<double, 1> atom_density_; //!< Nuclide atom density in [atom/b-cm]
double density_; //!< Total atom density in [atom/b-cm]
double density_gpcc_; //!< Total atom density in [g/cm^3]
double volume_ {-1.0}; //!< Volume in [cm^3]
bool fissionable_ {false}; //!< Does this material contain fissionable nuclides
double density_; //!< Total atom density in [atom/b-cm]
double density_gpcc_; //!< Total atom density in [g/cm^3]
double volume_ {-1.0}; //!< Volume in [cm^3]
bool fissionable_ {
false}; //!< Does this material contain fissionable nuclides
bool depletable_ {false}; //!< Is the material depletable?
vector<bool> p0_; //!< Indicate which nuclides are to be treated with
//!< iso-in-lab scattering

13
include/openmc/math_functions.h
View file

@ -10,7 +10,6 @@
#include "openmc/position.h"
namespace openmc {
//==============================================================================
@ -130,11 +129,11 @@ extern "C" void calc_zn_rad(int n, double rho, double zn_rad[]);
//! \param seed A pointer to the pseudorandom seed
//==============================================================================
extern "C" void rotate_angle_c(double uvw[3], double mu, const double* phi,
uint64_t* seed);
extern "C" void rotate_angle_c(
double uvw[3], double mu, const double* phi, uint64_t* seed);
Direction rotate_angle(Direction u, double mu, const double* phi,
uint64_t* seed);
Direction rotate_angle(
Direction u, double mu, const double* phi, uint64_t* seed);
//==============================================================================
//! Constructs a natural cubic spline.
@ -167,8 +166,8 @@ void spline(int n, const double x[], const double y[], double z[]);
//! \return Interpolated value
//==============================================================================
double spline_interpolate(int n, const double x[], const double y[],
const double z[], double xint);
double spline_interpolate(
int n, const double x[], const double y[], const double z[], double xint);
//==============================================================================
//! Evaluate the definite integral of the interpolating cubic spline between

131
include/openmc/mesh.h
View file

@ -16,10 +16,10 @@
#include "openmc/vector.h"
#ifdef DAGMC
#include "moab/Core.hpp"
#include "moab/AdaptiveKDTree.hpp"
#include "moab/Matrix3.hpp"
#include "moab/Core.hpp"
#include "moab/GeomUtil.hpp"
#include "moab/Matrix3.hpp"
#endif
#ifdef LIBMESH
@ -56,11 +56,10 @@ namespace settings {
// used when creating new libMesh::Mesh instances
extern unique_ptr<libMesh::LibMeshInit> libmesh_init;
extern const libMesh::Parallel::Communicator* libmesh_comm;
}
} // namespace settings
#endif
class Mesh
{
class Mesh {
public:
// Constructors and destructor
Mesh() = default;
@ -76,11 +75,8 @@ public:
//! \param[in] u Particle direction
//! \param[out] bins Bins that were crossed
//! \param[out] lengths Fraction of tracklength in each bin
virtual void bins_crossed(Position r0,
Position r1,
const Direction& u,
vector<int>& bins,
vector<double>& lengths) const = 0;
virtual void bins_crossed(Position r0, Position r1, const Direction& u,
vector<int>& bins, vector<double>& lengths) const = 0;
//! Determine which surface bins were crossed by a particle
//
@ -88,11 +84,8 @@ public:
//! \param[in] r1 Current position of the particle
//! \param[in] u Particle direction
//! \param[out] bins Surface bins that were crossed
virtual void
surface_bins_crossed(Position r0,
Position r1,
const Direction& u,
vector<int>& bins) const = 0;
virtual void surface_bins_crossed(
Position r0, Position r1, const Direction& u, vector<int>& bins) const = 0;
//! Get bin at a given position in space
//
@ -107,7 +100,7 @@ public:
virtual int n_surface_bins() const = 0;
//! Set the mesh ID
void set_id(int32_t id=-1);
void set_id(int32_t id = -1);
//! Write mesh data to an HDF5 group
//
@ -131,7 +124,7 @@ public:
virtual std::string bin_label(int bin) const = 0;
// Data members
int id_ {-1}; //!< User-specified ID
int id_ {-1}; //!< User-specified ID
int n_dimension_; //!< Number of dimensions
};
@ -147,11 +140,8 @@ public:
int n_surface_bins() const override;
void bins_crossed(Position r0,
Position r1,
const Direction& u,
vector<int>& bins,
vector<double>& lengths) const override;
void bins_crossed(Position r0, Position r1, const Direction& u,
vector<int>& bins, vector<double>& lengths) const override;
//! Count number of bank sites in each mesh bin / energy bin
//
@ -210,7 +200,7 @@ public:
std::string bin_label(int bin) const override;
// Data members
xt::xtensor<double, 1> lower_left_; //!< Lower-left coordinates of mesh
xt::xtensor<double, 1> lower_left_; //!< Lower-left coordinates of mesh
xt::xtensor<double, 1> upper_right_; //!< Upper-right coordinates of mesh
xt::xtensor<int, 1> shape_; //!< Number of mesh elements in each dimension
@ -224,19 +214,15 @@ protected:
//! Tessellation of n-dimensional Euclidean space by congruent squares or cubes
//==============================================================================
class RegularMesh : public StructuredMesh
{
class RegularMesh : public StructuredMesh {
public:
// Constructors
RegularMesh() = default;
RegularMesh(pugi::xml_node node);
// Overridden methods
void
surface_bins_crossed(Position r0,
Position r1,
const Direction& u,
vector<int>& bins) const override;
void surface_bins_crossed(Position r0, Position r1, const Direction& u,
vector<int>& bins) const override;
int get_index_in_direction(double r, int i) const override;
@ -260,24 +246,19 @@ public:
const SourceSite* bank, int64_t length, bool* outside) const;
// Data members
double volume_frac_; //!< Volume fraction of each mesh element
double volume_frac_; //!< Volume fraction of each mesh element
xt::xtensor<double, 1> width_; //!< Width of each mesh element
};
class RectilinearMesh : public StructuredMesh
{
class RectilinearMesh : public StructuredMesh {
public:
// Constructors
RectilinearMesh() = default;
RectilinearMesh(pugi::xml_node node);
// Overridden methods
void
surface_bins_crossed(Position r0,
Position r1,
const Direction& u,
vector<int>& bins) const override;
void surface_bins_crossed(Position r0, Position r1, const Direction& u,
vector<int>& bins) const override;
int get_index_in_direction(double r, int i) const override;
@ -305,11 +286,8 @@ public:
UnstructuredMesh(const std::string& filename);
// Overridden Methods
void
surface_bins_crossed(Position r0,
Position r1,
const Direction& u,
vector<int>& bins) const override;
void surface_bins_crossed(Position r0, Position r1, const Direction& u,
vector<int>& bins) const override;
void to_hdf5(hid_t group) const override;
@ -349,7 +327,8 @@ public:
virtual std::string library() const = 0;
// Data members
bool output_ {true}; //!< Write tallies onto the unstructured mesh at the end of a run
bool output_ {
true}; //!< Write tallies onto the unstructured mesh at the end of a run
std::string filename_; //!< Path to unstructured mesh file
private:
@ -370,12 +349,8 @@ public:
// Overridden Methods
void
bins_crossed(Position r0,
Position r1,
const Direction& u,
vector<int>& bins,
vector<double>& lengths) const override;
void bins_crossed(Position r0, Position r1, const Direction& u,
vector<int>& bins, vector<double>& lengths) const override;
int get_bin(Position r) const override;
@ -383,9 +358,8 @@ public:
int n_surface_bins() const override;
std::pair<vector<double>, vector<double>>
plot(Position plot_ll,
Position plot_ur) const override;
std::pair<vector<double>, vector<double>> plot(
Position plot_ll, Position plot_ur) const override;
std::string library() const override;
@ -396,9 +370,8 @@ public:
void remove_scores() override;
//! Set data for a score
void set_score_data(const std::string& score,
const vector<double>& values,
const vector<double>& std_dev) override;
void set_score_data(const std::string& score, const vector<double>& values,
const vector<double>& std_dev) override;
//! Write the mesh with any current tally data
void write(const std::string& base_filename) const override;
@ -408,7 +381,6 @@ public:
double volume(int bin) const override;
private:
void initialize() override;
// Methods
@ -438,8 +410,9 @@ private:
moab::EntityHandle get_tet(const Position& r) const;
//! Return the containing tet given a position
moab::EntityHandle get_tet(const moab::CartVect& r) const {
return get_tet(Position(r[0], r[1], r[2]));
moab::EntityHandle get_tet(const moab::CartVect& r) const
{
return get_tet(Position(r[0], r[1], r[2]));
};
//! Check for point containment within a tet; uses
@ -448,8 +421,7 @@ private:
//! \param[in] r Position to check
//! \param[in] MOAB terahedron to check
//! \return True if r is inside, False if r is outside
bool point_in_tet(const moab::CartVect& r,
moab::EntityHandle tet) const;
bool point_in_tet(const moab::CartVect& r, moab::EntityHandle tet) const;
//! Compute barycentric coordinate data for all tetrahedra
//! in the mesh.
@ -500,12 +472,11 @@ private:
//
//! \param[in] score Name of the score
//! \return The MOAB value and error tag handles, respectively
std::pair<moab::Tag, moab::Tag>
get_score_tags(std::string score) const;
std::pair<moab::Tag, moab::Tag> get_score_tags(std::string score) const;
// Data members
moab::Range ehs_; //!< Range of tetrahedra EntityHandle's in the mesh
moab::EntityHandle tetset_; //!< EntitySet containing all tetrahedra
moab::EntityHandle tetset_; //!< EntitySet containing all tetrahedra
moab::EntityHandle kdtree_root_; //!< Root of the MOAB KDTree
std::shared_ptr<moab::Interface> mbi_; //!< MOAB instance
unique_ptr<moab::AdaptiveKDTree> kdtree_; //!< MOAB KDTree instance
@ -524,11 +495,8 @@ public:
LibMesh(const std::string& filename);
// Overridden Methods
void bins_crossed(Position r0,
Position r1,
const Direction& u,
vector<int>& bins,
vector<double>& lengths) const override;
void bins_crossed(Position r0, Position r1, const Direction& u,
vector<int>& bins, vector<double>& lengths) const override;
int get_bin(Position r) const override;
@ -536,9 +504,8 @@ public:
int n_surface_bins() const override;
std::pair<vector<double>, vector<double>>
plot(Position plot_ll,
Position plot_ur) const override;
std::pair<vector<double>, vector<double>> plot(
Position plot_ll, Position plot_ur) const override;
std::string library() const override;
@ -546,9 +513,8 @@ public:
void remove_scores() override;
void set_score_data(const std::string& var_name,
const vector<double>& values,
const vector<double>& std_dev) override;
void set_score_data(const std::string& var_name, const vector<double>& values,
const vector<double>& std_dev) override;
void write(const std::string& base_filename) const override;
@ -557,7 +523,6 @@ public:
double volume(int bin) const override;
private:
void initialize() override;
// Methods
@ -573,11 +538,15 @@ private:
vector<unique_ptr<libMesh::PointLocatorBase>>
pl_; //!< per-thread point locators
unique_ptr<libMesh::EquationSystems>
equation_systems_; //!< pointer to the equation systems of the mesh
std::string eq_system_name_; //!< name of the equation system holding OpenMC results
std::unordered_map<std::string, unsigned int> variable_map_; //!< mapping of variable names (tally scores) to libMesh variable numbers
equation_systems_; //!< pointer to the equation systems of the mesh
std::string
eq_system_name_; //!< name of the equation system holding OpenMC results
std::unordered_map<std::string, unsigned int>
variable_map_; //!< mapping of variable names (tally scores) to libMesh
//!< variable numbers
libMesh::BoundingBox bbox_; //!< bounding box of the mesh
libMesh::dof_id_type first_element_id_; //!< id of the first element in the mesh
libMesh::dof_id_type
first_element_id_; //!< id of the first element in the mesh
};
#endif

10
include/openmc/message_passing.h
View file

@ -8,13 +8,13 @@
namespace openmc {
namespace mpi {
extern int rank;
extern int n_procs;
extern bool master;
extern int rank;
extern int n_procs;
extern bool master;
#ifdef OPENMC_MPI
extern MPI_Datatype source_site;
extern MPI_Comm intracomm;
extern MPI_Datatype source_site;
extern MPI_Comm intracomm;
#endif
} // namespace mpi

266
include/openmc/mgxs.h
View file

@ -22,8 +22,8 @@ namespace openmc {
struct CacheData {
double sqrtkT; // last temperature corresponding to t
int t; // temperature index
int a; // angle index
int t; // temperature index
int a; // angle index
// last angle that corresponds to a
double u;
double v;
@ -35,156 +35,150 @@ struct CacheData {
//==============================================================================
class Mgxs {
private:
private:
xt::xtensor<double, 1> kTs; // temperature in eV (k * T)
AngleDistributionType
scatter_format; // flag for if this is legendre, histogram, or tabular
int num_groups; // number of energy groups
int num_delayed_groups; // number of delayed neutron groups
vector<XsData> xs; // Cross section data
// MGXS Incoming Flux Angular grid information
bool is_isotropic; // used to skip search for angle indices if isotropic
int n_pol;
int n_azi;
vector<double> polar;
vector<double> azimuthal;
xt::xtensor<double, 1> kTs; // temperature in eV (k * T)
AngleDistributionType scatter_format; // flag for if this is legendre, histogram, or tabular
int num_groups; // number of energy groups
int num_delayed_groups; // number of delayed neutron groups
vector<XsData> xs; // Cross section data
// MGXS Incoming Flux Angular grid information
bool is_isotropic; // used to skip search for angle indices if isotropic
int n_pol;
int n_azi;
vector<double> polar;
vector<double> azimuthal;
//! \brief Initializes the Mgxs object metadata
//!
//! @param in_name Name of the object.
//! @param in_awr atomic-weight ratio.
//! @param in_kTs temperatures (in units of eV) that data is available.
//! @param in_fissionable Is this item fissionable or not.
//! @param in_scatter_format Denotes whether Legendre, Tabular, or
//! Histogram scattering is used.
//! @param in_is_isotropic Is this an isotropic or angular with respect to
//! the incoming particle.
//! @param in_polar Polar angle grid.
//! @param in_azimuthal Azimuthal angle grid.
void 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 vector<double>& in_azimuthal);
//! \brief Initializes the Mgxs object metadata
//!
//! @param in_name Name of the object.
//! @param in_awr atomic-weight ratio.
//! @param in_kTs temperatures (in units of eV) that data is available.
//! @param in_fissionable Is this item fissionable or not.
//! @param in_scatter_format Denotes whether Legendre, Tabular, or
//! Histogram scattering is used.
//! @param in_is_isotropic Is this an isotropic or angular with respect to
//! the incoming particle.
//! @param in_polar Polar angle grid.
//! @param in_azimuthal Azimuthal angle grid.
void 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 vector<double>& in_azimuthal);
//! \brief Initializes the Mgxs object metadata from the HDF5 file
//!
//! @param xs_id HDF5 group id for the cross section data.
//! @param temperature Temperatures to read.
//! @param temps_to_read Resultant list of temperatures in the library
//! to read which correspond to the requested temperatures.
//! @param order_dim Resultant dimensionality of the scattering order.
void metadata_from_hdf5(hid_t xs_id, const vector<double>& temperature,
vector<int>& temps_to_read, int& order_dim);
//! \brief Initializes the Mgxs object metadata from the HDF5 file
//!
//! @param xs_id HDF5 group id for the cross section data.
//! @param temperature Temperatures to read.
//! @param temps_to_read Resultant list of temperatures in the library
//! to read which correspond to the requested temperatures.
//! @param order_dim Resultant dimensionality of the scattering order.
void metadata_from_hdf5(hid_t xs_id, const vector<double>& temperature,
vector<int>& temps_to_read, int& order_dim);
//! \brief Performs the actual act of combining the microscopic data for a
//! single temperature.
//!
//! @param micros Microscopic objects to combine.
//! @param scalars Scalars to multiply the microscopic data by.
//! @param micro_ts The temperature index of the microscopic objects that
//! corresponds to the temperature of interest.
//! @param this_t The temperature index of the macroscopic object.
void combine(const vector<Mgxs*>& micros, const vector<double>& scalars,
const vector<int>& micro_ts, int this_t);
//! \brief Performs the actual act of combining the microscopic data for a
//! single temperature.
//!
//! @param micros Microscopic objects to combine.
//! @param scalars Scalars to multiply the microscopic data by.
//! @param micro_ts The temperature index of the microscopic objects that
//! corresponds to the temperature of interest.
//! @param this_t The temperature index of the macroscopic object.
void combine(const vector<Mgxs*>& micros, const vector<double>& scalars,
const vector<int>& micro_ts, int this_t);
//! \brief Checks to see if this and that are able to be combined
//!
//! This comparison is used when building macroscopic cross sections
//! from microscopic cross sections.
//! @param that The other Mgxs to compare to this one.
//! @return True if they can be combined, False otherwise.
bool equiv(const Mgxs& that);
//! \brief Checks to see if this and that are able to be combined
//!
//! This comparison is used when building macroscopic cross sections
//! from microscopic cross sections.
//! @param that The other Mgxs to compare to this one.
//! @return True if they can be combined, False otherwise.
bool equiv(const Mgxs& that);
public:
std::string name; // name of dataset, e.g., UO2
double awr; // atomic weight ratio
bool fissionable; // Is this fissionable
vector<CacheData> cache; // index and data cache
public:
Mgxs() = default;
std::string name; // name of dataset, e.g., UO2
double awr; // atomic weight ratio
bool fissionable; // Is this fissionable
vector<CacheData> cache; // index and data cache
//! \brief Constructor that loads the Mgxs object from the HDF5 file
//!
//! @param xs_id HDF5 group id for the cross section data.
//! @param temperature Temperatures to read.
//! @param num_group number of energy groups
//! @param num_delay number of delayed groups
Mgxs(hid_t xs_id, const vector<double>& temperature, int num_group,
int num_delay);
Mgxs() = default;
//! \brief Constructor that initializes and populates all data to build a
//! macroscopic cross section from microscopic cross sections.
//!
//! @param in_name Name of the object.
//! @param mat_kTs temperatures (in units of eV) that data is needed.
//! @param micros Microscopic objects to combine.
//! @param atom_densities Atom densities of those microscopic quantities.
//! @param num_group number of energy groups
//! @param num_delay number of delayed groups
Mgxs(const std::string& in_name, const vector<double>& mat_kTs,
const vector<Mgxs*>& micros, const vector<double>& atom_densities,
int num_group, int num_delay);
//! \brief Constructor that loads the Mgxs object from the HDF5 file
//!
//! @param xs_id HDF5 group id for the cross section data.
//! @param temperature Temperatures to read.
//! @param num_group number of energy groups
//! @param num_delay number of delayed groups
Mgxs(hid_t xs_id, const vector<double>& temperature, int num_group,
int num_delay);
//! \brief Provides a cross section value given certain parameters
//!
//! @param xstype Type of cross section requested, according to the
//! enumerated constants.
//! @param gin Incoming energy group.
//! @param gout Outgoing energy group; use nullptr if irrelevant, or if a
//! sum is requested.
//! @param mu Cosine of the change-in-angle, for scattering quantities;
//! use nullptr if irrelevant.
//! @param dg delayed group index; use nullptr if irrelevant.
//! @return Requested cross section value.
double get_xs(
MgxsType xstype, int gin, const int* gout, const double* mu, const int* dg);
//! \brief Constructor that initializes and populates all data to build a
//! macroscopic cross section from microscopic cross sections.
//!
//! @param in_name Name of the object.
//! @param mat_kTs temperatures (in units of eV) that data is needed.
//! @param micros Microscopic objects to combine.
//! @param atom_densities Atom densities of those microscopic quantities.
//! @param num_group number of energy groups
//! @param num_delay number of delayed groups
Mgxs(const std::string& in_name, const vector<double>& mat_kTs,
const vector<Mgxs*>& micros, const vector<double>& atom_densities,
int num_group, int num_delay);
inline double get_xs(MgxsType xstype, int gin)
{
return get_xs(xstype, gin, nullptr, nullptr, nullptr);
}
//! \brief Provides a cross section value given certain parameters
//!
//! @param xstype Type of cross section requested, according to the
//! enumerated constants.
//! @param gin Incoming energy group.
//! @param gout Outgoing energy group; use nullptr if irrelevant, or if a
//! sum is requested.
//! @param mu Cosine of the change-in-angle, for scattering quantities;
//! use nullptr if irrelevant.
//! @param dg delayed group index; use nullptr if irrelevant.
//! @return Requested cross section value.
double
get_xs(MgxsType xstype, int gin, const int* gout, const double* mu,
const int* dg);
//! \brief Samples the fission neutron energy and if prompt or delayed.
//!
//! @param gin Incoming energy group.
//! @param dg Sampled delayed group index.
//! @param gout Sampled outgoing energy group.
//! @param seed Pseudorandom seed pointer
void sample_fission_energy(int gin, int& dg, int& gout, uint64_t* seed);
inline double
get_xs(MgxsType xstype, int gin)
{return get_xs(xstype, gin, nullptr, nullptr, nullptr);}
//! \brief Samples the outgoing energy and angle from a scatter event.
//!
//! @param gin Incoming energy group.
//! @param gout Sampled outgoing energy group.
//! @param mu Sampled cosine of the change-in-angle.
//! @param wgt Weight of the particle to be adjusted.
//! @param seed Pseudorandom seed pointer.
void sample_scatter(
int gin, int& gout, double& mu, double& wgt, uint64_t* seed);
//! \brief Calculates cross section quantities needed for tracking.
//!
//! @param p The particle whose attributes set which MGXS to get.
void calculate_xs(Particle& p);
//! \brief Samples the fission neutron energy and if prompt or delayed.
//!
//! @param gin Incoming energy group.
//! @param dg Sampled delayed group index.
//! @param gout Sampled outgoing energy group.
//! @param seed Pseudorandom seed pointer
void
sample_fission_energy(int gin, int& dg, int& gout, uint64_t* seed);
//! \brief Sets the temperature index in cache given a temperature
//!
//! @param sqrtkT Temperature of the material.
void set_temperature_index(double sqrtkT);
//! \brief Samples the outgoing energy and angle from a scatter event.
//!
//! @param gin Incoming energy group.
//! @param gout Sampled outgoing energy group.
//! @param mu Sampled cosine of the change-in-angle.
//! @param wgt Weight of the particle to be adjusted.
//! @param seed Pseudorandom seed pointer.
void
sample_scatter(int gin, int& gout, double& mu, double& wgt, uint64_t* seed);
//! \brief Sets the angle index in cache given a direction
//!
//! @param u Incoming particle direction.
void set_angle_index(Direction u);
//! \brief Calculates cross section quantities needed for tracking.
//!
//! @param p The particle whose attributes set which MGXS to get.
void
calculate_xs(Particle& p);
//! \brief Sets the temperature index in cache given a temperature
//!
//! @param sqrtkT Temperature of the material.
void
set_temperature_index(double sqrtkT);
//! \brief Sets the angle index in cache given a direction
//!
//! @param u Incoming particle direction.
void
set_angle_index(Direction u);
//! \brief Provide const access to list of XsData held by this
const vector<XsData>& get_xsdata() const { return xs; }
//! \brief Provide const access to list of XsData held by this
const vector<XsData>& get_xsdata() const { return xs; }
};
} // namespace openmc

11
include/openmc/mgxs_interface.h
View file

@ -16,7 +16,6 @@ namespace openmc {
class MgxsInterface {
public:
MgxsInterface() = default;
// Construct from path to cross sections file, as well as a list
@ -49,10 +48,10 @@ public:
int num_energy_groups_;
int num_delayed_groups_;
vector<std::string> xs_names_; // available names in HDF5 file
vector<std::string> xs_to_read_; // XS which appear in materials
vector<vector<double>> xs_temps_to_read_; // temperatures used
std::string cross_sections_path_; // path to MGXS h5 file
vector<std::string> xs_names_; // available names in HDF5 file
vector<std::string> xs_to_read_; // XS which appear in materials
vector<vector<double>> xs_temps_to_read_; // temperatures used
std::string cross_sections_path_; // path to MGXS h5 file
vector<Mgxs> nuclides_;
vector<Mgxs> macro_xs_;
vector<double> energy_bins_;
@ -62,7 +61,7 @@ public:
};
namespace data {
extern MgxsInterface mg;
extern MgxsInterface mg;
}
// Puts available XS in MGXS file to globals so that when

13
include/openmc/neighbor_list.h
View file

@ -18,8 +18,7 @@ namespace openmc {
//! number of threads can safely read data without locks or reference counting.
//==============================================================================
class NeighborList
{
class NeighborList {
public:
using value_type = int32_t;
using const_iterator = std::forward_list<value_type>::const_iterator;
@ -43,7 +42,8 @@ public:
if (!list_.empty()) {
auto it1 = list_.cbegin();
auto it2 = ++list_.cbegin();
while (it2 != list_.cend()) it1 = it2++;
while (it2 != list_.cend())
it1 = it2++;
list_.insert_after(it1, new_elem);
} else {
list_.push_front(new_elem);
@ -52,12 +52,9 @@ public:
}
}
const_iterator cbegin() const
{return list_.cbegin();}
const_iterator cend() const
{return list_.cend();}
const_iterator cbegin() const { return list_.cbegin(); }
const_iterator cend() const { return list_.cend(); }
private:
std::forward_list<value_type> list_;

23
include/openmc/nuclide.h
View file

@ -48,7 +48,7 @@ public:
void calculate_sab_xs(int i_sab, double sab_frac, Particle& p);
// Methods
double nu(double E, EmissionMode mode, int group=0) const;
double nu(double E, EmissionMode mode, int group = 0) const;
void calculate_elastic_xs(Particle& p) const;
//! Determines the microscopic 0K elastic cross section at a trial relative
@ -66,15 +66,15 @@ public:
//! \param[in] energy Energy group boundaries in [eV]
//! \param[in] flux Flux in each energy group (not normalized per eV)
//! \return Reaction rate
double collapse_rate(int MT, double temperature, gsl::span<const double> energy,
gsl::span<const double> flux) const;
double collapse_rate(int MT, double temperature,
gsl::span<const double> energy, gsl::span<const double> flux) const;
// Data members
std::string name_; //!< Name of nuclide, e.g. "U235"
int Z_; //!< Atomic number
int A_; //!< Mass number
int metastable_; //!< Metastable state
double awr_; //!< Atomic weight ratio
int Z_; //!< Atomic number
int A_; //!< Mass number
int metastable_; //!< Metastable state
double awr_; //!< Atomic weight ratio
gsl::index index_; //!< Index in the nuclides array
// Temperature dependent cross section data
@ -86,11 +86,11 @@ public:
unique_ptr<WindowedMultipole> multipole_;
// Fission data
bool fissionable_ {false}; //!< Whether nuclide is fissionable
bool fissionable_ {false}; //!< Whether nuclide is fissionable
bool has_partial_fission_ {false}; //!< has partial fission reactions?
vector<Reaction*> fission_rx_; //!< Fission reactions
int n_precursor_ {0}; //!< Number of delayed neutron precursors
unique_ptr<Function1D> total_nu_; //!< Total neutron yield
int n_precursor_ {0}; //!< Number of delayed neutron precursors
unique_ptr<Function1D> total_nu_; //!< Total neutron yield
unique_ptr<Function1D> fission_q_prompt_; //!< Prompt fission energy release
unique_ptr<Function1D>
fission_q_recov_; //!< Recoverable fission energy release
@ -115,7 +115,8 @@ public:
vector<int> index_inelastic_scatter_;
private:
void create_derived(const Function1D* prompt_photons, const Function1D* delayed_photons);
void create_derived(
const Function1D* prompt_photons, const Function1D* delayed_photons);
//! Determine temperature index and interpolation factor
//

45
include/openmc/openmp_interface.h
View file

@ -13,37 +13,36 @@ namespace openmc {
//! This type meets the C++ "Lockable" requirements.
//==============================================================================
class OpenMPMutex
{
class OpenMPMutex {
public:
OpenMPMutex()
{
#ifdef _OPENMP
omp_init_lock(&mutex_);
#endif
#ifdef _OPENMP
omp_init_lock(&mutex_);
#endif
}
~OpenMPMutex()
{
#ifdef _OPENMP
omp_destroy_lock(&mutex_);
#endif
#ifdef _OPENMP
omp_destroy_lock(&mutex_);
#endif
}
// Mutexes cannot be copied. We need to explicitly delete the copy
// constructor and copy assignment operator to ensure the compiler doesn't
// "help" us by implicitly trying to copy the underlying mutexes.
OpenMPMutex(const OpenMPMutex&) = delete;
OpenMPMutex& operator= (const OpenMPMutex&) = delete;
OpenMPMutex& operator=(const OpenMPMutex&) = delete;
//! Lock the mutex.
//
//! This function blocks execution until the lock succeeds.
void lock()
{
#ifdef _OPENMP
omp_set_lock(&mutex_);
#endif
#ifdef _OPENMP
omp_set_lock(&mutex_);
#endif
}
//! Try to lock the mutex and indicate success.
@ -52,25 +51,25 @@ public:
//! the lock is unavailable.
bool try_lock() noexcept
{
#ifdef _OPENMP
return omp_test_lock(&mutex_);
#else
return true;
#endif
#ifdef _OPENMP
return omp_test_lock(&mutex_);
#else
return true;
#endif
}
//! Unlock the mutex.
void unlock() noexcept
{
#ifdef _OPENMP
omp_unset_lock(&mutex_);
#endif
#ifdef _OPENMP
omp_unset_lock(&mutex_);
#endif
}
private:
#ifdef _OPENMP
omp_lock_t mutex_;
#endif
#ifdef _OPENMP
omp_lock_t mutex_;
#endif
};
} // namespace openmc

13
include/openmc/particle.h
View file

@ -30,7 +30,6 @@ class Surface;
class Particle : public ParticleData {
public:
//==========================================================================
// Constructors
@ -86,18 +85,22 @@ public:
//! \param new_u The direction of the particle after translation/rotation.
//! \param new_surface The signed index of the surface that the particle will
//! reside on after translation/rotation.
void cross_periodic_bc(const Surface& surf, Position new_r, Direction new_u,
int new_surface);
void cross_periodic_bc(
const Surface& surf, Position new_r, Direction new_u, int new_surface);
//! mark a particle as lost and create a particle restart file
//! \param message A warning message to display
void mark_as_lost(const char* message);
void mark_as_lost(const std::string& message)
{mark_as_lost(message.c_str());}
{
mark_as_lost(message.c_str());
}
void mark_as_lost(const std::stringstream& message)
{mark_as_lost(message.str());}
{
mark_as_lost(message.str());
}
//! create a particle restart HDF5 file
void write_restart() const;

12
include/openmc/particle_data.h
View file

@ -207,18 +207,18 @@ private:
// Cross section caches
vector<NuclideMicroXS> neutron_xs_; //!< Microscopic neutron cross sections
vector<ElementMicroXS> photon_xs_; //!< Microscopic photon cross sections
MacroXS macro_xs_; //!< Macroscopic cross sections
MacroXS macro_xs_; //!< Macroscopic cross sections
int64_t id_; //!< Unique ID
ParticleType type_ {ParticleType::neutron}; //!< Particle type (n, p, e, etc.)
int n_coord_ {1}; //!< number of current coordinate levels
int cell_instance_; //!< offset for distributed properties
vector<LocalCoord> coord_; //!< coordinates for all levels
int n_coord_ {1}; //!< number of current coordinate levels
int cell_instance_; //!< offset for distributed properties
vector<LocalCoord> coord_; //!< coordinates for all levels
// Particle coordinates before crossing a surface
int n_coord_last_ {1}; //!< number of current coordinates
vector<int> cell_last_; //!< coordinates for all levels
int n_coord_last_ {1}; //!< number of current coordinates
vector<int> cell_last_; //!< coordinates for all levels
// Energy data
double E_; //!< post-collision energy in eV

20
include/openmc/photon.h
View file

@ -6,9 +6,9 @@
#include "openmc/particle.h"
#include "openmc/vector.h"
#include "xtensor/xtensor.hpp"
#include <gsl/gsl>
#include <hdf5.h>
#include "xtensor/xtensor.hpp"
#include <string>
#include <unordered_map>
@ -23,9 +23,9 @@ namespace openmc {
class ElectronSubshell {
public:
// Constructors
ElectronSubshell() { };
ElectronSubshell() {};
int index_subshell; //!< index in SUBSHELLS
int index_subshell; //!< index in SUBSHELLS
int threshold;
double n_electrons;
double binding_energy;
@ -59,7 +59,7 @@ public:
// Data members
std::string name_; //!< Name of element, e.g. "Zr"
int Z_; //!< Atomic number
int Z_; //!< Atomic number
gsl::index index_; //!< Index in global elements vector
// Microscopic cross sections
@ -79,8 +79,9 @@ public:
Tabulated1D coherent_anomalous_imag_;
// Photoionization and atomic relaxation data
std::unordered_map<int, int> shell_map_; //!< Given a shell designator, e.g. 3, this
//!< dictionary gives an index in shells_
std::unordered_map<int, int>
shell_map_; //!< Given a shell designator, e.g. 3, this
//!< dictionary gives an index in shells_
vector<ElectronSubshell> shells_;
// Compton profile data
@ -99,8 +100,8 @@ public:
xt::xtensor<double, 2> dcs_;
private:
void compton_doppler(double alpha, double mu, double* E_out, int* i_shell,
uint64_t* seed) const;
void compton_doppler(
double alpha, double mu, double* E_out, int* i_shell, uint64_t* seed) const;
};
//==============================================================================
@ -117,7 +118,8 @@ void free_memory_photon();
namespace data {
extern xt::xtensor<double, 1> compton_profile_pz; //! Compton profile momentum grid
extern xt::xtensor<double, 1>
compton_profile_pz; //! Compton profile momentum grid
//! Photon interaction data for each element
extern std::unordered_map<std::string, int> element_map;

25
include/openmc/physics.h
View file

@ -26,16 +26,17 @@ void sample_neutron_reaction(Particle& p);
void sample_photon_reaction(Particle& p);
//! Terminates the particle and either deposits all energy locally
//! (electron_treatment = ElectronTreatment::LED) or creates secondary bremsstrahlung
//! photons from electron deflections with charged particles (electron_treatment
//! = ElectronTreatment::TTB).
//! (electron_treatment = ElectronTreatment::LED) or creates secondary
//! bremsstrahlung photons from electron deflections with charged particles
//! (electron_treatment = ElectronTreatment::TTB).
void sample_electron_reaction(Particle& p);
//! Terminates the particle and either deposits all energy locally
//! (electron_treatment = ElectronTreatment::LED) or creates secondary bremsstrahlung
//! photons from electron deflections with charged particles (electron_treatment
//! = ElectronTreatment::TTB). Two annihilation photons of energy MASS_ELECTRON_EV (0.511
//! MeV) are created and travel in opposite directions.
//! (electron_treatment = ElectronTreatment::LED) or creates secondary
//! bremsstrahlung photons from electron deflections with charged particles
//! (electron_treatment = ElectronTreatment::TTB). Two annihilation photons of
//! energy MASS_ELECTRON_EV (0.511 MeV) are created and travel in opposite
//! directions.
void sample_positron_reaction(Particle& p);
//! Sample a nuclide based on their total cross sections and densities within
@ -53,15 +54,15 @@ int sample_element(Particle& p);
Reaction& sample_fission(int i_nuclide, Particle& p);
void sample_photon_product(int i_nuclide, Particle& p, int* i_rx, int* i_product);
void sample_photon_product(
int i_nuclide, Particle& p, int* i_rx, int* i_product);
void absorption(Particle& p, int i_nuclide);
void scatter(Particle& p, int i_nuclide);
//! Treats the elastic scattering of a neutron with a target.
void elastic_scatter(int i_nuclide, const Reaction& rx, double kT,
Particle& p);
void elastic_scatter(int i_nuclide, const Reaction& rx, double kT, Particle& p);
void sab_scatter(int i_nuclide, int i_sab, Particle& p);
@ -76,8 +77,8 @@ Direction sample_target_velocity(const Nuclide& nuc, double E, Direction u,
//! by most Monte Carlo codes, in which cross section is assumed to be constant
//! in energy. Excellent documentation for this method can be found in
//! FRA-TM-123.
Direction sample_cxs_target_velocity(double awr, double E, Direction u, double kT,
uint64_t* seed);
Direction sample_cxs_target_velocity(
double awr, double E, Direction u, double kT, uint64_t* seed);
void sample_fission_neutron(int i_nuclide, const Reaction& rx, double E_in,
SourceSite* site, uint64_t* seed);

15
include/openmc/physics_mg.h
View file

@ -12,32 +12,27 @@ namespace openmc {
//! \brief samples particle behavior after a collision event.
//! \param p Particle to operate on
void
collision_mg(Particle& p);
void collision_mg(Particle& p);
//! \brief samples a reaction type.
//!
//! Note that there is special logic when suvival biasing is turned on since
//! fission and disappearance are treated implicitly.
//! \param p Particle to operate on
void
sample_reaction(Particle& p);
void sample_reaction(Particle& p);
//! \brief Samples the scattering event
//! \param p Particle to operate on
void
scatter(Particle& p);
void scatter(Particle& p);
//! \brief Determines the average total, prompt and delayed neutrons produced
//! from fission and creates the appropriate bank sites.
//! \param p Particle to operate on
void
create_fission_sites(Particle& p);
void create_fission_sites(Particle& p);
//! \brief Handles an absorption event
//! \param p Particle to operate on
void
absorption(Particle& p);
void absorption(Particle& p);
} // namespace openmc
#endif // OPENMC_PHYSICS_MG_H

116
include/openmc/plot.h
View file

@ -1,21 +1,21 @@
#ifndef OPENMC_PLOT_H
#define OPENMC_PLOT_H
#include <unordered_map>
#include <sstream>
#include <unordered_map>
#include "pugixml.hpp"
#include "xtensor/xarray.hpp"
#include "hdf5.h"
#include "openmc/position.h"
#include "openmc/constants.h"
#include "openmc/cell.h"
#include "openmc/constants.h"
#include "openmc/error.h"
#include "openmc/geometry.h"
#include "openmc/particle.h"
#include "openmc/xml_interface.h"
#include "openmc/position.h"
#include "openmc/random_lcg.h"
#include "openmc/xml_interface.h"
namespace openmc {
@ -30,8 +30,9 @@ namespace model {
extern std::unordered_map<int, int> plot_map; //!< map of plot ids to index
extern vector<Plot> plots; //!< Plot instance container
extern uint64_t plotter_prn_seeds[N_STREAMS]; // Random number seeds used for plotter
extern int plotter_stream; // Stream index used by the plotter
extern uint64_t
plotter_prn_seeds[N_STREAMS]; // Random number seeds used for plotter
extern int plotter_stream; // Stream index used by the plotter
} // namespace model
@ -40,10 +41,10 @@ extern int plotter_stream; // Stream index used by the plotter
//===============================================================================
struct RGBColor {
//Constructors
RGBColor() : red(0), green(0), blue(0) { };
RGBColor(const int v[3]) : red(v[0]), green(v[1]), blue(v[2]) { };
RGBColor(int r, int g, int b) : red(r), green(g), blue(b) { };
// Constructors
RGBColor() : red(0), green(0), blue(0) {};
RGBColor(const int v[3]) : red(v[0]), green(v[1]), blue(v[2]) {};
RGBColor(int r, int g, int b) : red(r), green(g), blue(b) {};
RGBColor(const vector<int>& v)
{
@ -55,7 +56,8 @@ struct RGBColor {
blue = v[2];
}
bool operator ==(const RGBColor& other) {
bool operator==(const RGBColor& other)
{
return red == other.red && green == other.green && blue == other.blue;
}
@ -65,8 +67,7 @@ struct RGBColor {
// some default colors
const RGBColor WHITE {255, 255, 255};
const RGBColor RED {255, 0, 0};
const RGBColor RED {255, 0, 0};
typedef xt::xtensor<RGBColor, 2> ImageData;
@ -94,48 +95,40 @@ struct PropertyData {
xt::xtensor<double, 3> data_; //!< 2D array of temperature & density data
};
enum class PlotType {
slice = 1,
voxel = 2
};
enum class PlotType { slice = 1, voxel = 2 };
enum class PlotBasis {
xy = 1,
xz = 2,
yz = 3
};
enum class PlotBasis { xy = 1, xz = 2, yz = 3 };
enum class PlotColorBy {
cells = 0,
mats = 1
};
enum class PlotColorBy { cells = 0, mats = 1 };
//===============================================================================
// Plot class
//===============================================================================
class PlotBase {
public:
template<class T> T get_map() const;
template<class T>
T get_map() const;
// Members
public:
Position origin_; //!< Plot origin in geometry
Position width_; //!< Plot width in geometry
PlotBasis basis_; //!< Plot basis (XY/XZ/YZ)
Position origin_; //!< Plot origin in geometry
Position width_; //!< Plot width in geometry
PlotBasis basis_; //!< Plot basis (XY/XZ/YZ)
array<size_t, 3> pixels_; //!< Plot size in pixels
bool color_overlaps_; //!< Show overlapping cells?
int level_; //!< Plot universe level
bool color_overlaps_; //!< Show overlapping cells?
int level_; //!< Plot universe level
};
template<class T>
T PlotBase::get_map() const {
T PlotBase::get_map() const
{
size_t width = pixels_[0];
size_t height = pixels_[1];
// get pixel size
double in_pixel = (width_[0])/static_cast<double>(width);
double out_pixel = (width_[1])/static_cast<double>(height);
double in_pixel = (width_[0]) / static_cast<double>(width);
double out_pixel = (width_[1]) / static_cast<double>(height);
// size data array
T data(width, height);
@ -143,16 +136,16 @@ T PlotBase::get_map() const {
// setup basis indices and initial position centered on pixel
int in_i, out_i;
Position xyz = origin_;
switch(basis_) {
case PlotBasis::xy :
switch (basis_) {
case PlotBasis::xy:
in_i = 0;
out_i = 1;
break;
case PlotBasis::xz :
case PlotBasis::xz:
in_i = 0;
out_i = 2;
break;
case PlotBasis::yz :
case PlotBasis::yz:
in_i = 1;
out_i = 2;
break;
@ -167,25 +160,27 @@ T PlotBase::get_map() const {
// arbitrary direction
Direction dir = {0.7071, 0.7071, 0.0};
#pragma omp parallel
#pragma omp parallel
{
Particle p;
p.r() = xyz;
p.u() = dir;
p.coord(0).universe = model::root_universe;
int level = level_;
int j{};
int j {};
#pragma omp for
#pragma omp for
for (int y = 0; y < height; y++) {
p.r()[out_i] = xyz[out_i] - out_pixel * y;
p.r()[out_i] = xyz[out_i] - out_pixel * y;
for (int x = 0; x < width; x++) {
p.r()[in_i] = xyz[in_i] + in_pixel * x;
p.n_coord() = 1;
// local variables
bool found_cell = exhaustive_find_cell(p);
j = p.n_coord() - 1;
if (level >= 0) { j = level; }
if (level >= 0) {
j = level;
}
if (found_cell) {
data.set_value(y, x, p, j);
}
@ -193,8 +188,8 @@ T PlotBase::get_map() const {
data.set_overlap(y, x);
}
} // inner for
} // outer for
} // omp parallel
} // outer for
} // omp parallel
return data;
}
@ -221,18 +216,18 @@ private:
void set_mask(pugi::xml_node plot_node);
void set_overlap_color(pugi::xml_node plot_node);
// Members
// Members
public:
int id_; //!< Plot ID
PlotType type_; //!< Plot type (Slice/Voxel)
PlotColorBy color_by_; //!< Plot coloring (cell/material)
int meshlines_width_; //!< Width of lines added to the plot
int id_; //!< Plot ID
PlotType type_; //!< Plot type (Slice/Voxel)
PlotColorBy color_by_; //!< Plot coloring (cell/material)
int meshlines_width_; //!< Width of lines added to the plot
int index_meshlines_mesh_ {-1}; //!< Index of the mesh to draw on the plot
RGBColor meshlines_color_; //!< Color of meshlines on the plot
RGBColor not_found_ {WHITE}; //!< Plot background color
RGBColor overlap_color_ {RED}; //!< Plot overlap color
vector<RGBColor> colors_; //!< Plot colors
std::string path_plot_; //!< Plot output filename
RGBColor meshlines_color_; //!< Color of meshlines on the plot
RGBColor not_found_ {WHITE}; //!< Plot background color
RGBColor overlap_color_ {RED}; //!< Plot overlap color
vector<RGBColor> colors_; //!< Plot colors
std::string path_plot_; //!< Plot output filename
};
//===============================================================================
@ -255,16 +250,16 @@ void output_ppm(Plot const& pl, const ImageData& data);
//! \param[out] dataspace pointer to voxel data
//! \param[out] dataset pointer to voxesl data
//! \param[out] pointer to memory space of voxel data
void voxel_init(hid_t file_id, const hsize_t* dims, hid_t* dspace,
hid_t* dset, hid_t* memspace);
void voxel_init(hid_t file_id, const hsize_t* dims, hid_t* dspace, hid_t* dset,
hid_t* memspace);
//! Write a section of the voxel data to hdf5
//! \param[in] voxel slice
//! \param[out] dataspace pointer to voxel data
//! \param[out] dataset pointer to voxesl data
//! \param[out] pointer to data to write
void voxel_write_slice(int x, hid_t dspace, hid_t dset,
hid_t memspace, void* buf);
void voxel_write_slice(
int x, hid_t dspace, hid_t dset, hid_t memspace, void* buf);
//! Close voxel file entities
//! \param[in] data space to close
@ -291,6 +286,5 @@ void create_voxel(Plot const& pl);
//! \return RGBColor with random value
RGBColor random_color();
} // namespace openmc
#endif // OPENMC_PLOT_H

116
include/openmc/position.h
View file

@ -17,8 +17,8 @@ namespace openmc {
struct Position {
// Constructors
Position() = default;
Position(double x_, double y_, double z_) : x{x_}, y{y_}, z{z_} { };
Position(const double xyz[]) : x{xyz[0]}, y{xyz[1]}, z{xyz[2]} { };
Position(double x_, double y_, double z_) : x {x_}, y {y_}, z {z_} {};
Position(const double xyz[]) : x {xyz[0]}, y {xyz[1]}, z {xyz[2]} {};
Position(const vector<double>& xyz) : x {xyz[0]}, y {xyz[1]}, z {xyz[2]} {};
Position(const array<double, 3>& xyz) : x {xyz[0]}, y {xyz[1]}, z {xyz[2]} {};
@ -33,22 +33,30 @@ struct Position {
Position& operator/=(double);
Position operator-() const;
const double& operator[](int i) const {
const double& operator[](int i) const
{
switch (i) {
case 0: return x;
case 1: return y;
case 2: return z;
default:
throw std::out_of_range{"Index in Position must be between 0 and 2."};
case 0:
return x;
case 1:
return y;
case 2:
return z;
default:
throw std::out_of_range {"Index in Position must be between 0 and 2."};
}
}
double& operator[](int i) {
double& operator[](int i)
{
switch (i) {
case 0: return x;
case 1: return y;
case 2: return z;
default:
throw std::out_of_range{"Index in Position must be between 0 and 2."};
case 0:
return x;
case 1:
return y;
case 2:
return z;
default:
throw std::out_of_range {"Index in Position must be between 0 and 2."};
}
}
@ -69,12 +77,11 @@ struct Position {
//! Dot product of two vectors
//! \param[in] other Vector to take dot product with
//! \result Resulting dot product
inline double dot(Position other) const {
return x*other.x + y*other.y + z*other.z;
}
inline double norm() const {
return std::sqrt(x*x + y*y + z*z);
inline double dot(Position other) const
{
return x * other.x + y * other.y + z * other.z;
}
inline double norm() const { return std::sqrt(x * x + y * y + z * z); }
//! Reflect a direction across a normal vector
//! \param[in] other Vector to reflect across
@ -123,23 +130,60 @@ inline double& Position::get<2>()
}
// Binary operators
inline Position operator+(Position a, Position b) { return a += b; }
inline Position operator+(Position a, double b) { return a += b; }
inline Position operator+(double a, Position b) { return b += a; }
inline Position operator+(Position a, Position b)
{
return a += b;
}
inline Position operator+(Position a, double b)
{
return a += b;
}
inline Position operator+(double a, Position b)
{
return b += a;
}
inline Position operator-(Position a, Position b) { return a -= b; }
inline Position operator-(Position a, double b) { return a -= b; }
inline Position operator-(double a, Position b) { return b -= a; }
inline Position operator-(Position a, Position b)
{
return a -= b;
}
inline Position operator-(Position a, double b)
{
return a -= b;
}
inline Position operator-(double a, Position b)
{
return b -= a;
}
inline Position operator*(Position a, Position b) { return a *= b; }
inline Position operator*(Position a, double b) { return a *= b; }
inline Position operator*(double a, Position b) { return b *= a; }
inline Position operator*(Position a, Position b)
{
return a *= b;
}
inline Position operator*(Position a, double b)
{
return a *= b;
}
inline Position operator*(double a, Position b)
{
return b *= a;
}
inline Position operator/(Position a, Position b) { return a /= b; }
inline Position operator/(Position a, double b) { return a /= b; }
inline Position operator/(double a, Position b) { return b /= a; }
inline Position operator/(Position a, Position b)
{
return a /= b;
}
inline Position operator/(Position a, double b)
{
return a /= b;
}
inline Position operator/(double a, Position b)
{
return b /= a;
}
inline Position Position::reflect(Position n) const {
inline Position Position::reflect(Position n) const
{
const double projection = n.dot(*this);
const double magnitude = n.dot(n);
n *= (2.0 * projection / magnitude);
@ -147,10 +191,14 @@ inline Position Position::reflect(Position n) const {
}
inline bool operator==(Position a, Position b)
{return a.x == b.x && a.y == b.y && a.z == b.z;}
{
return a.x == b.x && a.y == b.y && a.z == b.z;
}
inline bool operator!=(Position a, Position b)
{return a.x != b.x || a.y != b.y || a.z != b.z;}
{
return a.x != b.x || a.y != b.y || a.z != b.z;
}
std::ostream& operator<<(std::ostream& os, Position a);

10
include/openmc/progress_bar.h
View file

@ -5,18 +5,16 @@
class ProgressBar {
public:
public:
// Constructor
ProgressBar();
void set_value(double val);
private:
std::string bar;
char bar_old[72] = "???% | |";
char bar_old[72] =
"???% | |";
};
#endif // OPENMC_PROGRESSBAR_H

3
include/openmc/random_dist.h
View file

@ -78,7 +78,8 @@ extern "C" double normal_variate(double mean, double std_dev, uint64_t* seed);
//! \result The sampled outgoing energy
//==============================================================================
extern "C" double muir_spectrum(double e0, double m_rat, double kt, uint64_t* seed);
extern "C" double muir_spectrum(
double e0, double m_rat, double kt, uint64_t* seed);
} // namespace openmc

11
include/openmc/random_lcg.h
View file

@ -3,19 +3,18 @@
#include <cstdint>
namespace openmc {
//==============================================================================
// Module constants.
//==============================================================================
constexpr int N_STREAMS {4};
constexpr int STREAM_TRACKING {0};
constexpr int STREAM_SOURCE {1};
constexpr int N_STREAMS {4};
constexpr int STREAM_TRACKING {0};
constexpr int STREAM_SOURCE {1};
constexpr int STREAM_URR_PTABLE {2};
constexpr int STREAM_VOLUME {3};
constexpr int64_t DEFAULT_SEED {1};
constexpr int STREAM_VOLUME {3};
constexpr int64_t DEFAULT_SEED {1};
//==============================================================================
//! Generate a pseudo-random number using a linear congruential generator.

10
include/openmc/reaction.h
View file

@ -6,8 +6,8 @@
#include <string>
#include <gsl/gsl>
#include "hdf5.h"
#include <gsl/gsl>
#include "openmc/reaction_product.h"
#include "openmc/vector.h"
@ -43,10 +43,10 @@ public:
vector<double> value;
};
int mt_; //!< ENDF MT value
double q_value_; //!< Reaction Q value in [eV]
bool scatter_in_cm_; //!< scattering system in center-of-mass?
bool redundant_; //!< redundant reaction?
int mt_; //!< ENDF MT value
double q_value_; //!< Reaction Q value in [eV]
bool scatter_in_cm_; //!< scattering system in center-of-mass?
bool redundant_; //!< redundant reaction?
vector<TemperatureXS> xs_; //!< Cross section at each temperature
vector<ReactionProduct> products_; //!< Reaction products
};

2
include/openmc/reaction_product.h
View file

@ -52,6 +52,6 @@ public:
vector<Secondary> distribution_; //!< Secondary angle-energy distribution
};
} // namespace opemc
} // namespace openmc
#endif // OPENMC_REACTION_PRODUCT_H

310
include/openmc/scattdata.h
View file

@ -21,151 +21,138 @@ class ScattDataTabular;
//==============================================================================
class ScattData {
public:
virtual ~ScattData() = default;
protected:
//! \brief Initializes the attributes of the base class.
void
base_init(int order, const xt::xtensor<int, 1>& in_gmin,
const xt::xtensor<int, 1>& in_gmax, const double_2dvec& in_energy,
const double_2dvec& in_mult);
public:
virtual ~ScattData() = default;
//! \brief Combines microscopic ScattDatas into a macroscopic one.
void 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);
protected:
//! \brief Initializes the attributes of the base class.
void base_init(int order, const xt::xtensor<int, 1>& in_gmin,
const xt::xtensor<int, 1>& in_gmax, const double_2dvec& in_energy,
const double_2dvec& in_mult);
public:
//! \brief Combines microscopic ScattDatas into a macroscopic one.
void 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);
double_2dvec energy; // Normalized p0 matrix for sampling Eout
double_2dvec mult; // nu-scatter multiplication (nu-scatt/scatt)
double_3dvec dist; // Angular distribution
xt::xtensor<int, 1> gmin; // minimum outgoing group
xt::xtensor<int, 1> gmax; // maximum outgoing group
xt::xtensor<double, 1> scattxs; // Isotropic Sigma_{s,g_{in}}
public:
double_2dvec energy; // Normalized p0 matrix for sampling Eout
double_2dvec mult; // nu-scatter multiplication (nu-scatt/scatt)
double_3dvec dist; // Angular distribution
xt::xtensor<int, 1> gmin; // minimum outgoing group
xt::xtensor<int, 1> gmax; // maximum outgoing group
xt::xtensor<double, 1> scattxs; // Isotropic Sigma_{s,g_{in}}
//! \brief Calculates the value of normalized f(mu).
//!
//! The value of f(mu) is normalized as in the integral of f(mu)dmu across
//! [-1,1] is 1.
//!
//! @param gin Incoming energy group of interest.
//! @param gout Outgoing energy group of interest.
//! @param mu Cosine of the change-in-angle of interest.
//! @return The value of f(mu).
virtual double
calc_f(int gin, int gout, double mu) = 0;
//! \brief Calculates the value of normalized f(mu).
//!
//! The value of f(mu) is normalized as in the integral of f(mu)dmu across
//! [-1,1] is 1.
//!
//! @param gin Incoming energy group of interest.
//! @param gout Outgoing energy group of interest.
//! @param mu Cosine of the change-in-angle of interest.
//! @return The value of f(mu).
virtual double calc_f(int gin, int gout, double mu) = 0;
//! \brief Samples the outgoing energy and angle from the ScattData info.
//!
//! @param gin Incoming energy group.
//! @param gout Sampled outgoing energy group.
//! @param mu Sampled cosine of the change-in-angle.
//! @param wgt Weight of the particle to be adjusted.
//! @param seed Pseudorandom number seed pointer
virtual void
sample(int gin, int& gout, double& mu, double& wgt, uint64_t* seed) = 0;
//! \brief Samples the outgoing energy and angle from the ScattData info.
//!
//! @param gin Incoming energy group.
//! @param gout Sampled outgoing energy group.
//! @param mu Sampled cosine of the change-in-angle.
//! @param wgt Weight of the particle to be adjusted.
//! @param seed Pseudorandom number seed pointer
virtual void sample(
int gin, int& gout, double& mu, double& wgt, uint64_t* seed) = 0;
//! \brief Initializes the ScattData object from a given scatter and
//! multiplicity matrix.
//!
//! @param in_gmin List of minimum outgoing groups for every incoming group
//! @param in_gmax List of maximum outgoing groups for every incoming group
//! @param in_mult Input sparse multiplicity matrix
//! @param coeffs Input sparse scattering matrix
virtual void
init(const xt::xtensor<int, 1>& in_gmin, const xt::xtensor<int, 1>& in_gmax,
const double_2dvec& in_mult, const double_3dvec& coeffs) = 0;
//! \brief Initializes the ScattData object from a given scatter and
//! multiplicity matrix.
//!
//! @param in_gmin List of minimum outgoing groups for every incoming group
//! @param in_gmax List of maximum outgoing groups for every incoming group
//! @param in_mult Input sparse multiplicity matrix
//! @param coeffs Input sparse scattering matrix
virtual void init(const xt::xtensor<int, 1>& in_gmin,
const xt::xtensor<int, 1>& in_gmax, const double_2dvec& in_mult,
const double_3dvec& coeffs) = 0;
//! \brief Combines the microscopic data.
//!
//! @param those_scatts Microscopic objects to combine.
//! @param scalars Scalars to multiply the microscopic data by.
virtual void combine(const vector<ScattData*>& those_scatts,
const vector<double>& scalars) = 0;
//! \brief Combines the microscopic data.
//!
//! @param those_scatts Microscopic objects to combine.
//! @param scalars Scalars to multiply the microscopic data by.
virtual void combine(
const vector<ScattData*>& those_scatts, const vector<double>& scalars) = 0;
//! \brief Getter for the dimensionality of the scattering order.
//!
//! If Legendre this is the "n" in "Pn"; for Tabular, this is the number
//! of points, and for Histogram this is the number of bins.
//!
//! @return The order.
virtual size_t
get_order() = 0;
//! \brief Getter for the dimensionality of the scattering order.
//!
//! If Legendre this is the "n" in "Pn"; for Tabular, this is the number
//! of points, and for Histogram this is the number of bins.
//!
//! @return The order.
virtual size_t get_order() = 0;
//! \brief Builds a dense scattering matrix from the constituent parts
//!
//! @param max_order If Legendre this is the maximum value of "n" in "Pn"
//! requested; ignored otherwise.
//! @return The dense scattering matrix.
virtual xt::xtensor<double, 3>
get_matrix(size_t max_order) = 0;
//! \brief Builds a dense scattering matrix from the constituent parts
//!
//! @param max_order If Legendre this is the maximum value of "n" in "Pn"
//! requested; ignored otherwise.
//! @return The dense scattering matrix.
virtual xt::xtensor<double, 3> get_matrix(size_t max_order) = 0;
//! \brief Samples the outgoing energy from the ScattData info.
//!
//! @param gin Incoming energy group.
//! @param gout Sampled outgoing energy group.
//! @param i_gout Sampled outgoing energy group index.
//! @param seed Pseudorandom number seed pointer
void
sample_energy(int gin, int& gout, int& i_gout, uint64_t* seed);
//! \brief Samples the outgoing energy from the ScattData info.
//!
//! @param gin Incoming energy group.
//! @param gout Sampled outgoing energy group.
//! @param i_gout Sampled outgoing energy group index.
//! @param seed Pseudorandom number seed pointer
void sample_energy(int gin, int& gout, int& i_gout, uint64_t* seed);
//! \brief Provides a cross section value given certain parameters
//!
//! @param xstype Type of cross section requested, according to the
//! enumerated constants.
//! @param gin Incoming energy group.
//! @param gout Outgoing energy group; use nullptr if irrelevant, or if a
//! sum is requested.
//! @param mu Cosine of the change-in-angle, for scattering quantities;
//! use nullptr if irrelevant.
//! @return Requested cross section value.
double
get_xs(MgxsType xstype, int gin, const int* gout, const double* mu);
//! \brief Provides a cross section value given certain parameters
//!
//! @param xstype Type of cross section requested, according to the
//! enumerated constants.
//! @param gin Incoming energy group.
//! @param gout Outgoing energy group; use nullptr if irrelevant, or if a
//! sum is requested.
//! @param mu Cosine of the change-in-angle, for scattering quantities;
//! use nullptr if irrelevant.
//! @return Requested cross section value.
double get_xs(MgxsType xstype, int gin, const int* gout, const double* mu);
};
//==============================================================================
// ScattDataLegendre represents the angular distributions as Legendre kernels
//==============================================================================
class ScattDataLegendre: public ScattData {
class ScattDataLegendre : public ScattData {
protected:
protected:
// Maximal value for rejection sampling from a rectangle
double_2dvec max_val;
// Maximal value for rejection sampling from a rectangle
double_2dvec max_val;
// Friend convert_legendre_to_tabular so it has access to protected
// parameters
friend void convert_legendre_to_tabular(
ScattDataLegendre& leg, ScattDataTabular& tab);
// Friend convert_legendre_to_tabular so it has access to protected
// parameters
friend void
convert_legendre_to_tabular(ScattDataLegendre& leg, ScattDataTabular& tab);
public:
void init(const xt::xtensor<int, 1>& in_gmin,
const xt::xtensor<int, 1>& in_gmax, const double_2dvec& in_mult,
const double_3dvec& coeffs);
public:
void combine(
const vector<ScattData*>& those_scatts, const vector<double>& scalars);
void
init(const xt::xtensor<int, 1>& in_gmin, const xt::xtensor<int, 1>& in_gmax,
const double_2dvec& in_mult, const double_3dvec& coeffs);
//! \brief Find the maximal value of the angular distribution to use as a
// bounding box with rejection sampling.
void update_max_val();
void combine(
const vector<ScattData*>& those_scatts, const vector<double>& scalars);
double calc_f(int gin, int gout, double mu);
//! \brief Find the maximal value of the angular distribution to use as a
// bounding box with rejection sampling.
void
update_max_val();
void sample(int gin, int& gout, double& mu, double& wgt, uint64_t* seed);
double
calc_f(int gin, int gout, double mu);
size_t get_order() { return dist[0][0].size() - 1; };
void
sample(int gin, int& gout, double& mu, double& wgt, uint64_t* seed);
size_t
get_order() {return dist[0][0].size() - 1;};
xt::xtensor<double, 3>
get_matrix(size_t max_order);
xt::xtensor<double, 3> get_matrix(size_t max_order);
};
//==============================================================================
@ -173,34 +160,28 @@ class ScattDataLegendre: public ScattData {
// would be if it came from a "mu" tally in OpenMC
//==============================================================================
class ScattDataHistogram: public ScattData {
class ScattDataHistogram : public ScattData {
protected:
protected:
xt::xtensor<double, 1> mu; // Angle distribution mu bin boundaries
double dmu; // Quick storage of the mu spacing
double_3dvec fmu; // The angular distribution histogram
xt::xtensor<double, 1> mu; // Angle distribution mu bin boundaries
double dmu; // Quick storage of the mu spacing
double_3dvec fmu; // The angular distribution histogram
public:
void init(const xt::xtensor<int, 1>& in_gmin,
const xt::xtensor<int, 1>& in_gmax, const double_2dvec& in_mult,
const double_3dvec& coeffs);
public:
void combine(
const vector<ScattData*>& those_scatts, const vector<double>& scalars);
void
init(const xt::xtensor<int, 1>& in_gmin, const xt::xtensor<int, 1>& in_gmax,
const double_2dvec& in_mult, const double_3dvec& coeffs);
double calc_f(int gin, int gout, double mu);
void combine(
const vector<ScattData*>& those_scatts, const vector<double>& scalars);
void sample(int gin, int& gout, double& mu, double& wgt, uint64_t* seed);
double
calc_f(int gin, int gout, double mu);
size_t get_order() { return dist[0][0].size(); };
void
sample(int gin, int& gout, double& mu, double& wgt, uint64_t* seed);
size_t
get_order() {return dist[0][0].size();};
xt::xtensor<double, 3>
get_matrix(size_t max_order);
xt::xtensor<double, 3> get_matrix(size_t max_order);
};
//==============================================================================
@ -208,39 +189,33 @@ class ScattDataHistogram: public ScattData {
// f(mu)
//==============================================================================
class ScattDataTabular: public ScattData {
class ScattDataTabular : public ScattData {
protected:
protected:
xt::xtensor<double, 1> mu; // Angle distribution mu grid points
double dmu; // Quick storage of the mu spacing
double_3dvec fmu; // The angular distribution function
xt::xtensor<double, 1> mu; // Angle distribution mu grid points
double dmu; // Quick storage of the mu spacing
double_3dvec fmu; // The angular distribution function
// Friend convert_legendre_to_tabular so it has access to protected
// parameters
friend void convert_legendre_to_tabular(
ScattDataLegendre& leg, ScattDataTabular& tab);
// Friend convert_legendre_to_tabular so it has access to protected
// parameters
friend void
convert_legendre_to_tabular(ScattDataLegendre& leg, ScattDataTabular& tab);
public:
void init(const xt::xtensor<int, 1>& in_gmin,
const xt::xtensor<int, 1>& in_gmax, const double_2dvec& in_mult,
const double_3dvec& coeffs);
public:
void combine(
const vector<ScattData*>& those_scatts, const vector<double>& scalars);
void
init(const xt::xtensor<int, 1>& in_gmin, const xt::xtensor<int, 1>& in_gmax,
const double_2dvec& in_mult, const double_3dvec& coeffs);
double calc_f(int gin, int gout, double mu);
void combine(
const vector<ScattData*>& those_scatts, const vector<double>& scalars);
void sample(int gin, int& gout, double& mu, double& wgt, uint64_t* seed);
double
calc_f(int gin, int gout, double mu);
size_t get_order() { return dist[0][0].size(); };
void
sample(int gin, int& gout, double& mu, double& wgt, uint64_t* seed);
size_t
get_order() {return dist[0][0].size();};
xt::xtensor<double, 3>
get_matrix(size_t max_order);
xt::xtensor<double, 3> get_matrix(size_t max_order);
};
//==============================================================================
@ -253,9 +228,8 @@ class ScattDataTabular: public ScattData {
//! @param leg The resultant ScattDataTabular object.
//! @param n_mu The number of mu points to use when building the
//! ScattDataTabular object.
void
convert_legendre_to_tabular(ScattDataLegendre& leg, ScattDataTabular& tab,
int n_mu);
void convert_legendre_to_tabular(
ScattDataLegendre& leg, ScattDataTabular& tab, int n_mu);
} // namespace openmc
#endif // OPENMC_SCATTDATA_H

11
include/openmc/search.h
View file

@ -11,17 +11,18 @@ namespace openmc {
//! Perform binary search
template<class It, class T>
typename std::iterator_traits<It>::difference_type
lower_bound_index(It first, It last, const T& value)
typename std::iterator_traits<It>::difference_type lower_bound_index(
It first, It last, const T& value)
{
if (*first == value) return 0;
if (*first == value)
return 0;
It index = std::lower_bound(first, last, value) - 1;
return (index == last) ? -1 : index - first;
}
template<class It, class T>
typename std::iterator_traits<It>::difference_type
upper_bound_index(It first, It last, const T& value)
typename std::iterator_traits<It>::difference_type upper_bound_index(
It first, It last, const T& value)
{
It index = std::upper_bound(first, last, value) - 1;
return (index == last) ? -1 : index - first;

16
include/openmc/secondary_correlated.h
View file

@ -23,11 +23,11 @@ class CorrelatedAngleEnergy : public AngleEnergy {
public:
//! Outgoing energy/angle at a single incoming energy
struct CorrTable {
int n_discrete; //!< Number of discrete lines
Interpolation interpolation; //!< Interpolation law
xt::xtensor<double, 1> e_out; //!< Outgoing energies [eV]
xt::xtensor<double, 1> p; //!< Probability density
xt::xtensor<double, 1> c; //!< Cumulative distribution
int n_discrete; //!< Number of discrete lines
Interpolation interpolation; //!< Interpolation law
xt::xtensor<double, 1> e_out; //!< Outgoing energies [eV]
xt::xtensor<double, 1> p; //!< Probability density
xt::xtensor<double, 1> c; //!< Cumulative distribution
vector<unique_ptr<Tabular>> angle; //!< Angle distribution
};
@ -38,8 +38,8 @@ public:
//! \param[out] E_out Outgoing energy in [eV]
//! \param[out] mu Outgoing cosine with respect to current direction
//! \param[inout] seed Pseudorandom seed pointer
void sample(double E_in, double& E_out, double& mu,
uint64_t* seed) const override;
void sample(
double E_in, double& E_out, double& mu, uint64_t* seed) const override;
// energy property
vector<double>& energy() { return energy_; }
@ -50,7 +50,7 @@ public:
const vector<CorrTable>& distribution() const { return distribution_; }
private:
int n_region_; //!< Number of interpolation regions
int n_region_; //!< Number of interpolation regions
vector<int> breakpoints_; //!< Breakpoints between regions
vector<Interpolation> interpolation_; //!< Interpolation laws
vector<double> energy_; //!< Energies [eV] at which distributions

19
include/openmc/secondary_kalbach.h
View file

@ -29,21 +29,22 @@ public:
//! \param[out] E_out Outgoing energy in [eV]
//! \param[out] mu Outgoing cosine with respect to current direction
//! \param[inout] seed Pseudorandom seed pointer
void sample(double E_in, double& E_out, double& mu,
uint64_t* seed) const override;
void sample(
double E_in, double& E_out, double& mu, uint64_t* seed) const override;
private:
//! Outgoing energy/angle at a single incoming energy
struct KMTable {
int n_discrete; //!< Number of discrete lines
Interpolation interpolation; //!< Interpolation law
int n_discrete; //!< Number of discrete lines
Interpolation interpolation; //!< Interpolation law
xt::xtensor<double, 1> e_out; //!< Outgoing energies [eV]
xt::xtensor<double, 1> p; //!< Probability density
xt::xtensor<double, 1> c; //!< Cumulative distribution
xt::xtensor<double, 1> r; //!< Pre-compound fraction
xt::xtensor<double, 1> a; //!< Parameterized function
xt::xtensor<double, 1> p; //!< Probability density
xt::xtensor<double, 1> c; //!< Cumulative distribution
xt::xtensor<double, 1> r; //!< Pre-compound fraction
xt::xtensor<double, 1> a; //!< Parameterized function
};
int n_region_; //!< Number of interpolation regions
int n_region_; //!< Number of interpolation regions
vector<int> breakpoints_; //!< Breakpoints between regions
vector<Interpolation> interpolation_; //!< Interpolation laws
vector<double> energy_; //!< Energies [eV] at which distributions

11
include/openmc/secondary_nbody.h
View file

@ -25,13 +25,14 @@ public:
//! \param[out] E_out Outgoing energy in [eV]
//! \param[out] mu Outgoing cosine with respect to current direction
//! \param[inout] seed Pseudorandom seed pointer
void sample(double E_in, double& E_out, double& mu,
uint64_t* seed) const override;
void sample(
double E_in, double& E_out, double& mu, uint64_t* seed) const override;
private:
int n_bodies_; //!< Number of particles distributed
int n_bodies_; //!< Number of particles distributed
double mass_ratio_; //!< Total mass of particles [neutron mass]
double A_; //!< Atomic weight ratio
double Q_; //!< Reaction Q-value [eV]
double A_; //!< Atomic weight ratio
double Q_; //!< Reaction Q-value [eV]
};
} // namespace openmc

39
include/openmc/secondary_thermal.h
View file

@ -9,8 +9,8 @@
#include "openmc/secondary_correlated.h"
#include "openmc/vector.h"
#include <hdf5.h>
#include "xtensor/xtensor.hpp"
#include <hdf5.h>
namespace openmc {
@ -25,14 +25,14 @@ public:
//! \param[in] xs Coherent elastic scattering cross section
explicit CoherentElasticAE(const CoherentElasticXS& xs);
//! Sample distribution for an angle and energy
//! \param[in] E_in Incoming energy in [eV]
//! \param[out] E_out Outgoing energy in [eV]
//! \param[out] mu Outgoing cosine with respect to current direction
//! \param[inout] seed Pseudorandom seed pointer
void sample(double E_in, double& E_out, double& mu,
uint64_t* seed) const override;
void sample(
double E_in, double& E_out, double& mu, uint64_t* seed) const override;
private:
const CoherentElasticXS& xs_; //!< Coherent elastic scattering cross section
};
@ -53,8 +53,9 @@ public:
//! \param[out] E_out Outgoing energy in [eV]
//! \param[out] mu Outgoing cosine with respect to current direction
//! \param[inout] seed Pseudorandom number seed pointer
void sample(double E_in, double& E_out, double& mu,
uint64_t* seed) const override;
void sample(
double E_in, double& E_out, double& mu, uint64_t* seed) const override;
private:
double debye_waller_;
};
@ -77,8 +78,9 @@ public:
//! \param[out] E_out Outgoing energy in [eV]
//! \param[out] mu Outgoing cosine with respect to current direction
//! \param[inout] seed Pseudorandom number seed pointer
void sample(double E_in, double& E_out, double& mu,
uint64_t* seed) const override;
void sample(
double E_in, double& E_out, double& mu, uint64_t* seed) const override;
private:
const vector<double>& energy_; //!< Energies at which cosines are tabulated
xt::xtensor<double, 2> mu_out_; //!< Cosines for each incident energy
@ -102,12 +104,15 @@ public:
//! \param[out] E_out Outgoing energy in [eV]
//! \param[out] mu Outgoing cosine with respect to current direction
//! \param[inout] seed Pseudorandom number seed pointer
void sample(double E_in, double& E_out, double& mu,
uint64_t* seed) const override;
void sample(
double E_in, double& E_out, double& mu, uint64_t* seed) const override;
private:
const vector<double>& energy_; //!< Incident energies
xt::xtensor<double, 2> energy_out_; //!< Outgoing energies for each incident energy
xt::xtensor<double, 3> mu_out_; //!< Outgoing cosines for each incident/outgoing energy
const vector<double>& energy_; //!< Incident energies
xt::xtensor<double, 2>
energy_out_; //!< Outgoing energies for each incident energy
xt::xtensor<double, 3>
mu_out_; //!< Outgoing cosines for each incident/outgoing energy
bool skewed_; //!< Whether outgoing energy distribution is skewed
};
@ -127,12 +132,13 @@ public:
//! \param[out] E_out Outgoing energy in [eV]
//! \param[out] mu Outgoing cosine with respect to current direction
//! \param[inout] seed Pseudorandom number seed pointer
void sample(double E_in, double& E_out, double& mu,
uint64_t* seed) const override;
void sample(
double E_in, double& E_out, double& mu, uint64_t* seed) const override;
private:
//! Secondary energy/angle distribution
struct DistEnergySab {
std::size_t n_e_out; //!< Number of outgoing energies
std::size_t n_e_out; //!< Number of outgoing energies
xt::xtensor<double, 1> e_out; //!< Outgoing energies
xt::xtensor<double, 1> e_out_pdf; //!< Probability density function
xt::xtensor<double, 1> e_out_cdf; //!< Cumulative distribution function
@ -144,7 +150,6 @@ private:
//!< each incident energy
};
} // namespace openmc
#endif // OPENMC_SECONDARY_THERMAL_H

7
include/openmc/secondary_uncorrelated.h
View file

@ -29,13 +29,14 @@ public:
//! \param[out] E_out Outgoing energy in [eV]
//! \param[out] mu Outgoing cosine with respect to current direction
//! \param[inout] seed Pseudorandom seed pointer
void sample(double E_in, double& E_out, double& mu,
uint64_t* seed) const override;
void sample(
double E_in, double& E_out, double& mu, uint64_t* seed) const override;
// Accessors
AngleDistribution& angle() { return angle_; }
private:
AngleDistribution angle_; //!< Angle distribution
AngleDistribution angle_; //!< Angle distribution
unique_ptr<EnergyDistribution> energy_; //!< Energy distribution
};

147
include/openmc/settings.h
View file

@ -22,89 +22,100 @@ namespace openmc {
namespace settings {
// Boolean flags
extern bool assume_separate; //!< assume tallies are spatially separate?
extern bool check_overlaps; //!< check overlaps in geometry?
extern bool confidence_intervals; //!< use confidence intervals for results?
extern bool create_fission_neutrons; //!< create fission neutrons (fixed source)?
extern "C" bool cmfd_run; //!< is a CMFD run?
extern bool delayed_photon_scaling; //!< Scale fission photon yield to include delayed
extern "C" bool entropy_on; //!< calculate Shannon entropy?
extern bool event_based; //!< use event-based mode (instead of history-based)
extern bool legendre_to_tabular; //!< convert Legendre distributions to tabular?
extern bool material_cell_offsets; //!< create material cells offsets?
extern "C" bool output_summary; //!< write summary.h5?
extern bool output_tallies; //!< write tallies.out?
extern bool particle_restart_run; //!< particle restart run?
extern "C" bool photon_transport; //!< photon transport turned on?
extern "C" bool reduce_tallies; //!< reduce tallies at end of batch?
extern bool res_scat_on; //!< use resonance upscattering method?
extern "C" bool restart_run; //!< restart run?
extern "C" bool run_CE; //!< run with continuous-energy data?
extern bool source_latest; //!< write latest source at each batch?
extern bool source_separate; //!< write source to separate file?
extern bool source_write; //!< write source in HDF5 files?
extern bool surf_source_write; //!< write surface source file?
extern bool surf_source_read; //!< read surface source file?
extern bool survival_biasing; //!< use survival biasing?
extern bool temperature_multipole; //!< use multipole data?
extern "C" bool trigger_on; //!< tally triggers enabled?
extern bool trigger_predict; //!< predict batches for triggers?
extern bool ufs_on; //!< uniform fission site method on?
extern bool urr_ptables_on; //!< use unresolved resonance prob. tables?
extern bool write_all_tracks; //!< write track files for every particle?
extern bool write_initial_source; //!< write out initial source file?
extern bool assume_separate; //!< assume tallies are spatially separate?
extern bool check_overlaps; //!< check overlaps in geometry?
extern bool confidence_intervals; //!< use confidence intervals for results?
extern bool
create_fission_neutrons; //!< create fission neutrons (fixed source)?
extern "C" bool cmfd_run; //!< is a CMFD run?
extern bool
delayed_photon_scaling; //!< Scale fission photon yield to include delayed
extern "C" bool entropy_on; //!< calculate Shannon entropy?
extern bool event_based; //!< use event-based mode (instead of history-based)
extern bool legendre_to_tabular; //!< convert Legendre distributions to tabular?
extern bool material_cell_offsets; //!< create material cells offsets?
extern "C" bool output_summary; //!< write summary.h5?
extern bool output_tallies; //!< write tallies.out?
extern bool particle_restart_run; //!< particle restart run?
extern "C" bool photon_transport; //!< photon transport turned on?
extern "C" bool reduce_tallies; //!< reduce tallies at end of batch?
extern bool res_scat_on; //!< use resonance upscattering method?
extern "C" bool restart_run; //!< restart run?
extern "C" bool run_CE; //!< run with continuous-energy data?
extern bool source_latest; //!< write latest source at each batch?
extern bool source_separate; //!< write source to separate file?
extern bool source_write; //!< write source in HDF5 files?
extern bool surf_source_write; //!< write surface source file?
extern bool surf_source_read; //!< read surface source file?
extern bool survival_biasing; //!< use survival biasing?
extern bool temperature_multipole; //!< use multipole data?
extern "C" bool trigger_on; //!< tally triggers enabled?
extern bool trigger_predict; //!< predict batches for triggers?
extern bool ufs_on; //!< uniform fission site method on?
extern bool urr_ptables_on; //!< use unresolved resonance prob. tables?
extern bool write_all_tracks; //!< write track files for every particle?
extern bool write_initial_source; //!< write out initial source file?
// Paths to various files
extern std::string path_cross_sections; //!< path to cross_sections.xml
extern std::string path_input; //!< directory where main .xml files resides
extern std::string path_output; //!< directory where output files are written
extern std::string path_cross_sections; //!< path to cross_sections.xml
extern std::string path_input; //!< directory where main .xml files resides
extern std::string path_output; //!< directory where output files are written
extern std::string path_particle_restart; //!< path to a particle restart file
extern std::string path_sourcepoint; //!< path to a source file
extern "C" std::string path_statepoint; //!< path to a statepoint file
extern "C" int32_t n_inactive; //!< number of inactive batches
extern "C" int32_t max_lost_particles; //!< maximum number of lost particles
extern double rel_max_lost_particles; //!< maximum number of lost particles, relative to the total number of particles
extern "C" int32_t gen_per_batch; //!< number of generations per batch
extern "C" int64_t n_particles; //!< number of particles per generation
extern "C" int32_t n_inactive; //!< number of inactive batches
extern "C" int32_t max_lost_particles; //!< maximum number of lost particles
extern double
rel_max_lost_particles; //!< maximum number of lost particles, relative to the
//!< total number of particles
extern "C" int32_t gen_per_batch; //!< number of generations per batch
extern "C" int64_t n_particles; //!< number of particles per generation
extern int64_t
max_particles_in_flight; //!< Max num. event-based particles in flight
extern int64_t max_particles_in_flight; //!< Max num. event-based particles in flight
extern ElectronTreatment electron_treatment; //!< how to treat secondary electrons
extern ElectronTreatment
electron_treatment; //!< how to treat secondary electrons
extern array<double, 4>
energy_cutoff; //!< Energy cutoff in [eV] for each particle type
extern int legendre_to_tabular_points; //!< number of points to convert Legendres
extern int max_order; //!< Maximum Legendre order for multigroup data
extern int n_log_bins; //!< number of bins for logarithmic energy grid
extern int n_batches; //!< number of (inactive+active) batches
extern int n_max_batches; //!< Maximum number of batches
extern int
legendre_to_tabular_points; //!< number of points to convert Legendres
extern int max_order; //!< Maximum Legendre order for multigroup data
extern int n_log_bins; //!< number of bins for logarithmic energy grid
extern int n_batches; //!< number of (inactive+active) batches
extern int n_max_batches; //!< Maximum number of batches
extern ResScatMethod res_scat_method; //!< resonance upscattering method
extern double res_scat_energy_min; //!< Min energy in [eV] for res. upscattering
extern double res_scat_energy_max; //!< Max energy in [eV] for res. upscattering
extern double res_scat_energy_min; //!< Min energy in [eV] for res. upscattering
extern double res_scat_energy_max; //!< Max energy in [eV] for res. upscattering
extern vector<std::string>
res_scat_nuclides; //!< Nuclides using res. upscattering treatment
extern RunMode run_mode; //!< Run mode (eigenvalue, fixed src, etc.)
extern std::unordered_set<int> sourcepoint_batch; //!< Batches when source should be written
extern std::unordered_set<int> statepoint_batch; //!< Batches when state should be written
extern std::unordered_set<int> source_write_surf_id; //!< Surface ids where sources will be written
extern int64_t max_surface_particles; //!< maximum number of particles to be banked on surfaces per process
extern TemperatureMethod temperature_method; //!< method for choosing temperatures
extern double temperature_tolerance; //!< Tolerance in [K] on choosing temperatures
extern double temperature_default; //!< Default T in [K]
res_scat_nuclides; //!< Nuclides using res. upscattering treatment
extern RunMode run_mode; //!< Run mode (eigenvalue, fixed src, etc.)
extern std::unordered_set<int>
sourcepoint_batch; //!< Batches when source should be written
extern std::unordered_set<int>
statepoint_batch; //!< Batches when state should be written
extern std::unordered_set<int>
source_write_surf_id; //!< Surface ids where sources will be written
extern int64_t max_surface_particles; //!< maximum number of particles to be
//!< banked on surfaces per process
extern TemperatureMethod
temperature_method; //!< method for choosing temperatures
extern double
temperature_tolerance; //!< Tolerance in [K] on choosing temperatures
extern double temperature_default; //!< Default T in [K]
extern array<double, 2>
temperature_range; //!< Min/max T in [K] over which to load xs
extern int trace_batch; //!< Batch to trace particle on
extern int trace_gen; //!< Generation to trace particle on
extern int64_t trace_particle; //!< Particle ID to enable trace on
temperature_range; //!< Min/max T in [K] over which to load xs
extern int trace_batch; //!< Batch to trace particle on
extern int trace_gen; //!< Generation to trace particle on
extern int64_t trace_particle; //!< Particle ID to enable trace on
extern vector<array<int, 3>>
track_identifiers; //!< Particle numbers for writing tracks
extern int trigger_batch_interval; //!< Batch interval for triggers
extern "C" int verbosity; //!< How verbose to make output
extern double weight_cutoff; //!< Weight cutoff for Russian roulette
extern double weight_survive; //!< Survival weight after Russian roulette
track_identifiers; //!< Particle numbers for writing tracks
extern int trigger_batch_interval; //!< Batch interval for triggers
extern "C" int verbosity; //!< How verbose to make output
extern double weight_cutoff; //!< Weight cutoff for Russian roulette
extern double weight_survive; //!< Survival weight after Russian roulette
} // namespace settings
//==============================================================================

35
include/openmc/shared_array.h
View file

@ -20,10 +20,10 @@ namespace openmc {
// call the thread_safe_append() function concurrently and store data to the
// object at the index returned from thread_safe_append() safely, but no other
// operations are protected.
template <typename T>
class SharedArray {
template<typename T>
class SharedArray {
public:
public:
//==========================================================================
// Constructors
@ -45,7 +45,7 @@ public:
//! Return a reference to the element at specified location i. No bounds
//! checking is performed.
T& operator[](int64_t i) {return data_[i];}
T& operator[](int64_t i) { return data_[i]; }
const T& operator[](int64_t i) const { return data_[i]; }
//! Allocate space in the container for the specified number of elements.
@ -58,7 +58,7 @@ public:
capacity_ = capacity;
}
//! Increase the size of the container by one and append value to the
//! Increase the size of the container by one and append value to the
//! array. Returns an index to the element of the array written to. Also
//! tests to enforce that the append operation does not read off the end
//! of the array. In the event that this does happen, set the size to be
@ -72,12 +72,12 @@ public:
{
// Atomically capture the index we want to write to
int64_t idx;
#pragma omp atomic capture seq_cst
#pragma omp atomic capture seq_cst
idx = size_++;
// Check that we haven't written off the end of the array
if (idx >= capacity_) {
#pragma omp atomic write seq_cst
#pragma omp atomic write seq_cst
size_ = capacity_;
return -1;
}
@ -98,32 +98,31 @@ public:
}
//! Return the number of elements in the container
int64_t size() {return size_;}
int64_t size() { return size_; }
//! Resize the container to contain a specified number of elements. This is
//! useful in cases where the container is written to in a non-thread safe manner,
//! where the internal size of the array needs to be manually updated.
//! useful in cases where the container is written to in a non-thread safe
//! manner, where the internal size of the array needs to be manually updated.
//
//! \param size The new size of the container
void resize(int64_t size) {size_ = size;}
void resize(int64_t size) { size_ = size; }
//! Return the number of elements that the container has currently allocated
//! space for.
int64_t capacity() {return capacity_;}
int64_t capacity() { return capacity_; }
//! Return pointer to the underlying array serving as element storage.
T* data() {return data_.get();}
const T* data() const {return data_.get();}
T* data() { return data_.get(); }
const T* data() const { return data_.get(); }
private:
private:
//==========================================================================
// Data members
unique_ptr<T[]> data_; //!< An RAII handle to the elements
int64_t size_ {0}; //!< The current number of elements
int64_t size_ {0}; //!< The current number of elements
int64_t capacity_ {0}; //!< The total space allocated for elements
};
};
} // namespace openmc

32
include/openmc/simulation.h
View file

@ -22,22 +22,24 @@ constexpr int STATUS_EXIT_ON_TRIGGER {2};
namespace simulation {
extern "C" int current_batch; //!< current batch
extern "C" int current_gen; //!< current fission generation
extern "C" bool initialized; //!< has simulation been initialized?
extern "C" double keff; //!< average k over batches
extern "C" double keff_std; //!< standard deviation of average k
extern "C" double k_col_abs; //!< sum over batches of k_collision * k_absorption
extern "C" double k_col_tra; //!< sum over batches of k_collision * k_tracklength
extern "C" double k_abs_tra; //!< sum over batches of k_absorption * k_tracklength
extern double log_spacing; //!< lethargy spacing for energy grid searches
extern "C" int n_lost_particles; //!< cumulative number of lost particles
extern "C" int current_batch; //!< current batch
extern "C" int current_gen; //!< current fission generation
extern "C" bool initialized; //!< has simulation been initialized?
extern "C" double keff; //!< average k over batches
extern "C" double keff_std; //!< standard deviation of average k
extern "C" double k_col_abs; //!< sum over batches of k_collision * k_absorption
extern "C" double
k_col_tra; //!< sum over batches of k_collision * k_tracklength
extern "C" double
k_abs_tra; //!< sum over batches of k_absorption * k_tracklength
extern double log_spacing; //!< lethargy spacing for energy grid searches
extern "C" int n_lost_particles; //!< cumulative number of lost particles
extern "C" bool need_depletion_rx; //!< need to calculate depletion rx?
extern "C" int restart_batch; //!< batch at which a restart job resumed
extern "C" bool satisfy_triggers; //!< have tally triggers been satisfied?
extern "C" int total_gen; //!< total number of generations simulated
extern double total_weight; //!< Total source weight in a batch
extern int64_t work_per_rank; //!< number of particles per MPI rank
extern "C" int restart_batch; //!< batch at which a restart job resumed
extern "C" bool satisfy_triggers; //!< have tally triggers been satisfied?
extern "C" int total_gen; //!< total number of generations simulated
extern double total_weight; //!< Total source weight in a batch
extern int64_t work_per_rank; //!< number of particles per MPI rank
extern const RegularMesh* entropy_mesh;
extern const RegularMesh* ufs_mesh;

9
include/openmc/source.h
View file

@ -67,10 +67,10 @@ public:
private:
ParticleType particle_ {ParticleType::neutron}; //!< Type of particle emitted
double strength_ {1.0}; //!< Source strength
UPtrSpace space_; //!< Spatial distribution
UPtrAngle angle_; //!< Angular distribution
UPtrDist energy_; //!< Energy distribution
double strength_ {1.0}; //!< Source strength
UPtrSpace space_; //!< Spatial distribution
UPtrAngle angle_; //!< Angular distribution
UPtrDist energy_; //!< Energy distribution
};
//==============================================================================
@ -106,6 +106,7 @@ public:
}
double strength() const override { return custom_source_->strength(); }
private:
void* shared_library_; //!< library from dlopen
unique_ptr<Source> custom_source_;

2
include/openmc/summary.h
View file

@ -11,6 +11,6 @@ void write_nuclides(hid_t file);
void write_geometry(hid_t file);
void write_materials(hid_t file);
}
} // namespace openmc
#endif // OPENMC_SUMMARY_H

81
include/openmc/surface.h
View file

@ -1,7 +1,7 @@
#ifndef OPENMC_SURFACE_H
#define OPENMC_SURFACE_H
#include <limits> // For numeric_limits
#include <limits> // For numeric_limits
#include <string>
#include <unordered_map>
@ -24,16 +24,15 @@ namespace openmc {
class Surface;
namespace model {
extern std::unordered_map<int, int> surface_map;
extern vector<unique_ptr<Surface>> surfaces;
extern std::unordered_map<int, int> surface_map;
extern vector<unique_ptr<Surface>> surfaces;
} // namespace model
//==============================================================================
//! Coordinates for an axis-aligned cuboid that bounds a geometric object.
//==============================================================================
struct BoundingBox
{
struct BoundingBox {
double xmin = -INFTY;
double xmax = INFTY;
double ymin = -INFTY;
@ -41,19 +40,21 @@ struct BoundingBox
double zmin = -INFTY;
double zmax = INFTY;
inline BoundingBox operator &(const BoundingBox& other) {
inline BoundingBox operator&(const BoundingBox& other)
{
BoundingBox result = *this;
return result &= other;
}
inline BoundingBox operator |(const BoundingBox& other) {
inline BoundingBox operator|(const BoundingBox& other)
{
BoundingBox result = *this;
return result |= other;
}
// intersect operator
inline BoundingBox& operator &=(const BoundingBox& other) {
inline BoundingBox& operator&=(const BoundingBox& other)
{
xmin = std::max(xmin, other.xmin);
xmax = std::min(xmax, other.xmax);
ymin = std::max(ymin, other.ymin);
@ -64,7 +65,8 @@ struct BoundingBox
}
// union operator
inline BoundingBox& operator |=(const BoundingBox& other) {
inline BoundingBox& operator|=(const BoundingBox& other)
{
xmin = std::min(xmin, other.xmin);
xmax = std::max(xmax, other.xmax);
ymin = std::min(ymin, other.ymin);
@ -73,22 +75,19 @@ struct BoundingBox
zmax = std::max(zmax, other.zmax);
return *this;
}
};
//==============================================================================
//! A geometry primitive used to define regions of 3D space.
//==============================================================================
class Surface
{
class Surface {
public:
int id_; //!< Unique ID
std::string name_; //!< User-defined name
int id_; //!< Unique ID
std::string name_; //!< User-defined name
std::shared_ptr<BoundaryCondition> bc_ {nullptr}; //!< Boundary condition
GeometryType geom_type_; //!< Geometry type indicator (CSG or DAGMC)
bool surf_source_ {false}; //!< Activate source banking for the surface?
GeometryType geom_type_; //!< Geometry type indicator (CSG or DAGMC)
bool surf_source_ {false}; //!< Activate source banking for the surface?
explicit Surface(pugi::xml_node surf_node);
Surface();
@ -110,8 +109,8 @@ public:
//! \return Outgoing direction of the ray
virtual Direction reflect(Position r, Direction u, Particle* p) const;
virtual Direction diffuse_reflect(Position r, Direction u,
uint64_t* seed) const;
virtual Direction diffuse_reflect(
Position r, Direction u, uint64_t* seed) const;
//! Evaluate the equation describing the surface.
//!
@ -143,8 +142,7 @@ protected:
virtual void to_hdf5_inner(hid_t group_id) const = 0;
};
class CSGSurface : public Surface
{
class CSGSurface : public Surface {
public:
explicit CSGSurface(pugi::xml_node surf_node);
CSGSurface();
@ -159,8 +157,7 @@ protected:
//! The plane is described by the equation \f$x - x_0 = 0\f$
//==============================================================================
class SurfaceXPlane : public CSGSurface
{
class SurfaceXPlane : public CSGSurface {
public:
explicit SurfaceXPlane(pugi::xml_node surf_node);
double evaluate(Position r) const;
@ -178,8 +175,7 @@ public:
//! The plane is described by the equation \f$y - y_0 = 0\f$
//==============================================================================
class SurfaceYPlane : public CSGSurface
{
class SurfaceYPlane : public CSGSurface {
public:
explicit SurfaceYPlane(pugi::xml_node surf_node);
double evaluate(Position r) const;
@ -197,8 +193,7 @@ public:
//! The plane is described by the equation \f$z - z_0 = 0\f$
//==============================================================================
class SurfaceZPlane : public CSGSurface
{
class SurfaceZPlane : public CSGSurface {
public:
explicit SurfaceZPlane(pugi::xml_node surf_node);
double evaluate(Position r) const;
@ -216,8 +211,7 @@ public:
//! The plane is described by the equation \f$A x + B y + C z - D = 0\f$
//==============================================================================
class SurfacePlane : public CSGSurface
{
class SurfacePlane : public CSGSurface {
public:
explicit SurfacePlane(pugi::xml_node surf_node);
double evaluate(Position r) const;
@ -235,8 +229,7 @@ public:
//! \f$(y - y_0)^2 + (z - z_0)^2 - R^2 = 0\f$
//==============================================================================
class SurfaceXCylinder : public CSGSurface
{
class SurfaceXCylinder : public CSGSurface {
public:
explicit SurfaceXCylinder(pugi::xml_node surf_node);
double evaluate(Position r) const;
@ -255,8 +248,7 @@ public:
//! \f$(x - x_0)^2 + (z - z_0)^2 - R^2 = 0\f$
//==============================================================================
class SurfaceYCylinder : public CSGSurface
{
class SurfaceYCylinder : public CSGSurface {
public:
explicit SurfaceYCylinder(pugi::xml_node surf_node);
double evaluate(Position r) const;
@ -275,8 +267,7 @@ public:
//! \f$(x - x_0)^2 + (y - y_0)^2 - R^2 = 0\f$
//==============================================================================
class SurfaceZCylinder : public CSGSurface
{
class SurfaceZCylinder : public CSGSurface {
public:
explicit SurfaceZCylinder(pugi::xml_node surf_node);
double evaluate(Position r) const;
@ -295,8 +286,7 @@ public:
//! \f$(x - x_0)^2 + (y - y_0)^2 + (z - z_0)^2 - R^2 = 0\f$
//==============================================================================
class SurfaceSphere : public CSGSurface
{
class SurfaceSphere : public CSGSurface {
public:
explicit SurfaceSphere(pugi::xml_node surf_node);
double evaluate(Position r) const;
@ -315,8 +305,7 @@ public:
//! \f$(y - y_0)^2 + (z - z_0)^2 - R^2 (x - x_0)^2 = 0\f$
//==============================================================================
class SurfaceXCone : public CSGSurface
{
class SurfaceXCone : public CSGSurface {
public:
explicit SurfaceXCone(pugi::xml_node surf_node);
double evaluate(Position r) const;
@ -334,8 +323,7 @@ public:
//! \f$(x - x_0)^2 + (z - z_0)^2 - R^2 (y - y_0)^2 = 0\f$
//==============================================================================
class SurfaceYCone : public CSGSurface
{
class SurfaceYCone : public CSGSurface {
public:
explicit SurfaceYCone(pugi::xml_node surf_node);
double evaluate(Position r) const;
@ -353,8 +341,7 @@ public:
//! \f$(x - x_0)^2 + (y - y_0)^2 - R^2 (z - z_0)^2 = 0\f$
//==============================================================================
class SurfaceZCone : public CSGSurface
{
class SurfaceZCone : public CSGSurface {
public:
explicit SurfaceZCone(pugi::xml_node surf_node);
double evaluate(Position r) const;
@ -368,11 +355,11 @@ public:
//==============================================================================
//! A general surface described by a quadratic equation.
//
//! \f$A x^2 + B y^2 + C z^2 + D x y + E y z + F x z + G x + H y + J z + K = 0\f$
//! \f$A x^2 + B y^2 + C z^2 + D x y + E y z + F x z + G x + H y + J z + K =
//! 0\f$
//==============================================================================
class SurfaceQuadric : public CSGSurface
{
class SurfaceQuadric : public CSGSurface {
public:
explicit SurfaceQuadric(pugi::xml_node surf_node);
double evaluate(Position r) const;

17
include/openmc/tallies/derivative.h
View file

@ -15,18 +15,14 @@
namespace openmc {
// Different independent variables
enum class DerivativeVariable {
DENSITY,
NUCLIDE_DENSITY,
TEMPERATURE
};
enum class DerivativeVariable { DENSITY, NUCLIDE_DENSITY, TEMPERATURE };
struct TallyDerivative {
DerivativeVariable variable; //!< Independent variable (like temperature)
int id; //!< User-defined identifier
int diff_material; //!< Material this derivative is applied to
int diff_nuclide; //!< Nuclide this material is applied to
DerivativeVariable variable; //!< Independent variable (like temperature)
int id; //!< User-defined identifier
int diff_material; //!< Material this derivative is applied to
int diff_nuclide; //!< Nuclide this material is applied to
TallyDerivative() {}
explicit TallyDerivative(pugi::xml_node node);
@ -41,8 +37,7 @@ void read_tally_derivatives(pugi::xml_node node);
//! Scale the given score by its logarithmic derivative
void
apply_derivative_to_score(const Particle& p, int i_tally, int i_nuclide,
void apply_derivative_to_score(const Particle& p, int i_tally, int i_nuclide,
double atom_density, int score_bin, double& score);
//! Adjust diff tally flux derivatives for a particle scattering event.

19
include/openmc/tallies/filter.h
View file

@ -21,8 +21,7 @@ namespace openmc {
//! Modifies tally score events.
//==============================================================================
class Filter
{
class Filter {
public:
//----------------------------------------------------------------------------
// Constructors, destructors, factory functions
@ -67,12 +66,11 @@ public:
//! \param[in] estimator Tally estimator being used
//! \param[out] match will contain the matching bins and corresponding
//! weights; note that there may be zero matching bins
virtual void
get_all_bins(const Particle& p, TallyEstimator estimator, FilterMatch& match) const = 0;
virtual void get_all_bins(
const Particle& p, TallyEstimator estimator, FilterMatch& match) const = 0;
//! Writes data describing this filter to an HDF5 statepoint group.
virtual void
to_statepoint(hid_t filter_group) const
virtual void to_statepoint(hid_t filter_group) const
{
write_dataset(filter_group, "type", type());
write_dataset(filter_group, "n_bins", n_bins_);
@ -107,6 +105,7 @@ public:
protected:
int n_bins_;
private:
int32_t id_ {C_NONE};
gsl::index index_;
@ -117,10 +116,10 @@ private:
//==============================================================================
namespace model {
extern "C" int32_t n_filters;
extern std::unordered_map<int, int> filter_map;
extern vector<unique_ptr<Filter>> tally_filters;
}
extern "C" int32_t n_filters;
extern std::unordered_map<int, int> filter_map;
extern vector<unique_ptr<Filter>> tally_filters;
} // namespace model
//==============================================================================
// Non-member functions

9
include/openmc/tallies/filter_azimuthal.h
View file

@ -14,8 +14,7 @@ namespace openmc {
//! Bins the incident neutron azimuthal angle (relative to the global xy-plane).
//==============================================================================
class AzimuthalFilter : public Filter
{
class AzimuthalFilter : public Filter {
public:
//----------------------------------------------------------------------------
// Constructors, destructors
@ -25,12 +24,12 @@ public:
//----------------------------------------------------------------------------
// Methods
std::string type() const override {return "azimuthal";}
std::string type() const override { return "azimuthal"; }
void from_xml(pugi::xml_node node) override;
void get_all_bins(const Particle& p, TallyEstimator estimator, FilterMatch& match)
const override;
void get_all_bins(const Particle& p, TallyEstimator estimator,
FilterMatch& match) const override;
void to_statepoint(hid_t filter_group) const override;

9
include/openmc/tallies/filter_cell.h
View file

@ -15,8 +15,7 @@ namespace openmc {
//! Specifies which geometric cells tally events reside in.
//==============================================================================
class CellFilter : public Filter
{
class CellFilter : public Filter {
public:
//----------------------------------------------------------------------------
// Constructors, destructors
@ -26,12 +25,12 @@ public:
//----------------------------------------------------------------------------
// Methods
std::string type() const override {return "cell";}
std::string type() const override { return "cell"; }
void from_xml(pugi::xml_node node) override;
void get_all_bins(const Particle& p, TallyEstimator estimator, FilterMatch& match)
const override;
void get_all_bins(const Particle& p, TallyEstimator estimator,
FilterMatch& match) const override;
void to_statepoint(hid_t filter_group) const override;

6
include/openmc/tallies/filter_cell_instance.h
View file

@ -28,12 +28,12 @@ public:
//----------------------------------------------------------------------------
// Methods
std::string type() const override {return "cellinstance";}
std::string type() const override { return "cellinstance"; }
void from_xml(pugi::xml_node node) override;
void get_all_bins(const Particle& p, TallyEstimator estimator, FilterMatch& match)
const override;
void get_all_bins(const Particle& p, TallyEstimator estimator,
FilterMatch& match) const override;
void to_statepoint(hid_t filter_group) const override;

9
include/openmc/tallies/filter_cellborn.h
View file

@ -11,16 +11,15 @@ namespace openmc {
//! Specifies which cell the particle was born in.
//==============================================================================
class CellbornFilter : public CellFilter
{
class CellbornFilter : public CellFilter {
public:
//----------------------------------------------------------------------------
// Methods
std::string type() const override {return "cellborn";}
std::string type() const override { return "cellborn"; }
void get_all_bins(const Particle& p, TallyEstimator estimator, FilterMatch& match)
const override;
void get_all_bins(const Particle& p, TallyEstimator estimator,
FilterMatch& match) const override;
std::string text_label(int bin) const override;
};

9
include/openmc/tallies/filter_cellfrom.h
View file

@ -11,16 +11,15 @@ namespace openmc {
//! Specifies which geometric cells particles exit when crossing a surface.
//==============================================================================
class CellFromFilter : public CellFilter
{
class CellFromFilter : public CellFilter {
public:
//----------------------------------------------------------------------------
// Methods
std::string type() const override {return "cellfrom";}
std::string type() const override { return "cellfrom"; }
void get_all_bins(const Particle& p, TallyEstimator estimator, FilterMatch& match)
const override;
void get_all_bins(const Particle& p, TallyEstimator estimator,
FilterMatch& match) const override;
std::string text_label(int bin) const override;
};

7
include/openmc/tallies/filter_collision.h
View file

@ -1,8 +1,8 @@
#ifndef OPENMC_TALLIES_FILTER_COLLISIONS_H
#define OPENMC_TALLIES_FILTER_COLLISIONS_H
#include <unordered_map>
#include <gsl/gsl>
#include <unordered_map>
#include "openmc/tallies/filter.h"
#include "openmc/vector.h"
@ -27,7 +27,7 @@ public:
void from_xml(pugi::xml_node node) override;
void get_all_bins(const Particle& p, TallyEstimator estimator,
void get_all_bins(const Particle& p, TallyEstimator estimator,
FilterMatch& match) const override;
void to_statepoint(hid_t filter_group) const override;
@ -46,8 +46,7 @@ protected:
vector<int> bins_;
std::unordered_map<int,int> map_;
std::unordered_map<int, int> map_;
};
} // namespace openmc

9
include/openmc/tallies/filter_delayedgroup.h
View file

@ -15,8 +15,7 @@ namespace openmc {
//! iterated over in the scoring subroutines.
//==============================================================================
class DelayedGroupFilter : public Filter
{
class DelayedGroupFilter : public Filter {
public:
//----------------------------------------------------------------------------
// Constructors, destructors
@ -26,12 +25,12 @@ public:
//----------------------------------------------------------------------------
// Methods
std::string type() const override {return "delayedgroup";}
std::string type() const override { return "delayedgroup"; }
void from_xml(pugi::xml_node node) override;
void get_all_bins(const Particle& p, TallyEstimator estimator, FilterMatch& match)
const override;
void get_all_bins(const Particle& p, TallyEstimator estimator,
FilterMatch& match) const override;
void to_statepoint(hid_t filter_group) const override;

9
include/openmc/tallies/filter_distribcell.h
View file

@ -11,8 +11,7 @@ namespace openmc {
//! Specifies which distributed geometric cells tally events reside in.
//==============================================================================
class DistribcellFilter : public Filter
{
class DistribcellFilter : public Filter {
public:
//----------------------------------------------------------------------------
// Constructors, destructors
@ -22,12 +21,12 @@ public:
//----------------------------------------------------------------------------
// Methods
std::string type() const override {return "distribcell";}
std::string type() const override { return "distribcell"; }
void from_xml(pugi::xml_node node) override;
void get_all_bins(const Particle& p, TallyEstimator estimator, FilterMatch& match)
const override;
void get_all_bins(const Particle& p, TallyEstimator estimator,
FilterMatch& match) const override;
void to_statepoint(hid_t filter_group) const override;

18
include/openmc/tallies/filter_energy.h
View file

@ -12,8 +12,7 @@ namespace openmc {
//! Bins the incident neutron energy.
//==============================================================================
class EnergyFilter : public Filter
{
class EnergyFilter : public Filter {
public:
//----------------------------------------------------------------------------
// Constructors, destructors
@ -23,12 +22,12 @@ public:
//----------------------------------------------------------------------------
// Methods
std::string type() const override {return "energy";}
std::string type() const override { return "energy"; }
void from_xml(pugi::xml_node node) override;
void get_all_bins(const Particle& p, TallyEstimator estimator, FilterMatch& match)
const override;
void get_all_bins(const Particle& p, TallyEstimator estimator,
FilterMatch& match) const override;
void to_statepoint(hid_t filter_group) const override;
@ -59,16 +58,15 @@ protected:
//! tallies manually iterate over the filter bins.
//==============================================================================
class EnergyoutFilter : public EnergyFilter
{
class EnergyoutFilter : public EnergyFilter {
public:
//----------------------------------------------------------------------------
// Methods
std::string type() const override {return "energyout";}
std::string type() const override { return "energyout"; }
void get_all_bins(const Particle& p, TallyEstimator estimator, FilterMatch& match)
const override;
void get_all_bins(const Particle& p, TallyEstimator estimator,
FilterMatch& match) const override;
std::string text_label(int bin) const override;
};

15
include/openmc/tallies/filter_energyfunc.h
View file

@ -11,29 +11,24 @@ namespace openmc {
//! described by a piecewise linear-linear interpolation.
//==============================================================================
class EnergyFunctionFilter : public Filter
{
class EnergyFunctionFilter : public Filter {
public:
//----------------------------------------------------------------------------
// Constructors, destructors
EnergyFunctionFilter()
: Filter {}
{
n_bins_ = 1;
}
EnergyFunctionFilter() : Filter {} { n_bins_ = 1; }
~EnergyFunctionFilter() = default;
//----------------------------------------------------------------------------
// Methods
std::string type() const override {return "energyfunction";}
std::string type() const override { return "energyfunction"; }
void from_xml(pugi::xml_node node) override;
void get_all_bins(const Particle& p, TallyEstimator estimator, FilterMatch& match)
const override;
void get_all_bins(const Particle& p, TallyEstimator estimator,
FilterMatch& match) const override;
void to_statepoint(hid_t filter_group) const override;

9
include/openmc/tallies/filter_legendre.h
View file

@ -11,8 +11,7 @@ namespace openmc {
//! Gives Legendre moments of the change in scattering angle
//==============================================================================
class LegendreFilter : public Filter
{
class LegendreFilter : public Filter {
public:
//----------------------------------------------------------------------------
// Constructors, destructors
@ -22,12 +21,12 @@ public:
//----------------------------------------------------------------------------
// Methods
std::string type() const override {return "legendre";}
std::string type() const override { return "legendre"; }
void from_xml(pugi::xml_node node) override;
void get_all_bins(const Particle& p, TallyEstimator estimator, FilterMatch& match)
const override;
void get_all_bins(const Particle& p, TallyEstimator estimator,
FilterMatch& match) const override;
void to_statepoint(hid_t filter_group) const override;

4
include/openmc/tallies/filter_match.h
View file

@ -1,15 +1,13 @@
#ifndef OPENMC_TALLIES_FILTERMATCH_H
#define OPENMC_TALLIES_FILTERMATCH_H
namespace openmc {
//==============================================================================
//! Stores bins and weights for filtered tally events.
//==============================================================================
class FilterMatch
{
class FilterMatch {
public:
vector<int> bins_;
vector<double> weights_;

9
include/openmc/tallies/filter_material.h
View file

@ -15,8 +15,7 @@ namespace openmc {
//! Specifies which material tally events reside in.
//==============================================================================
class MaterialFilter : public Filter
{
class MaterialFilter : public Filter {
public:
//----------------------------------------------------------------------------
// Constructors, destructors
@ -26,12 +25,12 @@ public:
//----------------------------------------------------------------------------
// Methods
std::string type() const override {return "material";}
std::string type() const override { return "material"; }
void from_xml(pugi::xml_node node) override;
void get_all_bins(const Particle& p, TallyEstimator estimator, FilterMatch& match)
const override;
void get_all_bins(const Particle& p, TallyEstimator estimator,
FilterMatch& match) const override;
void to_statepoint(hid_t filter_group) const override;

18
include/openmc/tallies/filter_mesh.h
View file

@ -3,8 +3,8 @@
#include <cstdint>
#include "openmc/tallies/filter.h"
#include "openmc/position.h"
#include "openmc/tallies/filter.h"
namespace openmc {
@ -14,8 +14,7 @@ namespace openmc {
//! correspond to the fraction of the track length that lies in that bin.
//==============================================================================
class MeshFilter : public Filter
{
class MeshFilter : public Filter {
public:
//----------------------------------------------------------------------------
// Constructors, destructors
@ -25,12 +24,12 @@ public:
//----------------------------------------------------------------------------
// Methods
std::string type() const override {return "mesh";}
std::string type() const override { return "mesh"; }
void from_xml(pugi::xml_node node) override;
void get_all_bins(const Particle& p, TallyEstimator estimator, FilterMatch& match)
const override;
void get_all_bins(const Particle& p, TallyEstimator estimator,
FilterMatch& match) const override;
void to_statepoint(hid_t filter_group) const override;
@ -39,7 +38,7 @@ public:
//----------------------------------------------------------------------------
// Accessors
virtual int32_t mesh() const {return mesh_;}
virtual int32_t mesh() const { return mesh_; }
virtual void set_mesh(int32_t mesh);
@ -47,10 +46,9 @@ public:
virtual void set_translation(const double translation[3]);
virtual const Position& translation() const {return translation_;}
virtual bool translated() const {return translated_;}
virtual const Position& translation() const { return translation_; }
virtual bool translated() const { return translated_; }
protected:
//----------------------------------------------------------------------------

29
include/openmc/tallies/filter_meshsurface.h
View file

@ -5,16 +5,15 @@
namespace openmc {
class MeshSurfaceFilter : public MeshFilter
{
class MeshSurfaceFilter : public MeshFilter {
public:
//----------------------------------------------------------------------------
// Methods
std::string type() const override {return "meshsurface";}
std::string type() const override { return "meshsurface"; }
void get_all_bins(const Particle& p, TallyEstimator estimator, FilterMatch& match)
const override;
void get_all_bins(const Particle& p, TallyEstimator estimator,
FilterMatch& match) const override;
std::string text_label(int bin) const override;
@ -24,18 +23,18 @@ public:
void set_mesh(int32_t mesh) override;
enum class MeshDir {
OUT_LEFT, // x min
IN_LEFT, // x min
OUT_LEFT, // x min
IN_LEFT, // x min
OUT_RIGHT, // x max
IN_RIGHT, // x max
OUT_BACK, // y min
IN_BACK, // y min
IN_RIGHT, // x max
OUT_BACK, // y min
IN_BACK, // y min
OUT_FRONT, // y max
IN_FRONT, // y max
OUT_BOTTOM, // z min
IN_BOTTOM, // z min
OUT_TOP, // z max
IN_TOP // z max
IN_FRONT, // y max
OUT_BOTTOM, // z min
IN_BOTTOM, // z min
OUT_TOP, // z max
IN_TOP // z max
};
};

9
include/openmc/tallies/filter_mu.h
View file

@ -13,8 +13,7 @@ namespace openmc {
//! reactions.
//==============================================================================
class MuFilter : public Filter
{
class MuFilter : public Filter {
public:
//----------------------------------------------------------------------------
// Constructors, destructors
@ -24,12 +23,12 @@ public:
//----------------------------------------------------------------------------
// Methods
std::string type() const override {return "mu";}
std::string type() const override { return "mu"; }
void from_xml(pugi::xml_node node) override;
void get_all_bins(const Particle& p, TallyEstimator estimator, FilterMatch& match)
const override;
void get_all_bins(const Particle& p, TallyEstimator estimator,
FilterMatch& match) const override;
void to_statepoint(hid_t filter_group) const override;

9
include/openmc/tallies/filter_particle.h
View file

@ -11,8 +11,7 @@ namespace openmc {
//! Bins by type of particle (e.g. neutron, photon).
//==============================================================================
class ParticleFilter : public Filter
{
class ParticleFilter : public Filter {
public:
//----------------------------------------------------------------------------
// Constructors, destructors
@ -22,12 +21,12 @@ public:
//----------------------------------------------------------------------------
// Methods
std::string type() const override {return "particle";}
std::string type() const override { return "particle"; }
void from_xml(pugi::xml_node node) override;
void get_all_bins(const Particle& p, TallyEstimator estimator, FilterMatch& match)
const override;
void get_all_bins(const Particle& p, TallyEstimator estimator,
FilterMatch& match) const override;
void to_statepoint(hid_t filter_group) const override;

9
include/openmc/tallies/filter_polar.h
View file

@ -14,8 +14,7 @@ namespace openmc {
//! Bins the incident neutron polar angle (relative to the global z-axis).
//==============================================================================
class PolarFilter : public Filter
{
class PolarFilter : public Filter {
public:
//----------------------------------------------------------------------------
// Constructors, destructors
@ -25,12 +24,12 @@ public:
//----------------------------------------------------------------------------
// Methods
std::string type() const override {return "polar";}
std::string type() const override { return "polar"; }
void from_xml(pugi::xml_node node) override;
void get_all_bins(const Particle& p, TallyEstimator estimator, FilterMatch& match)
const override;
void get_all_bins(const Particle& p, TallyEstimator estimator,
FilterMatch& match) const override;
void to_statepoint(hid_t filter_group) const override;

13
include/openmc/tallies/filter_sph_harm.h
View file

@ -9,16 +9,13 @@
namespace openmc {
enum class SphericalHarmonicsCosine {
scatter, particle
};
enum class SphericalHarmonicsCosine { scatter, particle };
//==============================================================================
//! Gives spherical harmonics expansion moments of a tally score
//==============================================================================
class SphericalHarmonicsFilter : public Filter
{
class SphericalHarmonicsFilter : public Filter {
public:
//----------------------------------------------------------------------------
// Constructors, destructors
@ -28,12 +25,12 @@ public:
//----------------------------------------------------------------------------
// Methods
std::string type() const override {return "sphericalharmonics";}
std::string type() const override { return "sphericalharmonics"; }
void from_xml(pugi::xml_node node) override;
void get_all_bins(const Particle& p, TallyEstimator estimator, FilterMatch& match)
const override;
void get_all_bins(const Particle& p, TallyEstimator estimator,
FilterMatch& match) const override;
void to_statepoint(hid_t filter_group) const override;

13
include/openmc/tallies/filter_sptl_legendre.h
View file

@ -7,16 +7,13 @@
namespace openmc {
enum class LegendreAxis {
x, y, z
};
enum class LegendreAxis { x, y, z };
//==============================================================================
//! Gives Legendre moments of the particle's normalized position along an axis
//==============================================================================
class SpatialLegendreFilter : public Filter
{
class SpatialLegendreFilter : public Filter {
public:
//----------------------------------------------------------------------------
// Constructors, destructors
@ -26,12 +23,12 @@ public:
//----------------------------------------------------------------------------
// Methods
std::string type() const override {return "spatiallegendre";}
std::string type() const override { return "spatiallegendre"; }
void from_xml(pugi::xml_node node) override;
void get_all_bins(const Particle& p, TallyEstimator estimator, FilterMatch& match)
const override;
void get_all_bins(const Particle& p, TallyEstimator estimator,
FilterMatch& match) const override;
void to_statepoint(hid_t filter_group) const override;

9
include/openmc/tallies/filter_surface.h
View file

@ -15,8 +15,7 @@ namespace openmc {
//! Specifies which surface particles are crossing
//==============================================================================
class SurfaceFilter : public Filter
{
class SurfaceFilter : public Filter {
public:
//----------------------------------------------------------------------------
// Constructors, destructors
@ -26,12 +25,12 @@ public:
//----------------------------------------------------------------------------
// Methods
std::string type() const override {return "surface";}
std::string type() const override { return "surface"; }
void from_xml(pugi::xml_node node) override;
void get_all_bins(const Particle& p, TallyEstimator estimator, FilterMatch& match)
const override;
void get_all_bins(const Particle& p, TallyEstimator estimator,
FilterMatch& match) const override;
void to_statepoint(hid_t filter_group) const override;

9
include/openmc/tallies/filter_universe.h
View file

@ -15,8 +15,7 @@ namespace openmc {
//! Specifies which geometric universes tally events reside in.
//==============================================================================
class UniverseFilter : public Filter
{
class UniverseFilter : public Filter {
public:
//----------------------------------------------------------------------------
// Constructors, destructors
@ -26,12 +25,12 @@ public:
//----------------------------------------------------------------------------
// Methods
std::string type() const override {return "universe";}
std::string type() const override { return "universe"; }
void from_xml(pugi::xml_node node) override;
void get_all_bins(const Particle& p, TallyEstimator estimator, FilterMatch& match)
const override;
void get_all_bins(const Particle& p, TallyEstimator estimator,
FilterMatch& match) const override;
void to_statepoint(hid_t filter_group) const override;

18
include/openmc/tallies/filter_zernike.h
View file

@ -11,8 +11,7 @@ namespace openmc {
//! Gives Zernike polynomial moments of a particle's position
//==============================================================================
class ZernikeFilter : public Filter
{
class ZernikeFilter : public Filter {
public:
//----------------------------------------------------------------------------
// Constructors, destructors
@ -22,12 +21,12 @@ public:
//----------------------------------------------------------------------------
// Methods
std::string type() const override {return "zernike";}
std::string type() const override { return "zernike"; }
void from_xml(pugi::xml_node node) override;
void get_all_bins(const Particle& p, TallyEstimator estimator, FilterMatch& match)
const override;
void get_all_bins(const Particle& p, TallyEstimator estimator,
FilterMatch& match) const override;
void to_statepoint(hid_t filter_group) const override;
@ -68,16 +67,15 @@ protected:
//! Gives even order radial Zernike polynomial moments of a particle's position
//==============================================================================
class ZernikeRadialFilter : public ZernikeFilter
{
class ZernikeRadialFilter : public ZernikeFilter {
public:
//----------------------------------------------------------------------------
// Methods
std::string type() const override {return "zernikeradial";}
std::string type() const override { return "zernikeradial"; }
void get_all_bins(const Particle& p, TallyEstimator estimator, FilterMatch& match)
const override;
void get_all_bins(const Particle& p, TallyEstimator estimator,
FilterMatch& match) const override;
std::string text_label(int bin) const override;

44
include/openmc/tallies/tally.h
View file

@ -7,10 +7,10 @@
#include "openmc/tallies/trigger.h"
#include "openmc/vector.h"
#include <gsl/gsl>
#include "pugixml.hpp"
#include "xtensor/xfixed.hpp"
#include "xtensor/xtensor.hpp"
#include <gsl/gsl>
#include <string>
#include <unordered_map>
@ -49,18 +49,18 @@ public:
const vector<int32_t>& filters() const { return filters_; }
int32_t filters(int i) const {return filters_[i];}
int32_t filters(int i) const { return filters_[i]; }
void set_filters(gsl::span<Filter*> filters);
//! Given already-set filters, set the stride lengths
void set_strides();
int32_t strides(int i) const {return strides_[i];}
int32_t strides(int i) const { return strides_[i]; }
int32_t n_filter_bins() const {return n_filter_bins_;}
int32_t n_filter_bins() const { return n_filter_bins_; }
bool writable() const { return writable_;}
bool writable() const { return writable_; }
//----------------------------------------------------------------------------
// Other methods.
@ -148,23 +148,24 @@ private:
//==============================================================================
namespace model {
extern std::unordered_map<int, int> tally_map;
extern vector<unique_ptr<Tally>> tallies;
extern vector<int> active_tallies;
extern vector<int> active_analog_tallies;
extern vector<int> active_tracklength_tallies;
extern vector<int> active_collision_tallies;
extern vector<int> active_meshsurf_tallies;
extern vector<int> active_surface_tallies;
}
extern std::unordered_map<int, int> tally_map;
extern vector<unique_ptr<Tally>> tallies;
extern vector<int> active_tallies;
extern vector<int> active_analog_tallies;
extern vector<int> active_tracklength_tallies;
extern vector<int> active_collision_tallies;
extern vector<int> active_meshsurf_tallies;
extern vector<int> active_surface_tallies;
} // namespace model
namespace simulation {
//! Global tallies (such as k-effective estimators)
extern xt::xtensor_fixed<double, xt::xshape<N_GLOBAL_TALLIES, 3>> global_tallies;
//! Global tallies (such as k-effective estimators)
extern xt::xtensor_fixed<double, xt::xshape<N_GLOBAL_TALLIES, 3>>
global_tallies;
//! Number of realizations for global tallies
extern "C" int32_t n_realizations;
}
//! Number of realizations for global tallies
extern "C" int32_t n_realizations;
} // namespace simulation
extern double global_tally_absorption;
extern double global_tally_collision;
@ -187,8 +188,9 @@ void setup_active_tallies();
// Alias for the type returned by xt::adapt(...). N is the dimension of the
// multidimensional array
template <std::size_t N>
using adaptor_type = xt::xtensor_adaptor<xt::xbuffer_adaptor<double*&, xt::no_ownership>, N>;
template<std::size_t N>
using adaptor_type =
xt::xtensor_adaptor<xt::xbuffer_adaptor<double*&, xt::no_ownership>, N>;
#ifdef OPENMC_MPI
//! Collect all tally results onto master process

12
include/openmc/tallies/tally_scoring.h
View file

@ -18,10 +18,8 @@ namespace openmc {
//! bins that are valid for the current tally event.
//==============================================================================
class FilterBinIter
{
class FilterBinIter {
public:
//! Construct an iterator over bins that match a given particle's state.
FilterBinIter(const Tally& tally, Particle& p);
@ -32,10 +30,14 @@ public:
const Tally& tally, bool end, vector<FilterMatch>* particle_filter_matches);
bool operator==(const FilterBinIter& other) const
{return index_ == other.index_;}
{
return index_ == other.index_;
}
bool operator!=(const FilterBinIter& other) const
{return !(*this == other);}
{
return !(*this == other);
}
FilterBinIter& operator++();

18
include/openmc/tallies/trigger.h
View file

@ -12,21 +12,23 @@ namespace openmc {
//==============================================================================
enum class TriggerMetric {
variance, relative_error, standard_deviation, not_active
variance,
relative_error,
standard_deviation,
not_active
};
//! Stops the simulation early if a desired tally uncertainty is reached.
struct Trigger {
TriggerMetric metric; //!< The type of uncertainty (e.g. std dev) measured
double threshold; //!< Uncertainty value below which trigger is satisfied
int score_index; //!< Index of the relevant score in the tally's arrays
TriggerMetric metric; //!< The type of uncertainty (e.g. std dev) measured
double threshold; //!< Uncertainty value below which trigger is satisfied
int score_index; //!< Index of the relevant score in the tally's arrays
};
//! Stops the simulation early if a desired k-effective uncertainty is reached.
struct KTrigger
{
struct KTrigger {
TriggerMetric metric {TriggerMetric::not_active};
double threshold {0.};
};
@ -35,9 +37,9 @@ struct KTrigger
// Global variable declarations
//==============================================================================
//TODO: consider a different namespace
// TODO: consider a different namespace
namespace settings {
extern KTrigger keff_trigger;
extern KTrigger keff_trigger;
}
//==============================================================================

33
include/openmc/thermal.h
View file

@ -25,7 +25,7 @@ class ThermalScattering;
namespace data {
extern std::unordered_map<std::string, int> thermal_scatt_map;
extern vector<unique_ptr<ThermalScattering>> thermal_scatt;
}
} // namespace data
//==============================================================================
//! Secondary angle-energy data for thermal neutron scattering at a single
@ -50,12 +50,13 @@ public:
//! \param[out] E_out Outgoing neutron energy in [eV]
//! \param[out] mu Outgoing scattering angle cosine
//! \param[inout] seed Pseudorandom seed pointer
void sample(const NuclideMicroXS& micro_xs, double E_in,
double* E_out, double* mu, uint64_t* seed);
void sample(const NuclideMicroXS& micro_xs, double E_in, double* E_out,
double* mu, uint64_t* seed);
private:
struct Reaction {
// Default constructor
Reaction() { }
Reaction() {}
// Data members
unique_ptr<Function1D> xs; //!< Cross section
@ -83,13 +84,13 @@ public:
//! Determine inelastic/elastic cross section at given energy
//!
//! \param[in] E incoming energy in [eV]
//! \param[in] sqrtkT square-root of temperature multipled by Boltzmann's constant
//! \param[out] i_temp corresponding temperature index
//! \param[out] elastic Thermal elastic scattering cross section
//! \param[out] inelastic Thermal inelastic scattering cross section
//! \param[inout] seed Pseudorandom seed pointer
//! \param[in] sqrtkT square-root of temperature multipled by Boltzmann's
//! constant \param[out] i_temp corresponding temperature index \param[out]
//! elastic Thermal elastic scattering cross section \param[out] inelastic
//! Thermal inelastic scattering cross section \param[inout] seed Pseudorandom
//! seed pointer
void calculate_xs(double E, double sqrtkT, int* i_temp, double* elastic,
double* inelastic, uint64_t* seed) const;
double* inelastic, uint64_t* seed) const;
//! Determine whether table applies to a particular nuclide
//!
@ -98,13 +99,13 @@ public:
bool has_nuclide(const char* name) const;
// Sample an outgoing energy and angle
void sample(const NuclideMicroXS& micro_xs, double E_in,
double* E_out, double* mu);
void sample(
const NuclideMicroXS& micro_xs, double E_in, double* E_out, double* mu);
std::string name_; //!< name of table, e.g. "c_H_in_H2O"
double awr_; //!< weight of nucleus in neutron masses
double energy_max_; //!< maximum energy for thermal scattering in [eV]
vector<double> kTs_; //!< temperatures in [eV] (k*T)
std::string name_; //!< name of table, e.g. "c_H_in_H2O"
double awr_; //!< weight of nucleus in neutron masses
double energy_max_; //!< maximum energy for thermal scattering in [eV]
vector<double> kTs_; //!< temperatures in [eV] (k*T)
vector<std::string> nuclides_; //!< Valid nuclides
//! cross sections and distributions at each temperature

4
include/openmc/timer.h
View file

@ -58,9 +58,9 @@ public:
void reset();
private:
bool running_ {false}; //!< is timer running?
bool running_ {false}; //!< is timer running?
std::chrono::time_point<clock> start_; //!< starting point for clock
double elapsed_ {0.0}; //!< elapsed time in [s]
double elapsed_ {0.0}; //!< elapsed time in [s]
};
//==============================================================================

2
include/openmc/urr.h
View file

@ -14,7 +14,7 @@ namespace openmc {
//! UrrData contains probability tables for the unresolved resonance range.
//==============================================================================
class UrrData{
class UrrData {
public:
Interpolation interp_; //!< interpolation type
int inelastic_flag_; //!< inelastic competition flag

24
include/openmc/volume_calc.h
View file

@ -9,8 +9,8 @@
#include "pugixml.hpp"
#include "xtensor/xtensor.hpp"
#include <string>
#include <gsl/gsl>
#include <string>
namespace openmc {
@ -28,14 +28,15 @@ public:
vector<double> atoms; //!< Number of atoms for each nuclide
vector<double> uncertainty; //!< Uncertainty on number of atoms
int iterations; //!< Number of iterations needed to obtain the results
}; // Results for a single domain
}; // Results for a single domain
// Constructors
VolumeCalculation(pugi::xml_node node);
// Methods
//! \brief Stochastically determine the volume of a set of domains along with the
//! \brief Stochastically determine the volume of a set of domains along with
//! the
//! average number densities of nuclides within the domain
//
//! \return Vector of results for each user-specified domain
@ -49,20 +50,17 @@ public:
const std::string& filename, const vector<Result>& results) const;
// Tally filter and map types
enum class TallyDomain {
UNIVERSE,
MATERIAL,
CELL
};
enum class TallyDomain { UNIVERSE, MATERIAL, CELL };
// Data members
TallyDomain domain_type_; //!< Type of domain (cell, material, etc.)
size_t n_samples_; //!< Number of samples to use
size_t n_samples_; //!< Number of samples to use
double threshold_ {-1.0}; //!< Error threshold for domain volumes
TriggerMetric trigger_type_ {TriggerMetric::not_active}; //!< Trigger metric for the volume calculation
Position lower_left_; //!< Lower-left position of bounding box
Position upper_right_; //!< Upper-right position of bounding box
vector<int> domain_ids_; //!< IDs of domains to find volumes of
TriggerMetric trigger_type_ {
TriggerMetric::not_active}; //!< Trigger metric for the volume calculation
Position lower_left_; //!< Lower-left position of bounding box
Position upper_right_; //!< Upper-right position of bounding box
vector<int> domain_ids_; //!< IDs of domains to find volumes of
private:
//! \brief Check whether a material has already been hit for a given domain.

33
include/openmc/wmp.h
View file

@ -39,8 +39,8 @@ class WindowedMultipole {
public:
// Types
struct WindowInfo {
int index_start; // Index of starting pole
int index_end; // Index of ending pole
int index_start; // Index of starting pole
int index_end; // Index of ending pole
bool broaden_poly; // Whether to broaden polynomial curvefit
};
@ -54,7 +54,8 @@ public:
//!
//! \param E Incident neutron energy in [eV]
//! \param sqrtkT Square root of temperature times Boltzmann constant
//! \return Tuple of elastic scattering, absorption, and fission cross sections in [b]
//! \return Tuple of elastic scattering, absorption, and fission cross
//! sections in [b]
std::tuple<double, double, double> evaluate(double E, double sqrtkT) const;
//! \brief Evaluates the windowed multipole equations for the derivative of
@ -65,18 +66,20 @@ public:
//! \param sqrtkT Square root of temperature times Boltzmann constant
//! \return Tuple of derivatives of elastic scattering, absorption, and
//! fission cross sections in [b/K]
std::tuple<double, double, double> evaluate_deriv(double E, double sqrtkT) const;
std::tuple<double, double, double> evaluate_deriv(
double E, double sqrtkT) const;
// Data members
std::string name_; //!< Name of nuclide
double E_min_; //!< Minimum energy in [eV]
double E_max_; //!< Maximum energy in [eV]
double sqrt_awr_; //!< Square root of atomic weight ratio
double inv_spacing_; //!< 1 / spacing in sqrt(E) space
int fit_order_; //!< Order of the fit
bool fissionable_; //!< Is the nuclide fissionable?
vector<WindowInfo> window_info_; // Information about a window
xt::xtensor<double, 3> curvefit_; // Curve fit coefficients (window, poly order, reaction)
std::string name_; //!< Name of nuclide
double E_min_; //!< Minimum energy in [eV]
double E_max_; //!< Maximum energy in [eV]
double sqrt_awr_; //!< Square root of atomic weight ratio
double inv_spacing_; //!< 1 / spacing in sqrt(E) space
int fit_order_; //!< Order of the fit
bool fissionable_; //!< Is the nuclide fissionable?
vector<WindowInfo> window_info_; // Information about a window
xt::xtensor<double, 3>
curvefit_; // Curve fit coefficients (window, poly order, reaction)
xt::xtensor<std::complex<double>, 2> data_; //!< Poles and residues
// Constant data
@ -99,7 +102,6 @@ void check_wmp_version(hid_t file);
//! \param[in] i_nuclide Index in global nuclides array
void read_multipole_data(int i_nuclide);
//==============================================================================
//! Doppler broadens the windowed multipole curvefit.
//!
@ -111,7 +113,8 @@ void read_multipole_data(int i_nuclide);
//! \param factors The output leading coefficient
//==============================================================================
extern "C" void broaden_wmp_polynomials(double E, double dopp, int n, double factors[]);
extern "C" void broaden_wmp_polynomials(
double E, double dopp, int n, double factors[]);
} // namespace openmc

13
include/openmc/xml_interface.h
View file

@ -6,21 +6,20 @@
#include <string>
#include "pugixml.hpp"
#include "xtensor/xarray.hpp"
#include "xtensor/xadapt.hpp"
#include "xtensor/xarray.hpp"
#include "openmc/vector.h"
namespace openmc {
inline bool
check_for_node(pugi::xml_node node, const char *name)
inline bool check_for_node(pugi::xml_node node, const char* name)
{
return node.attribute(name) || node.child(name);
}
std::string get_node_value(pugi::xml_node node, const char* name,
bool lowercase=false, bool strip=false);
bool lowercase = false, bool strip = false);
bool get_node_value_bool(pugi::xml_node node, const char* name);
@ -41,9 +40,9 @@ vector<T> get_node_array(
return values;
}
template <typename T>
xt::xarray<T> get_node_xarray(pugi::xml_node node, const char* name,
bool lowercase=false)
template<typename T>
xt::xarray<T> get_node_xarray(
pugi::xml_node node, const char* name, bool lowercase = false)
{
vector<T> v = get_node_array<T>(node, name, lowercase);
vector<std::size_t> shape = {v.size()};

202
include/openmc/xsdata.h
View file

@ -28,127 +28,117 @@ enum class AngleDistributionType {
class XsData {
private:
private:
//! \brief Reads scattering data from the HDF5 file
void scatter_from_hdf5(hid_t xsdata_grp, size_t n_ang,
AngleDistributionType scatter_format,
AngleDistributionType final_scatter_format, int order_data);
//! \brief Reads scattering data from the HDF5 file
void
scatter_from_hdf5(hid_t xsdata_grp, size_t n_ang, AngleDistributionType scatter_format,
AngleDistributionType final_scatter_format, int order_data);
//! \brief Reads fission data from the HDF5 file
void fission_from_hdf5(hid_t xsdata_grp, size_t n_ang, bool is_isotropic);
//! \brief Reads fission data from the HDF5 file
void
fission_from_hdf5(hid_t xsdata_grp, size_t n_ang, bool is_isotropic);
//! \brief Reads fission data formatted as chi and nu-fission vectors from
// the HDF5 file when beta is provided.
void fission_vector_beta_from_hdf5(
hid_t xsdata_grp, size_t n_ang, bool is_isotropic);
//! \brief Reads fission data formatted as chi and nu-fission vectors from
// the HDF5 file when beta is provided.
void
fission_vector_beta_from_hdf5(hid_t xsdata_grp, size_t n_ang, bool is_isotropic);
//! \brief Reads fission data formatted as chi and nu-fission vectors from
// the HDF5 file when beta is not provided.
void fission_vector_no_beta_from_hdf5(hid_t xsdata_grp, size_t n_ang);
//! \brief Reads fission data formatted as chi and nu-fission vectors from
// the HDF5 file when beta is not provided.
void
fission_vector_no_beta_from_hdf5(hid_t xsdata_grp, size_t n_ang);
//! \brief Reads fission data formatted as chi and nu-fission vectors from
// the HDF5 file when no delayed data is provided.
void fission_vector_no_delayed_from_hdf5(hid_t xsdata_grp, size_t n_ang);
//! \brief Reads fission data formatted as chi and nu-fission vectors from
// the HDF5 file when no delayed data is provided.
void
fission_vector_no_delayed_from_hdf5(hid_t xsdata_grp, size_t n_ang);
//! \brief Reads fission data formatted as a nu-fission matrix from
// the HDF5 file when beta is provided.
void fission_matrix_beta_from_hdf5(
hid_t xsdata_grp, size_t n_ang, bool is_isotropic);
//! \brief Reads fission data formatted as a nu-fission matrix from
// the HDF5 file when beta is provided.
void
fission_matrix_beta_from_hdf5(hid_t xsdata_grp, size_t n_ang, bool is_isotropic);
//! \brief Reads fission data formatted as a nu-fission matrix from
// the HDF5 file when beta is not provided.
void fission_matrix_no_beta_from_hdf5(hid_t xsdata_grp, size_t n_ang);
//! \brief Reads fission data formatted as a nu-fission matrix from
// the HDF5 file when beta is not provided.
void
fission_matrix_no_beta_from_hdf5(hid_t xsdata_grp, size_t n_ang);
//! \brief Reads fission data formatted as a nu-fission matrix from
// the HDF5 file when no delayed data is provided.
void fission_matrix_no_delayed_from_hdf5(hid_t xsdata_grp, size_t n_ang);
//! \brief Reads fission data formatted as a nu-fission matrix from
// the HDF5 file when no delayed data is provided.
void
fission_matrix_no_delayed_from_hdf5(hid_t xsdata_grp, size_t n_ang);
//! Number of energy and delayed neutron groups
size_t n_g_, n_dg_;
//! Number of energy and delayed neutron groups
size_t n_g_, n_dg_;
public:
// The following quantities have the following dimensions:
// [angle][incoming group]
xt::xtensor<double, 2> total;
xt::xtensor<double, 2> absorption;
xt::xtensor<double, 2> nu_fission;
xt::xtensor<double, 2> prompt_nu_fission;
xt::xtensor<double, 2> kappa_fission;
xt::xtensor<double, 2> fission;
xt::xtensor<double, 2> inverse_velocity;
public:
// decay_rate has the following dimensions:
// [angle][delayed group]
xt::xtensor<double, 2> decay_rate;
// delayed_nu_fission has the following dimensions:
// [angle][delayed group][incoming group]
xt::xtensor<double, 3> delayed_nu_fission;
// chi_prompt has the following dimensions:
// [angle][incoming group][outgoing group]
xt::xtensor<double, 3> chi_prompt;
// chi_delayed has the following dimensions:
// [angle][incoming group][outgoing group][delayed group]
xt::xtensor<double, 4> chi_delayed;
// scatter has the following dimensions: [angle]
vector<std::shared_ptr<ScattData>> scatter;
// The following quantities have the following dimensions:
// [angle][incoming group]
xt::xtensor<double, 2> total;
xt::xtensor<double, 2> absorption;
xt::xtensor<double, 2> nu_fission;
xt::xtensor<double, 2> prompt_nu_fission;
xt::xtensor<double, 2> kappa_fission;
xt::xtensor<double, 2> fission;
xt::xtensor<double, 2> inverse_velocity;
XsData() = default;
// decay_rate has the following dimensions:
// [angle][delayed group]
xt::xtensor<double, 2> decay_rate;
// delayed_nu_fission has the following dimensions:
// [angle][delayed group][incoming group]
xt::xtensor<double, 3> delayed_nu_fission;
// chi_prompt has the following dimensions:
// [angle][incoming group][outgoing group]
xt::xtensor<double, 3> chi_prompt;
// chi_delayed has the following dimensions:
// [angle][incoming group][outgoing group][delayed group]
xt::xtensor<double, 4> chi_delayed;
// scatter has the following dimensions: [angle]
vector<std::shared_ptr<ScattData>> scatter;
//! \brief Constructs the XsData object metadata.
//!
//! @param num_groups Number of energy groups.
//! @param num_delayed_groups Number of delayed groups.
//! @param fissionable Is this a fissionable data set or not.
//! @param scatter_format The scattering representation of the file.
//! @param n_pol Number of polar angles.
//! @param n_azi Number of azimuthal angles.
//! @param n_groups Number of energy groups.
//! @param n_d_groups Number of delayed neutron groups.
XsData(bool fissionable, AngleDistributionType scatter_format, int n_pol,
int n_azi, size_t n_groups, size_t n_d_groups);
XsData() = default;
//! \brief Loads the XsData object from the HDF5 file
//!
//! @param xs_id HDF5 group id for the cross section data.
//! @param fissionable Is this a fissionable data set or not.
//! @param scatter_format The scattering representation of the file.
//! @param final_scatter_format The scattering representation after reading;
//! this is different from scatter_format if converting a Legendre to
//! a tabular representation.
//! @param order_data The dimensionality of the scattering data in the file.
//! @param is_isotropic Is this an isotropic or angular with respect to
//! the incoming particle.
//! @param n_pol Number of polar angles.
//! @param n_azi Number of azimuthal angles.
void from_hdf5(hid_t xsdata_grp, bool fissionable,
AngleDistributionType scatter_format,
AngleDistributionType final_scatter_format, int order_data,
bool is_isotropic, int n_pol, int n_azi);
//! \brief Constructs the XsData object metadata.
//!
//! @param num_groups Number of energy groups.
//! @param num_delayed_groups Number of delayed groups.
//! @param fissionable Is this a fissionable data set or not.
//! @param scatter_format The scattering representation of the file.
//! @param n_pol Number of polar angles.
//! @param n_azi Number of azimuthal angles.
//! @param n_groups Number of energy groups.
//! @param n_d_groups Number of delayed neutron groups.
XsData(bool fissionable, AngleDistributionType scatter_format, int n_pol,
int n_azi, size_t n_groups, size_t n_d_groups);
//! \brief Combines the microscopic data to a macroscopic object.
//!
//! @param micros Microscopic objects to combine.
//! @param scalars Scalars to multiply the microscopic data by.
void combine(const vector<XsData*>& those_xs, const vector<double>& scalars);
//! \brief Loads the XsData object from the HDF5 file
//!
//! @param xs_id HDF5 group id for the cross section data.
//! @param fissionable Is this a fissionable data set or not.
//! @param scatter_format The scattering representation of the file.
//! @param final_scatter_format The scattering representation after reading;
//! this is different from scatter_format if converting a Legendre to
//! a tabular representation.
//! @param order_data The dimensionality of the scattering data in the file.
//! @param is_isotropic Is this an isotropic or angular with respect to
//! the incoming particle.
//! @param n_pol Number of polar angles.
//! @param n_azi Number of azimuthal angles.
void
from_hdf5(hid_t xsdata_grp, bool fissionable, AngleDistributionType scatter_format,
AngleDistributionType final_scatter_format, int order_data, bool is_isotropic, int n_pol,
int n_azi);
//! \brief Combines the microscopic data to a macroscopic object.
//!
//! @param micros Microscopic objects to combine.
//! @param scalars Scalars to multiply the microscopic data by.
void combine(
const vector<XsData*>& those_xs, const vector<double>& scalars);
//! \brief Checks to see if this and that are able to be combined
//!
//! This comparison is used when building macroscopic cross sections
//! from microscopic cross sections.
//! @param that The other XsData to compare to this one.
//! @return True if they can be combined.
bool
equiv(const XsData& that);
//! \brief Checks to see if this and that are able to be combined
//!
//! This comparison is used when building macroscopic cross sections
//! from microscopic cross sections.
//! @param that The other XsData to compare to this one.
//! @return True if they can be combined.
bool equiv(const XsData& that);
};
} //namespace openmc
} // namespace openmc
#endif // OPENMC_XSDATA_H

21
src/bank.cpp
View file

@ -7,7 +7,6 @@
#include <cstdint>
namespace openmc {
//==============================================================================
@ -20,10 +19,11 @@ vector<SourceSite> source_bank;
SharedArray<SourceSite> surf_source_bank;
// The fission bank is allocated as a SharedArray, rather than a vector, as it will
// be shared by all threads in the simulation. It will be allocated to a fixed
// maximum capacity in the init_fission_bank() function. Then, Elements will be
// added to it by using SharedArray's special thread_safe_append() function.
// The fission bank is allocated as a SharedArray, rather than a vector, as it
// will be shared by all threads in the simulation. It will be allocated to a
// fixed maximum capacity in the init_fission_bank() function. Then, Elements
// will be added to it by using SharedArray's special thread_safe_append()
// function.
SharedArray<SourceSite> fission_bank;
// Each entry in this vector corresponds to the number of progeny produced
@ -69,7 +69,7 @@ void sort_fission_bank()
int64_t tmp = simulation::progeny_per_particle[0];
simulation::progeny_per_particle[0] = 0;
for (int64_t i = 1; i < simulation::progeny_per_particle.size(); i++) {
int64_t value = simulation::progeny_per_particle[i-1] + tmp;
int64_t value = simulation::progeny_per_particle[i - 1] + tmp;
tmp = simulation::progeny_per_particle[i];
simulation::progeny_per_particle[i] = value;
}
@ -84,7 +84,8 @@ void sort_fission_bank()
vector<SourceSite> 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) {
if (simulation::fission_bank.size() >
simulation::fission_bank.capacity() / 2) {
sorted_bank_holder.resize(simulation::fission_bank.size());
sorted_bank = sorted_bank_holder.data();
} else { // otherwise, point sorted_bank to unused portion of the fission bank
@ -98,14 +99,14 @@ void sort_fission_bank()
int64_t idx = simulation::progeny_per_particle[offset] + site.progeny_id;
if (idx >= simulation::fission_bank.size()) {
fatal_error("Mismatch detected between sum of all particle progeny and "
"shared fission bank size.");
"shared fission bank size.");
}
sorted_bank[idx] = site;
}
// Copy sorted bank into the fission bank
std::copy(sorted_bank, sorted_bank + simulation::fission_bank.size(),
simulation::fission_bank.data());
simulation::fission_bank.data());
}
//==============================================================================
@ -141,7 +142,7 @@ extern "C" int openmc_fission_bank(void** ptr, int64_t* n)
return OPENMC_E_ALLOCATE;
} else {
*ptr = simulation::fission_bank.data();
*n = simulation::fission_bank.size();
*n = simulation::fission_bank.size();
return 0;
}
}

76
src/boundary_condition.cpp
View file

@ -14,8 +14,7 @@ namespace openmc {
// VacuumBC implementation
//==============================================================================
void
VacuumBC::handle_particle(Particle& p, const Surface& surf) const
void VacuumBC::handle_particle(Particle& p, const Surface& surf) const
{
p.cross_vacuum_bc(surf);
}
@ -24,8 +23,7 @@ VacuumBC::handle_particle(Particle& p, const Surface& surf) const
// ReflectiveBC implementation
//==============================================================================
void
ReflectiveBC::handle_particle(Particle& p, const Surface& surf) const
void ReflectiveBC::handle_particle(Particle& p, const Surface& surf) const
{
Direction u = surf.reflect(p.r(), p.u(), &p);
u /= u.norm();
@ -37,8 +35,7 @@ ReflectiveBC::handle_particle(Particle& p, const Surface& surf) const
// WhiteBC implementation
//==============================================================================
void
WhiteBC::handle_particle(Particle& p, const Surface& surf) const
void WhiteBC::handle_particle(Particle& p, const Surface& surf) const
{
Direction u = surf.diffuse_reflect(p.r(), p.u(), p.current_seed());
u /= u.norm();
@ -62,7 +59,8 @@ TranslationalPeriodicBC::TranslationalPeriodicBC(int i_surf, int j_surf)
} else if (const auto* ptr = dynamic_cast<const SurfaceZPlane*>(&surf1)) {
} else if (const auto* ptr = dynamic_cast<const SurfacePlane*>(&surf1)) {
} else {
throw std::invalid_argument(fmt::format("Surface {} is an invalid type for "
throw std::invalid_argument(fmt::format(
"Surface {} is an invalid type for "
"translational periodic BCs. Only planes are supported for these BCs.",
surf1.id_));
}
@ -73,7 +71,8 @@ TranslationalPeriodicBC::TranslationalPeriodicBC(int i_surf, int j_surf)
} else if (const auto* ptr = dynamic_cast<const SurfaceZPlane*>(&surf2)) {
} else if (const auto* ptr = dynamic_cast<const SurfacePlane*>(&surf2)) {
} else {
throw std::invalid_argument(fmt::format("Surface {} is an invalid type for "
throw std::invalid_argument(fmt::format(
"Surface {} is an invalid type for "
"translational periodic BCs. Only planes are supported for these BCs.",
surf2.id_));
}
@ -109,8 +108,8 @@ TranslationalPeriodicBC::TranslationalPeriodicBC(int i_surf, int j_surf)
translation_ = u * (d2 - d1);
}
void
TranslationalPeriodicBC::handle_particle(Particle& p, const Surface& surf) const
void TranslationalPeriodicBC::handle_particle(
Particle& p, const Surface& surf) const
{
// TODO: off-by-one on surface indices throughout this function.
int i_particle_surf = std::abs(p.surface()) - 1;
@ -126,7 +125,8 @@ TranslationalPeriodicBC::handle_particle(Particle& p, const Surface& surf) const
new_r = p.r() - translation_;
new_surface = p.surface() > 0 ? i_surf_ + 1 : -(i_surf_ + 1);
} else {
throw std::runtime_error("Called BoundaryCondition::handle_particle after "
throw std::runtime_error(
"Called BoundaryCondition::handle_particle after "
"hitting a surface, but that surface is not recognized by the BC.");
}
@ -153,9 +153,11 @@ RotationalPeriodicBC::RotationalPeriodicBC(int i_surf, int j_surf)
} else if (const auto* ptr = dynamic_cast<const SurfacePlane*>(&surf1)) {
surf1_is_xyplane = false;
} else {
throw std::invalid_argument(fmt::format("Surface {} is an invalid type for "
throw std::invalid_argument(fmt::format(
"Surface {} is an invalid type for "
"rotational periodic BCs. Only x-planes, y-planes, or general planes "
"(that are perpendicular to z) are supported for these BCs.", surf1.id_));
"(that are perpendicular to z) are supported for these BCs.",
surf1.id_));
}
// Check the type of the second surface
@ -167,9 +169,11 @@ RotationalPeriodicBC::RotationalPeriodicBC(int i_surf, int j_surf)
} else if (const auto* ptr = dynamic_cast<const SurfacePlane*>(&surf2)) {
surf2_is_xyplane = false;
} else {
throw std::invalid_argument(fmt::format("Surface {} is an invalid type for "
throw std::invalid_argument(fmt::format(
"Surface {} is an invalid type for "
"rotational periodic BCs. Only x-planes, y-planes, or general planes "
"(that are perpendicular to z) are supported for these BCs.", surf2.id_));
"(that are perpendicular to z) are supported for these BCs.",
surf2.id_));
}
// Compute the surface normal vectors and make sure they are perpendicular
@ -177,26 +181,34 @@ RotationalPeriodicBC::RotationalPeriodicBC(int i_surf, int j_surf)
Direction norm1 = surf1.normal({0, 0, 0});
Direction norm2 = surf2.normal({0, 0, 0});
if (std::abs(norm1.z) > FP_PRECISION) {
throw std::invalid_argument(fmt::format("Rotational periodic BCs are only "
throw std::invalid_argument(fmt::format(
"Rotational periodic BCs are only "
"supported for rotations about the z-axis, but surface {} is not "
"perpendicular to the z-axis.", surf1.id_));
"perpendicular to the z-axis.",
surf1.id_));
}
if (std::abs(norm2.z) > FP_PRECISION) {
throw std::invalid_argument(fmt::format("Rotational periodic BCs are only "
throw std::invalid_argument(fmt::format(
"Rotational periodic BCs are only "
"supported for rotations about the z-axis, but surface {} is not "
"perpendicular to the z-axis.", surf2.id_));
"perpendicular to the z-axis.",
surf2.id_));
}
// Make sure both surfaces intersect the origin
if (std::abs(surf1.evaluate({0, 0, 0})) > FP_COINCIDENT) {
throw std::invalid_argument(fmt::format("Rotational periodic BCs are only "
throw std::invalid_argument(fmt::format(
"Rotational periodic BCs are only "
"supported for rotations about the origin, but surface {} does not "
"intersect the origin.", surf1.id_));
"intersect the origin.",
surf1.id_));
}
if (std::abs(surf2.evaluate({0, 0, 0})) > FP_COINCIDENT) {
throw std::invalid_argument(fmt::format("Rotational periodic BCs are only "
throw std::invalid_argument(fmt::format(
"Rotational periodic BCs are only "
"supported for rotations about the origin, but surface {} does not "
"intersect the origin.", surf2.id_));
"intersect the origin.",
surf2.id_));
}
// Compute the BC rotation angle. Here it is assumed that both surface
@ -212,14 +224,15 @@ RotationalPeriodicBC::RotationalPeriodicBC(int i_surf, int j_surf)
// Warn the user if the angle does not evenly divide a circle
double rem = std::abs(std::remainder((2 * PI / angle_), 1.0));
if (rem > FP_REL_PRECISION && rem < 1 - FP_REL_PRECISION) {
warning(fmt::format("Rotational periodic BC specified with a rotation "
warning(fmt::format(
"Rotational periodic BC specified with a rotation "
"angle of {} degrees which does not evenly divide 360 degrees.",
angle_ * 180 / PI));
}
}
void
RotationalPeriodicBC::handle_particle(Particle& p, const Surface& surf) const
void RotationalPeriodicBC::handle_particle(
Particle& p, const Surface& surf) const
{
// TODO: off-by-one on surface indices throughout this function.
int i_particle_surf = std::abs(p.surface()) - 1;
@ -236,7 +249,8 @@ RotationalPeriodicBC::handle_particle(Particle& p, const Surface& surf) const
theta = -angle_;
new_surface = p.surface() > 0 ? -(i_surf_ + 1) : i_surf_ + 1;
} else {
throw std::runtime_error("Called BoundaryCondition::handle_particle after "
throw std::runtime_error(
"Called BoundaryCondition::handle_particle after "
"hitting a surface, but that surface is not recognized by the BC.");
}
@ -246,13 +260,9 @@ RotationalPeriodicBC::handle_particle(Particle& p, const Surface& surf) const
double cos_theta = std::cos(theta);
double sin_theta = std::sin(theta);
Position new_r = {
cos_theta*r.x - sin_theta*r.y,
sin_theta*r.x + cos_theta*r.y,
r.z};
cos_theta * r.x - sin_theta * r.y, sin_theta * r.x + cos_theta * r.y, r.z};
Direction new_u = {
cos_theta*u.x - sin_theta*u.y,
sin_theta*u.x + cos_theta*u.y,
u.z};
cos_theta * u.x - sin_theta * u.y, sin_theta * u.x + cos_theta * u.y, u.z};
// Pass the new location, direction, and surface to the particle.
p.cross_periodic_bc(surf, new_r, new_u, new_surface);

29
src/bremsstrahlung.cpp
View file

@ -47,30 +47,32 @@ void thick_target_bremsstrahlung(Particle& p, double* E_lost)
auto n_e = data::ttb_e_grid.size();
// Find the lower bounding index of the incident electron energy
size_t j = lower_bound_index(data::ttb_e_grid.cbegin(),
data::ttb_e_grid.cend(), e);
if (j == n_e - 1) --j;
size_t j =
lower_bound_index(data::ttb_e_grid.cbegin(), data::ttb_e_grid.cend(), e);
if (j == n_e - 1)
--j;
// Get the interpolation bounds
double e_l = data::ttb_e_grid(j);
double e_r = data::ttb_e_grid(j+1);
double e_r = data::ttb_e_grid(j + 1);
double y_l = mat->yield(j);
double y_r = mat->yield(j+1);
double y_r = mat->yield(j + 1);
// Calculate the interpolation weight w_j+1 of the bremsstrahlung energy PDF
// interpolated in log energy, which can be interpreted as the probability
// of index j+1
double f = (e - e_l)/(e_r - e_l);
double f = (e - e_l) / (e_r - e_l);
// Get the photon number yield for the given energy using linear
// interpolation on a log-log scale
double y = std::exp(y_l + (y_r - y_l)*f);
double y = std::exp(y_l + (y_r - y_l) * f);
// Sample number of secondary bremsstrahlung photons
int n = y + prn(p.current_seed());
*E_lost = 0.0;
if (n == 0) return;
if (n == 0)
return;
// Sample index of the tabulated PDF in the energy grid, j or j+1
double c_max;
@ -83,8 +85,8 @@ void thick_target_bremsstrahlung(Particle& p, double* E_lost)
double p_l = mat->pdf(i_e, i_e - 1);
double p_r = mat->pdf(i_e, i_e);
double c_l = mat->cdf(i_e, i_e - 1);
double a = std::log(p_r/p_l)/(e_r - e_l) + 1.0;
c_max = c_l + std::exp(e_l)*p_l/a*(std::exp(a*(e - e_l)) - 1.0);
double a = std::log(p_r / p_l) / (e_r - e_l) + 1.0;
c_max = c_l + std::exp(e_l) * p_l / a * (std::exp(a * (e - e_l)) - 1.0);
} else {
i_e = j;
@ -96,7 +98,7 @@ void thick_target_bremsstrahlung(Particle& p, double* E_lost)
for (int i = 0; i < n; ++i) {
// Generate a random number r and determine the index i for which
// cdf(i) <= r*cdf,max <= cdf(i+1)
double c = prn(p.current_seed())*c_max;
double c = prn(p.current_seed()) * c_max;
int i_w = lower_bound_index(&mat->cdf(i_e, 0), &mat->cdf(i_e, 0) + i_e, c);
// Sample the photon energy
@ -105,8 +107,9 @@ void thick_target_bremsstrahlung(Particle& p, double* E_lost)
double p_l = mat->pdf(i_e, i_w);
double p_r = mat->pdf(i_e, i_w + 1);
double c_l = mat->cdf(i_e, i_w);
double a = std::log(p_r/p_l)/(w_r - w_l) + 1.0;
double w = std::exp(w_l)*std::pow(a*(c - c_l)/(std::exp(w_l)*p_l) + 1.0, 1.0/a);
double a = std::log(p_r / p_l) / (w_r - w_l) + 1.0;
double w = std::exp(w_l) *
std::pow(a * (c - c_l) / (std::exp(w_l) * p_l) + 1.0, 1.0 / a);
if (w > settings::energy_cutoff[photon]) {
// Create secondary photon

302
src/cell.cpp
View file

@ -31,11 +31,11 @@ namespace openmc {
//==============================================================================
namespace model {
std::unordered_map<int32_t, int32_t> cell_map;
vector<unique_ptr<Cell>> cells;
std::unordered_map<int32_t, int32_t> cell_map;
vector<unique_ptr<Cell>> cells;
std::unordered_map<int32_t, int32_t> universe_map;
vector<unique_ptr<Universe>> universes;
std::unordered_map<int32_t, int32_t> universe_map;
vector<unique_ptr<Universe>> universes;
} // namespace model
//==============================================================================
@ -54,7 +54,7 @@ vector<int32_t> tokenize(const std::string region_spec)
}
// Parse all halfspaces and operators except for intersection (whitespace).
for (int i = 0; i < region_spec.size(); ) {
for (int i = 0; i < region_spec.size();) {
if (region_spec[i] == '(') {
tokens.push_back(OP_LEFT_PAREN);
i++;
@ -71,34 +71,37 @@ vector<int32_t> tokenize(const std::string region_spec)
tokens.push_back(OP_COMPLEMENT);
i++;
} else if (region_spec[i] == '-' || region_spec[i] == '+'
|| std::isdigit(region_spec[i])) {
} else if (region_spec[i] == '-' || region_spec[i] == '+' ||
std::isdigit(region_spec[i])) {
// This is the start of a halfspace specification. Iterate j until we
// find the end, then push-back everything between i and j.
int j = i + 1;
while (j < region_spec.size() && std::isdigit(region_spec[j])) {j++;}
tokens.push_back(std::stoi(region_spec.substr(i, j-i)));
while (j < region_spec.size() && std::isdigit(region_spec[j])) {
j++;
}
tokens.push_back(std::stoi(region_spec.substr(i, j - i)));
i = j;
} else if (std::isspace(region_spec[i])) {
i++;
} else {
auto err_msg = fmt::format(
"Region specification contains invalid character, \"{}\"", region_spec[i]);
auto err_msg =
fmt::format("Region specification contains invalid character, \"{}\"",
region_spec[i]);
fatal_error(err_msg);
}
}
// Add in intersection operators where a missing operator is needed.
int i = 0;
while (i < tokens.size()-1) {
while (i < tokens.size() - 1) {
bool left_compat {(tokens[i] < OP_UNION) || (tokens[i] == OP_RIGHT_PAREN)};
bool right_compat {(tokens[i+1] < OP_UNION)
|| (tokens[i+1] == OP_LEFT_PAREN)
|| (tokens[i+1] == OP_COMPLEMENT)};
bool right_compat {(tokens[i + 1] < OP_UNION) ||
(tokens[i + 1] == OP_LEFT_PAREN) ||
(tokens[i + 1] == OP_COMPLEMENT)};
if (left_compat && right_compat) {
tokens.insert(tokens.begin()+i+1, OP_INTERSECTION);
tokens.insert(tokens.begin() + i + 1, OP_INTERSECTION);
}
i++;
}
@ -126,9 +129,8 @@ vector<int32_t> generate_rpn(int32_t cell_id, vector<int32_t> infix)
while (stack.size() > 0) {
int32_t op = stack.back();
if (op < OP_RIGHT_PAREN &&
((token == OP_COMPLEMENT && token < op) ||
(token != OP_COMPLEMENT && token <= op))) {
if (op < OP_RIGHT_PAREN && ((token == OP_COMPLEMENT && token < op) ||
(token != OP_COMPLEMENT && token <= op))) {
// While there is an operator, op, on top of the stack, if the token
// is left-associative and its precedence is less than or equal to
// that of op or if the token is right-associative and its precedence
@ -156,7 +158,8 @@ vector<int32_t> generate_rpn(int32_t cell_id, vector<int32_t> infix)
// means there are mismatched parentheses.
if (it == stack.rend()) {
fatal_error(fmt::format(
"Mismatched parentheses in region specification for cell {}", cell_id));
"Mismatched parentheses in region specification for cell {}",
cell_id));
}
rpn.push_back(stack.back());
stack.pop_back();
@ -187,8 +190,7 @@ vector<int32_t> generate_rpn(int32_t cell_id, vector<int32_t> infix)
// Universe implementation
//==============================================================================
void
Universe::to_hdf5(hid_t universes_group) const
void Universe::to_hdf5(hid_t universes_group) const
{
// Create a group for this universe.
auto group = create_group(universes_group, fmt::format("universe {}", id_));
@ -199,39 +201,39 @@ Universe::to_hdf5(hid_t universes_group) const
// Write the contained cells.
if (cells_.size() > 0) {
vector<int32_t> cell_ids;
for (auto i_cell : cells_) cell_ids.push_back(model::cells[i_cell]->id_);
for (auto i_cell : cells_)
cell_ids.push_back(model::cells[i_cell]->id_);
write_dataset(group, "cells", cell_ids);
}
close_group(group);
}
bool
Universe::find_cell(Particle& p) const {
bool Universe::find_cell(Particle& p) const
{
const auto& cells {
!partitioner_
? cells_
: partitioner_->get_cells(p.r_local(), p.u_local())
};
!partitioner_ ? cells_ : partitioner_->get_cells(p.r_local(), p.u_local())};
for (auto it = cells.begin(); it != cells.end(); it++) {
int32_t i_cell = *it;
int32_t i_univ = p.coord(p.n_coord()-1).universe;
if (model::cells[i_cell]->universe_ != i_univ) continue;
int32_t i_univ = p.coord(p.n_coord() - 1).universe;
if (model::cells[i_cell]->universe_ != i_univ)
continue;
// Check if this cell contains the particle;
Position r {p.r_local()};
Direction u {p.u_local()};
auto surf = p.surface();
if (model::cells[i_cell]->contains(r, u, surf)) {
p.coord(p.n_coord()-1).cell = i_cell;
p.coord(p.n_coord() - 1).cell = i_cell;
return true;
}
}
return false;
}
BoundingBox Universe::bounding_box() const {
BoundingBox Universe::bounding_box() const
{
BoundingBox bbox = {INFTY, -INFTY, INFTY, -INFTY, INFTY, -INFTY};
if (cells_.size() == 0) {
return {};
@ -248,8 +250,8 @@ BoundingBox Universe::bounding_box() const {
// Cell implementation
//==============================================================================
void
Cell::set_rotation(const vector<double>& rot) {
void Cell::set_rotation(const vector<double>& rot)
{
if (fill_ == C_NONE) {
fatal_error(fmt::format("Cannot apply a rotation to cell {}"
" because it is not filled with another universe",
@ -290,40 +292,37 @@ Cell::set_rotation(const vector<double>& rot) {
}
}
double
Cell::temperature(int32_t instance) const
double Cell::temperature(int32_t instance) const
{
if (sqrtkT_.size() < 1) {
throw std::runtime_error{"Cell temperature has not yet been set."};
throw std::runtime_error {"Cell temperature has not yet been set."};
}
if (instance >= 0) {
double sqrtkT = sqrtkT_.size() == 1 ?
sqrtkT_.at(0) :
sqrtkT_.at(instance);
double sqrtkT = sqrtkT_.size() == 1 ? sqrtkT_.at(0) : sqrtkT_.at(instance);
return sqrtkT * sqrtkT / K_BOLTZMANN;
} else {
return sqrtkT_[0] * sqrtkT_[0] / K_BOLTZMANN;
}
}
void
Cell::set_temperature(double T, int32_t instance, bool set_contained)
void Cell::set_temperature(double T, int32_t instance, bool set_contained)
{
if (settings::temperature_method == TemperatureMethod::INTERPOLATION) {
if (T < data::temperature_min) {
throw std::runtime_error{"Temperature is below minimum temperature at "
"which data is available."};
throw std::runtime_error {"Temperature is below minimum temperature at "
"which data is available."};
} else if (T > data::temperature_max) {
throw std::runtime_error{"Temperature is above maximum temperature at "
"which data is available."};
throw std::runtime_error {"Temperature is above maximum temperature at "
"which data is available."};
}
}
if (type_ == Fill::MATERIAL) {
if (instance >= 0) {
// If temperature vector is not big enough, resize it first
if (sqrtkT_.size() != n_instances_) sqrtkT_.resize(n_instances_, sqrtkT_[0]);
if (sqrtkT_.size() != n_instances_)
sqrtkT_.resize(n_instances_, sqrtkT_[0]);
// Set temperature for the corresponding instance
sqrtkT_.at(instance) = std::sqrt(K_BOLTZMANN * T);
@ -335,15 +334,17 @@ Cell::set_temperature(double T, int32_t instance, bool set_contained)
}
} else {
if (!set_contained) {
throw std::runtime_error{fmt::format("Attempted to set the temperature of cell {} "
"which is not filled by a material.", id_)};
throw std::runtime_error {
fmt::format("Attempted to set the temperature of cell {} "
"which is not filled by a material.",
id_)};
}
auto contained_cells = this->get_contained_cells();
for (const auto& entry : contained_cells) {
auto& cell = model::cells[entry.first];
Expects(cell->type_ == Fill::MATERIAL);
auto& instances = entry.second;
auto& instances = entry.second;
for (auto instance : instances) {
cell->set_temperature(T, instance);
}
@ -377,7 +378,8 @@ void Cell::import_properties_hdf5(hid_t group)
auto n_temps = temps.size();
if (n_temps > 1 && n_temps != n_instances_) {
throw std::runtime_error(fmt::format(
"Number of temperatures for cell {} doesn't match number of instances", id_));
"Number of temperatures for cell {} doesn't match number of instances",
id_));
}
// Modify temperatures for the cell
@ -390,9 +392,8 @@ void Cell::import_properties_hdf5(hid_t group)
close_group(cell_group);
}
void
Cell::to_hdf5(hid_t cell_group) const {
void Cell::to_hdf5(hid_t cell_group) const
{
// Create a group for this cell.
auto group = create_group(cell_group, fmt::format("cell {}", id_));
@ -455,7 +456,8 @@ Cell::to_hdf5(hid_t cell_group) const {
//==============================================================================
// default constructor
CSGCell::CSGCell() {
CSGCell::CSGCell()
{
geom_type_ = GeometryType::CSG;
}
@ -483,19 +485,21 @@ CSGCell::CSGCell(pugi::xml_node cell_node)
bool fill_present = check_for_node(cell_node, "fill");
bool material_present = check_for_node(cell_node, "material");
if (!(fill_present || material_present)) {
fatal_error(fmt::format(
"Neither material nor fill was specified for cell {}", id_));
fatal_error(
fmt::format("Neither material nor fill was specified for cell {}", id_));
}
if (fill_present && material_present) {
fatal_error(fmt::format("Cell {} has both a material and a fill specified; "
"only one can be specified per cell", id_));
"only one can be specified per cell",
id_));
}
if (fill_present) {
fill_ = std::stoi(get_node_value(cell_node, "fill"));
if (fill_ == universe_) {
fatal_error(fmt::format("Cell {} is filled with the same universe that"
"it is contained in.", id_));
"it is contained in.",
id_));
}
} else {
fill_ = C_NONE;
@ -517,8 +521,8 @@ CSGCell::CSGCell(pugi::xml_node cell_node)
}
}
} else {
fatal_error(fmt::format("An empty material element was specified for cell {}",
id_));
fatal_error(fmt::format(
"An empty material element was specified for cell {}", id_));
}
}
@ -531,7 +535,8 @@ CSGCell::CSGCell(pugi::xml_node cell_node)
if (material_.size() == 0) {
fatal_error(fmt::format(
"Cell {} was specified with a temperature but no material. Temperature"
"specification is only valid for cells filled with a material.", id_));
"specification is only valid for cells filled with a material.",
id_));
}
// Make sure all temperatures are non-negative.
@ -563,8 +568,9 @@ CSGCell::CSGCell(pugi::xml_node cell_node)
if (r < OP_UNION) {
const auto& it {model::surface_map.find(abs(r))};
if (it == model::surface_map.end()) {
throw std::runtime_error{"Invalid surface ID " + std::to_string(abs(r))
+ " specified in region for cell " + std::to_string(id_) + "."};
throw std::runtime_error {
"Invalid surface ID " + std::to_string(abs(r)) +
" specified in region for cell " + std::to_string(id_) + "."};
}
r = (r > 0) ? it->second + 1 : -(it->second + 1);
}
@ -601,13 +607,14 @@ CSGCell::CSGCell(pugi::xml_node cell_node)
if (check_for_node(cell_node, "translation")) {
if (fill_ == C_NONE) {
fatal_error(fmt::format("Cannot apply a translation to cell {}"
" because it is not filled with another universe", id_));
" because it is not filled with another universe",
id_));
}
auto xyz {get_node_array<double>(cell_node, "translation")};
if (xyz.size() != 3) {
fatal_error(fmt::format(
"Non-3D translation vector applied to cell {}", id_));
fatal_error(
fmt::format("Non-3D translation vector applied to cell {}", id_));
}
translation_ = xyz;
}
@ -621,8 +628,7 @@ CSGCell::CSGCell(pugi::xml_node cell_node)
//==============================================================================
bool
CSGCell::contains(Position r, Direction u, int32_t on_surface) const
bool CSGCell::contains(Position r, Direction u, int32_t on_surface) const
{
if (simple_) {
return contains_simple(r, u, on_surface);
@ -633,24 +639,25 @@ CSGCell::contains(Position r, Direction u, int32_t on_surface) const
//==============================================================================
std::pair<double, int32_t>
CSGCell::distance(Position r, Direction u, int32_t on_surface, Particle* p) const
std::pair<double, int32_t> CSGCell::distance(
Position r, Direction u, int32_t on_surface, Particle* p) const
{
double min_dist {INFTY};
int32_t i_surf {std::numeric_limits<int32_t>::max()};
for (int32_t token : rpn_) {
// Ignore this token if it corresponds to an operator rather than a region.
if (token >= OP_UNION) continue;
if (token >= OP_UNION)
continue;
// Calculate the distance to this surface.
// Note the off-by-one indexing
bool coincident {std::abs(token) == std::abs(on_surface)};
double d {model::surfaces[abs(token)-1]->distance(r, u, coincident)};
double d {model::surfaces[abs(token) - 1]->distance(r, u, coincident)};
// Check if this distance is the new minimum.
if (d < min_dist) {
if (min_dist - d >= FP_PRECISION*min_dist) {
if (min_dist - d >= FP_PRECISION * min_dist) {
min_dist = d;
i_surf = -token;
}
@ -662,8 +669,7 @@ CSGCell::distance(Position r, Direction u, int32_t on_surface, Particle* p) cons
//==============================================================================
void
CSGCell::to_hdf5_inner(hid_t group_id) const
void CSGCell::to_hdf5_inner(hid_t group_id) const
{
write_string(group_id, "geom_type", "csg", false);
@ -683,19 +689,19 @@ CSGCell::to_hdf5_inner(hid_t group_id) const
region_spec << " |";
} else {
// Note the off-by-one indexing
auto surf_id = model::surfaces[abs(token)-1]->id_;
auto surf_id = model::surfaces[abs(token) - 1]->id_;
region_spec << " " << ((token > 0) ? surf_id : -surf_id);
}
}
write_string(group_id, "region", region_spec.str(), false);
}
}
BoundingBox CSGCell::bounding_box_simple() const {
BoundingBox CSGCell::bounding_box_simple() const
{
BoundingBox bbox;
for (int32_t token : rpn_) {
bbox &= model::surfaces[abs(token)-1]->bounding_box(token > 0);
bbox &= model::surfaces[abs(token) - 1]->bounding_box(token > 0);
}
return bbox;
}
@ -704,9 +710,13 @@ void CSGCell::apply_demorgan(
vector<int32_t>::iterator start, vector<int32_t>::iterator stop)
{
while (start < stop) {
if (*start < OP_UNION) { *start *= -1; }
else if (*start == OP_UNION) { *start = OP_INTERSECTION; }
else if (*start == OP_INTERSECTION) { *start = OP_UNION; }
if (*start < OP_UNION) {
*start *= -1;
} else if (*start == OP_UNION) {
*start = OP_INTERSECTION;
} else if (*start == OP_INTERSECTION) {
*start = OP_UNION;
}
start++;
}
}
@ -725,7 +735,7 @@ vector<int32_t>::iterator CSGCell::find_left_parenthesis(
// decrement parenthesis level if there are two adjacent surfaces
if (one < OP_UNION && two < OP_UNION) {
parenthesis_level--;
// increment if there are two adjacent operators
// increment if there are two adjacent operators
} else if (one >= OP_UNION && two >= OP_UNION) {
parenthesis_level++;
}
@ -787,14 +797,14 @@ BoundingBox CSGCell::bounding_box_complex(vector<int32_t> rpn)
return stack.front();
}
BoundingBox CSGCell::bounding_box() const {
BoundingBox CSGCell::bounding_box() const
{
return simple_ ? bounding_box_simple() : bounding_box_complex(rpn_);
}
//==============================================================================
bool
CSGCell::contains_simple(Position r, Direction u, int32_t on_surface) const
bool CSGCell::contains_simple(Position r, Direction u, int32_t on_surface) const
{
for (int32_t token : rpn_) {
// Assume that no tokens are operators. Evaluate the sense of particle with
@ -806,8 +816,10 @@ CSGCell::contains_simple(Position r, Direction u, int32_t on_surface) const
return false;
} else {
// Note the off-by-one indexing
bool sense = model::surfaces[abs(token)-1]->sense(r, u);
if (sense != (token > 0)) {return false;}
bool sense = model::surfaces[abs(token) - 1]->sense(r, u);
if (sense != (token > 0)) {
return false;
}
}
}
return true;
@ -815,8 +827,8 @@ CSGCell::contains_simple(Position r, Direction u, int32_t on_surface) const
//==============================================================================
bool
CSGCell::contains_complex(Position r, Direction u, int32_t on_surface) const
bool 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.
@ -828,11 +840,11 @@ CSGCell::contains_complex(Position r, Direction u, int32_t on_surface) const
// the last two items on the stack. If the token is a unary operator
// (complement), apply it to the last item on the stack.
if (token == OP_UNION) {
stack[i_stack-1] = stack[i_stack-1] || stack[i_stack];
i_stack --;
stack[i_stack - 1] = stack[i_stack - 1] || stack[i_stack];
i_stack--;
} else if (token == OP_INTERSECTION) {
stack[i_stack-1] = stack[i_stack-1] && stack[i_stack];
i_stack --;
stack[i_stack - 1] = stack[i_stack - 1] && stack[i_stack];
i_stack--;
} else if (token == OP_COMPLEMENT) {
stack[i_stack] = !stack[i_stack];
} else {
@ -840,14 +852,14 @@ CSGCell::contains_complex(Position r, Direction u, int32_t on_surface) const
// respect to the surface and see if the token matches the sense. If the
// particle's surface attribute is set and matches the token, that
// overrides the determination based on sense().
i_stack ++;
i_stack++;
if (token == on_surface) {
stack[i_stack] = true;
} else if (-token == on_surface) {
stack[i_stack] = false;
} else {
// Note the off-by-one indexing
bool sense = model::surfaces[abs(token)-1]->sense(r, u);
bool sense = model::surfaces[abs(token) - 1]->sense(r, u);
stack[i_stack] = (sense == (token > 0));
}
}
@ -908,7 +920,8 @@ UniversePartitioner::UniversePartitioner(const Universe& univ)
// It is difficult to determine the bounds of a complex cell, so add complex
// cells to all partitions.
if (!model::cells[i_cell]->simple_) {
for (auto& p : partitions_) p.push_back(i_cell);
for (auto& p : partitions_)
p.push_back(i_cell);
continue;
}
@ -933,7 +946,8 @@ UniversePartitioner::UniversePartitioner(const Universe& univ)
// If there are no bounding z-planes, add this cell to all partitions.
if (lower_token == 0) {
for (auto& p : partitions_) p.push_back(i_cell);
for (auto& p : partitions_)
p.push_back(i_cell);
continue;
}
@ -989,7 +1003,7 @@ const vector<int32_t>& UniversePartitioner::get_cells(
left = middle + 1;
middle = right_leaf;
} else {
return partitions_[middle+1];
return partitions_[middle + 1];
}
} else {
@ -998,7 +1012,7 @@ const vector<int32_t>& UniversePartitioner::get_cells(
// side of this surface.
int left_leaf = left + (middle - left) / 2;
if (left_leaf != middle) {
right = middle-1;
right = middle - 1;
middle = left_leaf;
} else {
return partitions_[middle];
@ -1015,7 +1029,9 @@ void read_cells(pugi::xml_node node)
{
// Count the number of cells.
int n_cells = 0;
for (pugi::xml_node cell_node: node.children("cell")) {n_cells++;}
for (pugi::xml_node cell_node : node.children("cell")) {
n_cells++;
}
// Loop over XML cell elements and populate the array.
model::cells.reserve(n_cells);
@ -1030,7 +1046,8 @@ void read_cells(pugi::xml_node node)
if (search == model::cell_map.end()) {
model::cell_map[id] = i;
} else {
fatal_error(fmt::format("Two or more cells use the same unique ID: {}", id));
fatal_error(
fmt::format("Two or more cells use the same unique ID: {}", id));
}
}
@ -1065,8 +1082,8 @@ void read_cells(pugi::xml_node node)
// C-API functions
//==============================================================================
extern "C" int
openmc_cell_get_fill(int32_t index, int* type, int32_t** indices, int32_t* n)
extern "C" int openmc_cell_get_fill(
int32_t index, int* type, int32_t** indices, int32_t* n)
{
if (index >= 0 && index < model::cells.size()) {
Cell& c {*model::cells[index]};
@ -1085,9 +1102,8 @@ openmc_cell_get_fill(int32_t index, int* type, int32_t** indices, int32_t* n)
return 0;
}
extern "C" int
openmc_cell_set_fill(int32_t index, int type, int32_t n,
const int32_t* indices)
extern "C" int openmc_cell_set_fill(
int32_t index, int type, int32_t n, const int32_t* indices)
{
Fill filltype = static_cast<Fill>(type);
if (index >= 0 && index < model::cells.size()) {
@ -1119,8 +1135,8 @@ openmc_cell_set_fill(int32_t index, int type, int32_t n,
return 0;
}
extern "C" int
openmc_cell_set_temperature(int32_t index, double T, const int32_t* instance, bool set_contained)
extern "C" int openmc_cell_set_temperature(
int32_t index, double T, const int32_t* instance, bool set_contained)
{
if (index < 0 || index >= model::cells.size()) {
strcpy(openmc_err_msg, "Index in cells array is out of bounds.");
@ -1137,8 +1153,8 @@ openmc_cell_set_temperature(int32_t index, double T, const int32_t* instance, bo
return 0;
}
extern "C" int
openmc_cell_get_temperature(int32_t index, const int32_t* instance, double* T)
extern "C" int openmc_cell_get_temperature(
int32_t index, const int32_t* instance, double* T)
{
if (index < 0 || index >= model::cells.size()) {
strcpy(openmc_err_msg, "Index in cells array is out of bounds.");
@ -1156,8 +1172,9 @@ openmc_cell_get_temperature(int32_t index, const int32_t* instance, double* T)
}
//! Get the bounding box of a cell
extern "C" int
openmc_cell_bounding_box(const int32_t index, double* llc, double* urc) {
extern "C" int openmc_cell_bounding_box(
const int32_t index, double* llc, double* urc)
{
BoundingBox bbox;
@ -1178,8 +1195,8 @@ openmc_cell_bounding_box(const int32_t index, double* llc, double* urc) {
}
//! Get the name of a cell
extern "C" int
openmc_cell_get_name(int32_t index, const char** name) {
extern "C" int openmc_cell_get_name(int32_t index, const char** name)
{
if (index < 0 || index >= model::cells.size()) {
set_errmsg("Index in cells array is out of bounds.");
return OPENMC_E_OUT_OF_BOUNDS;
@ -1191,8 +1208,8 @@ openmc_cell_get_name(int32_t index, const char** name) {
}
//! Set the name of a cell
extern "C" int
openmc_cell_set_name(int32_t index, const char* name) {
extern "C" int openmc_cell_set_name(int32_t index, const char* name)
{
if (index < 0 || index >= model::cells.size()) {
set_errmsg("Index in cells array is out of bounds.");
return OPENMC_E_OUT_OF_BOUNDS;
@ -1232,24 +1249,25 @@ void Cell::get_contained_cells_inner(
instance += cell->offset_[distribcell_index_];
} else if (cell->type_ == Fill::LATTICE) {
auto& lattice = model::lattices[cell->fill_];
instance += lattice->offset(this->distribcell_index_, parent_cell.lattice_index);
instance += lattice->offset(
this->distribcell_index_, parent_cell.lattice_index);
}
}
}
// add entry to contained cells
contained_cells[model::cell_map[id_]].push_back(instance);
// filled with universe, add the containing cell to the parent cells
// and recurse
// filled with universe, add the containing cell to the parent cells
// and recurse
} else if (type_ == Fill::UNIVERSE) {
parent_cells.push_back({model::cell_map[id_], -1});
auto& univ = model::universes[fill_];
for(auto cell_index : univ->cells_) {
for (auto cell_index : univ->cells_) {
auto& cell = model::cells[cell_index];
cell->get_contained_cells_inner(contained_cells, parent_cells);
}
parent_cells.pop_back();
// filled with a lattice, visit each universe in the lattice
// with a recursive call to collect the cell instances
// filled with a lattice, visit each universe in the lattice
// with a recursive call to collect the cell instances
} else if (type_ == Fill::LATTICE) {
auto& lattice = model::lattices[fill_];
for (auto i = lattice->begin(); i != lattice->end(); ++i) {
@ -1265,8 +1283,7 @@ void Cell::get_contained_cells_inner(
}
//! Return the index in the cells array of a cell with a given ID
extern "C" int
openmc_get_cell_index(int32_t id, int32_t* index)
extern "C" int openmc_get_cell_index(int32_t id, int32_t* index)
{
auto it = model::cell_map.find(id);
if (it != model::cell_map.end()) {
@ -1279,8 +1296,7 @@ openmc_get_cell_index(int32_t id, int32_t* index)
}
//! Return the ID of a cell
extern "C" int
openmc_cell_get_id(int32_t index, int32_t* id)
extern "C" int openmc_cell_get_id(int32_t index, int32_t* id)
{
if (index >= 0 && index < model::cells.size()) {
*id = model::cells[index]->id_;
@ -1292,8 +1308,7 @@ openmc_cell_get_id(int32_t index, int32_t* id)
}
//! Set the ID of a cell
extern "C" int
openmc_cell_set_id(int32_t index, int32_t id)
extern "C" int openmc_cell_set_id(int32_t index, int32_t id)
{
if (index >= 0 && index < model::cells.size()) {
model::cells[index]->id_ = id;
@ -1327,7 +1342,7 @@ extern "C" int openmc_cell_set_translation(int32_t index, const double xyz[])
if (model::cells[index]->fill_ == C_NONE) {
set_errmsg(fmt::format("Cannot apply a translation to cell {}"
" because it is not filled with another universe",
index));
index));
return OPENMC_E_GEOMETRY;
}
model::cells[index]->translation_ = Position(xyz);
@ -1353,8 +1368,8 @@ extern "C" int openmc_cell_get_rotation(int32_t index, double rot[], size_t* n)
}
//! Set the flattened rotation matrix of a cell
extern "C" int openmc_cell_set_rotation(int32_t index, const double rot[],
size_t rot_len)
extern "C" int openmc_cell_set_rotation(
int32_t index, const double rot[], size_t rot_len)
{
if (index >= 0 && index < model::cells.size()) {
if (model::cells[index]->fill_ == C_NONE) {
@ -1373,8 +1388,8 @@ extern "C" int openmc_cell_set_rotation(int32_t index, const double rot[],
}
//! Get the number of instances of the requested cell
extern "C" int
openmc_cell_get_num_instances(int32_t index, int32_t* num_instances)
extern "C" int openmc_cell_get_num_instances(
int32_t index, int32_t* num_instances)
{
if (index < 0 || index >= model::cells.size()) {
set_errmsg("Index in cells array is out of bounds.");
@ -1385,17 +1400,22 @@ openmc_cell_get_num_instances(int32_t index, int32_t* num_instances)
}
//! Extend the cells array by n elements
extern "C" int
openmc_extend_cells(int32_t n, int32_t* index_start, int32_t* index_end)
extern "C" int openmc_extend_cells(
int32_t n, int32_t* index_start, int32_t* index_end)
{
if (index_start) *index_start = model::cells.size();
if (index_end) *index_end = model::cells.size() + n - 1;
if (index_start)
*index_start = model::cells.size();
if (index_end)
*index_end = model::cells.size() + n - 1;
for (int32_t i = 0; i < n; i++) {
model::cells.push_back(make_unique<CSGCell>());
}
return 0;
}
extern "C" int cells_size() { return model::cells.size(); }
extern "C" int cells_size()
{
return model::cells.size();
}
} // namespace openmc

118
src/cmfd_solver.cpp
View file

@ -66,7 +66,7 @@ int get_cmfd_energy_bin(const double E)
} else {
// Iterate through energy grid to find matching bin
for (int g = 0; g < cmfd::ng; g++) {
if (E >= cmfd::egrid[g] && E < cmfd::egrid[g+1]) {
if (E >= cmfd::egrid[g] && E < cmfd::egrid[g + 1]) {
return g;
}
}
@ -79,7 +79,8 @@ int get_cmfd_energy_bin(const double E)
// COUNT_BANK_SITES bins fission sites according to CMFD mesh and energy
//==============================================================================
xt::xtensor<double, 1> count_bank_sites(xt::xtensor<int, 1>& bins, bool* outside)
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;
@ -106,22 +107,22 @@ xt::xtensor<double, 1> count_bank_sites(xt::xtensor<int, 1>& bins, bool* outside
int energy_bin = get_cmfd_energy_bin(site.E);
// add to appropriate bin
cnt(mesh_bin*cmfd::ng+energy_bin) += site.wgt;
cnt(mesh_bin * cmfd::ng + energy_bin) += site.wgt;
// store bin index which is used again when updating weights
bins[i] = mesh_bin*cmfd::ng+energy_bin;
bins[i] = mesh_bin * cmfd::ng + energy_bin;
}
// Create copy of count data. Since ownership will be acquired by xtensor,
// std::allocator must be used to avoid Valgrind mismatched free() / delete
// warnings.
int total = cnt.size();
double* cnt_reduced = std::allocator<double>{}.allocate(total);
double* cnt_reduced = std::allocator<double> {}.allocate(total);
#ifdef OPENMC_MPI
// collect values from all processors
MPI_Reduce(cnt.data(), cnt_reduced, total, MPI_DOUBLE, MPI_SUM, 0,
mpi::intracomm);
MPI_Reduce(
cnt.data(), cnt_reduced, total, MPI_DOUBLE, MPI_SUM, 0, mpi::intracomm);
// Check if there were sites outside the mesh for any processor
MPI_Reduce(&outside_, outside, 1, MPI_C_BOOL, MPI_LOR, 0, mpi::intracomm);
@ -142,8 +143,8 @@ xt::xtensor<double, 1> count_bank_sites(xt::xtensor<int, 1>& bins, bool* outside
// OPENMC_CMFD_REWEIGHT performs reweighting of particles in source bank
//==============================================================================
extern "C"
void openmc_cmfd_reweight(const bool feedback, const double* cmfd_src)
extern "C" void openmc_cmfd_reweight(
const bool feedback, const double* cmfd_src)
{
// Get size of source bank and cmfd_src
auto bank_size = simulation::source_bank.size();
@ -152,8 +153,8 @@ void openmc_cmfd_reweight(const bool feedback, const double* cmfd_src)
// count bank sites for CMFD mesh, store bins in bank_bins for reweighting
xt::xtensor<int, 1> bank_bins({bank_size}, 0);
bool sites_outside;
xt::xtensor<double, 1> sourcecounts = count_bank_sites(bank_bins,
&sites_outside);
xt::xtensor<double, 1> sourcecounts =
count_bank_sites(bank_bins, &sites_outside);
// Compute CMFD weightfactors
xt::xtensor<double, 1> weightfactors = xt::xtensor<double, 1>({src_size}, 1.);
@ -162,7 +163,7 @@ void openmc_cmfd_reweight(const bool feedback, const double* cmfd_src)
fatal_error("Source sites outside of the CMFD mesh");
}
double norm = xt::sum(sourcecounts)()/cmfd::norm;
double norm = xt::sum(sourcecounts)() / cmfd::norm;
for (int i = 0; i < src_size; i++) {
if (sourcecounts[i] > 0 && cmfd_src[i] > 0) {
weightfactors[i] = cmfd_src[i] * norm / sourcecounts[i];
@ -170,7 +171,8 @@ void openmc_cmfd_reweight(const bool feedback, const double* cmfd_src)
}
}
if (!feedback) return;
if (!feedback)
return;
#ifdef OPENMC_MPI
// Send weightfactors to all processors
@ -188,9 +190,8 @@ void openmc_cmfd_reweight(const bool feedback, const double* cmfd_src)
// OPENMC_INITIALIZE_MESH_EGRID sets the mesh and energy grid for CMFD reweight
//==============================================================================
extern "C"
void openmc_initialize_mesh_egrid(const int meshtally_id, const int* cmfd_indices,
const double norm)
extern "C" void openmc_initialize_mesh_egrid(
const int meshtally_id, const int* cmfd_indices, const double norm)
{
// Make sure all CMFD memory is freed
free_memory_cmfd();
@ -242,9 +243,9 @@ void openmc_initialize_mesh_egrid(const int meshtally_id, const int* cmfd_indice
void matrix_to_indices(int irow, int& g, int& i, int& j, int& k)
{
g = irow % cmfd::ng;
i = cmfd::indexmap(irow/cmfd::ng, 0);
j = cmfd::indexmap(irow/cmfd::ng, 1);
k = cmfd::indexmap(irow/cmfd::ng, 2);
i = cmfd::indexmap(irow / cmfd::ng, 0);
j = cmfd::indexmap(irow / cmfd::ng, 1);
k = cmfd::indexmap(irow / cmfd::ng, 2);
}
//==============================================================================
@ -254,7 +255,7 @@ void matrix_to_indices(int irow, int& g, int& i, int& j, int& k)
int get_diagonal_index(int row)
{
for (int j = cmfd::indptr[row]; j < cmfd::indptr[row+1]; j++) {
for (int j = cmfd::indptr[row]; j < cmfd::indptr[row + 1]; j++) {
if (cmfd::indices[j] == row)
return j;
}
@ -272,7 +273,7 @@ void set_indexmap(const int* coremap)
for (int z = 0; z < cmfd::nz; z++) {
for (int y = 0; y < cmfd::ny; y++) {
for (int x = 0; x < cmfd::nx; x++) {
int idx = (z*cmfd::ny*cmfd::nx) + (y*cmfd::nx) + x;
int idx = (z * cmfd::ny * cmfd::nx) + (y * cmfd::nx) + x;
if (coremap[idx] != CMFD_NOACCEL) {
int counter = coremap[idx];
cmfd::indexmap(counter, 0) = x;
@ -288,8 +289,8 @@ void set_indexmap(const int* coremap)
// CMFD_LINSOLVER_1G solves a one group CMFD linear system
//==============================================================================
int cmfd_linsolver_1g(const double* A_data, const double* b, double* x,
double tol)
int cmfd_linsolver_1g(
const double* A_data, const double* b, double* x, double tol)
{
// Set overrelaxation parameter
double w = 1.0;
@ -304,14 +305,15 @@ int cmfd_linsolver_1g(const double* A_data, const double* b, double* x,
// Perform red/black Gauss-Seidel iterations
for (int irb = 0; irb < 2; irb++) {
// Loop around matrix rows
#pragma omp parallel for reduction (+:err) if(cmfd::use_all_threads)
// Loop around matrix rows
#pragma omp parallel for reduction(+ : err) if (cmfd::use_all_threads)
for (int irow = 0; irow < cmfd::dim; irow++) {
int g, i, j, k;
matrix_to_indices(irow, g, i, j, k);
// Filter out black cells
if ((i+j+k) % 2 != irb) continue;
if ((i + j + k) % 2 != irb)
continue;
// Get index of diagonal for current row
int didx = get_diagonal_index(irow);
@ -341,7 +343,7 @@ int cmfd_linsolver_1g(const double* A_data, const double* b, double* x,
return igs;
// Calculate new overrelaxation parameter
w = 1.0/(1.0 - 0.25 * cmfd::spectral * w);
w = 1.0 / (1.0 - 0.25 * cmfd::spectral * w);
}
// Throw error, as max iterations met
@ -355,8 +357,8 @@ int cmfd_linsolver_1g(const double* A_data, const double* b, double* x,
// CMFD_LINSOLVER_2G solves a two group CMFD linear system
//==============================================================================
int cmfd_linsolver_2g(const double* A_data, const double* b, double* x,
double tol)
int cmfd_linsolver_2g(
const double* A_data, const double* b, double* x, double tol)
{
// Set overrelaxation parameter
double w = 1.0;
@ -371,38 +373,41 @@ int cmfd_linsolver_2g(const double* A_data, const double* b, double* x,
// Perform red/black Gauss-Seidel iterations
for (int irb = 0; irb < 2; irb++) {
// Loop around matrix rows
#pragma omp parallel for reduction (+:err) if(cmfd::use_all_threads)
for (int irow = 0; irow < cmfd::dim; irow+=2) {
// Loop around matrix rows
#pragma omp parallel for reduction(+ : err) if (cmfd::use_all_threads)
for (int irow = 0; irow < cmfd::dim; irow += 2) {
int g, i, j, k;
matrix_to_indices(irow, g, i, j, k);
// Filter out black cells
if ((i+j+k) % 2 != irb) continue;
if ((i + j + k) % 2 != irb)
continue;
// Get index of diagonals for current row and next row
int d1idx = get_diagonal_index(irow);
int d2idx = get_diagonal_index(irow+1);
int d2idx = get_diagonal_index(irow + 1);
// Get block diagonal
double m11 = A_data[d1idx]; // group 1 diagonal
double m12 = A_data[d1idx + 1]; // group 1 right of diagonal (sorted by col)
double m21 = A_data[d2idx - 1]; // group 2 left of diagonal (sorted by col)
double m22 = A_data[d2idx]; // group 2 diagonal
double m11 = A_data[d1idx]; // group 1 diagonal
double m12 =
A_data[d1idx + 1]; // group 1 right of diagonal (sorted by col)
double m21 =
A_data[d2idx - 1]; // group 2 left of diagonal (sorted by col)
double m22 = A_data[d2idx]; // group 2 diagonal
// Analytically invert the diagonal
double dm = m11*m22 - m12*m21;
double d11 = m22/dm;
double d12 = -m12/dm;
double d21 = -m21/dm;
double d22 = m11/dm;
double dm = m11 * m22 - m12 * m21;
double d11 = m22 / dm;
double d12 = -m12 / dm;
double d21 = -m21 / dm;
double d22 = m11 / dm;
// Perform temporary sums, first do left of diag, then right of diag
double tmp1 = 0.0;
double tmp2 = 0.0;
for (int icol = cmfd::indptr[irow]; icol < d1idx; icol++)
tmp1 += A_data[icol] * x[cmfd::indices[icol]];
for (int icol = cmfd::indptr[irow+1]; icol < d2idx-1; icol++)
for (int icol = cmfd::indptr[irow + 1]; icol < d2idx - 1; icol++)
tmp2 += A_data[icol] * x[cmfd::indices[icol]];
for (int icol = d1idx + 2; icol < cmfd::indptr[irow + 1]; icol++)
tmp1 += A_data[icol] * x[cmfd::indices[icol]];
@ -414,8 +419,8 @@ int cmfd_linsolver_2g(const double* A_data, const double* b, double* x,
tmp2 = b[irow + 1] - tmp2;
// Solve for new x
double x1 = d11*tmp1 + d12*tmp2;
double x2 = d21*tmp1 + d22*tmp2;
double x1 = d11 * tmp1 + d12 * tmp2;
double x2 = d21 * tmp1 + d22 * tmp2;
// Perform overrelaxation
x[irow] = (1.0 - w) * x[irow] + w * x1;
@ -433,7 +438,7 @@ int cmfd_linsolver_2g(const double* A_data, const double* b, double* x,
return igs;
// Calculate new overrelaxation parameter
w = 1.0/(1.0 - 0.25 * cmfd::spectral * w);
w = 1.0 / (1.0 - 0.25 * cmfd::spectral * w);
}
// Throw error, as max iterations met
@ -447,8 +452,8 @@ int cmfd_linsolver_2g(const double* A_data, const double* b, double* x,
// CMFD_LINSOLVER_NG solves a general CMFD linear system
//==============================================================================
int cmfd_linsolver_ng(const double* A_data, const double* b, double* x,
double tol)
int cmfd_linsolver_ng(
const double* A_data, const double* b, double* x, double tol)
{
// Set overrelaxation parameter
double w = 1.0;
@ -489,7 +494,7 @@ int cmfd_linsolver_ng(const double* A_data, const double* b, double* x,
return igs;
// Calculate new overrelaxation parameter
w = 1.0/(1.0 - 0.25 * cmfd::spectral * w);
w = 1.0 / (1.0 - 0.25 * cmfd::spectral * w);
}
// Throw error, as max iterations met
@ -504,11 +509,9 @@ int cmfd_linsolver_ng(const double* A_data, const double* b, double* x,
// linear solver
//==============================================================================
extern "C"
void openmc_initialize_linsolver(const int* indptr, int len_indptr,
const int* indices, int n_elements, int dim,
double spectral, const int* map,
bool use_all_threads)
extern "C" void openmc_initialize_linsolver(const int* indptr, int len_indptr,
const int* indices, int n_elements, int dim, double spectral, const int* map,
bool use_all_threads)
{
// Store elements of indptr
for (int i = 0; i < len_indptr; i++)
@ -538,9 +541,8 @@ void openmc_initialize_linsolver(const int* indptr, int len_indptr,
// equations
//==============================================================================
extern "C"
int openmc_run_linsolver(const double* A_data, const double* b, double* x,
double tol)
extern "C" int openmc_run_linsolver(
const double* A_data, const double* b, double* x, double tol)
{
switch (cmfd::ng) {
case 1:

59
src/cross_sections.cpp
View file

@ -4,8 +4,8 @@
#include "openmc/constants.h"
#include "openmc/container_util.h"
#include "openmc/error.h"
#include "openmc/geometry_aux.h"
#include "openmc/file_utils.h"
#include "openmc/geometry_aux.h"
#include "openmc/hdf5_interface.h"
#include "openmc/material.h"
#include "openmc/message_passing.h"
@ -15,10 +15,10 @@
#include "openmc/settings.h"
#include "openmc/simulation.h"
#include "openmc/string_utils.h"
#include "openmc/timer.h"
#include "openmc/thermal.h"
#include "openmc/xml_interface.h"
#include "openmc/timer.h"
#include "openmc/wmp.h"
#include "openmc/xml_interface.h"
#include "pugixml.hpp"
@ -35,7 +35,7 @@ namespace data {
std::map<LibraryKey, std::size_t> library_map;
vector<Library> libraries;
}
} // namespace data
//==============================================================================
// Library methods
@ -111,7 +111,8 @@ void read_cross_sections_xml()
if (settings::run_CE) {
char* envvar = std::getenv("OPENMC_CROSS_SECTIONS");
if (!envvar) {
fatal_error("No cross_sections.xml file was specified in "
fatal_error(
"No cross_sections.xml file was specified in "
"materials.xml or in the OPENMC_CROSS_SECTIONS"
" environment variable. OpenMC needs such a file to identify "
"where to find data libraries. Please consult the"
@ -122,12 +123,13 @@ void read_cross_sections_xml()
} else {
char* envvar = std::getenv("OPENMC_MG_CROSS_SECTIONS");
if (!envvar) {
fatal_error("No mgxs.h5 file was specified in "
"materials.xml or in the OPENMC_MG_CROSS_SECTIONS environment "
"variable. OpenMC needs such a file to identify where to "
"find MG cross section libraries. Please consult the user's "
"guide at https://docs.openmc.org for information on "
"how to set up MG cross section libraries.");
fatal_error(
"No mgxs.h5 file was specified in "
"materials.xml or in the OPENMC_MG_CROSS_SECTIONS environment "
"variable. OpenMC needs such a file to identify where to "
"find MG cross section libraries. Please consult the user's "
"guide at https://docs.openmc.org for information on "
"how to set up MG cross section libraries.");
}
settings::path_cross_sections = envvar;
}
@ -157,8 +159,8 @@ void read_cross_sections_xml()
for (const auto& name : settings::res_scat_nuclides) {
LibraryKey key {Library::Type::neutron, name};
if (data::library_map.find(key) == data::library_map.end()) {
fatal_error("Could not find resonant scatterer " +
name + " in cross_sections.xml file!");
fatal_error("Could not find resonant scatterer " + name +
" in cross_sections.xml file!");
}
}
}
@ -188,11 +190,13 @@ void read_ce_cross_sections(const vector<vector<double>>& nuc_temps,
std::string& name = nuclide_names[i_nuc];
// If we've already read this nuclide, skip it
if (already_read.find(name) != already_read.end()) continue;
if (already_read.find(name) != already_read.end())
continue;
const auto& temps = nuc_temps[i_nuc];
int err = openmc_load_nuclide(name.c_str(), temps.data(), temps.size());
if (err < 0) throw std::runtime_error{openmc_err_msg};
if (err < 0)
throw std::runtime_error {openmc_err_msg};
already_read.insert(name);
}
@ -232,14 +236,17 @@ void read_ce_cross_sections(const vector<vector<double>>& nuc_temps,
mat->finalize();
} // materials
if (settings::photon_transport && settings::electron_treatment == ElectronTreatment::TTB) {
if (settings::photon_transport &&
settings::electron_treatment == ElectronTreatment::TTB) {
// Take logarithm of energies since they are log-log interpolated
data::ttb_e_grid = xt::log(data::ttb_e_grid);
}
// Show minimum/maximum temperature
write_message(4, "Minimum neutron data temperature: {} K", data::temperature_min);
write_message(4, "Maximum neutron data temperature: {} K", data::temperature_max);
write_message(
4, "Minimum neutron data temperature: {} K", data::temperature_min);
write_message(
4, "Maximum neutron data temperature: {} K", data::temperature_max);
// If the user wants multipole, make sure we found a multipole library.
if (settings::temperature_multipole) {
@ -252,8 +259,8 @@ void read_ce_cross_sections(const vector<vector<double>>& nuc_temps,
}
if (mpi::master && !mp_found) {
warning("Windowed multipole functionality is turned on, but no multipole "
"libraries were found. Make sure that windowed multipole data is "
"present in your cross_sections.xml file.");
"libraries were found. Make sure that windowed multipole data is "
"present in your cross_sections.xml file.");
}
}
}
@ -264,8 +271,7 @@ void read_ce_cross_sections_xml()
const auto& filename = settings::path_cross_sections;
if (!file_exists(filename)) {
// Could not find cross_sections.xml file
fatal_error("Cross sections XML file '" + filename +
"' does not exist.");
fatal_error("Cross sections XML file '" + filename + "' does not exist.");
}
write_message("Reading cross sections XML file...", 5);
@ -301,11 +307,13 @@ void read_ce_cross_sections_xml()
// Make sure file was not empty
if (data::libraries.empty()) {
fatal_error("No cross section libraries present in cross_sections.xml file.");
fatal_error(
"No cross section libraries present in cross_sections.xml file.");
}
}
void finalize_cross_sections(){
void finalize_cross_sections()
{
if (settings::run_mode != RunMode::PLOTTING) {
simulation::time_read_xs.start();
if (settings::run_CE) {
@ -326,7 +334,8 @@ void finalize_cross_sections(){
}
}
void library_clear() {
void library_clear()
{
data::libraries.clear();
data::library_map.clear();
}

Some files were not shown because too many files have changed in this diff Show more