From 0a2933ce5304ad35f562b3c131af7a482e1422c7 Mon Sep 17 00:00:00 2001 From: church89 Date: Fri, 15 Mar 2024 13:37:44 +0100 Subject: [PATCH] replaced batchwise nomenclature with reactivity_control one --- openmc/deplete/__init__.py | 2 +- openmc/deplete/abc.py | 52 ++++++++------- .../{batchwise.py => reactivity_control.py} | 66 ++++++++++--------- openmc/deplete/stepresult.py | 18 ++--- openmc/search.py | 2 +- .../__init__.py | 0 .../test.py | 13 ++-- ....py => test_deplete_reactivity_control.py} | 53 ++++++++------- 8 files changed, 108 insertions(+), 98 deletions(-) rename openmc/deplete/{batchwise.py => reactivity_control.py} (95%) rename tests/regression_tests/{deplete_with_batchwise => deplete_with_reactivity_control}/__init__.py (100%) rename tests/regression_tests/{deplete_with_batchwise => deplete_with_reactivity_control}/test.py (91%) rename tests/unit_tests/{test_deplete_batchwise.py => test_deplete_reactivity_control.py} (79%) diff --git a/openmc/deplete/__init__.py b/openmc/deplete/__init__.py index c86a93c8a1..5e0063c90e 100644 --- a/openmc/deplete/__init__.py +++ b/openmc/deplete/__init__.py @@ -17,7 +17,7 @@ from .stepresult import * from .results import * from .integrators import * from .transfer_rates import * -from .batchwise import * +from .reactivity_control import * from . import abc from . import cram from . import helpers diff --git a/openmc/deplete/abc.py b/openmc/deplete/abc.py index c73f397e5a..e77ff1d11e 100644 --- a/openmc/deplete/abc.py +++ b/openmc/deplete/abc.py @@ -26,8 +26,11 @@ from .results import Results from .pool import deplete from .transfer_rates import TransferRates from openmc import Material, Cell -from .batchwise import (BatchwiseCellGeometrical, BatchwiseCellTemperature, - BatchwiseMaterialRefuel) +from .reactivity_control import ( + GeometricalCellReactivityController, + TemperatureCellReactivityController, + RefuelMaterialReactivityController +) __all__ = [ "OperatorResult", "TransportOperator", @@ -556,8 +559,8 @@ class Integrator(ABC): transfer_rates : openmc.deplete.TransferRates Instance of TransferRates class to perform continuous transfer during depletion - batchwise : openmc.deplete.Batchwise - Instance of Batchwise class to perform batch-wise scheme during + reactivity_control : openmc.deplete.ReactivityController + Instance of ReactivityController class to perform reactivity control during transport-depletion simulation. .. versionadded:: 0.14.0 @@ -641,7 +644,7 @@ class Integrator(ABC): self.source_rates = asarray(source_rates) self.transfer_rates = None - self._batchwise = None + self._reactivity_control = None if isinstance(solver, str): # Delay importing of cram module, which requires this file @@ -691,8 +694,8 @@ class Integrator(ABC): self._solver = func @property - def batchwise(self): - return self._batchwise + def reactivity_control(self): + return self._reactivity_control def _timed_deplete(self, n, rates, dt, matrix_func=None): start = time.time() @@ -773,11 +776,11 @@ class Integrator(ABC): return (self.operator.prev_res[-1].time[-1], len(self.operator.prev_res) - 1) - def _get_bos_from_batchwise(self, step_index, bos_conc): - """Get BOS from criticality batch-wise control.""" + def _get_bos_from_reactivity_control(self, step_index, bos_conc): + """Get BOS from reactivity control.""" x = deepcopy(bos_conc) # Get new vector after keff criticality control - x, root = self._batchwise.search_for_keff(x, step_index) + x, root = self._reactivity_control.search_for_keff(x, step_index) return x, root def integrate( @@ -814,9 +817,9 @@ class Integrator(ABC): # Solve transport equation (or obtain result from restart) if i > 0 or self.operator.prev_res is None: - # Update geometry/material according to batchwise definition - if self._batchwise is not None and source_rate != 0.0: - n, root = self._get_bos_from_batchwise(i, n) + # Update geometry/material according to reactivity control + if self._reactivity_control is not None and source_rate != 0.0: + n, root = self._get_bos_from_reactivity_control(i, n) else: root = None n, res = self._get_bos_data_from_operator(i, source_rate, n) @@ -843,8 +846,8 @@ class Integrator(ABC): # solve) if output and final_step and comm.rank == 0: print(f"[openmc.deplete] t={t} (final operator evaluation)") - if self._batchwise is not None and source_rate != 0.0: - n, root = self._get_bos_from_batchwise(i+1, n) + if self._reactivity_control is not None and source_rate != 0.0: + n, root = self._get_bos_from_reactivity_control(i+1, n) else: root = None res_list = [self.operator(n, source_rate if final_step else 0.0)] @@ -882,31 +885,32 @@ class Integrator(ABC): self.transfer_rates.set_transfer_rate(material, components, transfer_rate, transfer_rate_units, destination_material) - def add_batchwise(self, obj, attr, **kwargs): - """Add batchwise operation to integrator scheme. + def add_reactivity_control(self, obj, attr, **kwargs): + """Add reactivity control to integrator scheme. Parameters ---------- obj : openmc.Cell or openmc.Material object or id or str name - Cell or Materials identifier to where add batchwise scheme + Cell or Materials identifier to where add reactivity control attr : str - Attribute to specify the type of batchwise scheme. Accepted values + Attribute to specify the type of reactivity control. Accepted values are: 'translation', 'rotation', 'temperature' for an openmc.Cell object; 'refuel' for an openmc.Material object. **kwargs - keyword arguments that are passed to the batchwise class. + keyword arguments that are passed to ReactivityController. """ check_value('attribute', attr, ('translation', 'rotation', 'temperature', 'refuel')) if attr in ('translation', 'rotation'): - batchwise = BatchwiseCellGeometrical + reactivity_control = GeometricalCellReactivityController elif attr == 'temperature': - batchwise = BatchwiseCellTemperature + reactivity_control = TemperatureCellReactivityController elif attr == 'refuel': - batchwise = BatchwiseMaterialRefuel + reactivity_control = RefuelMaterialReactivityController - self._batchwise = batchwise.from_params(obj, attr, self.operator,**kwargs) + self._reactivity_control = reactivity_control.from_params(obj, attr, + self.operator,**kwargs) @add_params class SIIntegrator(Integrator): diff --git a/openmc/deplete/batchwise.py b/openmc/deplete/reactivity_control.py similarity index 95% rename from openmc/deplete/batchwise.py rename to openmc/deplete/reactivity_control.py index 6b055aae00..8191d88ef7 100644 --- a/openmc/deplete/batchwise.py +++ b/openmc/deplete/reactivity_control.py @@ -19,20 +19,20 @@ from openmc.checkvalue import ( ) -class Batchwise(ABC): - """Abstract class defining a generalized batch wise scheme. +class ReactivityController(ABC): + """Abstract class defining a generalized reactivity control. - Batchwise schemes, such as control rod adjustment or material refuelling to - control reactivity and maintain keff constant and equal to a desired value, - usually one. + Reactivity control schemes, such as control rod adjustment or material + refuelling to control reactivity and maintain keff constant and equal to a + desired value, usually one. - A batch wise scheme can be added here to an integrator instance, + A reactivity control scheme can be added here to an integrator instance, such as :class:`openmc.deplete.CECMIntegrator`, to parametrize one system variable with the aim of satisfy certain design criteria, such as keeping keff equal to one, while running transport-depletion calculations. - Specific classes for running batch wise depletion calculations are - implemented as derived class of Batchwise. + Specific classes for running reactivity control depletion calculations are + implemented as derived class of ReactivityController. .. versionadded:: 0.14.1 @@ -348,7 +348,7 @@ class Batchwise(ABC): """Update number density and material compositions in OpenMC on all processes. If density_treatment is set to 'constant-density' - :meth:`openmc.deplete.batchwise._update_volumes` is called to update + :meth:`openmc.deplete.reactivity_control._update_volumes` is called to update material volumes in AtomNumber, keeping the material total density constant, before re-normalizing the atom densities and assigning them to the model in memory. @@ -430,11 +430,11 @@ class Batchwise(ABC): return x -class BatchwiseCell(Batchwise): - """Abstract class holding batch wise cell-based functions. +class CellReactivityController(ReactivityController): + """Abstract class holding reactivity control cell-based functions. - Specific classes for running batch wise depletion calculations are - implemented as derived class of BatchwiseCell. + Specific classes for running reactivity control depletion calculations are + implemented as derived class of CellReactivityController. .. versionadded:: 0.14.1 @@ -674,13 +674,13 @@ class BatchwiseCell(Batchwise): return x, root -class BatchwiseCellGeometrical(BatchwiseCell): - """Batch wise cell-based with geometrical-attribute class. +class GeometricalCellReactivityController(CellReactivityController): + """Reactivity control cell-based with geometrical-attribute class. A user doesn't need to call this class directly. Instead an instance of this class is automatically created by calling - :meth:`openmc.deplete.Integrator.add_batchwise` method from an integrator - class, such as :class:`openmc.deplete.CECMIntegrator`. + :meth:`openmc.deplete.Integrator.add_reactivity_control` method from an + integrator class, such as :class:`openmc.deplete.CECMIntegrator`. .. versionadded:: 0.14.1 @@ -850,13 +850,13 @@ class BatchwiseCellGeometrical(BatchwiseCell): return volumes -class BatchwiseCellTemperature(BatchwiseCell): - """Batch wise cell-based with temperature-attribute class. +class TemperatureCellReactivityController(CellReactivityController): + """Reactivity control cell-based with temperature-attribute class. A user doesn't need to call this class directly. Instead an instance of this class is automatically created by calling - :meth:`openmc.deplete.Integrator.add_batchwise` method from an integrator - class, such as :class:`openmc.deplete.CECMIntegrator`. + :meth:`openmc.deplete.Integrator.add_reactivity_control` method from an + integrator class, such as :class:`openmc.deplete.CECMIntegrator`. .. versionadded:: 0.14.1 @@ -972,11 +972,11 @@ class BatchwiseCellTemperature(BatchwiseCell): self.lib_cell.set_temperature(val) -class BatchwiseMaterial(Batchwise): - """Abstract class holding batch wise material-based functions. +class MaterialReactivityController(ReactivityController): + """Abstract class holding reactivity control material-based functions. - Specific classes for running batch wise depletion calculations are - implemented as derived class of BatchwiseMaterial. + Specific classes for running reactivity control depletion calculations are + implemented as derived class of MaterialReactivityController. .. versionadded:: 0.14.1 @@ -1140,13 +1140,14 @@ class BatchwiseMaterial(Batchwise): return x, root -class BatchwiseMaterialRefuel(BatchwiseMaterial): - """Batch wise material-based class for refuelling (addition or removal) scheme. +class RefuelMaterialReactivityController(MaterialReactivityController): + """Reactivity control material-based class for refuelling (addition or + removal) scheme. A user doesn't need to call this class directly. Instead an instance of this class is automatically created by calling - :meth:`openmc.deplete.Integrator.add_batchwise` method from an integrator - class, such as :class:`openmc.deplete.CECMIntegrator`. + :meth:`openmc.deplete.Integrator.add_reactivity_control` method from an + integrator class, such as :class:`openmc.deplete.CECMIntegrator`. .. versionadded:: 0.14.1 @@ -1315,14 +1316,15 @@ class BatchwiseMaterialRefuel(BatchwiseMaterial): return self.model def _calculate_volumes(self, res): - """Uses :meth:`openmc.batchwise._search_for_keff` solution as grams of - material to add or remove to calculate new material volume. + """Uses :meth:`openmc.deplete.reactivity_control._search_for_keff` + solution as grams of material to add or remove to calculate new material + volume. Parameters ---------- res : float Solution in grams of material, coming from - :meth:`openmc.batchwise._search_for_keff` + :meth:`openmc.deplete.reactivity_control._search_for_keff` Returns ------- diff --git a/openmc/deplete/stepresult.py b/openmc/deplete/stepresult.py index dd9a0f2cc6..bef7fffdd0 100644 --- a/openmc/deplete/stepresult.py +++ b/openmc/deplete/stepresult.py @@ -56,7 +56,7 @@ class StepResult: Number of stages in simulation. data : numpy.ndarray Atom quantity, stored by stage, mat, then by nuclide. - batchwise : float + reac_cont : float The root returned by the reactivity controller. proc_time : int Average time spent depleting a material across all @@ -76,7 +76,7 @@ class StepResult: self.mat_to_hdf5_ind = None self.data = None - self.batchwise = None + self.reac_cont = None def __repr__(self): t = self.time[0] @@ -353,7 +353,7 @@ class StepResult: dtype="float64") handle.create_dataset( - "batchwise_root", (1,), maxshape=(None,), + "reac_cont_root", (1,), maxshape=(None,), dtype="float64") def _to_hdf5(self, handle, index, parallel=False): @@ -386,7 +386,7 @@ class StepResult: time_dset = handle["/time"] source_rate_dset = handle["/source_rate"] proc_time_dset = handle["/depletion time"] - root_dset = handle["/batchwise_root"] + root_dset = handle["/reac_cont_root"] # Get number of results stored number_shape = list(number_dset.shape) @@ -447,7 +447,7 @@ class StepResult: proc_time_dset[index] = ( self.proc_time / (comm.size * self.n_hdf5_mats) ) - root_dset[index] = self.batchwise + root_dset[index] = self.reac_cont @classmethod def from_hdf5(cls, handle, step): @@ -482,9 +482,9 @@ class StepResult: if step < proc_time_dset.shape[0]: results.proc_time = proc_time_dset[step] - if "batchwise_root" in handle: - root_dset = handle["/batchwise_root"] - results.batchwise = root_dset[step] + if "reac_cont_root" in handle: + root_dset = handle["/reac_cont_root"] + results.reac_cont = root_dset[step] if results.proc_time is None: results.proc_time = np.array([np.nan]) @@ -582,7 +582,7 @@ class StepResult: results.proc_time = proc_time if results.proc_time is not None: results.proc_time = comm.reduce(proc_time, op=MPI.SUM) - results.batchwise = root + results.reac_cont = root if not Path(path).is_file(): Path(path).parent.mkdir(parents=True, exist_ok=True) diff --git a/openmc/search.py b/openmc/search.py index 527417a193..9b18e87002 100644 --- a/openmc/search.py +++ b/openmc/search.py @@ -223,5 +223,5 @@ def search_for_keff(model_builder, initial_guess=None, target=1.0, return guesses, results # In case the root finder is not successful except Exception as e: - warn(f'{e}) + warn(f'{e}') return guesses, results diff --git a/tests/regression_tests/deplete_with_batchwise/__init__.py b/tests/regression_tests/deplete_with_reactivity_control/__init__.py similarity index 100% rename from tests/regression_tests/deplete_with_batchwise/__init__.py rename to tests/regression_tests/deplete_with_reactivity_control/__init__.py diff --git a/tests/regression_tests/deplete_with_batchwise/test.py b/tests/regression_tests/deplete_with_reactivity_control/test.py similarity index 91% rename from tests/regression_tests/deplete_with_batchwise/test.py rename to tests/regression_tests/deplete_with_reactivity_control/test.py index 9c45045a65..1f1fa543d5 100644 --- a/tests/regression_tests/deplete_with_batchwise/test.py +++ b/tests/regression_tests/deplete_with_reactivity_control/test.py @@ -1,4 +1,4 @@ -""" Tests for Batchwise class """ +""" Tests for ReactivityController class """ from pathlib import Path import shutil @@ -83,8 +83,9 @@ def model(): ('rot_cell', 'rotation', [-90,90], 2, None, 'depletion_with_rotation'), ('f', 'refuel', [-100,100], None, {'U235':1}, 'depletion_with_refuel') ]) -def test_batchwise(run_in_tmpdir, model, obj, attribute, bracket_limit, axis, - vec, ref_result): +def test_reactivity_control(run_in_tmpdir, model, obj, attribute, bracket_limit, + axis, vec, ref_result): + chain_file = Path(__file__).parents[2] / 'chain_simple.xml' op = CoupledOperator(model, chain_file) @@ -100,7 +101,7 @@ def test_batchwise(run_in_tmpdir, model, obj, attribute, bracket_limit, axis, if axis is not None: kwargs['axis'] = axis - integrator.add_batchwise(obj, attribute, **kwargs) + integrator.add_reactivity_control(obj, attribute, **kwargs) integrator.integrate() # Get path to test and reference results @@ -117,5 +118,5 @@ def test_batchwise(run_in_tmpdir, model, obj, attribute, bracket_limit, axis, res_ref = openmc.deplete.Results(path_reference) # Use high tolerance here - assert [res.batchwise for res in res_test] == pytest.approx( - [res.batchwise for res in res_ref], rel=2) + assert [res.reac_cont for res in res_test] == pytest.approx( + [res.reac_cont for res in res_ref], rel=2) diff --git a/tests/unit_tests/test_deplete_batchwise.py b/tests/unit_tests/test_deplete_reactivity_control.py similarity index 79% rename from tests/unit_tests/test_deplete_batchwise.py rename to tests/unit_tests/test_deplete_reactivity_control.py index e48d86edba..98944f42d8 100644 --- a/tests/unit_tests/test_deplete_batchwise.py +++ b/tests/unit_tests/test_deplete_reactivity_control.py @@ -1,4 +1,4 @@ -""" Tests for Batchwise class """ +""" Tests for ReactivityController class """ from pathlib import Path @@ -8,8 +8,11 @@ import numpy as np import openmc import openmc.lib from openmc.deplete import CoupledOperator -from openmc.deplete import (BatchwiseCellGeometrical, BatchwiseCellTemperature, - BatchwiseMaterialRefuel) +from openmc.deplete import ( + GeometricalCellReactivityController, + TemperatureCellReactivityController, + RefuelMaterialReactivityController +) CHAIN_PATH = Path(__file__).parents[1] / "chain_simple.xml" @@ -97,36 +100,36 @@ def test_attributes(case_name, model, operator, integrator, obj, attribute, if case_name == "invalid_1": with pytest.raises(ValueError) as e: - integrator.add_batchwise(obj, attribute, **kwargs) + integrator.add_reactivity_control(obj, attribute, **kwargs) assert str(e.value) == 'Unable to set "Material name" to "universe_cell" '\ 'since it is not in "[\'fuel\', \'water\']"' elif case_name == "invalid_2": with pytest.raises(ValueError) as e: - integrator.add_batchwise(obj, attribute, **kwargs) + integrator.add_reactivity_control(obj, attribute, **kwargs) assert str(e.value) == 'Unable to set "Cell name exists" to "fuel" since '\ 'it is not in "[\'fuel_cell\', \'universe_cell\', \'\', \'\']"' elif case_name == "invalid_3": with pytest.raises(ValueError) as e: - integrator.add_batchwise(obj, attribute, **kwargs) + integrator.add_reactivity_control(obj, attribute, **kwargs) assert str(e.value) == 'Unable to set "Cell name exists" to "fuel" since '\ 'it is not in "[\'fuel_cell\', \'universe_cell\', \'\', \'\']"' else: - integrator.add_batchwise(obj, attribute, **kwargs) + integrator.add_reactivity_control(obj, attribute, **kwargs) if attribute in ('translation','rotation'): - assert integrator.batchwise.universe_cells == [cell for cell in \ + assert integrator.reactivity_control.universe_cells == [cell for cell in \ model.geometry.get_cells_by_name(obj)[0].fill.cells.values() \ if cell.fill.depletable] - assert integrator.batchwise.axis == axis + assert integrator.reactivity_control.axis == axis elif attribute == 'refuel': - assert integrator.batchwise.mat_vector == vec + assert integrator.reactivity_control.mat_vector == vec - assert integrator.batchwise.attrib_name == attribute - assert integrator.batchwise.bracket == bracket - assert integrator.batchwise.bracket_limit == limit - assert integrator.batchwise.burn_mats == operator.burnable_mats - assert integrator.batchwise.local_mats == operator.local_mats + assert integrator.reactivity_control.attrib_name == attribute + assert integrator.reactivity_control.bracket == bracket + assert integrator.reactivity_control.bracket_limit == limit + assert integrator.reactivity_control.burn_mats == operator.burnable_mats + assert integrator.reactivity_control.local_mats == operator.local_mats @pytest.mark.parametrize("obj, attribute, value_to_set", [ ('universe_cell', 'translation', 0), @@ -139,15 +142,15 @@ def test_cell_methods(run_in_tmpdir, model, operator, integrator, obj, attribute """ kwargs = {'bracket':[-1,1], 'bracket_limit':[-10,10], 'axis':2, 'tol':0.1} - integrator.add_batchwise(obj, attribute, **kwargs) + integrator.add_reactivity_control(obj, attribute, **kwargs) model.export_to_xml() openmc.lib.init() - integrator.batchwise._set_cell_attrib(value_to_set) - assert integrator.batchwise._get_cell_attrib() == value_to_set + integrator.reactivity_control._set_cell_attrib(value_to_set) + assert integrator.reactivity_control._get_cell_attrib() == value_to_set - vol = integrator.batchwise._calculate_volumes() - for cell in integrator.batchwise.universe_cells: + vol = integrator.reactivity_control._calculate_volumes() + for cell in integrator.reactivity_control.universe_cells: assert vol[str(cell.id)] == pytest.approx([ mat.volume for mat in model.materials \ if mat.id == cell.id][0], rel=tolerance) @@ -167,7 +170,7 @@ def test_internal_methods(run_in_tmpdir, model, operator, integrator, nuclide, kwargs = {'bracket':[-1,1], 'bracket_limit':[-10,10], 'mat_vector':{}} - integrator.add_batchwise('fuel', 'refuel', **kwargs) + integrator.add_reactivity_control('fuel', 'refuel', **kwargs) model.export_to_xml() openmc.lib.init() @@ -175,12 +178,12 @@ def test_internal_methods(run_in_tmpdir, model, operator, integrator, nuclide, #Increase number of atoms of U238 in fuel by fix amount and check the # volume increase at constant-density #extract fuel material from model materials - mat = integrator.batchwise.material + mat = integrator.reactivity_control.material mat_index = operator.number.index_mat[str(mat.id)] nuc_index = operator.number.index_nuc[nuclide] vol = operator.number.get_mat_volume(str(mat.id)) operator.number.number[mat_index][nuc_index] += atoms_to_add - integrator.batchwise._update_volumes() + integrator.reactivity_control._update_volumes() vol_to_compare = vol + (atoms_to_add * openmc.data.atomic_mass(nuclide) /\ openmc.data.AVOGADRO / mat.density) @@ -188,14 +191,14 @@ def test_internal_methods(run_in_tmpdir, model, operator, integrator, nuclide, assert operator.number.get_mat_volume(str(mat.id)) == pytest.approx(vol_to_compare) x = [i[:operator.number.n_nuc_burn] for i in operator.number.number] - integrator.batchwise._update_materials(x) + integrator.reactivity_control._update_materials(x) nuc_index_lib = openmc.lib.materials[mat.id].nuclides.index(nuclide) dens_to_compare = 1.0e-24 * operator.number.get_atom_density(str(mat.id), nuclide) assert openmc.lib.materials[mat.id].densities[nuc_index_lib] == pytest.approx(dens_to_compare) volumes = {str(mat.id): vol + 1} - new_x = integrator.batchwise._update_x_and_set_volumes(x, volumes) + new_x = integrator.reactivity_control._update_x_and_set_volumes(x, volumes) dens_to_compare = 1.0e24 * volumes[str(mat.id)] *\ openmc.lib.materials[mat.id].densities[nuc_index_lib] assert new_x[mat_index][nuc_index] == pytest.approx(dens_to_compare)