diff --git a/doc/conf.py b/doc/conf.py index 50cee653a..8d12aa4d6 100644 --- a/doc/conf.py +++ b/doc/conf.py @@ -36,13 +36,13 @@ # -- sphinx-multiversion configuration --------------------------------------- # Whitelist pattern for tags (set to None to ignore all tags) -smv_tag_whitelist = r'^v\d[.][^12][.]\d.*$' +smv_tag_whitelist = r'^v\d[.][^1234][.]\d$' # Whitelist pattern for branches (set to None to ignore all branches) smv_branch_whitelist = r'^(master)*$' # Whitelist pattern for remotes (set to None to use local branches only) -smv_remote_whitelist = r'^(origin|upstream)$' +smv_remote_whitelist = r'^upstream$' # Pattern for released versions smv_released_pattern = r'^tags/.*$' diff --git a/doc/io_formats/saltproc_input.rst b/doc/io_formats/saltproc_input.rst index 4d75b7c8d..15135c20f 100644 --- a/doc/io_formats/saltproc_input.rst +++ b/doc/io_formats/saltproc_input.rst @@ -72,7 +72,7 @@ Required properties are as follows: ``proc_input_file``, ``dot_input_file``, ``o .. _mpi_args_property: ``mpi_args`` ---------------------- +------------ :description: Arguments for running simulations on supercomputers using ``mpiexec`` @@ -93,7 +93,7 @@ Required properties are as follows: ``proc_input_file``, ``dot_input_file``, ``o .. _rebuild_saltproc_results_property: ``rebuild_saltproc_results`` ---------------------- +---------------------------- :description: Flag to reconstruct the ``saltproc_results.h5`` files from the stepwise @@ -110,7 +110,7 @@ Required properties are as follows: ``proc_input_file``, ``dot_input_file``, ``o .. _run_without_reprocessing_property: ``run_without_reprocessing`` ---------------------- +---------------------------- :description: Flag to run SaltProc with no material reprocessing. diff --git a/doc/methods/coupling.rst b/doc/methods/coupling.rst deleted file mode 100644 index f49178090..000000000 --- a/doc/methods/coupling.rst +++ /dev/null @@ -1,6 +0,0 @@ -.. _methods_coupling: - -Coupling -======== - -SaltProc used file-based coupling to interface with external depletion solvers.... diff --git a/doc/methods/geometry_switching.rst b/doc/methods/geometry_switching.rst deleted file mode 100644 index a05cca675..000000000 --- a/doc/methods/geometry_switching.rst +++ /dev/null @@ -1,7 +0,0 @@ -.. _methods_geometry_switching: - -Geometry Switching -================== - -coming soon... - diff --git a/doc/methods/index.rst b/doc/methods/index.rst index e38b3c891..3cc2274c5 100644 --- a/doc/methods/index.rst +++ b/doc/methods/index.rst @@ -14,6 +14,4 @@ about the SaltProc's program flow, design, mathematical background, and more. .. toctree:: :maxdepth: 1 - coupling reprocessing - geometry_switching diff --git a/doc/methods/reprocessing.rst b/doc/methods/reprocessing.rst index b8b26ad1b..a7009b319 100644 --- a/doc/methods/reprocessing.rst +++ b/doc/methods/reprocessing.rst @@ -3,4 +3,163 @@ Reprocessing Methods ==================== -Coming soon! +SaltProc models separations and feeds using three different data structures: + +Material flows +-------------- +A material flow represents a material with a given +volume :math:`V`, density :math:`\rho`, temperature :math:`T`, and nuclide composition :math:`\mathbf{N}` flowing in or out +of a processing component. +It can also include information such as void fraction. :class:`saltproc.Materialflow` +objects contain the prior mentioned quantities as attributes, as well as +methods to perform the following: + +1. Add two :class:`saltproc.Materialflow` objects together + + a. The mass of the sum is :math:`m_{1+2} = m_{1} + m_{2}` + + b. The composition of the sum is :math:`\mathbf{N}_{1+2} = \frac{\mathbf{N}_{1} * m_{1} + \mathbf{N}_{2} * m_{2}}{m_{1} + m_{2}}` + + c. The temperature and density are assumed to be equal to the first :class:`saltproc.Materialflow` object + +2. Scale a :class:`saltproc.Materialflow` object by a constant, specifically the mass and volume of the :class:`saltproc.Materialflow` object. + +:class:`saltproc.Materialflow`. objects are used to store information about +materials in reprocessing as well as materials being fed into the system. + +Processes +......... +A process is an abstraction of chemical separation, extraction, or some +other removal. Two processes commonly used in \Gls{msr}s include +extracting metals using gas sparging and filtering. In SaltProc, +:class:`saltproc.Process` objects contain data and functions to perform their +associated processing task. At a minimum, a :class:`saltproc.Process` object includes +the following + +1. A mass flow rate, :math:`\dot{m}`, which specifies the mass of fuel salt a process can operate on per unit time +2. An extraction efficiency, :math:`\epsilon`, for target element(s) +3. A method to apply the process on a :class:`saltproc.Materialflow` object + +Graphs +...... +A graph is a mathematical object that connects *nodes* +with *edges*. More formally, +a graph is a pair of sets, :math:`(V, E)`, where + +- :math:`V` is a set whose elements are called nodes +- :math:`E` is a set whose elements are pairs of elements in :math:`V` + +A directed graph is a graph in which the elements are ordered pairs of elements +in :math:`V`. This gives the edges a direction. SaltProc uses directed graphs to +model the order and path in which processes operate on materials. + +Processes and feeds are defined in one JSON input file, and the graph linking +processes is defined in a DOT file. The process graph must be directed and +acyclic in order to work with SaltProc. At runtime, +SaltProc reads this input file to create :class:`saltproc.Process` objects for each item +in the file. Every process file must have at least a :class:`core_outlet` and +:class:`core_inlet` Process. + +Material reprocessing +--------------------- + +Recall that SaltProc uses a *batchwise* reprocessing scheme. +Let :math:`\mathbf{n}(t)^{j}` denote the nuclide mass vector for depletable material +:math:`j` as a function of time. For each depletable material :math:`j`, the depletion +solver numerically integrates the equation + +.. math:: + + \frac{d\mathbf{n}^{j}(t)}{dt} = \mathbf{A}(\mathbf{n}^{j}(t), t) + +from time :math:`i` to time :math:`i+1` to get :math:`\mathbf{n}^{j}(i+1)`, where :math:`A` is the +depletion matrix. This sequence is called a **depletion step**. + +Now, let the mass and volume of depletable material :math:`j` be +:math:`m^{j}` and :math:`V^{j}` respectively. Let the mass flow rate of process :math:`p` be +:math:`\dot{m}_{p}`. At the end of each depletion step, SaltProc constructs process +paths from the process graph defined in the DOT file, and sequentially applies +each process :math:`p` in each path :math:`r` to the relevant materials to obtain through +and waste streams for each material. SaltProc tracks the mass and nuclide vector for both through and waste streams. For through +streams, SaltProc also tracks the volume and mass flow rate. For every node +:math:`p\in[0,l]` where :math:`0` represents the core outlet and :math:`l` represents the core +inlet, in the path :math:`r`, for the through streams we have + +.. math:: + + \mathbf{n}^{j}_{\text{through, }p,r} = \mathbf{n}^{j}_{\text{through, }p-1,r} (1 - \pmb{\epsilon}^{j}_{p,r}) + +.. math:: + + m^{j}_{\text{through, } p,r} = \alpha_{p} m^{j}_{\text{through, }p-1,r} - m^{j}_{\text{waste, }p,r} + +.. math:: + + V^{j}_{\text{through, }p,r} = \alpha_{p}V^{j}_{\text{through, }p-1,r} + +where + +.. math:: + + \alpha_{p,r} = \frac{\dot{m}_{p,r}}{\dot{m}_{\text{outlet}}} + +and the initial conditions are + +.. math:: + + \mathbf{n}^{j}_{\text{through, }0,r} = \mathbf{n}^{j}(i+1) + +.. math:: + + m^{j}_{\text{through, }0,r} = \rho^{j}(i+1)V^{j}(i+1) + +.. math:: + + V^{j}_{\text{through, }0,r} = V^{j}(i+1) + +Similarly, for the waste streams, we have + +.. math:: + + \mathbf{n}^{j}_{\text{waste, }p,r} = \mathbf{n}^{j}_{\text{through, }p-1,r} \cdot \pmb{\epsilon}^{j}_{p,r} + +.. math:: + + m^{j}_{\text{waste, }p,r} = \alpha_{p,r} m^{j}_{\text{through, }p-1,r} \langle\mathbf{1},\mathbf{n}^{j}_{\text{waste, }p,r}\rangle + + +SaltProc does not currently track the volume and mass flow rate of waste streams. +In practice, since it is extremely resource intensive to separate individual +isotopes, SaltProc only allows extraction efficiencies to be defined for +elements. Additionally, any chemical processing would only act on elements, so there is little point in having isotope specific extration efficiencies. So, for any isotope :math:`a` of xenon, +:math:`\epsilon_{\ce{^{a}Xe}} = \epsilon_{\ce{^{a^{\prime}}Xe}}` where +:math:`a^{\prime} \in \text{isotopes of Xe}` + +After the recursive computation, SaltProc sums through and waste streams over all +paths to get the total through stream at the inlet, and the total waste stream at +the inlet which represents all material removed during reprocessing. In practice, +we are working with nuclide mass fractions, not total masses, so in the program +there is an expansion and then normalization of the vectors: + +.. math:: + + \mathbf{n}^{j}_\text{through, inlet, net} = \frac{\sum_{r} m^{j}_{\text{through, inlet, }r} \mathbf{n}^{j}_{\text{through, inlet, }r}}{\sum_{r} m^{j}_{\text{through, inlet, }r}} + +.. math:: + + \mathbf{n}^{j}_{\text{waste, inlet, net}} = \frac{\sum_{r} m^{j}_{\text{waste, inlet, }r} \mathbf{n}^{j}_{\text{waste, inlet, }r}}{m^{j}_{\text{waste, inlet, }r}} + +Before running the next depletion step, for any material that has an associated +feed material defined, SaltProc will add an amount of the feed material +equivalent to the removed mass so that the mass of fuel salt undergoing depletion +remains constant. For feed :math:`j'` corresponding to material :math:`j`, we have + +.. math:: + + \mathbf{n}^{j}_\text{filled} = \frac{m^{j}_{\text{through, }l}\mathbf{n}^{j}_\text{through, inlet, net} + m^{j}_{\text{removed}}\mathbf{n}^{j'}}{m^{j}_{\text{through, }0}} + +where + +.. math:: + + m^{j}_\text{removed} = m^{j}_{\text{through, }0} - m^{j}_{\text{through, }l}