From be84b38ce62122bd3b4db00c15e552959f0df7f6 Mon Sep 17 00:00:00 2001 From: Paul Romano Date: Wed, 16 Jun 2021 14:36:33 +0700 Subject: [PATCH] Rename pincell_depletion --> depletion --- depletion.ipynb | 886 ++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 886 insertions(+) create mode 100644 depletion.ipynb diff --git a/depletion.ipynb b/depletion.ipynb new file mode 100644 index 0000000..0ab2f1a --- /dev/null +++ b/depletion.ipynb @@ -0,0 +1,886 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Depletion\n", + "This notebook is intended to introduce the reader to the depletion interface contained in OpenMC. It is recommended that you are moderately familiar with building models using the OpenMC Python API. The earlier examples are excellent starting points, as this notebook will not focus heavily on model building.\n", + "\n", + "If you have a real power reactor, the fuel composition is constantly changing as fission events produce energy, remove some fissile isotopes, and produce fission products. Other reactions, like $(n, \\alpha)$ and $(n, \\gamma)$ will alter the composition as well. Furthermore, some nuclides undergo spontaneous decay with widely ranging frequencies. Depletion is the process of modeling this behavior.\n", + "\n", + "In this notebook, we will model a simple fuel pin in an infinite lattice using the Python API. We will then build and examine some of the necessary components for performing depletion analysis. Then, we will use the depletion interface in OpenMC to simulate the fuel pin producing power over several months. Lastly, we will wrap up with some helpful tips to improve the fidelity of depletion simulations." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib inline\n", + "import math\n", + "import openmc" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Build the Geometry\n", + "\n", + "Much of this section is borrowed from the \"Modeling a Pin-Cell\" example. If you find yourself not understanding some aspects of this section, feel free to refer to that example, as some details may be glossed over for brevity.\n", + "\n", + "First, we will create our fuel, cladding, and water materials to represent a typical PWR." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "fuel = openmc.Material(name=\"uo2\")\n", + "fuel.add_element(\"U\", 1, percent_type=\"ao\", enrichment=4.25)\n", + "fuel.add_element(\"O\", 2)\n", + "fuel.set_density(\"g/cc\", 10.4)\n", + "\n", + "clad = openmc.Material(name=\"clad\")\n", + "clad.add_element(\"Zr\", 1)\n", + "clad.set_density(\"g/cc\", 6)\n", + "\n", + "water = openmc.Material(name=\"water\")\n", + "water.add_element(\"O\", 1)\n", + "water.add_element(\"H\", 2)\n", + "water.set_density(\"g/cc\", 1.0)\n", + "water.add_s_alpha_beta(\"c_H_in_H2O\")\n", + "materials = openmc.Materials([fuel, clad, water])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Here, we are going to use the `openmc.model.pin` function to build our pin cell. The `pin` function anticipates concentric cylinders and materials to fill the inner regions. One additional material is needed than the number of cylinders to cover the domain outside the final ring. \n", + "\n", + "To do this, we define two radii for the outer radius of our fuel pin, and the outer radius of the cladding." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "radii = [0.42, 0.45]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Using these radii, we define concentric `ZCylinder` objects. So long as the cylinders are concentric and increasing in radius, any orientation can be used. We also take advantage of the fact that the `openmc.Materials` object is a subclass of the `list` object to assign materials to the regions defined by the surfaces." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "pin_surfaces = [openmc.ZCylinder(r=r) for r in radii]\n", + "pin_univ = openmc.model.pin(pin_surfaces, materials)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The first material, in our case `fuel`, is placed inside the first cylinder in the inner-most region. The second material, `clad`, fills the space between our cylinders, while `water` is placed outside the last ring. The `pin` function returns an `openmc.Universe` object, and has some additional features we will mention later. Finally, we need to place the fuel pin universe in a bounding cell." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "bound_box = openmc.rectangular_prism(1.24, 1.24, boundary_type=\"reflective\")\n", + "root_cell = openmc.Cell(fill=pin_univ, region=bound_box)\n", + "geometry = openmc.Geometry([root_cell])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To ensure our geometry looks right, let's plot it." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "geometry.root_universe.plot()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Lastly we construct our settings. For the sake of time, a relatively low number of particles will be used." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "settings = openmc.Settings()\n", + "settings.particles = 1000\n", + "settings.inactive = 10\n", + "settings.batches = 50" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The depletion interface relies on `OpenMC` to perform the transport simulation and obtain reaction rates and other important information. Normally, we would need to export XML files before running OpenMC, but the depletion interface takes care of this for us." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "However, we must first add one bit of information: the volume of our fuel. In order to translate the reaction rates obtained by `openmc` to meaningful units for depletion, we have to normalize them to a correct power. This requires us to know, or be able to calculate, how much fuel is in our problem. Correctly setting the volumes is a critical step, and can lead to incorrect answers, as the fuel is over- or under-depleted due to poor normalization.\n", + "\n", + "For our problem, we can assign the \"volume\" to be the cross-sectional area of our fuel. This is identical to modeling our fuel pin inside a box with height of 1 cm." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "fuel.volume = math.pi * radii[0] ** 2" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Setting up for depletion\n", + "\n", + "The OpenMC depletion interface can be accessed from the `openmc.deplete` module, and has a variety of classes that will help us." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "import openmc.deplete" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In order to run the depletion calculation we need the following information:\n", + "\n", + "1. Nuclide decay, fission yield, and reaction data\n", + "2. Operational power or power density\n", + "3. Desired depletion schedule\n", + "4. Desired time integration scheme\n", + "\n", + "The first item is necessary to determine the paths by which nuclides transmute over the depletion simulation. This includes spontaneous decay, fission product yield distributions, and nuclides produced through neutron-reactions. For example,\n", + "* Te129 decays to I129 with a half life of ~70 minutes\n", + "* A fission event for U-235 produces fission products like Xe135 according to a distribution\n", + "* For thermal problems, Am241 will produce metastable Am242 about 8% of the time during an $(n,\\gamma)$ reaction. The other 92% of capture reactions will produce ground state Am242\n", + "\n", + "These data are often distributed with other nuclear data, like incident neutron cross sections with ENDF/B-VII.\n", + "OpenMC uses the [`openmc.deplete.Chain`](https://docs.openmc.org/en/latest/pythonapi/generated/openmc.deplete.Chain.html#openmc.deplete.Chain) to collect represent the various decay and transmutation pathways in a single object.\n", + "While a complete `Chain` can be created using nuclear data files, users may prefer to download pre-generated XML-representations instead.\n", + "Such files can be found at https://openmc.org/depletion-chains/ and include full and compressed chains, with capture branching ratios derived using PWR- or SFR-spectra.\n", + "\n", + "For this problem, we will be using a much smaller depletion chain that contains very few nuclides. In a realistic problem, over 1000 isotopes may be included in the depletion chain." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "OrderedDict([('I135', 0),\n", + " ('Xe135', 1),\n", + " ('Xe136', 2),\n", + " ('Cs135', 3),\n", + " ('Gd157', 4),\n", + " ('Gd156', 5),\n", + " ('U234', 6),\n", + " ('U235', 7),\n", + " ('U238', 8)])" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "chain = openmc.deplete.Chain.from_xml(\"./chain_simple.xml\")\n", + "chain.nuclide_dict" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The primary entry point for depletion is the `openmc.deplete.Operator`. It relies on the `openmc.deplete.Chain` and helper classes to run `openmc`, retrieve and normalize reaction rates, and other perform other tasks. For a thorough description, please see the full API documentation." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We will create our Operator using the geometry and settings from above, and our simple chain file. The materials are read in automatically using the `materials.xml` file." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "operator = openmc.deplete.Operator(geometry, settings, \"./chain_simple.xml\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We will then simulate our fuel pin operating at linear power of 174 W/cm, or 174 W given a unit height for our problem." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "power = 174" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "For this problem, we will take depletion step sizes of 30 days, and instruct OpenMC to re-run a transport simulation every 30 days until we have modeled the problem over a six month cycle. The depletion interface expects the time to be given in seconds, so we will have to convert. Note that these values are not cumulative." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "time_steps = [30] * 6" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "And lastly, we will use the basic predictor, or forward Euler, time integration scheme. Other, more advanced methods are provided to the user through `openmc.deplete`" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "integrator = openmc.deplete.PredictorIntegrator(operator, time_steps, power, timestep_units='d')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To perform the simulation, we use the `integrate` method, and let `openmc` take care of the rest." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "integrator.integrate()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Processing the outputs\n", + "\n", + "The depletion simulation produces a few output files. First, the statepoint files from each individual transport simulation are written to `openmc_simulation_n.h5`, where `` indicates the current depletion step. Any tallies that we defined in `tallies.xml` will be included in these files across our simulations. We have 7 such files, one for each our of 6 depletion steps and the initial state." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "depletion_results.h5\t openmc_simulation_n3.h5 statepoint.50.h5\r\n", + "openmc_simulation_n0.h5 openmc_simulation_n4.h5 summary.h5\r\n", + "openmc_simulation_n1.h5 openmc_simulation_n5.h5\r\n", + "openmc_simulation_n2.h5 openmc_simulation_n6.h5\r\n" + ] + } + ], + "source": [ + "!ls *.h5" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The `depletion_results.h5` file contains information that is aggregated over all time steps through depletion. This includes the multiplication factor, as well as concentrations. We can process this file using the `openmc.deplete.ResultsList` object" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "results = openmc.deplete.ResultsList.from_hdf5(\"./depletion_results.h5\")" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "time, k = results.get_eigenvalue()" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "time /= (24 * 60 * 60) # convert back to days from seconds" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[1.4618427 , 0.00459795],\n", + " [1.43996612, 0.00407154],\n", + " [1.4293619 , 0.0051392 ],\n", + " [1.4262837 , 0.00367395],\n", + " [1.41334423, 0.00460271],\n", + " [1.42301155, 0.0045317 ],\n", + " [1.41417596, 0.0045945 ]])" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "k" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The first column of `k` is the value of `k-combined` at each point in our simulation, while the second column contains the associated uncertainty. We can plot this using `matplotlib`" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [], + "source": [ + "from matplotlib import pyplot" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "pyplot.errorbar(time, k[:, 0], yerr=k[:, 1])\n", + "pyplot.xlabel(\"Time [d]\")\n", + "pyplot.ylabel(\"$k_{eff}\\pm \\sigma$\");" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Due to the low number of particles selected, the uncertainty on each value is rather high. However, we can still see the decline over time due to fuel consumption." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can then examine concentrations of atoms in each of our materials. This requires knowing the material ID, which can be obtained from the `materials.xml` file." + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [], + "source": [ + "_, u5 = results.get_atoms(\"1\", \"U235\")\n", + "_, xe135 = results.get_atoms(\"1\", \"Xe135\")" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "pyplot.plot(time, u5, label=\"U235\")\n", + "pyplot.xlabel(\"Time [d]\")\n", + "pyplot.ylabel(\"Number of atoms - U235\");" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "pyplot.plot(time, xe135, label=\"Xe135\")\n", + "pyplot.xlabel(\"Time [d]\")\n", + "pyplot.ylabel(\"Number of atoms - Xe135\");" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can also examine reaction rates over time using the `ResultsList`" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [], + "source": [ + "_, u5_fission = results.get_reaction_rate(\"1\", \"U235\", \"fission\")" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "pyplot.plot(time, u5_fission)\n", + "pyplot.xlabel(\"Time [d]\")\n", + "pyplot.ylabel(\"Fission reactions / s\");" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Helpful tips\n", + "\n", + "Depletion is a tricky task to get correct. Use too short of time steps and you may never get your results due to running many transport simulations. Use long of time steps and you may get incorrect answers. Consider the xenon plot from above. Xenon-135 is a fission product with a thermal absorption cross section on the order of millions of barns, but has a half life of ~9 hours. Taking smaller time steps at the beginning of your simulation to build up some equilibrium in your fission products is highly recommended.\n", + "\n", + "When possible, differentiate materials that reappear in multiple places. If we had built an entire core with the single `fuel` material, every pin would be depleted using the same averaged spectrum and reaction rates which is incorrect. The `Operator` can differentiate these materials using the `diff_burnable_mats` argument, but note that the volumes will be copied from the original material.\n", + "\n", + "Using higher-order integrators, like the `CECMIntegrator`, `EPCRK4Integrator` with a fourth order Runge-Kutta, or the `LEQIIntegrator`, can improve the accuracy of a simulation, or at least allow you to take longer depletion steps between transport simulations with similar accuracy.\n", + "\n", + "Fuel pins with integrated burnable absorbers, like gadolinia, experience strong flux gradients until the absorbers are mostly burned away. This means that the spectrum and magnitude of the flux at the edge of the fuel pin can be vastly different than that in the interior. The helper `pin` function can be used to subdivide regions into equal volume segments, as follows." + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [], + "source": [ + "div_surfs_1 = [openmc.ZCylinder(r=1)]\n", + "div_1 = openmc.model.pin(div_surfs_1, [fuel, water], subdivisions={0: 10})" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 29, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "div_1.plot(width=(2.0, 2.0))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The innermost region has been divided into 10 equal volume regions. We can pass additional arguments to divide multiple regions, except for the region outside the last cylinder." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Register depletion chain\n", + "\n", + "The depletion chain we created can be registered into the OpenMC `cross_sections.xml` file, so we don't have to always pass the `chain_file` argument to the `Operator`. To do this, we create a `DataLibrary` using `openmc.data`. Without any arguments, the `from_xml` method will look for the file located at `OPENMC_CROSS_SECTIONS`. For this example, we will just create a bare library." + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [], + "source": [ + "data_lib = openmc.data.DataLibrary()" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [], + "source": [ + "data_lib.register_file(\"./chain_simple.xml\")" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [], + "source": [ + "data_lib.export_to_xml()" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r\n", + "\r\n", + " \r\n", + "\r\n" + ] + } + ], + "source": [ + "!cat cross_sections.xml" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This allows us to make an `Operator` simply with the geometry and settings arguments, provided we exported our library to `OPENMC_CROSS_SECTIONS`. For a problem where we built and registered a `Chain` using all the available nuclear data, we might see something like the following." + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [], + "source": [ + "new_op = openmc.deplete.Operator(geometry, settings)" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "228" + ] + }, + "execution_count": 35, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "len(new_op.chain.nuclide_dict)" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['B10', 'B11', 'O16', 'Br81', 'Br82', 'Kr82', 'Kr83', 'Kr84', 'Kr85', 'Kr86']" + ] + }, + "execution_count": 36, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "[nuc.name for nuc in new_op.chain.nuclides[:10]]" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['Am242',\n", + " 'Am242_m1',\n", + " 'Am243',\n", + " 'Am244',\n", + " 'Am244_m1',\n", + " 'Cm242',\n", + " 'Cm243',\n", + " 'Cm244',\n", + " 'Cm245',\n", + " 'Cm246']" + ] + }, + "execution_count": 37, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "[nuc.name for nuc in new_op.chain.nuclides[-10:]]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Choice of depletion step size\n", + "\n", + "A general rule of thumb is to use depletion step sizes around 2 MWd/kgHM, where kgHM is really the initial heavy metal mass in kg. If your problem includes integral burnable absorbers, these typically require shorter time steps at or below 1 MWd/kgHM. These are typically valid for the predictor scheme, as the point of recent schemes is to extend this step size. A good convergence study, where the step size is decreased until some convergence metric is satisfied, is a beneficial exercise.\n", + "\n", + "We can use the `Operator` to determine our maximum step size using this recommendation. The `heavy_metal` attribute returns the mass of initial heavy metal in g, which, using our power, can be used to compute this step size. $$\\frac{2\\,MWd}{kgHM} = \\frac{P\\times\\Delta}{hm_{op}}$$" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "5.080339195584719" + ] + }, + "execution_count": 38, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "operator.heavy_metal" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [], + "source": [ + "max_step = 2 * operator.heavy_metal / power * 1E3" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\"Maximum\" depletion step: 58.4 [d]\n" + ] + } + ], + "source": [ + "print(\"\\\"Maximum\\\" depletion step: {:5.3} [d]\".format(max_step))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Alternatively, if we were provided the power density of our problem, we can provide this directly with `openmc.deplete.PredictorIntegrator(operator, time_steps, power_density=pdens)`. The values of `power` and `power_density` do not have to be scalars. For problems with variable power, we can provide an iterable with the same number of elements as `time_steps`." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.3" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +}