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

Refactor depletion unit tests with parametrization

Browse source 
Removed unit test files for test_deplete_*py that pertained to a
single integrator type only. Similarly removed tests where the
integrators are used to perform simple restart analysis.
These tests are still present, but done with two parametrized tests.
Each of the integrators has the exact same solution in the unit tests
with and without restarting,by nature of their design.
This and the near-fixture like way the tests
are structured allowed these tests to be easily parametrized provided
1) integrator, 2) reference solutions for atoms 1 and 2.

Exact results for each integrator in the unit test are contained
inside a collections.namedtuple, along with the Integrator class.
These named tuples are placed in a dictionary in
tests/dummy_operator.py that can be easily iterated over to provide
access to a name of the scheme, e.g. "predictor", and the tuple of
integrator, results for atom 1, and results for atom 2.
Exact results for atoms 1 and 2 should be provided using the depletion
matrix produced by the tests.dummy_operator.DummyOperator for two
time steps of 0.75 seconds.
This commit is contained in:
Andrew Johnson 2019-08-20 18:51:52 -05:00
parent a0bff1194f
commit dbd24035a3
No known key found for this signature in database
GPG key ID: 253418E91B7F6FEB
11 changed files with 136 additions and 667 deletions
Download patch file Download diff file Expand all files Collapse all files

75
tests/dummy_operator.py
View file

@ -1,9 +1,76 @@
from collections import namedtuple
import numpy as np
import scipy.sparse as sp
from uncertainties import ufloat
from openmc.deplete.reaction_rates import ReactionRates
from openmc.deplete.abc import TransportOperator, OperatorResult
from openmc.deplete import (
CECMIntegrator, PredictorIntegrator, CELIIntegrator, LEQIIntegrator,
EPCRK4Integrator, CF4Integrator, SICELIIntegrator, SILEQIIntegrator
)
# Bundle for nicely passing test data to depletion unit tests
# solver should be a concrete subclass of openmc.deplete.abc.Integrator
# atoms_1 should be the number of atoms of type 1 through the simulation
# similar for atoms_2, but for type 2. This includes the first step
# Solutions should be the exact solution that can be obtained using
# the DummyOperator depletion matrix with two 0.75 second time steps
DepletionSolutionTuple = namedtuple(
"DepletionSolutionTuple", "solver atoms_1 atoms_2")
predictor_solution = DepletionSolutionTuple(
PredictorIntegrator, np.array([1.0, 2.46847546272295, 4.11525874568034]),
np.array([1.0, 0.986431226850467, -0.0581692232513460]))
cecm_solution = DepletionSolutionTuple(
CECMIntegrator, np.array([1.0, 1.86872629872102, 2.18097439443550]),
np.array([1.0, 1.395525772416039, 2.69429754646747]))
cf4_solution = DepletionSolutionTuple(
CF4Integrator, np.array([1.0, 2.06101629, 2.57241318]),
np.array([1.0, 1.37783588, 2.63731630]))
epc_rk4_solution = DepletionSolutionTuple(
EPCRK4Integrator, np.array([1.0, 2.01978516, 2.05246421]),
np.array([1.0, 1.42038037, 3.06177191]))
celi_solution = DepletionSolutionTuple(
CELIIntegrator, np.array([1.0, 1.82078767, 2.68441779]),
np.array([1.0, 0.97122898, 0.05125966]))
si_celi_solution = DepletionSolutionTuple(
SICELIIntegrator, np.array([1.0, 2.03325094, 2.69291933]),
np.array([1.0, 1.16826254, 0.37907772]))
leqi_solution = DepletionSolutionTuple(
LEQIIntegrator, np.array([1.0, 1.82078767, 2.74526197]),
np.array([1.0, 0.97122898, 0.23339915]))
si_leqi_solution = DepletionSolutionTuple(
SILEQIIntegrator, np.array([1.0, 2.03325094, 2.92711288]),
np.array([1.0, 1.16826254, 0.53753236]))
SCHEMES = {
"predictor": predictor_solution,
"cecm": cecm_solution,
"celi": celi_solution,
"cf4": cf4_solution,
"epc_rk4": epc_rk4_solution,
"leqi": leqi_solution,
"si_leqi": si_leqi_solution,
"si_celi": si_celi_solution,
}
class DummyOperator(TransportOperator):
@ -21,6 +88,7 @@ class DummyOperator(TransportOperator):
"""
def __init__(self, previous_results=None):
self.prev_res = previous_results
self.output_dir = "."
def __call__(self, vec, power, print_out=False):
"""Evaluates F(y)
@ -76,7 +144,6 @@ class DummyOperator(TransportOperator):
y_1 = rates[0, 0]
y_2 = rates[1, 0]
mat = np.zeros((2, 2))
a11 = np.sin(y_2)
a12 = np.cos(y_1)
a21 = -np.cos(y_2)
@ -106,7 +173,8 @@ class DummyOperator(TransportOperator):
def local_mats(self):
"""
local_mats : list of str
A list of all material IDs to be burned. Used for sorting the simulation.
A list of all material IDs to be burned. Used for sorting the
simulation.
"""
return ["1"]
@ -153,7 +221,8 @@ class DummyOperator(TransportOperator):
nuc_list : list of str
A list of all nuclide names. Used for sorting the simulation.
burn_list : list of int
A list of all cell IDs to be burned. Used for sorting the simulation.
A list of all cell IDs to be burned. Used for sorting the
simulation.
full_burn_list : OrderedDict of str to int
Maps cell name to index in global geometry.

44
tests/unit_tests/test_deplete_cecm.py
View file

@ -1,44 +0,0 @@
"""Regression tests for openmc.deplete.integrator.cecm algorithm.
These tests integrate a simple test problem described in dummy_geometry.py.
"""
from pytest import approx
from openmc.deplete import CECMIntegrator, ResultsList
from tests import dummy_operator
def test_cecm(run_in_tmpdir):
"""Integral regression test of integrator algorithm using CE/CM."""
op = dummy_operator.DummyOperator()
op.output_dir = "test_integrator_regression"
# Perform simulation using the MCNPX/MCNP6 algorithm
dt = [0.75, 0.75]
power = 1.0
integrator = CECMIntegrator(op, dt, power)
integrator.integrate()
# Load the files
res = ResultsList.from_hdf5(op.output_dir / "depletion_results.h5")
_, y1 = res.get_atoms("1", "1")
_, y2 = res.get_atoms("1", "2")
# Mathematica solution
s1 = [1.86872629872102, 1.395525772416039]
s2 = [2.18097439443550, 2.69429754646747]
assert y1[1] == approx(s1[0])
assert y2[1] == approx(s1[1])
assert y1[2] == approx(s2[0])
assert y2[2] == approx(s2[1])
# Test structure of depletion time dataset
dep_time = res.get_depletion_time()
assert dep_time.shape == (len(dt), )
assert all(dep_time > 0)

43
tests/unit_tests/test_deplete_celi.py
View file

@ -1,43 +0,0 @@
"""Regression tests for openmc.deplete.integrator.celi algorithm.
These tests integrate a simple test problem described in dummy_geometry.py.
"""
from pytest import approx
from openmc.deplete import ResultsList, CELIIntegrator
from tests import dummy_operator
def test_celi(run_in_tmpdir):
"""Integral regression test of integrator algorithm using celi"""
op = dummy_operator.DummyOperator()
op.output_dir = "test_integrator_regression"
# Perform simulation using the celi algorithm
dt = [0.75, 0.75]
power = 1.0
CELIIntegrator(op, dt, power).integrate()
# Load the files
res = ResultsList.from_hdf5(op.output_dir / "depletion_results.h5")
_, y1 = res.get_atoms("1", "1")
_, y2 = res.get_atoms("1", "2")
# Reference solution
s1 = [1.82078767, 0.97122898]
s2 = [2.68441779, 0.05125966]
assert y1[1] == approx(s1[0])
assert y2[1] == approx(s1[1])
assert y1[2] == approx(s2[0])
assert y2[2] == approx(s2[1])
# Test structure of depletion time dataset
dep_time = res.get_depletion_time()
assert dep_time.shape == (len(dt), )
assert all(dep_time > 0)

43
tests/unit_tests/test_deplete_cf4.py
View file

@ -1,43 +0,0 @@
"""Regression tests for openmc.deplete.integrator.cf4 algorithm.
These tests integrate a simple test problem described in dummy_geometry.py.
"""
from pytest import approx
from openmc.deplete import CF4Integrator, ResultsList
from tests import dummy_operator
def test_cf4(run_in_tmpdir):
"""Integral regression test of integrator algorithm using CF4"""
op = dummy_operator.DummyOperator()
op.output_dir = "test_integrator_regression"
# Perform simulation using the cf4 algorithm
dt = [0.75, 0.75]
power = 1.0
CF4Integrator(op, dt, power).integrate()
# Load the files
res = ResultsList.from_hdf5(op.output_dir / "depletion_results.h5")
_, y1 = res.get_atoms("1", "1")
_, y2 = res.get_atoms("1", "2")
# Reference solution
s1 = [2.06101629, 1.37783588]
s2 = [2.57241318, 2.63731630]
assert y1[1] == approx(s1[0])
assert y2[1] == approx(s1[1])
assert y1[2] == approx(s2[0])
assert y2[2] == approx(s2[1])
# Test structure of depletion time dataset
dep_time = res.get_depletion_time()
assert dep_time.shape == (len(dt), )
assert all(dep_time > 0)

43
tests/unit_tests/test_deplete_epc_rk4.py
View file

@ -1,43 +0,0 @@
"""Regression tests for openmc.deplete.integrator.epc_rk4 algorithm.
These tests integrate a simple test problem described in dummy_geometry.py.
"""
from pytest import approx
from openmc.deplete import EPCRK4Integrator, ResultsList
from tests import dummy_operator
def test_epc_rk4(run_in_tmpdir):
"""Integral regression test of integrator algorithm using epc_rk4"""
op = dummy_operator.DummyOperator()
op.output_dir = "test_integrator_regression"
# Perform simulation using the epc_rk4 algorithm
dt = [0.75, 0.75]
power = 1.0
EPCRK4Integrator(op, dt, power).integrate()
# Load the files
res = ResultsList.from_hdf5(op.output_dir / "depletion_results.h5")
_, y1 = res.get_atoms("1", "1")
_, y2 = res.get_atoms("1", "2")
# Reference solution
s1 = [2.01978516, 1.42038037]
s2 = [2.05246421, 3.06177191]
assert y1[1] == approx(s1[0])
assert y2[1] == approx(s1[1])
assert y1[2] == approx(s2[0])
assert y2[2] == approx(s2[1])
# Test structure of depletion time dataset
dep_time = res.get_depletion_time()
assert dep_time.shape == (len(dt), )
assert all(dep_time > 0)

35
tests/unit_tests/test_deplete_integrator.py
View file

@ -7,7 +7,6 @@ will be left unimplemented and testing will be done via regression.
"""
import copy
import os
from unittest.mock import MagicMock
import numpy as np
@ -18,6 +17,8 @@ from openmc.deplete import (
ReactionRates, Results, ResultsList, comm, OperatorResult,
PredictorIntegrator, SICELIIntegrator)
from tests import dummy_operator
def test_results_save(run_in_tmpdir):
"""Test data save module"""
@ -41,10 +42,11 @@ def test_results_save(run_in_tmpdir):
full_burn_list.append(str(2*i))
full_burn_list.append(str(2*i + 1))
burn_list = full_burn_list[2*comm.rank : 2*comm.rank + 2]
burn_list = full_burn_list[2*comm.rank: 2*comm.rank + 2]
nuc_list = ["na", "nb"]
op.get_results_info.return_value = vol_dict, nuc_list, burn_list, full_burn_list
op.get_results_info.return_value = (
vol_dict, nuc_list, burn_list, full_burn_list)
# Construct x
x1 = []
@ -130,3 +132,30 @@ def test_bad_integrator_inputs(timesteps):
with pytest.raises(ValueError, match="n_steps"):
SICELIIntegrator(op, timesteps, [1], n_steps=0)
@pytest.mark.parametrize("scheme", dummy_operator.SCHEMES)
def test_integrator(run_in_tmpdir, scheme):
"""Test the integrators against their expected values"""
bundle = dummy_operator.SCHEMES[scheme]
operator = dummy_operator.DummyOperator()
bundle.solver(operator, [0.75, 0.75], 1.0).integrate()
# get expected results
res = ResultsList.from_hdf5(
operator.output_dir / "depletion_results.h5")
t1, y1 = res.get_atoms("1", "1")
t2, y2 = res.get_atoms("1", "2")
assert (t1 == [0.0, 0.75, 1.5]).all()
assert y1 == pytest.approx(bundle.atoms_1)
assert (t2 == [0.0, 0.75, 1.5]).all()
assert y2 == pytest.approx(bundle.atoms_2)
# test structure of depletion time dataset
dep_time = res.get_depletion_time()
assert dep_time.shape == (2, )
assert all(dep_time > 0)

43
tests/unit_tests/test_deplete_leqi.py
View file

@ -1,43 +0,0 @@
"""Regression tests for openmc.deplete.integrator.leqi algorithm.
These tests integrate a simple test problem described in dummy_geometry.py.
"""
from pytest import approx
from openmc.deplete import LEQIIntegrator, ResultsList
from tests import dummy_operator
def test_leqi(run_in_tmpdir):
"""Integral regression test of integrator algorithm using leqi"""
op = dummy_operator.DummyOperator()
op.output_dir = "test_integrator_regression"
# Perform simulation using the leqi algorithm
dt = [0.75, 0.75]
power = 1.0
LEQIIntegrator(op, dt, power).integrate()
# Load the files
res = ResultsList.from_hdf5(op.output_dir / "depletion_results.h5")
_, y1 = res.get_atoms("1", "1")
_, y2 = res.get_atoms("1", "2")
# Reference solution
s1 = [1.82078767, 0.97122898]
s2 = [2.74526197, 0.23339915]
assert y1[1] == approx(s1[0])
assert y2[1] == approx(s1[1])
assert y1[2] == approx(s2[0])
assert y2[2] == approx(s2[1])
# Test structure of depletion time dataset
dep_time = res.get_depletion_time()
assert dep_time.shape == (len(dt), )
assert all(dep_time > 0)

44
tests/unit_tests/test_deplete_predictor.py
View file

@ -1,44 +0,0 @@
"""Regression tests for openmc.deplete.integrator.predictor algorithm.
These tests integrate a simple test problem described in dummy_geometry.py.
"""
from pytest import approx
from openmc.deplete import PredictorIntegrator, ResultsList
from tests import dummy_operator
def test_predictor(run_in_tmpdir):
"""Integral regression test of integrator algorithm using predictor"""
op = dummy_operator.DummyOperator()
op.output_dir = "test_integrator_regression"
# Perform simulation using the predictor algorithm
dt = [0.75, 0.75]
power = 1.0
PredictorIntegrator(op, dt, power).integrate()
# Load the files
res = ResultsList.from_hdf5(op.output_dir / "depletion_results.h5")
_, y1 = res.get_atoms("1", "1")
_, y2 = res.get_atoms("1", "2")
# Mathematica solution
s1 = [2.46847546272295, 0.986431226850467]
s2 = [4.11525874568034, -0.0581692232513460]
assert y1[1] == approx(s1[0])
assert y2[1] == approx(s1[1])
assert y1[2] == approx(s2[0])
assert y2[2] == approx(s2[1])
# Test structure of depletion time dataset
dep_time = res.get_depletion_time()
assert dep_time.shape == (len(dt), )
assert all(dep_time > 0)

347
tests/unit_tests/test_deplete_restart.py
View file

@ -4,96 +4,13 @@ These tests run in two steps, a first run then a restart run, a simple test
problem described in dummy_geometry.py.
"""
from pytest import approx, raises
import pytest
import openmc.deplete
from openmc.deplete import (
CECMIntegrator, PredictorIntegrator, CELIIntegrator, LEQIIntegrator,
EPCRK4Integrator, CF4Integrator, SICELIIntegrator, SILEQIIntegrator
)
from tests import dummy_operator
def test_restart_predictor(run_in_tmpdir):
"""Integral regression test of integrator algorithm using predictor."""
op = dummy_operator.DummyOperator()
output_dir = "test_restart_predictor"
op.output_dir = output_dir
# Perform simulation using the predictor algorithm
dt = [0.75]
power = 1.0
PredictorIntegrator(op, dt, power).integrate()
# Load the files
prev_res = openmc.deplete.ResultsList.from_hdf5(op.output_dir / "depletion_results.h5")
# Re-create depletion operator and load previous results
op = dummy_operator.DummyOperator(prev_res)
op.output_dir = output_dir
# Perform restarts simulation using the predictor algorithm
PredictorIntegrator(op, dt, power).integrate()
# Load the files
res = openmc.deplete.ResultsList.from_hdf5(op.output_dir / "depletion_results.h5")
_, y1 = res.get_atoms("1", "1")
_, y2 = res.get_atoms("1", "2")
# Mathematica solution
s1 = [2.46847546272295, 0.986431226850467]
s2 = [4.11525874568034, -0.0581692232513460]
assert y1[1] == approx(s1[0])
assert y2[1] == approx(s1[1])
assert y1[2] == approx(s2[0])
assert y2[2] == approx(s2[1])
def test_restart_cecm(run_in_tmpdir):
"""Integral regression test of integrator algorithm using CE/CM."""
op = dummy_operator.DummyOperator()
output_dir = "test_restart_cecm"
op.output_dir = output_dir
# Perform simulation using the MCNPX/MCNP6 algorithm
dt = [0.75]
power = 1.0
cecm = CECMIntegrator(op, dt, power)
cecm.integrate()
# Load the files
prev_res = openmc.deplete.ResultsList.from_hdf5(op.output_dir / "depletion_results.h5")
# Re-create depletion operator and load previous results
op = dummy_operator.DummyOperator(prev_res)
op.output_dir = output_dir
# Perform restarts simulation using the MCNPX/MCNP6 algorithm
cecm_restart = CECMIntegrator(op, dt, power)
cecm_restart.integrate()
# Load the files
res = openmc.deplete.ResultsList.from_hdf5(op.output_dir / "depletion_results.h5")
_, y1 = res.get_atoms("1", "1")
_, y2 = res.get_atoms("1", "2")
# Mathematica solution
s1 = [1.86872629872102, 1.395525772416039]
s2 = [2.18097439443550, 2.69429754646747]
assert y1[1] == approx(s1[0])
assert y2[1] == approx(s1[1])
assert y1[2] == approx(s2[0])
assert y2[2] == approx(s2[1])
def test_restart_predictor_cecm(run_in_tmpdir):
"""Test to ensure that schemes with different stages are not compatible"""
@ -104,18 +21,19 @@ def test_restart_predictor_cecm(run_in_tmpdir):
# Perform simulation using the predictor algorithm
dt = [0.75]
power = 1.0
PredictorIntegrator(op, dt, power).integrate()
openmc.deplete.PredictorIntegrator(op, dt, power).integrate()
# Load the files
prev_res = openmc.deplete.ResultsList.from_hdf5(op.output_dir / "depletion_results.h5")
prev_res = openmc.deplete.ResultsList.from_hdf5(
op.output_dir / "depletion_results.h5")
# Re-create depletion operator and load previous results
op = dummy_operator.DummyOperator(prev_res)
op.output_dir = output_dir
# check ValueError is raised, indicating previous and current stages
with raises(ValueError, match="incompatible.* 1.*2"):
CECMIntegrator(op, dt, power)
with pytest.raises(ValueError, match="incompatible.* 1.*2"):
openmc.deplete.CECMIntegrator(op, dt, power)
def test_restart_cecm_predictor(run_in_tmpdir):
@ -129,249 +47,48 @@ def test_restart_cecm_predictor(run_in_tmpdir):
# Perform simulation using the MCNPX/MCNP6 algorithm
dt = [0.75]
power = 1.0
cecm = CECMIntegrator(op, dt, power)
cecm = openmc.deplete.CECMIntegrator(op, dt, power)
cecm.integrate()
# Load the files
prev_res = openmc.deplete.ResultsList.from_hdf5(op.output_dir / "depletion_results.h5")
prev_res = openmc.deplete.ResultsList.from_hdf5(
op.output_dir / "depletion_results.h5")
# Re-create depletion operator and load previous results
op = dummy_operator.DummyOperator(prev_res)
op.output_dir = output_dir
# check ValueError is raised, indicating previous and current stages
with raises(ValueError, match="incompatible.* 2.*1"):
PredictorIntegrator(op, dt, power)
with pytest.raises(ValueError, match="incompatible.* 2.*1"):
openmc.deplete.PredictorIntegrator(op, dt, power)
def test_restart_cf4(run_in_tmpdir):
"""Integral regression test of integrator algorithm using CF4."""
op = dummy_operator.DummyOperator()
output_dir = "test_restart_cf4"
op.output_dir = output_dir
@pytest.mark.parametrize("scheme", dummy_operator.SCHEMES)
def test_restart(run_in_tmpdir, scheme):
# set up the problem
# Perform simulation
dt = [0.75]
power = 1.0
CF4Integrator(op, dt, power).integrate()
bundle = dummy_operator.SCHEMES[scheme]
# Load the files
prev_res = openmc.deplete.ResultsList.from_hdf5(op.output_dir / "depletion_results.h5")
operator = dummy_operator.DummyOperator()
# Re-create depletion operator and load previous results
op = dummy_operator.DummyOperator(prev_res)
op.output_dir = output_dir
# take first step
bundle.solver(operator, [0.75], 1.0).integrate()
# Perform restarts simulation
CF4Integrator(op, dt, power).integrate()
# restart
prev_res = openmc.deplete.ResultsList.from_hdf5(
operator.output_dir / "depletion_results.h5")
operator = dummy_operator.DummyOperator(prev_res)
# Load the files
res = openmc.deplete.ResultsList.from_hdf5(op.output_dir / "depletion_results.h5")
# take second step
bundle.solver(operator, [0.75], 1.0).integrate()
_, y1 = res.get_atoms("1", "1")
_, y2 = res.get_atoms("1", "2")
# compare results
# Reference solution
s1 = [2.06101629, 1.37783588]
s2 = [2.57241318, 2.63731630]
results = openmc.deplete.ResultsList.from_hdf5(
operator.output_dir / "depletion_results.h5")
assert y1[1] == approx(s1[0])
assert y2[1] == approx(s1[1])
_t, y1 = results.get_atoms("1", "1")
_t, y2 = results.get_atoms("1", "2")
assert y1[2] == approx(s2[0])
assert y2[2] == approx(s2[1])
def test_restart_epc_rk4(run_in_tmpdir):
"""Integral regression test of integrator algorithm using EPC-RK4."""
op = dummy_operator.DummyOperator()
output_dir = "test_restart_epc_rk4"
op.output_dir = output_dir
# Perform simulation
dt = [0.75]
power = 1.0
EPCRK4Integrator(op, dt, power).integrate()
# Load the files
prev_res = openmc.deplete.ResultsList.from_hdf5(op.output_dir / "depletion_results.h5")
# Re-create depletion operator and load previous results
op = dummy_operator.DummyOperator(prev_res)
op.output_dir = output_dir
# Perform restarts simulation
EPCRK4Integrator(op, dt, power).integrate()
# Load the files
res = openmc.deplete.ResultsList.from_hdf5(op.output_dir / "depletion_results.h5")
_, y1 = res.get_atoms("1", "1")
_, y2 = res.get_atoms("1", "2")
# Reference solution
s1 = [2.01978516, 1.42038037]
s2 = [2.05246421, 3.06177191]
assert y1[1] == approx(s1[0])
assert y2[1] == approx(s1[1])
assert y1[2] == approx(s2[0])
assert y2[2] == approx(s2[1])
def test_restart_celi(run_in_tmpdir):
"""Integral regression test of integrator algorithm using CELI."""
op = dummy_operator.DummyOperator()
output_dir = "test_restart_celi"
op.output_dir = output_dir
# Perform simulation
dt = [0.75]
power = 1.0
CELIIntegrator(op, dt, power).integrate()
# Load the files
prev_res = openmc.deplete.ResultsList.from_hdf5(op.output_dir / "depletion_results.h5")
# Re-create depletion operator and load previous results
op = dummy_operator.DummyOperator(prev_res)
op.output_dir = output_dir
# Perform restarts simulation
CELIIntegrator(op, dt, power).integrate()
# Load the files
res = openmc.deplete.ResultsList.from_hdf5(op.output_dir / "depletion_results.h5")
_, y1 = res.get_atoms("1", "1")
_, y2 = res.get_atoms("1", "2")
# Reference solution
s1 = [1.82078767, 0.97122898]
s2 = [2.68441779, 0.05125966]
assert y1[1] == approx(s1[0])
assert y2[1] == approx(s1[1])
assert y1[2] == approx(s2[0])
assert y2[2] == approx(s2[1])
def test_restart_leqi(run_in_tmpdir):
"""Integral regression test of integrator algorithm using LEQI."""
op = dummy_operator.DummyOperator()
output_dir = "test_restart_leqi"
op.output_dir = output_dir
# Perform simulation
dt = [0.75]
power = 1.0
LEQIIntegrator(op, dt, power).integrate()
# Load the files
prev_res = openmc.deplete.ResultsList.from_hdf5(op.output_dir / "depletion_results.h5")
# Re-create depletion operator and load previous results
op = dummy_operator.DummyOperator(prev_res)
op.output_dir = output_dir
# Perform restarts simulation
LEQIIntegrator(op, dt, power).integrate()
# Load the files
res = openmc.deplete.ResultsList.from_hdf5(op.output_dir / "depletion_results.h5")
_, y1 = res.get_atoms("1", "1")
_, y2 = res.get_atoms("1", "2")
# Reference solution
s1 = [1.82078767, 0.97122898]
s2 = [2.74526197, 0.23339915]
assert y1[1] == approx(s1[0])
assert y2[1] == approx(s1[1])
assert y1[2] == approx(s2[0])
assert y2[2] == approx(s2[1])
def test_restart_si_celi(run_in_tmpdir):
"""Integral regression test of integrator algorithm using SI-CELI."""
op = dummy_operator.DummyOperator()
output_dir = "test_restart_si_celi"
op.output_dir = output_dir
# Perform simulation
dt = [0.75]
power = 1.0
SICELIIntegrator(op, dt, power).integrate()
# Load the files
prev_res = openmc.deplete.ResultsList.from_hdf5(op.output_dir / "depletion_results.h5")
# Re-create depletion operator and load previous results
op = dummy_operator.DummyOperator(prev_res)
op.output_dir = output_dir
# Perform restarts simulation
SICELIIntegrator(op, dt, power).integrate()
# Load the files
res = openmc.deplete.ResultsList.from_hdf5(op.output_dir / "depletion_results.h5")
_, y1 = res.get_atoms("1", "1")
_, y2 = res.get_atoms("1", "2")
# Reference solution
s1 = [2.03325094, 1.16826254]
s2 = [2.69291933, 0.37907772]
assert y1[1] == approx(s1[0])
assert y2[1] == approx(s1[1])
assert y1[2] == approx(s2[0])
assert y2[2] == approx(s2[1])
def test_restart_si_leqi(run_in_tmpdir):
"""Integral regression test of integrator algorithm using SI-LEQI."""
op = dummy_operator.DummyOperator()
output_dir = "test_restart_si_leqi"
op.output_dir = output_dir
# Perform simulation
dt = [0.75]
power = 1.0
nstages = 10
SILEQIIntegrator(op, dt, power, nstages).integrate()
# Load the files
prev_res = openmc.deplete.ResultsList.from_hdf5(op.output_dir / "depletion_results.h5")
# Re-create depletion operator and load previous results
op = dummy_operator.DummyOperator(prev_res)
op.output_dir = output_dir
# Perform restarts simulation
SILEQIIntegrator(op, dt, power, nstages).integrate()
# Load the files
res = openmc.deplete.ResultsList.from_hdf5(op.output_dir / "depletion_results.h5")
_, y1 = res.get_atoms("1", "1")
_, y2 = res.get_atoms("1", "2")
# Reference solution
s1 = [2.03325094, 1.16826254]
s2 = [2.92711288, 0.53753236]
assert y1[1] == approx(s1[0])
assert y2[1] == approx(s1[1])
assert y1[2] == approx(s2[0])
assert y2[2] == approx(s2[1])
assert y1 == pytest.approx(bundle.atoms_1)
assert y2 == pytest.approx(bundle.atoms_2)

43
tests/unit_tests/test_deplete_si_celi.py
View file

@ -1,43 +0,0 @@
"""Regression tests for openmc.deplete.integrator.si_celi algorithm.
These tests integrate a simple test problem described in dummy_geometry.py.
"""
from pytest import approx
from openmc.deplete import SICELIIntegrator, ResultsList
from tests import dummy_operator
def test_si_celi(run_in_tmpdir):
"""Integral regression test of integrator algorithm using si_celi"""
op = dummy_operator.DummyOperator()
op.output_dir = "test_integrator_regression"
# Perform simulation using the si_celi algorithm
dt = [0.75, 0.75]
power = 1.0
SICELIIntegrator(op, dt, power).integrate()
# Load the files
res = ResultsList.from_hdf5(op.output_dir / "depletion_results.h5")
_, y1 = res.get_atoms("1", "1")
_, y2 = res.get_atoms("1", "2")
# Reference solution
s1 = [2.03325094, 1.16826254]
s2 = [2.69291933, 0.37907772]
assert y1[1] == approx(s1[0])
assert y2[1] == approx(s1[1])
assert y1[2] == approx(s2[0])
assert y2[2] == approx(s2[1])
# Test structure of depletion time dataset
dep_time = res.get_depletion_time()
assert dep_time.shape == (len(dt), )
assert all(dep_time > 0)

43
tests/unit_tests/test_deplete_si_leqi.py
View file

@ -1,43 +0,0 @@
"""Regression tests for openmc.deplete.integrator.si_leqi algorithm.
These tests integrate a simple test problem described in dummy_geometry.py.
"""
from pytest import approx
from openmc.deplete import SILEQIIntegrator, ResultsList
from tests import dummy_operator
def test_si_leqi(run_in_tmpdir):
"""Integral regression test of integrator algorithm using si_leqi"""
op = dummy_operator.DummyOperator()
op.output_dir = "test_integrator_regression"
# Perform simulation using the si_leqi algorithm
dt = [0.75, 0.75]
power = 1.0
SILEQIIntegrator(op, dt, power, 10).integrate()
# Load the files
res = ResultsList.from_hdf5(op.output_dir / "depletion_results.h5")
_, y1 = res.get_atoms("1", "1")
_, y2 = res.get_atoms("1", "2")
# Reference solution
s1 = [2.03325094, 1.16826254]
s2 = [2.92711288, 0.53753236]
assert y1[1] == approx(s1[0])
assert y2[1] == approx(s1[1])
assert y1[2] == approx(s2[0])
assert y2[2] == approx(s2[1])
# Test structure of depletion time dataset
dep_time = res.get_depletion_time()
assert dep_time.shape == (len(dt), )
assert all(dep_time > 0)