diff --git a/docs/source/examples/c5g7.h5 b/docs/source/examples/c5g7.h5 new file mode 100644 index 000000000..323afd078 Binary files /dev/null and b/docs/source/examples/c5g7.h5 differ diff --git a/docs/source/pythonapi/examples/images/mdgxs.png b/docs/source/examples/images/mdgxs.png similarity index 100% rename from docs/source/pythonapi/examples/images/mdgxs.png rename to docs/source/examples/images/mdgxs.png diff --git a/docs/source/pythonapi/examples/images/mgxs.png b/docs/source/examples/images/mgxs.png similarity index 100% rename from docs/source/pythonapi/examples/images/mgxs.png rename to docs/source/examples/images/mgxs.png diff --git a/docs/source/examples/index.rst b/docs/source/examples/index.rst new file mode 100644 index 000000000..c1117b463 --- /dev/null +++ b/docs/source/examples/index.rst @@ -0,0 +1,26 @@ +.. _examples: + +================= +Example Notebooks +================= + +The following series of Jupyter_ Notebooks provide examples for usage of OpenMC +features via the :ref:`pythonapi`. + +.. _Jupyter: https://jupyter.org/ + +.. toctree:: + :maxdepth: 1 + + post-processing + pandas-dataframes + tally-arithmetic + mgxs-part-i + mgxs-part-ii + mgxs-part-iii + mg-mode-part-i + mg-mode-part-ii + mg-mode-part-iii + mdgxs-part-i + mdgxs-part-ii + nuclear-data diff --git a/docs/source/pythonapi/examples/mdgxs-part-i.ipynb b/docs/source/examples/mdgxs-part-i.ipynb similarity index 100% rename from docs/source/pythonapi/examples/mdgxs-part-i.ipynb rename to docs/source/examples/mdgxs-part-i.ipynb diff --git a/docs/source/examples/mdgxs-part-i.rst b/docs/source/examples/mdgxs-part-i.rst new file mode 100644 index 000000000..260a7d042 --- /dev/null +++ b/docs/source/examples/mdgxs-part-i.rst @@ -0,0 +1,13 @@ +.. _notebook_mdgxs_part_i: + +=================================================================== +Multi-Group (Delayed) Cross Section Generation Part I: Introduction +=================================================================== + +.. only:: html + + .. notebook:: mdgxs-part-i.ipynb + +.. only:: latex + + IPython notebooks must be viewed in the online HTML documentation. diff --git a/docs/source/pythonapi/examples/mdgxs-part-ii.ipynb b/docs/source/examples/mdgxs-part-ii.ipynb similarity index 100% rename from docs/source/pythonapi/examples/mdgxs-part-ii.ipynb rename to docs/source/examples/mdgxs-part-ii.ipynb diff --git a/docs/source/examples/mdgxs-part-ii.rst b/docs/source/examples/mdgxs-part-ii.rst new file mode 100644 index 000000000..0f1350bd2 --- /dev/null +++ b/docs/source/examples/mdgxs-part-ii.rst @@ -0,0 +1,13 @@ +.. _notebook_mdgxs_part_ii: + +========================================================================= +Multi-Group (Delayed) Cross Section Generation Part II: Advanced Features +========================================================================= + +.. only:: html + + .. notebook:: mdgxs-part-ii.ipynb + +.. only:: latex + + IPython notebooks must be viewed in the online HTML documentation. diff --git a/docs/source/examples/mg-mode-part-i.ipynb b/docs/source/examples/mg-mode-part-i.ipynb new file mode 100644 index 000000000..1affe5e28 --- /dev/null +++ b/docs/source/examples/mg-mode-part-i.ipynb @@ -0,0 +1,724 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This Notebook illustrates the usage of OpenMC's multi-group calculational mode with the Python API. This example notebook creates and executes the 2-D [C5G7](https://www.oecd-nea.org/science/docs/2003/nsc-doc2003-16.pdf) benchmark model using the `openmc.MGXSLibrary` class to create the supporting data library on the fly." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Generate MGXS Library" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "import os\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import matplotlib.colors as colors\n", + "import numpy as np\n", + "\n", + "import openmc\n", + "\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We will now create the multi-group library using data directly from Appendix A of the [C5G7](https://www.oecd-nea.org/science/docs/2003/nsc-doc2003-16.pdf) benchmark documentation. All of the data below will be created at 294K, consistent with the benchmark.\n", + "\n", + "This notebook will first begin by setting the group structure and building the groupwise data for UO2. As you can see, the cross sections are input in the order of increasing groups (or decreasing energy).\n", + "\n", + "*Note*: The C5G7 benchmark uses transport-corrected cross sections. So the total cross section we input here will technically be the transport cross section." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# Create a 7-group structure with arbitrary boundaries (the specific boundaries are unimportant)\n", + "groups = openmc.mgxs.EnergyGroups(np.logspace(-5, 7, 8))\n", + "\n", + "uo2_xsdata = openmc.XSdata('uo2', groups)\n", + "uo2_xsdata.order = 0\n", + "\n", + "# When setting the data let the object know you are setting the data for a temperature of 294K.\n", + "uo2_xsdata.set_total([1.77949E-1, 3.29805E-1, 4.80388E-1, 5.54367E-1,\n", + " 3.11801E-1, 3.95168E-1, 5.64406E-1], temperature=294.)\n", + "\n", + "uo2_xsdata.set_absorption([8.0248E-03, 3.7174E-3, 2.6769E-2, 9.6236E-2,\n", + " 3.0020E-02, 1.1126E-1, 2.8278E-1], temperature=294.)\n", + "uo2_xsdata.set_fission([7.21206E-3, 8.19301E-4, 6.45320E-3, 1.85648E-2,\n", + " 1.78084E-2, 8.30348E-2, 2.16004E-1], temperature=294.)\n", + "\n", + "uo2_xsdata.set_nu_fission([2.005998E-2, 2.027303E-3, 1.570599E-2, 4.518301E-2,\n", + " 4.334208E-2, 2.020901E-1, 5.257105E-1], temperature=294.)\n", + "\n", + "uo2_xsdata.set_chi([5.87910E-1, 4.11760E-1, 3.39060E-4, 1.17610E-7,\n", + " 0.00000E-0, 0.00000E-0, 0.00000E-0], temperature=294.)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We will now add the scattering matrix data. \n", + "\n", + "*Note*: Most users familiar with deterministic transport libraries are already familiar with the idea of entering one scattering matrix for every order (i.e. scattering order as the outer dimension). However, the shape of OpenMC's scattering matrix entry is instead [Incoming groups, Outgoing Groups, Scattering Order] to best enable other scattering representations. We will follow the more familiar approach in this notebook, and then use numpy's `numpy.rollaxis` function to change the ordering to what we need (scattering order on the inner dimension)." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "# The scattering matrix is ordered with incoming groups as rows and outgoing groups as columns\n", + "# (i.e., below the diagonal is up-scattering).\n", + "scatter_matrix = \\\n", + " [[[1.27537E-1, 4.23780E-2, 9.43740E-6, 5.51630E-9, 0.00000E-0, 0.00000E-0, 0.00000E-0],\n", + " [0.00000E-0, 3.24456E-1, 1.63140E-3, 3.14270E-9, 0.00000E-0, 0.00000E-0, 0.00000E-0],\n", + " [0.00000E-0, 0.00000E-0, 4.50940E-1, 2.67920E-3, 0.00000E-0, 0.00000E-0, 0.00000E-0],\n", + " [0.00000E-0, 0.00000E-0, 0.00000E-0, 4.52565E-1, 5.56640E-3, 0.00000E-0, 0.00000E-0],\n", + " [0.00000E-0, 0.00000E-0, 0.00000E-0, 1.25250E-4, 2.71401E-1, 1.02550E-2, 1.00210E-8],\n", + " [0.00000E-0, 0.00000E-0, 0.00000E-0, 0.00000E-0, 1.29680E-3, 2.65802E-1, 1.68090E-2],\n", + " [0.00000E-0, 0.00000E-0, 0.00000E-0, 0.00000E-0, 0.00000E-0, 8.54580E-3, 2.73080E-1]]]\n", + "scatter_matrix = np.array(scatter_matrix)\n", + "scatter_matrix = np.rollaxis(scatter_matrix, 0, 3)\n", + "uo2_xsdata.set_scatter_matrix(scatter_matrix, temperature=294.)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now that the UO2 data has been created, we can move on to the remaining materials using the same process.\n", + "\n", + "However, we will actually skip repeating the above for now. Our simulation will instead use the `c5g7.h5` file that has already been created using exactly the same logic as above, but for the remaining materials in the benchmark problem.\n", + "\n", + "For now we will show how you would use the `uo2_xsdata` information to create an `openmc.MGXSLibrary` object and write to disk." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# Initialize the library\n", + "mg_cross_sections_file = openmc.MGXSLibrary(groups)\n", + "\n", + "# Add the UO2 data to it\n", + "mg_cross_sections_file.add_xsdata(uo2_xsdata)\n", + "\n", + "# And write to disk\n", + "mg_cross_sections_file.export_to_hdf5('mgxs.h5')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Generate 2-D C5G7 Problem Input Files" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To build the actual 2-D model, we will first begin by creating the `materials.xml` file.\n", + "\n", + "First we need to define materials that will be used in the problem. In other notebooks, either `openmc.Nuclide`s or `openmc.Element`s were created at the equivalent stage. We can do that in multi-group mode as well. However, multi-group cross-sections are sometimes provided as macroscopic cross-sections; the C5G7 benchmark data are macroscopic. In this case, we can instead use `openmc.Macroscopic` objects to in-place of `openmc.Nuclide` or `openmc.Element` objects.\n", + "\n", + "`openmc.Macroscopic`, unlike `openmc.Nuclide` and `openmc.Element` objects, do not need to be provided enough information to calculate number densities, as no number densities are needed.\n", + "\n", + "When assigning `openmc.Macroscopic` objects to `openmc.Material` objects, the density can still be scaled by setting the density to a value that is not 1.0. This would be useful, for example, when slightly perturbing the density of water due to a small change in temperature (while of course ignoring any resultant spectral shift). The density of a macroscopic dataset is set to 1.0 in the `openmc.Material` object by default when an `openmc.Macroscopic` dataset is used; so we will show its use the first time and then afterwards it will not be required.\n", + "\n", + "Aside from these differences, the following code is very similar to similar code in other OpenMC example Notebooks." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "# For every cross section data set in the library, assign an openmc.Macroscopic object to a material\n", + "materials = {}\n", + "for xs in ['uo2', 'mox43', 'mox7', 'mox87', 'fiss_chamber', 'guide_tube', 'water']:\n", + " materials[xs] = openmc.Material(name=xs)\n", + " materials[xs].set_density('macro', 1.)\n", + " materials[xs].add_macroscopic(xs)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we can go ahead and produce a `materials.xml` file for use by OpenMC" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# Instantiate a Materials collection, register all Materials, and export to XML\n", + "materials_file = openmc.Materials(materials.values())\n", + "\n", + "# Set the location of the cross sections file to our pre-written set\n", + "materials_file.cross_sections = 'c5g7.h5'\n", + "\n", + "materials_file.export_to_xml()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Our next step will be to create the geometry information needed for our assembly and to write that to the `geometry.xml` file.\n", + "\n", + "We will begin by defining the surfaces, cells, and universes needed for each of the individual fuel pins, guide tubes, and fission chambers." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "# Create the surface used for each pin\n", + "pin_surf = openmc.ZCylinder(x0=0, y0=0, R=0.54, name='pin_surf')\n", + "\n", + "# Create the cells which will be used to represent each pin type.\n", + "cells = {}\n", + "universes = {}\n", + "for material in materials.values():\n", + " # Create the cell for the material inside the cladding\n", + " cells[material.name] = openmc.Cell(name=material.name)\n", + " # Assign the half-spaces to the cell\n", + " cells[material.name].region = -pin_surf\n", + " # Register the material with this cell\n", + " cells[material.name].fill = material\n", + " \n", + " # Repeat the above for the material outside the cladding (i.e., the moderator)\n", + " cell_name = material.name + '_moderator'\n", + " cells[cell_name] = openmc.Cell(name=cell_name)\n", + " cells[cell_name].region = +pin_surf\n", + " cells[cell_name].fill = materials['water']\n", + " \n", + " # Finally add the two cells we just made to a Universe object\n", + " universes[material.name] = openmc.Universe(name=material.name)\n", + " universes[material.name].add_cells([cells[material.name], cells[cell_name]])" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": true + }, + "source": [ + "The next step is to take our universes (representing the different pin types) and lay them out in a lattice to represent the assembly types" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "lattices = {}\n", + "\n", + "# Instantiate the UO2 Lattice\n", + "lattices['UO2 Assembly'] = openmc.RectLattice(name='UO2 Assembly')\n", + "lattices['UO2 Assembly'].dimension = [17, 17]\n", + "lattices['UO2 Assembly'].lower_left = [-10.71, -10.71]\n", + "lattices['UO2 Assembly'].pitch = [1.26, 1.26]\n", + "u = universes['uo2']\n", + "g = universes['guide_tube']\n", + "f = universes['fiss_chamber']\n", + "lattices['UO2 Assembly'].universes = \\\n", + " [[u, u, u, u, u, u, u, u, u, u, u, u, u, u, u, u, u],\n", + " [u, u, u, u, u, u, u, u, u, u, u, u, u, u, u, u, u],\n", + " [u, u, u, u, u, g, u, u, g, u, u, g, u, u, u, u, u],\n", + " [u, u, u, g, u, u, u, u, u, u, u, u, u, g, u, u, u],\n", + " [u, u, u, u, u, u, u, u, u, u, u, u, u, u, u, u, u],\n", + " [u, u, g, u, u, g, u, u, g, u, u, g, u, u, g, u, u],\n", + " [u, u, u, u, u, u, u, u, u, u, u, u, u, u, u, u, u],\n", + " [u, u, u, u, u, u, u, u, u, u, u, u, u, u, u, u, u],\n", + " [u, u, g, u, u, g, u, u, f, u, u, g, u, u, g, u, u],\n", + " [u, u, u, u, u, u, u, u, u, u, u, u, u, u, u, u, u],\n", + " [u, u, u, u, u, u, u, u, u, u, u, u, u, u, u, u, u],\n", + " [u, u, g, u, u, g, u, u, g, u, u, g, u, u, g, u, u],\n", + " [u, u, u, u, u, u, u, u, u, u, u, u, u, u, u, u, u],\n", + " [u, u, u, g, u, u, u, u, u, u, u, u, u, g, u, u, u],\n", + " [u, u, u, u, u, g, u, u, g, u, u, g, u, u, u, u, u],\n", + " [u, u, u, u, u, u, u, u, u, u, u, u, u, u, u, u, u],\n", + " [u, u, u, u, u, u, u, u, u, u, u, u, u, u, u, u, u]]\n", + " \n", + "# Create a containing cell and universe\n", + "cells['UO2 Assembly'] = openmc.Cell(name='UO2 Assembly')\n", + "cells['UO2 Assembly'].fill = lattices['UO2 Assembly']\n", + "universes['UO2 Assembly'] = openmc.Universe(name='UO2 Assembly')\n", + "universes['UO2 Assembly'].add_cell(cells['UO2 Assembly'])\n", + "\n", + "# Instantiate the MOX Lattice\n", + "lattices['MOX Assembly'] = openmc.RectLattice(name='MOX Assembly')\n", + "lattices['MOX Assembly'].dimension = [17, 17]\n", + "lattices['MOX Assembly'].lower_left = [-10.71, -10.71]\n", + "lattices['MOX Assembly'].pitch = [1.26, 1.26]\n", + "m = universes['mox43']\n", + "n = universes['mox7']\n", + "o = universes['mox87']\n", + "g = universes['guide_tube']\n", + "f = universes['fiss_chamber']\n", + "lattices['MOX Assembly'].universes = \\\n", + " [[m, m, m, m, m, m, m, m, m, m, m, m, m, m, m, m, m],\n", + " [m, n, n, n, n, n, n, n, n, n, n, n, n, n, n, n, m],\n", + " [m, n, n, n, n, g, n, n, g, n, n, g, n, n, n, n, m],\n", + " [m, n, n, g, n, o, o, o, o, o, o, o, n, g, n, n, m],\n", + " [m, n, n, n, o, o, o, o, o, o, o, o, o, n, n, n, m],\n", + " [m, n, g, o, o, g, o, o, g, o, o, g, o, o, g, n, m],\n", + " [m, n, n, o, o, o, o, o, o, o, o, o, o, o, n, n, m],\n", + " [m, n, n, o, o, o, o, o, o, o, o, o, o, o, n, n, m],\n", + " [m, n, g, o, o, g, o, o, f, o, o, g, o, o, g, n, m],\n", + " [m, n, n, o, o, o, o, o, o, o, o, o, o, o, n, n, m],\n", + " [m, n, n, o, o, o, o, o, o, o, o, o, o, o, n, n, m],\n", + " [m, n, g, o, o, g, o, o, g, o, o, g, o, o, g, n, m],\n", + " [m, n, n, n, o, o, o, o, o, o, o, o, o, n, n, n, m],\n", + " [m, n, n, g, n, o, o, o, o, o, o, o, n, g, n, n, m],\n", + " [m, n, n, n, n, g, n, n, g, n, n, g, n, n, n, n, m],\n", + " [m, n, n, n, n, n, n, n, n, n, n, n, n, n, n, n, m],\n", + " [m, m, m, m, m, m, m, m, m, m, m, m, m, m, m, m, m]]\n", + " \n", + "# Create a containing cell and universe\n", + "cells['MOX Assembly'] = openmc.Cell(name='MOX Assembly')\n", + "cells['MOX Assembly'].fill = lattices['MOX Assembly']\n", + "universes['MOX Assembly'] = openmc.Universe(name='MOX Assembly')\n", + "universes['MOX Assembly'].add_cell(cells['MOX Assembly'])\n", + " \n", + "# Instantiate the reflector Lattice\n", + "lattices['Reflector Assembly'] = openmc.RectLattice(name='Reflector Assembly')\n", + "lattices['Reflector Assembly'].dimension = [1,1]\n", + "lattices['Reflector Assembly'].lower_left = [-10.71, -10.71]\n", + "lattices['Reflector Assembly'].pitch = [21.42, 21.42]\n", + "lattices['Reflector Assembly'].universes = [[universes['water']]]\n", + "\n", + "# Create a containing cell and universe\n", + "cells['Reflector Assembly'] = openmc.Cell(name='Reflector Assembly')\n", + "cells['Reflector Assembly'].fill = lattices['Reflector Assembly']\n", + "universes['Reflector Assembly'] = openmc.Universe(name='Reflector Assembly')\n", + "universes['Reflector Assembly'].add_cell(cells['Reflector Assembly'])" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": true + }, + "source": [ + "Let's now create the core layout in a 3x3 lattice where each lattice position is one of the assemblies we just defined.\n", + "\n", + "After that we can create the final cell to contain the entire core." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "lattices['Core'] = openmc.RectLattice(name='3x3 core lattice')\n", + "lattices['Core'].dimension= [3, 3]\n", + "lattices['Core'].lower_left = [-32.13, -32.13]\n", + "lattices['Core'].pitch = [21.42, 21.42]\n", + "r = universes['Reflector Assembly']\n", + "u = universes['UO2 Assembly']\n", + "m = universes['MOX Assembly']\n", + "lattices['Core'].universes = [[u, m, r],\n", + " [m, u, r],\n", + " [r, r, r]]\n", + "\n", + "# Create boundary planes to surround the geometry\n", + "min_x = openmc.XPlane(x0=-32.13, boundary_type='reflective')\n", + "max_x = openmc.XPlane(x0=+32.13, boundary_type='vacuum')\n", + "min_y = openmc.YPlane(y0=-32.13, boundary_type='vacuum')\n", + "max_y = openmc.YPlane(y0=+32.13, boundary_type='reflective')\n", + "\n", + "# Create root Cell\n", + "root_cell = openmc.Cell(name='root cell')\n", + "root_cell.fill = lattices['Core']\n", + "\n", + "# Add boundary planes\n", + "root_cell.region = +min_x & -max_x & +min_y & -max_y\n", + "\n", + "# Create root Universe\n", + "root_universe = openmc.Universe(name='root universe', universe_id=0)\n", + "root_universe.add_cell(root_cell)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Before we commit to the geometry, we should view it using the Python API's plotting capability" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAQcAAAD8CAYAAAB6iWHJAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "root_universe.plot(center=(0., 0., 0.), width=(3 * 21.42, 3 * 21.42), pixels=(500, 500),\n", + " color_by='material')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "OK, it looks pretty good, let's go ahead and write the file" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "# Create Geometry and set root Universe\n", + "geometry = openmc.Geometry(root_universe)\n", + "\n", + "# Export to \"geometry.xml\"\n", + "geometry.export_to_xml()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can now create the tally file information. The tallies will be set up to give us the pin powers in this notebook. We will do this with a mesh filter, with one mesh cell per pin." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "tallies_file = openmc.Tallies()\n", + "\n", + "# Instantiate a tally Mesh\n", + "mesh = openmc.Mesh()\n", + "mesh.type = 'regular'\n", + "mesh.dimension = [17 * 2, 17 * 2]\n", + "mesh.lower_left = [-32.13, -10.71]\n", + "mesh.upper_right = [+10.71, +32.13]\n", + "\n", + "# Instantiate tally Filter\n", + "mesh_filter = openmc.MeshFilter(mesh)\n", + "\n", + "# Instantiate the Tally\n", + "tally = openmc.Tally(name='mesh tally')\n", + "tally.filters = [mesh_filter]\n", + "tally.scores = ['fission']\n", + "\n", + "# Add tally to collection\n", + "tallies_file.append(tally)\n", + "\n", + "# Export all tallies to a \"tallies.xml\" file\n", + "tallies_file.export_to_xml()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "With the geometry and materials finished, we now just need to define simulation parameters for the `settings.xml` file. Note the use of the `energy_mode` attribute of our `settings_file` object. This is used to tell OpenMC that we intend to run in multi-group mode instead of the default continuous-energy mode. If we didn't specify this but our cross sections file was not a continuous-energy data set, then OpenMC would complain.\n", + "\n", + "This will be a relatively coarse calculation with only 500,000 active histories. A benchmark-fidelity run would of course require many more!" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "# OpenMC simulation parameters\n", + "batches = 150\n", + "inactive = 50\n", + "particles = 5000\n", + "\n", + "# Instantiate a Settings object\n", + "settings_file = openmc.Settings()\n", + "settings_file.batches = batches\n", + "settings_file.inactive = inactive\n", + "settings_file.particles = particles\n", + "\n", + "# Tell OpenMC this is a multi-group problem\n", + "settings_file.energy_mode = 'multi-group'\n", + "\n", + "# Set the verbosity to 6 so we dont see output for every batch\n", + "settings_file.verbosity = 6\n", + "\n", + "# Create an initial uniform spatial source distribution over fissionable zones\n", + "bounds = [-32.13, -10.71, -1e50, 10.71, 32.13, 1e50]\n", + "uniform_dist = openmc.stats.Box(bounds[:3], bounds[3:], only_fissionable=True)\n", + "settings_file.source = openmc.source.Source(space=uniform_dist)\n", + "\n", + "# Tell OpenMC we want to run in eigenvalue mode\n", + "settings_file.run_mode = 'eigenvalue'\n", + "\n", + "# Export to \"settings.xml\"\n", + "settings_file.export_to_xml()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's go ahead and execute the simulation! You'll notice that the output for multi-group mode is exactly the same as for continuous-energy. The differences are all under the hood." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + " %%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%\n", + " ############### %%%%%%%%%%%%%%%%%%%%%%%%\n", + " ################## %%%%%%%%%%%%%%%%%%%%%%%\n", + " ################### %%%%%%%%%%%%%%%%%%%%%%%\n", + " #################### %%%%%%%%%%%%%%%%%%%%%%\n", + " ##################### %%%%%%%%%%%%%%%%%%%%%\n", + " ###################### %%%%%%%%%%%%%%%%%%%%\n", + " ####################### %%%%%%%%%%%%%%%%%%\n", + " ####################### %%%%%%%%%%%%%%%%%\n", + " ###################### %%%%%%%%%%%%%%%%%\n", + " #################### %%%%%%%%%%%%%%%%%\n", + " ################# %%%%%%%%%%%%%%%%%\n", + " ############### %%%%%%%%%%%%%%%%\n", + " ############ %%%%%%%%%%%%%%%\n", + " ######## %%%%%%%%%%%%%%\n", + " %%%%%%%%%%%\n", + "\n", + " | The OpenMC Monte Carlo Code\n", + " Copyright | 2011-2017 Massachusetts Institute of Technology\n", + " License | http://openmc.readthedocs.io/en/latest/license.html\n", + " Version | 0.8.0\n", + " Git SHA1 | 966169de084fcfda3a5aaca3edc0065c8caf6bbc\n", + " Date/Time | 2017-03-09 08:18:02\n", + " OpenMP Threads | 8\n", + "\n", + " Reading settings XML file...\n", + " Reading geometry XML file...\n", + " Reading materials XML file...\n", + " Reading cross sections HDF5 file...\n", + " Reading tallies XML file...\n", + " Loading cross section data...\n", + " Loading uo2 data...\n", + " Loading mox43 data...\n", + " Loading mox7 data...\n", + " Loading mox87 data...\n", + " Loading fiss_chamber data...\n", + " Loading guide_tube data...\n", + " Loading water data...\n", + " Building neighboring cells lists for each surface...\n", + " Initializing source particles...\n", + "\n", + " ====================> K EIGENVALUE SIMULATION <====================\n", + "\n", + " Creating state point statepoint.150.h5...\n", + "\n", + " =======================> TIMING STATISTICS <=======================\n", + "\n", + " Total time for initialization = 1.3630E-01 seconds\n", + " Reading cross sections = 3.0827E-02 seconds\n", + " Total time in simulation = 8.9648E+00 seconds\n", + " Time in transport only = 8.2752E+00 seconds\n", + " Time in inactive batches = 2.4798E+00 seconds\n", + " Time in active batches = 6.4849E+00 seconds\n", + " Time synchronizing fission bank = 1.4553E-02 seconds\n", + " Sampling source sites = 1.0318E-02 seconds\n", + " SEND/RECV source sites = 4.0840E-03 seconds\n", + " Time accumulating tallies = 4.2427E-04 seconds\n", + " Total time for finalization = 1.7081E-02 seconds\n", + " Total time elapsed = 9.1340E+00 seconds\n", + " Calculation Rate (inactive) = 1.00813E+05 neutrons/second\n", + " Calculation Rate (active) = 77101.8 neutrons/second\n", + "\n", + " ============================> RESULTS <============================\n", + "\n", + " k-effective (Collision) = 1.18880 +/- 0.00179\n", + " k-effective (Track-length) = 1.18853 +/- 0.00244\n", + " k-effective (Absorption) = 1.18601 +/- 0.00111\n", + " Combined k-effective = 1.18628 +/- 0.00111\n", + " Leakage Fraction = 0.00175 +/- 0.00006\n", + "\n" + ] + }, + { + "data": { + "text/plain": [ + "0" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Run OpenMC\n", + "openmc.run()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Results Visualization\n", + "\n", + "Now that we have run the simulation, let's look at the fission rate and flux tallies that we tallied." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAS4AAAEICAYAAADhtRloAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nkOESQpQOGS4hROmQ4RJClA4ZLiFE6fj/bGZR578SvHsAAAAASUVORK5CYII=\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Load the last statepoint file and keff value\n", + "sp = openmc.StatePoint('statepoint.' + str(batches) + '.h5')\n", + "\n", + "# Get the OpenMC pin power tally data\n", + "mesh_tally = sp.get_tally(name='mesh tally')\n", + "fission_rates = mesh_tally.get_values(scores=['fission'])\n", + "\n", + "# Reshape array to 2D for plotting\n", + "fission_rates.shape = mesh.dimension\n", + "\n", + "# Normalize to the average pin power\n", + "fission_rates /= np.mean(fission_rates)\n", + "\n", + "# Force zeros to be NaNs so their values are not included when matplotlib calculates\n", + "# the color scale\n", + "fission_rates[fission_rates == 0.] = np.nan\n", + "\n", + "# Plot the pin powers and the fluxes\n", + "plt.figure()\n", + "plt.imshow(fission_rates, interpolation='none', cmap='jet', origin='lower')\n", + "plt.colorbar()\n", + "plt.title('Pin Powers')\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "There we have it! We have just successfully run the C5G7 benchmark model!" + ] + } + ], + "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.6.0" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/docs/source/examples/mg-mode-part-i.rst b/docs/source/examples/mg-mode-part-i.rst new file mode 100644 index 000000000..bfbe63bb7 --- /dev/null +++ b/docs/source/examples/mg-mode-part-i.rst @@ -0,0 +1,13 @@ +.. _notebook_mg_mode_part_i: + +===================================== +Multi-Group Mode Part I: Introduction +===================================== + +.. only:: html + + .. notebook:: mg-mode-part-i.ipynb + +.. only:: latex + + IPython notebooks must be viewed in the online HTML documentation. diff --git a/docs/source/examples/mg-mode-part-ii.ipynb b/docs/source/examples/mg-mode-part-ii.ipynb new file mode 100644 index 000000000..22cc2c45f --- /dev/null +++ b/docs/source/examples/mg-mode-part-ii.ipynb @@ -0,0 +1,1645 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The previous Notebook in this series used multi-group mode to perform a calculation with previously defined cross sections. However, in many circumstances the multi-group data is not given and one must instead generate the cross sections for the specific application (or at least verify the use of cross sections from another application). \n", + "\n", + "This Notebook illustrates the use of the openmc.mgxs.Library class specifically for the calculation of MGXS to be used in OpenMC's multi-group mode. This example notebook is therefore very similar to the MGXS Part III notebook, except OpenMC is used as the multi-group solver instead of OpenMOC.\n", + "\n", + "During this process, this notebook will illustrate the following features:\n", + "\n", + " - Calculation of multi-group cross sections for a fuel assembly\n", + " - Automated creation and storage of MGXS with openmc.mgxs.Library\n", + " - Steady-state pin-by-pin fission rates comparison between continuous-energy and multi-group OpenMC.\n", + " - Modification of the scattering data in the library to show the flexibility of the multi-group solver\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Generate Input Files" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import os\n", + "\n", + "import openmc\n", + "\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We will begin by creating three materials for the fuel, water, and cladding of the fuel pins." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "# 1.6% enriched fuel\n", + "fuel = openmc.Material(name='1.6% Fuel')\n", + "fuel.set_density('g/cm3', 10.31341)\n", + "fuel.add_element('U', 1., enrichment=1.6)\n", + "fuel.add_element('O', 2.)\n", + "\n", + "# zircaloy\n", + "zircaloy = openmc.Material(name='Zircaloy')\n", + "zircaloy.set_density('g/cm3', 6.55)\n", + "zircaloy.add_element('Zr', 1.)\n", + "\n", + "# borated water\n", + "water = openmc.Material(name='Borated Water')\n", + "water.set_density('g/cm3', 0.740582)\n", + "water.add_element('H', 4.9457e-2)\n", + "water.add_element('O', 2.4732e-2)\n", + "water.add_element('B', 8.0042e-6)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "With our three materials, we can now create a Materials object that can be exported to an actual XML file." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# Instantiate a Materials object\n", + "materials_file = openmc.Materials((fuel, zircaloy, water))\n", + "\n", + "# Export to \"materials.xml\"\n", + "materials_file.export_to_xml()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now let's move on to the geometry. This problem will be a square array of fuel pins and control rod guide tubes for which we can use OpenMC's lattice/universe feature. The basic universe will have three regions for the fuel, the clad, and the surrounding coolant. The first step is to create the bounding surfaces for fuel and clad, as well as the outer bounding surfaces of the problem." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# Create cylinders for the fuel and clad\n", + "# The x0 and y0 parameters (0. and 0.) are the default values for an\n", + "# openmc.ZCylinder object. We could therefore leave them out to no effect\n", + "fuel_outer_radius = openmc.ZCylinder(x0=0.0, y0=0.0, R=0.39218)\n", + "clad_outer_radius = openmc.ZCylinder(x0=0.0, y0=0.0, R=0.45720)\n", + "\n", + "# Create boundary planes to surround the geometry\n", + "min_x = openmc.XPlane(x0=-10.71, boundary_type='reflective')\n", + "max_x = openmc.XPlane(x0=+10.71, boundary_type='reflective')\n", + "min_y = openmc.YPlane(y0=-10.71, boundary_type='reflective')\n", + "max_y = openmc.YPlane(y0=+10.71, boundary_type='reflective')\n", + "min_z = openmc.ZPlane(z0=-10., boundary_type='reflective')\n", + "max_z = openmc.ZPlane(z0=+10., boundary_type='reflective')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "With the surfaces defined, we can now construct a fuel pin cell from cells that are defined by intersections of half-spaces created by the surfaces." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "# Create a Universe to encapsulate a fuel pin\n", + "fuel_pin_universe = openmc.Universe(name='1.6% Fuel Pin')\n", + "\n", + "# Create fuel Cell\n", + "fuel_cell = openmc.Cell(name='1.6% Fuel')\n", + "fuel_cell.fill = fuel\n", + "fuel_cell.region = -fuel_outer_radius\n", + "fuel_pin_universe.add_cell(fuel_cell)\n", + "\n", + "# Create a clad Cell\n", + "clad_cell = openmc.Cell(name='1.6% Clad')\n", + "clad_cell.fill = zircaloy\n", + "clad_cell.region = +fuel_outer_radius & -clad_outer_radius\n", + "fuel_pin_universe.add_cell(clad_cell)\n", + "\n", + "# Create a moderator Cell\n", + "moderator_cell = openmc.Cell(name='1.6% Moderator')\n", + "moderator_cell.fill = water\n", + "moderator_cell.region = +clad_outer_radius\n", + "fuel_pin_universe.add_cell(moderator_cell)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Likewise, we can construct a control rod guide tube with the same surfaces." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "# Create a Universe to encapsulate a control rod guide tube\n", + "guide_tube_universe = openmc.Universe(name='Guide Tube')\n", + "\n", + "# Create guide tube Cell\n", + "guide_tube_cell = openmc.Cell(name='Guide Tube Water')\n", + "guide_tube_cell.fill = water\n", + "guide_tube_cell.region = -fuel_outer_radius\n", + "guide_tube_universe.add_cell(guide_tube_cell)\n", + "\n", + "# Create a clad Cell\n", + "clad_cell = openmc.Cell(name='Guide Clad')\n", + "clad_cell.fill = zircaloy\n", + "clad_cell.region = +fuel_outer_radius & -clad_outer_radius\n", + "guide_tube_universe.add_cell(clad_cell)\n", + "\n", + "# Create a moderator Cell\n", + "moderator_cell = openmc.Cell(name='Guide Tube Moderator')\n", + "moderator_cell.fill = water\n", + "moderator_cell.region = +clad_outer_radius\n", + "guide_tube_universe.add_cell(moderator_cell)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Using the pin cell universe, we can construct a 17x17 rectangular lattice with a 1.26 cm pitch." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "# Create fuel assembly Lattice\n", + "assembly = openmc.RectLattice(name='1.6% Fuel Assembly')\n", + "assembly.pitch = (1.26, 1.26)\n", + "assembly.lower_left = [-1.26 * 17. / 2.0] * 2" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Next, we create a NumPy array of fuel pin and guide tube universes for the lattice." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# Create array indices for guide tube locations in lattice\n", + "template_x = np.array([5, 8, 11, 3, 13, 2, 5, 8, 11, 14, 2, 5, 8,\n", + " 11, 14, 2, 5, 8, 11, 14, 3, 13, 5, 8, 11])\n", + "template_y = np.array([2, 2, 2, 3, 3, 5, 5, 5, 5, 5, 8, 8, 8, 8,\n", + " 8, 11, 11, 11, 11, 11, 13, 13, 14, 14, 14])\n", + "\n", + "# Initialize an empty 17x17 array of the lattice universes\n", + "universes = np.empty((17, 17), dtype=openmc.Universe)\n", + "\n", + "# Fill the array with the fuel pin and guide tube universes\n", + "universes[:, :] = fuel_pin_universe\n", + "universes[template_x, template_y] = guide_tube_universe\n", + "\n", + "# Store the array of universes in the lattice\n", + "assembly.universes = universes" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "OpenMC requires that there is a \"root\" universe. Let us create a root cell that is filled by the pin cell universe and then assign it to the root universe." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "# Create root Cell\n", + "root_cell = openmc.Cell(name='root cell')\n", + "root_cell.fill = assembly\n", + "\n", + "# Add boundary planes\n", + "root_cell.region = +min_x & -max_x & +min_y & -max_y & +min_z & -max_z\n", + "\n", + "# Create root Universe\n", + "root_universe = openmc.Universe(name='root universe', universe_id=0)\n", + "root_universe.add_cell(root_cell)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Before proceeding lets check the geometry." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAARAAAAD8CAYAAAC/+/tYAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "root_universe.plot(center=(0., 0., 0.), width=(21.42, 21.42), pixels=(500, 500), color_by='material')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Looks good!\n", + "\n", + "We now must create a geometry that is assigned a root universe and export it to XML." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "# Create Geometry and set root universe\n", + "geometry = openmc.Geometry(root_universe)\n", + "\n", + "# Export to \"geometry.xml\"\n", + "geometry.export_to_xml()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "With the geometry and materials finished, we now just need to define simulation parameters." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# OpenMC simulation parameters\n", + "batches = 600\n", + "inactive = 50\n", + "particles = 2000\n", + "\n", + "# Instantiate a Settings object\n", + "settings_file = openmc.Settings()\n", + "settings_file.batches = batches\n", + "settings_file.inactive = inactive\n", + "settings_file.particles = particles\n", + "settings_file.output = {'tallies': False}\n", + "settings_file.run_mode = 'eigenvalue'\n", + "settings_file.verbosity = 4\n", + "\n", + "# Create an initial uniform spatial source distribution over fissionable zones\n", + "bounds = [-10.71, -10.71, -10, 10.71, 10.71, 10.]\n", + "uniform_dist = openmc.stats.Box(bounds[:3], bounds[3:], only_fissionable=True)\n", + "settings_file.source = openmc.source.Source(space=uniform_dist)\n", + "\n", + "# Export to \"settings.xml\"\n", + "settings_file.export_to_xml()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Create an MGXS Library\n", + "\n", + "Now we are ready to generate multi-group cross sections! First, let's define a 2-group structure using the built-in EnergyGroups class." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "# Instantiate a 2-group EnergyGroups object\n", + "groups = openmc.mgxs.EnergyGroups([0., 0.625, 20.0e6])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Next, we will instantiate an openmc.mgxs.Library for the energy groups with our the fuel assembly geometry." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# Initialize a 2-group MGXS Library for OpenMC\n", + "mgxs_lib = openmc.mgxs.Library(geometry)\n", + "mgxs_lib.energy_groups = groups" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now, we must specify to the Library which types of cross sections to compute. OpenMC's multi-group mode can accept isotropic flux-weighted cross sections or angle-dependent cross sections, as well as supporting anisotropic scattering represented by either Legendre polynomials, histogram, or tabular angular distributions. We will create the following multi-group cross sections needed to run an OpenMC simulation to verify the accuracy of our cross sections: \"total\", \"absorption\", \"nu-fission\", '\"fission\", \"nu-scatter matrix\", \"multiplicity matrix\", and \"chi\".\n", + "\n", + "The \"multiplicity matrix\" type is a relatively rare cross section type. This data is needed to provide OpenMC's multi-group mode with additional information needed to accurately treat scattering multiplication (i.e., (n,xn) reactions)), including how this multiplication varies depending on both incoming and outgoing neutron energies." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# Specify multi-group cross section types to compute\n", + "mgxs_lib.mgxs_types = ['total', 'absorption', 'nu-fission', 'fission',\n", + " 'nu-scatter matrix', 'multiplicity matrix', 'chi']" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we must specify the type of domain over which we would like the `Library` to compute multi-group cross sections. The domain type corresponds to the type of tally filter to be used in the tallies created to compute multi-group cross sections. At the present time, the `Library` supports \"material\", \"cell\", \"universe\", and \"mesh\" domain types. In this simple example, we wish to compute multi-group cross sections only for each material and therefore will use a \"material\" domain type.\n", + "\n", + "**NOTE:** By default, the `Library` class will instantiate `MGXS` objects for each and every domain (material, cell, universe, or mesh) in the geometry of interest. However, one may specify a subset of these domains to the `Library.domains` property." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "# Specify a \"cell\" domain type for the cross section tally filters\n", + "mgxs_lib.domain_type = \"material\"\n", + "\n", + "# Specify the cell domains over which to compute multi-group cross sections\n", + "mgxs_lib.domains = geometry.get_all_materials().values()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We will instruct the library to not compute cross sections on a nuclide-by-nuclide basis, and instead to focus on generating material-specific macroscopic cross sections.\n", + "\n", + "**NOTE:** The default value of the `by_nuclide` parameter is `False`, so the following step is not necessary but is included for illustrative purposes." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "# Do not compute cross sections on a nuclide-by-nuclide basis\n", + "mgxs_lib.by_nuclide = False" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we will set the scattering order that we wish to use. For this problem we will use P3 scattering. A warning is expected telling us that the default behavior (a P0 correction on the scattering data) is over-ridden by our choice of using a Legendre expansion to treat anisotropic scattering." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/nelsonag/git/openmc/openmc/mgxs/library.py:412: RuntimeWarning: The P0 correction will be ignored since the scattering order 0 is greater than zero\n", + " warn(msg, RuntimeWarning)\n" + ] + } + ], + "source": [ + "# Set the Legendre order to 3 for P3 scattering\n", + "mgxs_lib.legendre_order = 3" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now that the `Library` has been setup let's verify that it contains the types of cross sections which meet the needs of OpenMC's multi-group solver. Note that this step is done automatically when writing the Multi-Group Library file later in the process (as part of `mgxs_lib.write_mg_library()`), but it is a good practice to also run this before spending all the time running OpenMC to generate the cross sections.\n", + "\n", + "If no error is raised, then we have a good set of data." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "# Check the library - if no errors are raised, then the library is satisfactory.\n", + "mgxs_lib.check_library_for_openmc_mgxs()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Great, now we can use the `Library` to construct the tallies needed to compute all of the requested multi-group cross sections in each domain." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "# Construct all tallies needed for the multi-group cross section library\n", + "mgxs_lib.build_library()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The tallies can now be exported to a \"tallies.xml\" input file for OpenMC.\n", + "\n", + "**NOTE:** At this point the `Library` has constructed nearly 100 distinct Tally objects. The overhead to tally in OpenMC scales as O(N) for N tallies, which can become a bottleneck for large tally datasets. To compensate for this, the Python API's `Tally`, `Filter` and `Tallies` classes allow for the smart merging of tallies when possible. The `Library` class supports this runtime optimization with the use of the optional `merge` parameter (`False` by default) for the `Library.add_to_tallies_file(...)` method, as shown below." + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# Create a \"tallies.xml\" file for the MGXS Library\n", + "tallies_file = openmc.Tallies()\n", + "mgxs_lib.add_to_tallies_file(tallies_file, merge=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In addition, we instantiate a fission rate mesh tally that we will eventually use to compare with the corresponding multi-group results." + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# Instantiate a tally Mesh\n", + "mesh = openmc.Mesh()\n", + "mesh.type = 'regular'\n", + "mesh.dimension = [17, 17]\n", + "mesh.lower_left = [-10.71, -10.71]\n", + "mesh.upper_right = [+10.71, +10.71]\n", + "\n", + "# Instantiate tally Filter\n", + "mesh_filter = openmc.MeshFilter(mesh)\n", + "\n", + "# Instantiate the Tally\n", + "tally = openmc.Tally(name='mesh tally')\n", + "tally.filters = [mesh_filter]\n", + "tally.scores = ['fission']\n", + "\n", + "# Add tally to collection\n", + "tallies_file.append(tally, merge=True)\n", + "\n", + "# Export all tallies to a \"tallies.xml\" file\n", + "tallies_file.export_to_xml()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": true + }, + "source": [ + "Time to run the calculation and get our results!" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + " %%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%\n", + " ############### %%%%%%%%%%%%%%%%%%%%%%%%\n", + " ################## %%%%%%%%%%%%%%%%%%%%%%%\n", + " ################### %%%%%%%%%%%%%%%%%%%%%%%\n", + " #################### %%%%%%%%%%%%%%%%%%%%%%\n", + " ##################### %%%%%%%%%%%%%%%%%%%%%\n", + " ###################### %%%%%%%%%%%%%%%%%%%%\n", + " ####################### %%%%%%%%%%%%%%%%%%\n", + " ####################### %%%%%%%%%%%%%%%%%\n", + " ###################### %%%%%%%%%%%%%%%%%\n", + " #################### %%%%%%%%%%%%%%%%%\n", + " ################# %%%%%%%%%%%%%%%%%\n", + " ############### %%%%%%%%%%%%%%%%\n", + " ############ %%%%%%%%%%%%%%%\n", + " ######## %%%%%%%%%%%%%%\n", + " %%%%%%%%%%%\n", + "\n", + " | The OpenMC Monte Carlo Code\n", + " Copyright | 2011-2017 Massachusetts Institute of Technology\n", + " License | http://openmc.readthedocs.io/en/latest/license.html\n", + " Version | 0.8.0\n", + " Git SHA1 | 4b01fd311461f1350989cb84ec18fe2cbaa8fa9f\n", + " Date/Time | 2017-03-10 17:30:51\n", + " OpenMP Threads | 8\n", + "\n", + "\n", + " ====================> K EIGENVALUE SIMULATION <====================\n", + "\n", + "\n", + " ============================> RESULTS <============================\n", + "\n", + " k-effective (Collision) = 1.16584 +/- 0.00111\n", + " k-effective (Track-length) = 1.16532 +/- 0.00131\n", + " k-effective (Absorption) = 1.16513 +/- 0.00100\n", + " Combined k-effective = 1.16538 +/- 0.00086\n", + " Leakage Fraction = 0.00000 +/- 0.00000\n", + "\n" + ] + }, + { + "data": { + "text/plain": [ + "0" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Run OpenMC\n", + "openmc.run()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To make sure the results we need are available after running the multi-group calculation, we will now rename the statepoint and summary files." + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "# Move the statepoint File\n", + "ce_spfile = './statepoint_ce.h5'\n", + "os.rename('statepoint.' + str(batches) + '.h5', ce_spfile)\n", + "# Move the Summary file\n", + "ce_sumfile = './summary_ce.h5'\n", + "os.rename('summary.h5', ce_sumfile)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Tally Data Processing\n", + "\n", + "Our simulation ran successfully and created statepoint and summary output files. Let's begin by loading the StatePoint file." + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "# Load the statepoint file\n", + "sp = openmc.StatePoint(ce_spfile, autolink=False)\n", + "\n", + "# Load the summary file in its new location\n", + "su = openmc.Summary(ce_sumfile)\n", + "sp.link_with_summary(su)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The statepoint is now ready to be analyzed by the `Library`. We simply have to load the tallies from the statepoint into the `Library` and our `MGXS` objects will compute the cross sections for us under-the-hood." + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "# Initialize MGXS Library with OpenMC statepoint data\n", + "mgxs_lib.load_from_statepoint(sp)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The next step will be to prepare the input for OpenMC to use our newly created multi-group data." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Multi-Group OpenMC Calculation" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We will now use the `Library` to produce a multi-group cross section data set for use by the OpenMC multi-group solver. \n", + "Note that since this simulation included so few histories, it is reasonable to expect some data has not had any scores, and thus we could see division by zero errors. This will show up as a runtime warning in the following step. The `Library` class is designed to gracefully handle these scenarios." + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/nelsonag/git/openmc/openmc/tallies.py:1834: RuntimeWarning: invalid value encountered in true_divide\n", + " self_rel_err = data['self']['std. dev.'] / data['self']['mean']\n", + "/home/nelsonag/git/openmc/openmc/tallies.py:1835: RuntimeWarning: invalid value encountered in true_divide\n", + " other_rel_err = data['other']['std. dev.'] / data['other']['mean']\n", + "/home/nelsonag/git/openmc/openmc/tallies.py:1836: RuntimeWarning: invalid value encountered in true_divide\n", + " new_tally._mean = data['self']['mean'] / data['other']['mean']\n" + ] + } + ], + "source": [ + "# Create a MGXS File which can then be written to disk\n", + "mgxs_file = mgxs_lib.create_mg_library(xs_type='macro', xsdata_names=['fuel', 'zircaloy', 'water'])\n", + "\n", + "# Write the file to disk using the default filename of \"mgxs.h5\"\n", + "mgxs_file.export_to_hdf5()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "OpenMC's multi-group mode uses the same input files as does the continuous-energy mode (materials, geometry, settings, plots, and tallies file). Differences would include the use of a flag to tell the code to use multi-group transport, a location of the multi-group library file, and any changes needed in the materials.xml and geometry.xml files to re-define materials as necessary. The materials and geometry file changes could be necessary if materials or their nuclide/element/macroscopic constituents need to be renamed.\n", + "\n", + "In this example we have created macroscopic cross sections (by material), and thus we will need to change the material definitions accordingly.\n", + "\n", + "First we will create the new materials.xml file." + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "# Re-define our materials to use the multi-group macroscopic data\n", + "# instead of the continuous-energy data.\n", + "\n", + "# 1.6% enriched fuel UO2\n", + "fuel_mg = openmc.Material(name='UO2')\n", + "fuel_mg.add_macroscopic('fuel')\n", + "\n", + "# cladding\n", + "zircaloy_mg = openmc.Material(name='Clad')\n", + "zircaloy_mg.add_macroscopic('zircaloy')\n", + "\n", + "# moderator\n", + "water_mg = openmc.Material(name='Water')\n", + "water_mg.add_macroscopic('water')\n", + "\n", + "# Finally, instantiate our Materials object\n", + "materials_file = openmc.Materials((fuel_mg, zircaloy_mg, water_mg))\n", + "\n", + "# Set the location of the cross sections file\n", + "materials_file.cross_sections = 'mgxs.h5'\n", + "\n", + "# Export to \"materials.xml\"\n", + "materials_file.export_to_xml()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "No geometry file neeeds to be written as the continuous-energy file is correctly defined for the multi-group case as well." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Next, we can make the changes we need to the simulation parameters.\n", + "These changes are limited to telling OpenMC to run a multi-group vice contrinuous-energy calculation." + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# Set the energy mode\n", + "settings_file.energy_mode = 'multi-group'\n", + "\n", + "# Export to \"settings.xml\"\n", + "settings_file.export_to_xml()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Lets clear the tallies file so it doesn't include tallies for re-generating a multi-group library, but then put back in a tally for the fission mesh." + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# Create a \"tallies.xml\" file for the MGXS Library\n", + "tallies_file = openmc.Tallies()\n", + "\n", + "# Add fission and flux mesh to tally for plotting using the same mesh we've already defined\n", + "mesh_tally = openmc.Tally(name='mesh tally')\n", + "mesh_tally.filters = [openmc.MeshFilter(mesh)]\n", + "mesh_tally.scores = ['fission']\n", + "tallies_file.add_tally(mesh_tally)\n", + "\n", + "# Export to \"tallies.xml\"\n", + "tallies_file.export_to_xml()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "Before running the calculation let's visually compare a subset of the newly-generated multi-group cross section data to the continuous-energy data. We will do this using the cross section plotting functionality built-in to the OpenMC Python API." + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAY4AAAEaCAYAAAAG87ApAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\njImIJQ5jjDERscRhjDEmIv8PVlN3HymW/GgAAAAASUVORK5CYII=\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYgAAAEaCAYAAAAL7cBuAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nRU5ErkJggg==\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAY4AAAEaCAYAAAAG87ApAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nuChxiIhIXJQ4REQkLkocIiISl/8PMcPiun1YM38AAAAASUVORK5CYII=\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# First lets plot the fuel data\n", + "# We will first add the continuous-energy data\n", + "fig = openmc.plot_xs(fuel, ['total'])\n", + "\n", + "# We will now add in the corresponding multi-group data and show the result\n", + "openmc.plot_xs(fuel_mg, ['total'], plot_CE=False, mg_cross_sections='mgxs.h5', axis=fig.axes[0])\n", + "fig.axes[0].legend().set_visible(False)\n", + "plt.show()\n", + "plt.close()\n", + "\n", + "# Then repeat for the zircaloy data\n", + "fig = openmc.plot_xs(zircaloy, ['total'])\n", + "openmc.plot_xs(zircaloy_mg, ['total'], plot_CE=False, mg_cross_sections='mgxs.h5', axis=fig.axes[0])\n", + "fig.axes[0].legend().set_visible(False)\n", + "plt.show()\n", + "plt.close()\n", + "\n", + "# And finally repeat for the water data\n", + "fig = openmc.plot_xs(water, ['total'])\n", + "openmc.plot_xs(water_mg, ['total'], plot_CE=False, mg_cross_sections='mgxs.h5', axis=fig.axes[0])\n", + "fig.axes[0].legend().set_visible(False)\n", + "plt.show()\n", + "plt.close()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "At this point, the problem is set up and we can run the multi-group calculation." + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": { + "collapsed": false, + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + " %%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%\n", + " ############### %%%%%%%%%%%%%%%%%%%%%%%%\n", + " ################## %%%%%%%%%%%%%%%%%%%%%%%\n", + " ################### %%%%%%%%%%%%%%%%%%%%%%%\n", + " #################### %%%%%%%%%%%%%%%%%%%%%%\n", + " ##################### %%%%%%%%%%%%%%%%%%%%%\n", + " ###################### %%%%%%%%%%%%%%%%%%%%\n", + " ####################### %%%%%%%%%%%%%%%%%%\n", + " ####################### %%%%%%%%%%%%%%%%%\n", + " ###################### %%%%%%%%%%%%%%%%%\n", + " #################### %%%%%%%%%%%%%%%%%\n", + " ################# %%%%%%%%%%%%%%%%%\n", + " ############### %%%%%%%%%%%%%%%%\n", + " ############ %%%%%%%%%%%%%%%\n", + " ######## %%%%%%%%%%%%%%\n", + " %%%%%%%%%%%\n", + "\n", + " | The OpenMC Monte Carlo Code\n", + " Copyright | 2011-2017 Massachusetts Institute of Technology\n", + " License | http://openmc.readthedocs.io/en/latest/license.html\n", + " Version | 0.8.0\n", + " Git SHA1 | 4b01fd311461f1350989cb84ec18fe2cbaa8fa9f\n", + " Date/Time | 2017-03-10 17:31:49\n", + " OpenMP Threads | 8\n", + "\n", + "\n", + " ====================> K EIGENVALUE SIMULATION <====================\n", + "\n", + "\n", + " ============================> RESULTS <============================\n", + "\n", + " k-effective (Collision) = 1.16235 +/- 0.00111\n", + " k-effective (Track-length) = 1.16345 +/- 0.00134\n", + " k-effective (Absorption) = 1.16397 +/- 0.00058\n", + " Combined k-effective = 1.16388 +/- 0.00058\n", + " Leakage Fraction = 0.00000 +/- 0.00000\n", + "\n" + ] + }, + { + "data": { + "text/plain": [ + "0" + ] + }, + "execution_count": 32, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Run the Multi-Group OpenMC Simulation\n", + "openmc.run()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Results Comparison\n", + "Now we can compare the multi-group and continuous-energy results.\n", + "\n", + "We will begin by loading the multi-group statepoint file we just finished writing and extracting the calculated keff." + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "# Move the StatePoint File\n", + "mg_spfile = './statepoint_mg.h5'\n", + "os.rename('statepoint.' + str(batches) + '.h5', mg_spfile)\n", + "# Move the Summary file\n", + "mg_sumfile = './summary_mg.h5'\n", + "os.rename('summary.h5', mg_sumfile)\n", + "\n", + "# Rename and then load the last statepoint file and keff value\n", + "mgsp = openmc.StatePoint(mg_spfile, autolink=False)\n", + "\n", + "# Load the summary file in its new location\n", + "mgsu = openmc.Summary(mg_sumfile)\n", + "mgsp.link_with_summary(mgsu)\n", + "\n", + "# Get keff\n", + "mg_keff = mgsp.k_combined" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Next, we can load the continuous-energy eigenvalue for comparison." + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "ce_keff = sp.k_combined" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Lets compare the two eigenvalues, including their bias" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Continuous-Energy keff = 1.165379\n", + "Multi-Group keff = 1.163885\n", + "bias [pcm]: 149.4\n" + ] + } + ], + "source": [ + "bias = 1.0E5 * (ce_keff[0] - mg_keff[0])\n", + "\n", + "print('Continuous-Energy keff = {0:1.6f}'.format(ce_keff[0]))\n", + "print('Multi-Group keff = {0:1.6f}'.format(mg_keff[0]))\n", + "print('bias [pcm]: {0:1.1f}'.format(bias))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This shows a small but nontrivial pcm bias between the two methods. Some degree of mismatch is expected simply to the very few histories being used in these example problems. An additional mismatch is always inherent in the practical application of multi-group theory due to the high degree of approximations inherent in that method." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Pin Power Visualizations" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Next we will visualize the pin power results obtained from both the Continuous-Energy and Multi-Group OpenMC calculations.\n", + "\n", + "First, we extract volume-integrated fission rates from the Multi-Group calculation's mesh fission rate tally for each pin cell in the fuel assembly." + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "# Get the OpenMC fission rate mesh tally data\n", + "mg_mesh_tally = mgsp.get_tally(name='mesh tally')\n", + "mg_fission_rates = mg_mesh_tally.get_values(scores=['fission'])\n", + "\n", + "# Reshape array to 2D for plotting\n", + "mg_fission_rates.shape = (17,17)\n", + "\n", + "# Normalize to the average pin power\n", + "mg_fission_rates /= np.mean(mg_fission_rates)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can now do the same for the Continuous-Energy results." + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "# Get the OpenMC fission rate mesh tally data\n", + "ce_mesh_tally = sp.get_tally(name='mesh tally')\n", + "ce_fission_rates = ce_mesh_tally.get_values(scores=['fission'])\n", + "\n", + "# Reshape array to 2D for plotting\n", + "ce_fission_rates.shape = (17,17)\n", + "\n", + "# Normalize to the average pin power\n", + "ce_fission_rates /= np.mean(ce_fission_rates)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we can easily use Matplotlib to visualize the two fission rates side-by-side." + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 38, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAX4AAADHCAYAAAAeaDj1AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Force zeros to be NaNs so their values are not included when matplotlib calculates\n", + "# the color scale\n", + "ce_fission_rates[ce_fission_rates == 0.] = np.nan\n", + "mg_fission_rates[mg_fission_rates == 0.] = np.nan\n", + "\n", + "# Plot the CE fission rates in the left subplot\n", + "fig = plt.subplot(121)\n", + "plt.imshow(ce_fission_rates, interpolation='none', cmap='jet')\n", + "plt.title('Continuous-Energy Fission Rates')\n", + "\n", + "# Plot the MG fission rates in the right subplot\n", + "fig2 = plt.subplot(122)\n", + "plt.imshow(mg_fission_rates, interpolation='none', cmap='jet')\n", + "plt.title('Multi-Group Fission Rates')\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": true + }, + "source": [ + "These figures really indicate that more histories are probably necessary when trying to achieve a fully converged solution, but hey, this is good enough for our example!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Scattering Anisotropy Treatments\n", + "\n", + "We will next show how we can work with the scattering angular distributions. OpenMC's MG solver has the capability to use group-to-group angular distributions which are represented as any of the following: a truncated Legendre series of up to the 10th order, a histogram distribution, and a tabular distribution. Any combination of these representations can be used by OpenMC during the transport process, so long as all constituents of a given material use the same representation. This means it is possible to have water represented by a tabular distribution and fuel represented by a Legendre if so desired.\n", + "\n", + "*Note*: To have the highest runtime performance OpenMC natively converts Legendre series to a tabular distribution before the transport begins. This default functionality can be turned off with the `tabular_legendre` element of the `settings.xml` file (or for the Python API, the `openmc.Settings.tabular_legendre` attribute).\n", + "\n", + "This section will examine the following:\n", + "- Re-run the MG-mode calculation with P0 scattering everywhere using the `openmc.Settings.max_order` attribute\n", + "- Re-run the problem with only the water represented with P3 scattering and P0 scattering for the remaining materials using the Python API's ability to convert between formats." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "## Global P0 Scattering\n", + "First we begin by re-running with P0 scattering (i.e., isotropic) everywhere. If a global maximum order is requested, the most effective way to do this is to use the `max_order` attribute of our `openmc.Settings` object." + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# Set the maximum scattering order to 0 (i.e., isotropic scattering)\n", + "settings_file.max_order = 0\n", + "\n", + "# Export to \"settings.xml\"\n", + "settings_file.export_to_xml()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we can re-run OpenMC to obtain our results" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + " %%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%\n", + " ############### %%%%%%%%%%%%%%%%%%%%%%%%\n", + " ################## %%%%%%%%%%%%%%%%%%%%%%%\n", + " ################### %%%%%%%%%%%%%%%%%%%%%%%\n", + " #################### %%%%%%%%%%%%%%%%%%%%%%\n", + " ##################### %%%%%%%%%%%%%%%%%%%%%\n", + " ###################### %%%%%%%%%%%%%%%%%%%%\n", + " ####################### %%%%%%%%%%%%%%%%%%\n", + " ####################### %%%%%%%%%%%%%%%%%\n", + " ###################### %%%%%%%%%%%%%%%%%\n", + " #################### %%%%%%%%%%%%%%%%%\n", + " ################# %%%%%%%%%%%%%%%%%\n", + " ############### %%%%%%%%%%%%%%%%\n", + " ############ %%%%%%%%%%%%%%%\n", + " ######## %%%%%%%%%%%%%%\n", + " %%%%%%%%%%%\n", + "\n", + " | The OpenMC Monte Carlo Code\n", + " Copyright | 2011-2017 Massachusetts Institute of Technology\n", + " License | http://openmc.readthedocs.io/en/latest/license.html\n", + " Version | 0.8.0\n", + " Git SHA1 | 4b01fd311461f1350989cb84ec18fe2cbaa8fa9f\n", + " Date/Time | 2017-03-10 17:32:18\n", + " OpenMP Threads | 8\n", + "\n", + "\n", + " ====================> K EIGENVALUE SIMULATION <====================\n", + "\n", + "\n", + " ============================> RESULTS <============================\n", + "\n", + " k-effective (Collision) = 1.16104 +/- 0.00109\n", + " k-effective (Track-length) = 1.16004 +/- 0.00125\n", + " k-effective (Absorption) = 1.16297 +/- 0.00061\n", + " Combined k-effective = 1.16273 +/- 0.00061\n", + " Leakage Fraction = 0.00000 +/- 0.00000\n", + "\n" + ] + }, + { + "data": { + "text/plain": [ + "0" + ] + }, + "execution_count": 40, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Run the Multi-Group OpenMC Simulation\n", + "openmc.run()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "And then get the eigenvalue differences from the Continuous-Energy and P3 MG solution" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "P3 bias [pcm]: 149.4\n", + "P0 bias [pcm]: 265.3\n" + ] + } + ], + "source": [ + "# Move the statepoint File\n", + "mgp0_spfile = './statepoint_mg_p0.h5'\n", + "os.rename('statepoint.' + str(batches) + '.h5', mgp0_spfile)\n", + "# Move the Summary file\n", + "mgp0_sumfile = './summary_mg_p0.h5'\n", + "os.rename('summary.h5', mgp0_sumfile)\n", + "\n", + "# Load the last statepoint file and keff value\n", + "mgsp_p0 = openmc.StatePoint(mgp0_spfile, autolink=False)\n", + "\n", + "# Get keff\n", + "mg_p0_keff = mgsp_p0.k_combined\n", + "\n", + "bias_p0 = 1.0E5 * (ce_keff[0] - mg_p0_keff[0])\n", + "\n", + "print('P3 bias [pcm]: {0:1.1f}'.format(bias))\n", + "print('P0 bias [pcm]: {0:1.1f}'.format(bias_p0))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Mixed Scattering Representations\n", + "OpenMC's Multi-Group mode also includes a feature where not every data in the library is required to have the same scattering treatment. For example, we could represent the water with P3 scattering, and the fuel and cladding with P0 scattering. This series will show how this can be done.\n", + "\n", + "First we will convert the data to P0 scattering, unless its water, then we will leave that as P3 data." + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "# Convert the zircaloy and fuel data to P0 scattering\n", + "for i, xsdata in enumerate(mgxs_file.xsdatas):\n", + " if xsdata.name != 'water':\n", + " mgxs_file.xsdatas[i] = xsdata.convert_scatter_format('legendre', 0)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can also use whatever scattering format that we want for the materials in the library. As an example, we will take this P0 data and convert zircaloy to a histogram anisotropic scattering format and the fuel to a tabular anisotropic scattering format" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# Convert the formats as discussed\n", + "for i, xsdata in enumerate(mgxs_file.xsdatas):\n", + " if xsdata.name == 'zircaloy':\n", + " mgxs_file.xsdatas[i] = xsdata.convert_scatter_format('histogram', 2)\n", + " elif xsdata.name == 'fuel':\n", + " mgxs_file.xsdatas[i] = xsdata.convert_scatter_format('tabular', 2)\n", + " \n", + "mgxs_file.export_to_hdf5('mgxs.h5')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Finally we will re-set our `max_order` parameter of our `openmc.Settings` object to our maximum order so that OpenMC will use whatever scattering data is available in the library.\n", + "\n", + "After we do this we can re-run the simulation." + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + " %%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%\n", + " ############### %%%%%%%%%%%%%%%%%%%%%%%%\n", + " ################## %%%%%%%%%%%%%%%%%%%%%%%\n", + " ################### %%%%%%%%%%%%%%%%%%%%%%%\n", + " #################### %%%%%%%%%%%%%%%%%%%%%%\n", + " ##################### %%%%%%%%%%%%%%%%%%%%%\n", + " ###################### %%%%%%%%%%%%%%%%%%%%\n", + " ####################### %%%%%%%%%%%%%%%%%%\n", + " ####################### %%%%%%%%%%%%%%%%%\n", + " ###################### %%%%%%%%%%%%%%%%%\n", + " #################### %%%%%%%%%%%%%%%%%\n", + " ################# %%%%%%%%%%%%%%%%%\n", + " ############### %%%%%%%%%%%%%%%%\n", + " ############ %%%%%%%%%%%%%%%\n", + " ######## %%%%%%%%%%%%%%\n", + " %%%%%%%%%%%\n", + "\n", + " | The OpenMC Monte Carlo Code\n", + " Copyright | 2011-2017 Massachusetts Institute of Technology\n", + " License | http://openmc.readthedocs.io/en/latest/license.html\n", + " Version | 0.8.0\n", + " Git SHA1 | 4b01fd311461f1350989cb84ec18fe2cbaa8fa9f\n", + " Date/Time | 2017-03-10 17:32:48\n", + " OpenMP Threads | 8\n", + "\n", + "\n", + " ====================> K EIGENVALUE SIMULATION <====================\n", + "\n", + "\n", + " ============================> RESULTS <============================\n", + "\n", + " k-effective (Collision) = 1.16348 +/- 0.00117\n", + " k-effective (Track-length) = 1.16263 +/- 0.00133\n", + " k-effective (Absorption) = 1.16485 +/- 0.00063\n", + " Combined k-effective = 1.16459 +/- 0.00061\n", + " Leakage Fraction = 0.00000 +/- 0.00000\n", + "\n" + ] + }, + { + "data": { + "text/plain": [ + "0" + ] + }, + "execution_count": 44, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "settings_file.max_order = None\n", + "\n", + "# Export to \"settings.xml\"\n", + "settings_file.export_to_xml()\n", + "\n", + "# Run the Multi-Group OpenMC Simulation\n", + "openmc.run()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "For a final step we can again obtain the eigenvalue differences from this case and compare with the same from the P3 MG solution" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "P3 bias [pcm]: 149.4\n", + "Mixed Scattering bias [pcm]: 79.0\n" + ] + } + ], + "source": [ + "# Load the last statepoint file and keff value\n", + "mgsp_mixed = openmc.StatePoint('./statepoint.' + str(batches) + '.h5')\n", + "\n", + "mg_mixed_keff = mgsp_mixed.k_combined\n", + "bias_mixed = 1.0E5 * (ce_keff[0] - mg_mixed_keff[0])\n", + "\n", + "print('P3 bias [pcm]: {0:1.1f}'.format(bias))\n", + "print('Mixed Scattering bias [pcm]: {0:1.1f}'.format(bias_mixed))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Our tests in this section showed the flexibility of data formatting within OpenMC's multi-group mode: every material can be represented with its own format with the approximations that make the most sense. Now, as you'll see above, the runtimes from our P3, P0, and mixed cases are not significantly different and therefore this might not be a useful strategy for multi-group Monte Carlo. However, this capability provides a useful benchmark for the accuracy hit one may expect due to these scattering approximations before implementing this generality in a deterministic solver where the runtime savings are more significant.\n", + "\n", + "**NOTE**: The biases obtained above with P3, P0, and mixed representations do not necessarily reflect the inherent accuracies of the options. These cases were *not* run with a sufficient number of histories to truly differentiate methods improvement from statistical noise." + ] + } + ], + "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.6.0" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/docs/source/examples/mg-mode-part-ii.rst b/docs/source/examples/mg-mode-part-ii.rst new file mode 100644 index 000000000..2df2d9a18 --- /dev/null +++ b/docs/source/examples/mg-mode-part-ii.rst @@ -0,0 +1,13 @@ +.. _notebook_mg_mode_part_ii: + +============================================================= +Multi-Group Mode Part II: MGXS Library Generation With OpenMC +============================================================= + +.. only:: html + + .. notebook:: mg-mode-part-ii.ipynb + +.. only:: latex + + IPython notebooks must be viewed in the online HTML documentation. diff --git a/docs/source/examples/mg-mode-part-iii.ipynb b/docs/source/examples/mg-mode-part-iii.ipynb new file mode 100644 index 000000000..5d5faefd4 --- /dev/null +++ b/docs/source/examples/mg-mode-part-iii.ipynb @@ -0,0 +1,1517 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This Notebook illustrates the use of the the more advanced features of OpenMC's multi-group mode and the openmc.mgxs.Library class. During this process, this notebook will illustrate the following features:\n", + "\n", + " - Calculation of multi-group cross sections for a simplified BWR 8x8 assembly with isotropic and angle-dependent MGXS.\n", + " - Automated creation and storage of MGXS with openmc.mgxs.Library\n", + " - Fission rate comparison between continuous-energy and the two multi-group OpenMC cases.\n", + "\n", + "To avoid focusing on unimportant details, the BWR assembly in this notebook is greatly simplified. The descriptions which follow will point out some areas of simplification." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Generate Input Files" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "import os\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "import openmc\n", + "\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We will be running a rodded 8x8 assembly with Gadolinia fuel pins. Let's create all the elemental data we would need for this case." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# Instantiate some elements\n", + "elements = {}\n", + "for elem in ['H', 'O', 'U', 'Zr', 'Gd', 'B', 'C', 'Fe']:\n", + " elements[elem] = openmc.Element(elem)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "With the elements we defined, we will now create the materials we will use later.\n", + "\n", + "Material Definition Simplifications:\n", + "\n", + "- This model will be run at room temperature so the NNDC ENDF-B/VII.1 data set can be used but the water density will be representative of a module with around 20% voiding. This water density will be non-physically used in all regions of the problem.\n", + "- Steel is composed of more than just iron, but we will only treat it as such here.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "materials = {}\n", + "\n", + "# Fuel\n", + "materials['Fuel'] = openmc.Material(name='Fuel')\n", + "materials['Fuel'].set_density('g/cm3', 10.32)\n", + "materials['Fuel'].add_element(elements['O'], 2)\n", + "materials['Fuel'].add_element(elements['U'], 1, enrichment=3.)\n", + "\n", + "# Gadolinia bearing fuel\n", + "materials['Gad'] = openmc.Material(name='Gad')\n", + "materials['Gad'].set_density('g/cm3', 10.23)\n", + "materials['Gad'].add_element(elements['O'], 2)\n", + "materials['Gad'].add_element(elements['U'], 1, enrichment=3.)\n", + "materials['Gad'].add_element(elements['Gd'], .02)\n", + "\n", + "# Zircaloy\n", + "materials['Zirc2'] = openmc.Material(name='Zirc2')\n", + "materials['Zirc2'].set_density('g/cm3', 6.55)\n", + "materials['Zirc2'].add_element(elements['Zr'], 1)\n", + "\n", + "# Boiling Water\n", + "materials['Water'] = openmc.Material(name='Water')\n", + "materials['Water'].set_density('g/cm3', 0.6)\n", + "materials['Water'].add_element(elements['H'], 2)\n", + "materials['Water'].add_element(elements['O'], 1)\n", + "\n", + "# Boron Carbide for the Control Rods\n", + "materials['B4C'] = openmc.Material(name='B4C')\n", + "materials['B4C'].set_density('g/cm3', 0.7 * 2.52)\n", + "materials['B4C'].add_element(elements['B'], 4)\n", + "materials['B4C'].add_element(elements['C'], 1)\n", + "\n", + "# Steel \n", + "materials['Steel'] = openmc.Material(name='Steel')\n", + "materials['Steel'].set_density('g/cm3', 7.75)\n", + "materials['Steel'].add_element(elements['Fe'], 1)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can now create a Materials object that can be exported to an actual XML file." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# Instantiate a Materials object\n", + "materials_file = openmc.Materials(materials.values())\n", + "\n", + "# Export to \"materials.xml\"\n", + "materials_file.export_to_xml()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now let's move on to the geometry. The first step is to define some constants which will be used to set our dimensions and then we can start creating the surfaces and regions for the problem, the 8x8 lattice, the rods and the control blade.\n", + "\n", + "Before proceeding let's discuss some simplifications made to the problem geometry:\n", + "- To enable the use of an equal-width mesh for running the multi-group calculations, the intra-assembly gap was increased to the same size as the pitch of the 8x8 fuel lattice\n", + "- The can is neglected\n", + "- The pin-in-water geometry for the control blade is ignored and instead the blade is a solid block of B4C\n", + "- Rounded corners are ignored\n", + "- There is no cladding for the water rod" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "# Set constants for the problem and assembly dimensions\n", + "fuel_rad = 0.53213\n", + "clad_rad = 0.61341\n", + "Np = 8\n", + "pin_pitch = 1.6256\n", + "length = float(Np + 2) * pin_pitch\n", + "assembly_width = length - 2. * pin_pitch\n", + "rod_thick = 0.47752 / 2. + 0.14224\n", + "rod_span = 7. * pin_pitch\n", + "\n", + "surfaces = {}\n", + "\n", + "# Create boundary planes to surround the geometry\n", + "surfaces['Global x-'] = openmc.XPlane(x0=0., boundary_type='reflective')\n", + "surfaces['Global x+'] = openmc.XPlane(x0=length, boundary_type='reflective')\n", + "surfaces['Global y-'] = openmc.YPlane(y0=0., boundary_type='reflective')\n", + "surfaces['Global y+'] = openmc.YPlane(y0=length, boundary_type='reflective')\n", + "\n", + "# Create cylinders for the fuel and clad\n", + "surfaces['Fuel Radius'] = openmc.ZCylinder(R=fuel_rad)\n", + "surfaces['Clad Radius'] = openmc.ZCylinder(R=clad_rad)\n", + "\n", + "surfaces['Assembly x-'] = openmc.XPlane(x0=pin_pitch)\n", + "surfaces['Assembly x+'] = openmc.XPlane(x0=length - pin_pitch)\n", + "surfaces['Assembly y-'] = openmc.YPlane(y0=pin_pitch)\n", + "surfaces['Assembly y+'] = openmc.YPlane(y0=length - pin_pitch)\n", + "\n", + "# Set surfaces for the control blades\n", + "surfaces['Top Blade y-'] = openmc.YPlane(y0=length - rod_thick)\n", + "surfaces['Top Blade x-'] = openmc.XPlane(x0=pin_pitch)\n", + "surfaces['Top Blade x+'] = openmc.XPlane(x0=rod_span)\n", + "surfaces['Left Blade x+'] = openmc.XPlane(x0=rod_thick)\n", + "surfaces['Left Blade y-'] = openmc.YPlane(y0=length - rod_span)\n", + "surfaces['Left Blade y+'] = openmc.YPlane(y0=9. * pin_pitch)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "With the surfaces defined, we can now construct regions with these surfaces before we use those to create cells" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# Set regions for geometry building\n", + "regions = {}\n", + "regions['Global'] = \\\n", + " (+surfaces['Global x-'] & -surfaces['Global x+'] &\n", + " +surfaces['Global y-'] & -surfaces['Global y+'])\n", + "regions['Assembly'] = \\\n", + " (+surfaces['Assembly x-'] & -surfaces['Assembly x+'] &\n", + " +surfaces['Assembly y-'] & -surfaces['Assembly y+'])\n", + "regions['Fuel'] = -surfaces['Fuel Radius']\n", + "regions['Clad'] = +surfaces['Fuel Radius'] & -surfaces['Clad Radius']\n", + "regions['Water'] = +surfaces['Clad Radius']\n", + "regions['Top Blade'] = \\\n", + " (+surfaces['Top Blade y-'] & -surfaces['Global y+']) & \\\n", + " (+surfaces['Top Blade x-'] & -surfaces['Top Blade x+'])\n", + "regions['Top Steel'] = \\\n", + " (+surfaces['Global x-'] & -surfaces['Top Blade x-']) & \\\n", + " (+surfaces['Top Blade y-'] & -surfaces['Global y+'])\n", + "regions['Left Blade'] = \\\n", + " (+surfaces['Left Blade y-'] & -surfaces['Left Blade y+']) & \\\n", + " (+surfaces['Global x-'] & -surfaces['Left Blade x+'])\n", + "regions['Left Steel'] = \\\n", + " (+surfaces['Left Blade y+'] & -surfaces['Top Blade y-']) & \\\n", + " (+surfaces['Global x-'] & -surfaces['Left Blade x+'])\n", + "regions['Corner Blade'] = \\\n", + " regions['Left Steel'] | regions['Top Steel']\n", + "regions['Water Fill'] = \\\n", + " regions['Global'] & ~regions['Assembly'] & \\\n", + " ~regions['Top Blade'] & ~regions['Left Blade'] &\\\n", + " ~regions['Corner Blade']" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We will begin building the 8x8 assembly. To do that we will have to build the cells and universe for each pin type (fuel, gadolinia-fuel, and water)." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "universes = {}\n", + "cells = {}\n", + "\n", + "for name, mat, in zip(['Fuel Pin', 'Gd Pin'],\n", + " [materials['Fuel'], materials['Gad']]):\n", + " universes[name] = openmc.Universe(name=name)\n", + " cells[name] = openmc.Cell(name=name)\n", + " cells[name].fill = mat\n", + " cells[name].region = regions['Fuel']\n", + " universes[name].add_cell(cells[name])\n", + " \n", + " cells[name + ' Clad'] = openmc.Cell(name=name + ' Clad')\n", + " cells[name + ' Clad'].fill = materials['Zirc2']\n", + " cells[name + ' Clad'].region = regions['Clad']\n", + " universes[name].add_cell(cells[name + ' Clad'])\n", + " \n", + " cells[name + ' Water'] = openmc.Cell(name=name + ' Water')\n", + " cells[name + ' Water'].fill = materials['Water']\n", + " cells[name + ' Water'].region = regions['Water']\n", + " universes[name].add_cell(cells[name + ' Water'])\n", + "\n", + "universes['Hole'] = openmc.Universe(name='Hole')\n", + "cells['Hole'] = openmc.Cell(name='Hole')\n", + "cells['Hole'].fill = materials['Water']\n", + "universes['Hole'].add_cell(cells['Hole'])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's use this pin information to create our 8x8 assembly." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# Create fuel assembly Lattice\n", + "universes['Assembly'] = openmc.RectLattice(name='Assembly')\n", + "universes['Assembly'].pitch = (pin_pitch, pin_pitch)\n", + "universes['Assembly'].lower_left = [pin_pitch, pin_pitch]\n", + "\n", + "f = universes['Fuel Pin']\n", + "g = universes['Gd Pin']\n", + "h = universes['Hole']\n", + "\n", + "lattices = [[f, f, f, f, f, f, f, f],\n", + " [f, f, f, f, f, f, f, f],\n", + " [f, f, f, g, f, g, f, f],\n", + " [f, f, g, h, h, f, g, f],\n", + " [f, f, f, h, h, f, f, f],\n", + " [f, f, g, f, f, f, g, f],\n", + " [f, f, f, g, f, g, f, f],\n", + " [f, f, f, f, f, f, f, f]]\n", + "\n", + "# Store the array of lattice universes\n", + "universes['Assembly'].universes = lattices\n", + "\n", + "cells['Assembly'] = openmc.Cell(name='Assembly')\n", + "cells['Assembly'].fill = universes['Assembly']\n", + "cells['Assembly'].region = regions['Assembly']" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "So far we have the rods and water within the assembly , but we still need the control blade and the water which fills the rest of the space. We will create those cells now" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# The top portion of the blade, poisoned with B4C\n", + "cells['Top Blade'] = openmc.Cell(name='Top Blade')\n", + "cells['Top Blade'].fill = materials['B4C']\n", + "cells['Top Blade'].region = regions['Top Blade']\n", + "\n", + "# The left portion of the blade, poisoned with B4C\n", + "cells['Left Blade'] = openmc.Cell(name='Left Blade')\n", + "cells['Left Blade'].fill = materials['B4C']\n", + "cells['Left Blade'].region = regions['Left Blade']\n", + "\n", + "# The top-left corner portion of the blade, with no poison\n", + "cells['Corner Blade'] = openmc.Cell(name='Corner Blade')\n", + "cells['Corner Blade'].fill = materials['Steel']\n", + "cells['Corner Blade'].region = regions['Corner Blade']\n", + "\n", + "# Water surrounding all other cells and our assembly\n", + "cells['Water Fill'] = openmc.Cell(name='Water Fill')\n", + "cells['Water Fill'].fill = materials['Water']\n", + "cells['Water Fill'].region = regions['Water Fill']" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "OpenMC requires that there is a \"root\" universe. Let us create our root universe and fill it with the cells just defined." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "# Create root Universe\n", + "universes['Root'] = openmc.Universe(name='root universe', universe_id=0)\n", + "universes['Root'].add_cells([cells['Assembly'], cells['Top Blade'],\n", + " cells['Corner Blade'], cells['Left Blade'],\n", + " cells['Water Fill']])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "What do you do after you create your model? Check it! We will use the plotting capabilities of the Python API to do this for us.\n", + "\n", + "When doing so, we will coloring by material with fuel being red, gadolinia-fuel as yellow, zirc cladding as a light grey, water as blue, B4C as black and steel as a darker gray." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAP8AAAD8CAYAAAC4nHJkAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nQmCC\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "universes['Root'].plot(center=(length / 2., length / 2., 0.),\n", + " pixels=(500, 500), width=(length, length),\n", + " color_by='material',\n", + " colors={materials['Fuel']: (1., 0., 0.),\n", + " materials['Gad']: (1., 1., 0.),\n", + " materials['Zirc2']: (0.5, 0.5, 0.5),\n", + " materials['Water']: (0.0, 0.0, 1.0),\n", + " materials['B4C']: (0.0, 0.0, 0.0),\n", + " materials['Steel']: (0.4, 0.4, 0.4)})" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Looks pretty good to us!\n", + "\n", + "We now must create a geometry that is assigned a root universe and export it to XML." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "# Create Geometry and set root universe\n", + "geometry = openmc.Geometry(universes['Root'])\n", + "\n", + "# Export to \"geometry.xml\"\n", + "geometry.export_to_xml()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "With the geometry and materials finished, we now just need to define simulation parameters, including how to run the model and what we want to learn from the model (i.e., define the tallies). We will start with our simulation parameters in the next block.\n", + "\n", + "This will include setting the run strategy, telling OpenMC not to bother creating a `tallies.out` file, and limiting the verbosity of our output to just the header and results to not clog up our notebook with results from each batch." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# OpenMC simulation parameters\n", + "batches = 1000\n", + "inactive = 20\n", + "particles = 1000\n", + "\n", + "# Instantiate a Settings object\n", + "settings_file = openmc.Settings()\n", + "settings_file.batches = batches\n", + "settings_file.inactive = inactive\n", + "settings_file.particles = particles\n", + "settings_file.output = {'tallies': False}\n", + "settings_file.verbosity = 4\n", + "\n", + "# Create an initial uniform spatial source distribution over fissionable zones\n", + "bounds = [pin_pitch, pin_pitch, 10, length - pin_pitch, length - pin_pitch, 10]\n", + "uniform_dist = openmc.stats.Box(bounds[:3], bounds[3:], only_fissionable=True)\n", + "settings_file.source = openmc.source.Source(space=uniform_dist)\n", + "\n", + "# Export to \"settings.xml\"\n", + "settings_file.export_to_xml()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Create an MGXS Library\n", + "\n", + "Now we are ready to generate multi-group cross sections! First, let's define a 2-group structure using the built-in EnergyGroups class." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "# Instantiate a 2-group EnergyGroups object\n", + "groups = openmc.mgxs.EnergyGroups()\n", + "groups.group_edges = np.array([0., 0.625, 20.0e6])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Next, we will instantiate an openmc.mgxs.Library for the energy groups with our the problem geometry. This library will use the default setting of isotropically-weighting the multi-group cross sections." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# Initialize a 2-group Isotropic MGXS Library for OpenMC\n", + "iso_mgxs_lib = openmc.mgxs.Library(geometry)\n", + "iso_mgxs_lib.energy_groups = groups" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now, we must specify to the Library which types of cross sections to compute. OpenMC's multi-group mode can accept isotropic flux-weighted cross sections or angle-dependent cross sections, as well as supporting anisotropic scattering represented by either Legendre polynomials, histogram, or tabular angular distributions. \n", + "\n", + "Just like before, we will create the following multi-group cross sections needed to run an OpenMC simulation to verify the accuracy of our cross sections: \"total\", \"absorption\", \"nu-fission\", '\"fission\", \"nu-scatter matrix\", \"multiplicity matrix\", and \"chi\".\n", + "\"multiplicity matrix\" is needed to provide OpenMC's multi-group mode with additional information needed to accurately treat scattering multiplication (i.e., (n,xn) reactions)) explicitly." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# Specify multi-group cross section types to compute\n", + "iso_mgxs_lib.mgxs_types = ['total', 'absorption', 'nu-fission', 'fission',\n", + " 'nu-scatter matrix', 'multiplicity matrix', 'chi']" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we must specify the type of domain over which we would like the `Library` to compute multi-group cross sections. The domain type corresponds to the type of tally filter to be used in the tallies created to compute multi-group cross sections. At the present time, the `Library` supports \"material\" \"cell\", \"universe\", and \"mesh\" domain types. \n", + "\n", + "For the sake of example we will use a mesh to gather our cross sections. This mesh will be set up so there is one mesh bin for every pin cell." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "# Instantiate a tally Mesh\n", + "mesh = openmc.Mesh()\n", + "mesh.type = 'regular'\n", + "mesh.dimension = [10, 10]\n", + "mesh.lower_left = [0., 0.]\n", + "mesh.upper_right = [length, length]\n", + "\n", + "# Specify a \"mesh\" domain type for the cross section tally filters\n", + "iso_mgxs_lib.domain_type = \"mesh\"\n", + "\n", + "# Specify the mesh over which to compute multi-group cross sections\n", + "iso_mgxs_lib.domains = [mesh]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we will set the scattering treatment that we wish to use.\n", + "\n", + "In the [mg-mode-part-ii](mg-mode-part-ii.html) notebook, the cross sections were generated with a typical P3 scattering expansion in mind. Now, however, we will use a more advanced technique: OpenMC will directly provide us a histogram of the change-in-angle (i.e., $\\mu$) distribution.\n", + "\n", + "Where as in the [mg-mode-part-ii](mg-mode-part-ii.html) notebook, all that was required was to set the `legendre_order` attribute of `mgxs_lib`, here we have only slightly more work: we have to tell the Library that we want to use a histogram distribution (as it is not the default), and then tell it the number of bins.\n", + "\n", + "For this problem we will use 11 bins." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "# Set the scattering format to histogram and then define the number of bins\n", + "\n", + "# Avoid a warning that corrections don't make sense with histogram data\n", + "iso_mgxs_lib.correction = None\n", + "# Set the histogram data\n", + "iso_mgxs_lib.scatter_format = 'histogram'\n", + "iso_mgxs_lib.histogram_bins = 11" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Ok, we made our isotropic library with histogram-scattering!\n", + "\n", + "Now why don't we go ahead and create a library to do the same, but with angle-dependent MGXS. That is, we will avoid making the isotropic flux weighting approximation and instead just store a cross section for every polar and azimuthal angle pair.\n", + "\n", + "To do this with the Python API and OpenMC, all we have to do is set the number of polar and azimuthal bins. Here we only need to set the number of bins, the API will convert all of angular space into equal-width bins for us.\n", + "\n", + "Since this problem is symmetric in the z-direction, we only need to concern ourselves with the azimuthal variation here. We will use eight angles.\n", + "\n", + "Ok, we will repeat all the above steps for a new library object, but will also set the number of azimuthal bins at the end." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# Let's repeat all of the above for an angular MGXS library so we can gather\n", + "# that in the same continuous-energy calculation\n", + "angle_mgxs_lib = openmc.mgxs.Library(geometry)\n", + "angle_mgxs_lib.energy_groups = groups\n", + "angle_mgxs_lib.mgxs_types = ['total', 'absorption', 'nu-fission', 'fission',\n", + " 'nu-scatter matrix', 'multiplicity matrix', 'chi']\n", + "\n", + "angle_mgxs_lib.domain_type = \"mesh\"\n", + "angle_mgxs_lib.domains = [mesh]\n", + "angle_mgxs_lib.correction = None\n", + "angle_mgxs_lib.scatter_format = 'histogram'\n", + "angle_mgxs_lib.histogram_bins = 11\n", + "\n", + "# Set the angular bins to 8\n", + "angle_mgxs_lib.num_azimuthal = 8" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now that our libraries have been setup, let's make sure they contain the types of cross sections which meet the needs of OpenMC's multi-group solver. Note that this step is done automatically when writing the Multi-Group Library file later in the process (as part of the `mgxs_lib.write_mg_library()`), but it is a good practice to also run this before spending all the time running OpenMC to generate the cross sections." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "# Check the libraries - if no errors are raised, then the library is satisfactory.\n", + "iso_mgxs_lib.check_library_for_openmc_mgxs()\n", + "angle_mgxs_lib.check_library_for_openmc_mgxs()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Lastly, we use our two `Library` objects to construct the tallies needed to compute all of the requested multi-group cross sections in each domain.\n", + "\n", + "We expect a warning here telling us that the default Legendre order is not meaningful since we are using histogram scattering." + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/nelsonag/git/openmc/openmc/mgxs/mgxs.py:3801: UserWarning: The legendre order will be ignored since the scatter format is set to histogram\n", + " warnings.warn(msg)\n" + ] + } + ], + "source": [ + "# Construct all tallies needed for the multi-group cross section library\n", + "iso_mgxs_lib.build_library()\n", + "angle_mgxs_lib.build_library()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The tallies within the libraries can now be exported to a \"tallies.xml\" input file for OpenMC." + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# Create a \"tallies.xml\" file for the MGXS Library\n", + "tallies_file = openmc.Tallies()\n", + "iso_mgxs_lib.add_to_tallies_file(tallies_file, merge=True)\n", + "angle_mgxs_lib.add_to_tallies_file(tallies_file, merge=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In addition, we instantiate a fission rate mesh tally for eventual comparison of results." + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# Instantiate tally Filter\n", + "mesh_filter = openmc.MeshFilter(mesh)\n", + "\n", + "# Instantiate the Tally\n", + "tally = openmc.Tally(name='mesh tally')\n", + "tally.filters = [mesh_filter]\n", + "tally.scores = ['fission']\n", + "\n", + "# Add tally to collection\n", + "tallies_file.append(tally, merge=True)\n", + "\n", + "# Export all tallies to a \"tallies.xml\" file\n", + "tallies_file.export_to_xml()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": true + }, + "source": [ + "Time to run the calculation and get our results!" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + " %%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%\n", + " ############### %%%%%%%%%%%%%%%%%%%%%%%%\n", + " ################## %%%%%%%%%%%%%%%%%%%%%%%\n", + " ################### %%%%%%%%%%%%%%%%%%%%%%%\n", + " #################### %%%%%%%%%%%%%%%%%%%%%%\n", + " ##################### %%%%%%%%%%%%%%%%%%%%%\n", + " ###################### %%%%%%%%%%%%%%%%%%%%\n", + " ####################### %%%%%%%%%%%%%%%%%%\n", + " ####################### %%%%%%%%%%%%%%%%%\n", + " ###################### %%%%%%%%%%%%%%%%%\n", + " #################### %%%%%%%%%%%%%%%%%\n", + " ################# %%%%%%%%%%%%%%%%%\n", + " ############### %%%%%%%%%%%%%%%%\n", + " ############ %%%%%%%%%%%%%%%\n", + " ######## %%%%%%%%%%%%%%\n", + " %%%%%%%%%%%\n", + "\n", + " | The OpenMC Monte Carlo Code\n", + " Copyright | 2011-2017 Massachusetts Institute of Technology\n", + " License | http://openmc.readthedocs.io/en/latest/license.html\n", + " Version | 0.8.0\n", + " Git SHA1 | 966169de084fcfda3a5aaca3edc0065c8caf6bbc\n", + " Date/Time | 2017-03-09 09:18:01\n", + " OpenMP Threads | 8\n", + "\n", + "\n", + " ====================> K EIGENVALUE SIMULATION <====================\n", + "\n", + "\n", + " ============================> RESULTS <============================\n", + "\n", + " k-effective (Collision) = 0.83694 +/- 0.00098\n", + " k-effective (Track-length) = 0.83663 +/- 0.00116\n", + " k-effective (Absorption) = 0.83775 +/- 0.00102\n", + " Combined k-effective = 0.83724 +/- 0.00083\n", + " Leakage Fraction = 0.00000 +/- 0.00000\n", + "\n" + ] + }, + { + "data": { + "text/plain": [ + "0" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Run OpenMC\n", + "openmc.run()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To make the files available and not be over-written when running the multi-group calculation, we will now rename the statepoint and summary files." + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "# Move the StatePoint File\n", + "ce_spfile = './statepoint_ce.h5'\n", + "os.rename('statepoint.' + str(batches) + '.h5', ce_spfile)\n", + "# Move the Summary file\n", + "ce_sumfile = './summary_ce.h5'\n", + "os.rename('summary.h5', ce_sumfile)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Tally Data Processing\n", + "\n", + "Our simulation ran successfully and created statepoint and summary output files. Let's begin by loading the StatePoint file, but not automatically linking the summary file." + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "# Load the statepoint file, but not the summary file, as it is a different filename than expected.\n", + "sp = openmc.StatePoint(ce_spfile, autolink=False)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In addition to the statepoint file, our simulation also created a summary file which encapsulates information about the materials and geometry. This is necessary for the `openmc.Library` to properly process the tally data. We first create a `Summary` object and link it with the statepoint. Normally this would not need to be performed, but since we have renamed our summary file to avoid conflicts with the Multi-Group calculation's summary file, we will load this in explicitly." + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "su = openmc.Summary(ce_sumfile)\n", + "sp.link_with_summary(su)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The statepoint is now ready to be analyzed. To create our libraries we simply have to load the tallies from the statepoint into each `Library` and our `MGXS` objects will compute the cross sections for us under-the-hood." + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "# Initialize MGXS Library with OpenMC statepoint data\n", + "iso_mgxs_lib.load_from_statepoint(sp)\n", + "angle_mgxs_lib.load_from_statepoint(sp)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The next step will be to prepare the input for OpenMC to use our newly created multi-group data." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Isotropic Multi-Group OpenMC Calculation" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We will now use the `Library` to produce the isotropic multi-group cross section data set for use by the OpenMC multi-group solver. \n", + "\n", + "If the model to be run in multi-group mode is the same as the continuous-energy mode, the `openmc.mgxs.Library` class has the ability to directly create the multi-group geometry, materials, and multi-group library for us. \n", + "Note that this feature is only useful if the MG model is intended to replicate the CE geometry - it is not useful if the CE library is not the same geometry (like it would be for generating MGXS from a generic spectral region).\n", + "\n", + "This method creates and assigns the materials automatically, including creating a geometry which is equivalent to our mesh cells for which the cross sections were derived." + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/nelsonag/git/openmc/openmc/tallies.py:1835: RuntimeWarning: invalid value encountered in true_divide\n", + " self_rel_err = data['self']['std. dev.'] / data['self']['mean']\n", + "/home/nelsonag/git/openmc/openmc/tallies.py:1836: RuntimeWarning: invalid value encountered in true_divide\n", + " other_rel_err = data['other']['std. dev.'] / data['other']['mean']\n", + "/home/nelsonag/git/openmc/openmc/tallies.py:1837: RuntimeWarning: invalid value encountered in true_divide\n", + " new_tally._mean = data['self']['mean'] / data['other']['mean']\n" + ] + } + ], + "source": [ + "# Allow the API to create our Library, materials, and geometry file\n", + "iso_mgxs_file, materials_file, geometry_file = iso_mgxs_lib.create_mg_mode()\n", + "\n", + "# Tell the materials file what we want to call the multi-group library\n", + "materials_file.cross_sections = 'mgxs.h5'\n", + "\n", + "# Write our newly-created files to disk\n", + "iso_mgxs_file.export_to_hdf5('mgxs.h5')\n", + "materials_file.export_to_xml()\n", + "geometry_file.export_to_xml()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Next, we can make the changes we need to the settings file.\n", + "These changes are limited to telling OpenMC to run a multi-group calculation and provide the location of our multi-group cross section file." + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# Set the energy mode\n", + "settings_file.energy_mode = 'multi-group'\n", + "\n", + "# Export to \"settings.xml\"\n", + "settings_file.export_to_xml()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's clear up the tallies file so it doesn't include all the extra tallies for re-generating a multi-group library" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# Create a \"tallies.xml\" file for the MGXS Library\n", + "tallies_file = openmc.Tallies()\n", + "\n", + "# Add our fission rate mesh tally\n", + "tallies_file.add_tally(tally)\n", + "\n", + "# Export to \"tallies.xml\"\n", + "tallies_file.export_to_xml()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Before running the calculation let's look at our meshed model. It might not be interesting, but let's take a look anyways." + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAP8AAAD8CAYAAAC4nHJkAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "geometry_file.root_universe.plot(center=(length / 2., length / 2., 0.),\n", + " pixels=(300, 300), width=(length, length),\n", + " color_by='material')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "So, we see a 10x10 grid with a different color for every material, sounds good!\n", + "\n", + "At this point, the problem is set up and we can run the multi-group calculation." + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + " %%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%\n", + " ############### %%%%%%%%%%%%%%%%%%%%%%%%\n", + " ################## %%%%%%%%%%%%%%%%%%%%%%%\n", + " ################### %%%%%%%%%%%%%%%%%%%%%%%\n", + " #################### %%%%%%%%%%%%%%%%%%%%%%\n", + " ##################### %%%%%%%%%%%%%%%%%%%%%\n", + " ###################### %%%%%%%%%%%%%%%%%%%%\n", + " ####################### %%%%%%%%%%%%%%%%%%\n", + " ####################### %%%%%%%%%%%%%%%%%\n", + " ###################### %%%%%%%%%%%%%%%%%\n", + " #################### %%%%%%%%%%%%%%%%%\n", + " ################# %%%%%%%%%%%%%%%%%\n", + " ############### %%%%%%%%%%%%%%%%\n", + " ############ %%%%%%%%%%%%%%%\n", + " ######## %%%%%%%%%%%%%%\n", + " %%%%%%%%%%%\n", + "\n", + " | The OpenMC Monte Carlo Code\n", + " Copyright | 2011-2017 Massachusetts Institute of Technology\n", + " License | http://openmc.readthedocs.io/en/latest/license.html\n", + " Version | 0.8.0\n", + " Git SHA1 | 966169de084fcfda3a5aaca3edc0065c8caf6bbc\n", + " Date/Time | 2017-03-09 09:18:56\n", + " OpenMP Threads | 8\n", + "\n", + "\n", + " ====================> K EIGENVALUE SIMULATION <====================\n", + "\n", + "\n", + " ============================> RESULTS <============================\n", + "\n", + " k-effective (Collision) = 0.82605 +/- 0.00103\n", + " k-effective (Track-length) = 0.82596 +/- 0.00103\n", + " k-effective (Absorption) = 0.82503 +/- 0.00075\n", + " Combined k-effective = 0.82528 +/- 0.00067\n", + " Leakage Fraction = 0.00000 +/- 0.00000\n", + "\n" + ] + }, + { + "data": { + "text/plain": [ + "0" + ] + }, + "execution_count": 33, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Execute the Isotropic MG OpenMC Run\n", + "openmc.run()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Before we go the angle-dependent case, let's save the StatePoint and Summary files so they don't get over-written" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# Move the StatePoint File\n", + "iso_mg_spfile = './statepoint_mg_iso.h5'\n", + "os.rename('statepoint.' + str(batches) + '.h5', iso_mg_spfile)\n", + "# Move the Summary file\n", + "iso_mg_sumfile = './summary_mg_iso.h5'\n", + "os.rename('summary.h5', iso_mg_sumfile)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Angle-Dependent Multi-Group OpenMC Calculation\n", + "\n", + "Let's now run the calculation with the angle-dependent multi-group cross sections. This process will be the exact same as above, except this time we will use the angle-dependent Library as our starting point.\n", + "\n", + "We do not need to re-write the materials, geometry, or tallies file to disk since they are the same as for the isotropic case." + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/nelsonag/git/openmc/openmc/tallies.py:1835: RuntimeWarning: invalid value encountered in true_divide\n", + " self_rel_err = data['self']['std. dev.'] / data['self']['mean']\n", + "/home/nelsonag/git/openmc/openmc/tallies.py:1836: RuntimeWarning: invalid value encountered in true_divide\n", + " other_rel_err = data['other']['std. dev.'] / data['other']['mean']\n", + "/home/nelsonag/git/openmc/openmc/tallies.py:1837: RuntimeWarning: invalid value encountered in true_divide\n", + " new_tally._mean = data['self']['mean'] / data['other']['mean']\n" + ] + } + ], + "source": [ + "# Let's repeat for the angle-dependent case\n", + "angle_mgxs_lib.load_from_statepoint(sp)\n", + "angle_mgxs_file, materials_file, geometry_file = angle_mgxs_lib.create_mg_mode()\n", + "angle_mgxs_file.export_to_hdf5()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "At this point, the problem is set up and we can run the multi-group calculation." + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + " %%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%\n", + " ############### %%%%%%%%%%%%%%%%%%%%%%%%\n", + " ################## %%%%%%%%%%%%%%%%%%%%%%%\n", + " ################### %%%%%%%%%%%%%%%%%%%%%%%\n", + " #################### %%%%%%%%%%%%%%%%%%%%%%\n", + " ##################### %%%%%%%%%%%%%%%%%%%%%\n", + " ###################### %%%%%%%%%%%%%%%%%%%%\n", + " ####################### %%%%%%%%%%%%%%%%%%\n", + " ####################### %%%%%%%%%%%%%%%%%\n", + " ###################### %%%%%%%%%%%%%%%%%\n", + " #################### %%%%%%%%%%%%%%%%%\n", + " ################# %%%%%%%%%%%%%%%%%\n", + " ############### %%%%%%%%%%%%%%%%\n", + " ############ %%%%%%%%%%%%%%%\n", + " ######## %%%%%%%%%%%%%%\n", + " %%%%%%%%%%%\n", + "\n", + " | The OpenMC Monte Carlo Code\n", + " Copyright | 2011-2017 Massachusetts Institute of Technology\n", + " License | http://openmc.readthedocs.io/en/latest/license.html\n", + " Version | 0.8.0\n", + " Git SHA1 | 966169de084fcfda3a5aaca3edc0065c8caf6bbc\n", + " Date/Time | 2017-03-09 09:19:06\n", + " OpenMP Threads | 8\n", + "\n", + "\n", + " ====================> K EIGENVALUE SIMULATION <====================\n", + "\n", + "\n", + " ============================> RESULTS <============================\n", + "\n", + " k-effective (Collision) = 0.83752 +/- 0.00102\n", + " k-effective (Track-length) = 0.83708 +/- 0.00104\n", + " k-effective (Absorption) = 0.83678 +/- 0.00077\n", + " Combined k-effective = 0.83684 +/- 0.00068\n", + " Leakage Fraction = 0.00000 +/- 0.00000\n", + "\n" + ] + }, + { + "data": { + "text/plain": [ + "0" + ] + }, + "execution_count": 36, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Execute the angle-dependent OpenMC Run\n", + "openmc.run()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Results Comparison\n", + "In this section we will compare the eigenvalues and fission rate distributions of the continuous-energy, isotropic multi-group and angle-dependent multi-group cases.\n", + "\n", + "We will begin by loading the multi-group statepoint files, first the isotropic, then angle-dependent. The angle-dependent was not renamed, so we can autolink its summary." + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "# Load the isotropic statepoint file\n", + "iso_mgsp = openmc.StatePoint(iso_mg_spfile, autolink=False)\n", + "iso_mgsum = openmc.Summary(iso_mg_sumfile)\n", + "iso_mgsp.link_with_summary(iso_mgsum)\n", + "\n", + "# Load the angle-dependent statepoint file\n", + "angle_mgsp = openmc.StatePoint('statepoint.' + str(batches) + '.h5')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Eigenvalue Comparison\n", + "Next, we can load the eigenvalues for comparison and do that comparison" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "ce_keff = sp.k_combined\n", + "iso_mg_keff = iso_mgsp.k_combined\n", + "angle_mg_keff = angle_mgsp.k_combined\n", + "\n", + "# Find eigenvalue bias\n", + "iso_bias = 1.0E5 * (ce_keff[0] - iso_mg_keff[0])\n", + "angle_bias = 1.0E5 * (ce_keff[0] - angle_mg_keff[0])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's compare the eigenvalues in units of pcm" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Isotropic to CE Bias [pcm]: 1195.9\n", + "Angle to CE Bias [pcm]: 40.4\n" + ] + } + ], + "source": [ + "print('Isotropic to CE Bias [pcm]: {0:1.1f}'.format(iso_bias))\n", + "print('Angle to CE Bias [pcm]: {0:1.1f}'.format(angle_bias))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We see a large reduction in error by switching to the usage of angle-dependent multi-group cross sections! \n", + "\n", + "Of course, this rodded and partially voided BWR problem was chosen specifically to exacerbate the angular variation of the reaction rates (and thus cross sections). Such improvements should not be expected in every case, especially if localized absorbers are not present.\n", + "\n", + "It is important to note that both eigenvalues can be improved by the application of finer geometric or energetic discretizations, but this shows that the angle discretization may be a factor for consideration.\n", + "\n", + "## Fission Rate Distribution Comparison\n", + "Next we will visualize the mesh tally results obtained from our three cases.\n", + "\n", + "This will be performed by first obtaining the one-group fission rate tally information from our state point files. After we have this information we will re-shape the data to match the original mesh laydown. We will then normalize, and finally create side-by-side plots of all." + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": { + "collapsed": false, + "scrolled": false + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAArwAAAEDCAYAAADXztd+AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nAajbsJNqTdi0AAAAAElFTkSuQmCC\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sp_files = [sp, iso_mgsp, angle_mgsp]\n", + "titles = ['Continuous-Energy', 'Isotropic Multi-Group',\n", + " 'Angle-Dependent Multi-Group']\n", + "fiss_rates = []\n", + "fig = plt.figure(figsize=(12, 6))\n", + "for i, (case, title) in enumerate(zip(sp_files, titles)):\n", + " # Get our mesh tally information\n", + " mesh_tally = case.get_tally(name='mesh tally')\n", + " fiss_rates.append(mesh_tally.get_values(scores=['fission']))\n", + " \n", + " # Reshape the array\n", + " fiss_rates[-1].shape = mesh.dimension\n", + " \n", + " # Normalize the fission rates\n", + " fiss_rates[-1] /= np.mean(fiss_rates[-1])\n", + " \n", + " # Set 0s to NaNs so they show as white\n", + " fiss_rates[-1][fiss_rates[-1] == 0.] = np.nan\n", + "\n", + " fig = plt.subplot(1, len(titles), i + 1)\n", + " # Plot only the fueled regions\n", + " plt.imshow(fiss_rates[-1][1:-1, 1:-1], cmap='jet', origin='lower',\n", + " vmin=0.4, vmax=4.)\n", + " plt.title(title + '\\nFission Rates')" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": true + }, + "source": [ + "With this colormap, dark blue is the lowest power and dark red is the highest power.\n", + "\n", + "We see general agreement between the fission rate distributions, but it looks like there may be less of a gradient near the rods in the continuous-energy and angle-dependent MGXS cases than in the isotropic MGXS case. \n", + "\n", + "To better see the differences, let's plot ratios of the fission powers for our two multi-group cases compared to the continuous-energy case t" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 41, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAt0AAAFfCAYAAACSp3C8AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nkjRi/w9hvYqGSZgiKAAAAABJRU5ErkJggg==\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Calculate and plot the ratios of MG to CE for each of the 2 MG cases\n", + "ratios = []\n", + "fig, axes = plt.subplots(figsize=(12, 6), nrows=1, ncols=2)\n", + "for i, (case, title, axis) in enumerate(zip(sp_files[1:], titles[1:], axes.flat)):\n", + " # Get our ratio relative to the CE (in fiss_ratios[0])\n", + " ratios.append(np.divide(fiss_rates[i + 1], fiss_rates[0]))\n", + " \n", + " # Plot only the fueled regions\n", + " im = axis.imshow(ratios[-1][1:-1, 1:-1], cmap='bwr', origin='lower',\n", + " vmin = 0.9, vmax = 1.1)\n", + " axis.set_title(title + '\\nFission Rates Relative\\nto Continuous-Energy')\n", + " \n", + "# Add a color bar\n", + "fig.subplots_adjust(right=0.8)\n", + "cbar_ax = fig.add_axes([0.85, 0.15, 0.05, 0.7])\n", + "fig.colorbar(im, cax=cbar_ax)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "With this ratio its clear that the errors are significantly worse in the isotropic case. These errors are conveniently located right where the most anisotropy is espected: by the control blades and by the Gd-bearing pins!" + ] + } + ], + "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.6.0" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/docs/source/pythonapi/examples/mgxs-part-iv.rst b/docs/source/examples/mg-mode-part-iii.rst similarity index 63% rename from docs/source/pythonapi/examples/mgxs-part-iv.rst rename to docs/source/examples/mg-mode-part-iii.rst index e24325521..e59452ce5 100644 --- a/docs/source/pythonapi/examples/mgxs-part-iv.rst +++ b/docs/source/examples/mg-mode-part-iii.rst @@ -1,12 +1,12 @@ -.. _notebook_mgxs_part_iv: +.. _notebook_mg_mode_part_iii: ==================================================== -MGXS Part IV: Multi-Group Mode Cross-Section Library +Multi-Group Mode Part III: Advanced Feature Showcase ==================================================== .. only:: html - .. notebook:: mgxs-part-iv.ipynb + .. notebook:: mg-mode-part-iii.ipynb .. only:: latex diff --git a/docs/source/pythonapi/examples/mgxs-part-i.ipynb b/docs/source/examples/mgxs-part-i.ipynb similarity index 100% rename from docs/source/pythonapi/examples/mgxs-part-i.ipynb rename to docs/source/examples/mgxs-part-i.ipynb diff --git a/docs/source/pythonapi/examples/mgxs-part-i.rst b/docs/source/examples/mgxs-part-i.rst similarity index 100% rename from docs/source/pythonapi/examples/mgxs-part-i.rst rename to docs/source/examples/mgxs-part-i.rst diff --git a/docs/source/pythonapi/examples/mgxs-part-ii.ipynb b/docs/source/examples/mgxs-part-ii.ipynb similarity index 100% rename from docs/source/pythonapi/examples/mgxs-part-ii.ipynb rename to docs/source/examples/mgxs-part-ii.ipynb diff --git a/docs/source/pythonapi/examples/mgxs-part-ii.rst b/docs/source/examples/mgxs-part-ii.rst similarity index 100% rename from docs/source/pythonapi/examples/mgxs-part-ii.rst rename to docs/source/examples/mgxs-part-ii.rst diff --git a/docs/source/pythonapi/examples/mgxs-part-iii.ipynb b/docs/source/examples/mgxs-part-iii.ipynb similarity index 100% rename from docs/source/pythonapi/examples/mgxs-part-iii.ipynb rename to docs/source/examples/mgxs-part-iii.ipynb diff --git a/docs/source/pythonapi/examples/mgxs-part-iii.rst b/docs/source/examples/mgxs-part-iii.rst similarity index 100% rename from docs/source/pythonapi/examples/mgxs-part-iii.rst rename to docs/source/examples/mgxs-part-iii.rst diff --git a/docs/source/pythonapi/examples/nuclear-data.ipynb b/docs/source/examples/nuclear-data.ipynb similarity index 100% rename from docs/source/pythonapi/examples/nuclear-data.ipynb rename to docs/source/examples/nuclear-data.ipynb diff --git a/docs/source/pythonapi/examples/nuclear-data.rst b/docs/source/examples/nuclear-data.rst similarity index 100% rename from docs/source/pythonapi/examples/nuclear-data.rst rename to docs/source/examples/nuclear-data.rst diff --git a/docs/source/pythonapi/examples/pandas-dataframes.ipynb b/docs/source/examples/pandas-dataframes.ipynb similarity index 100% rename from docs/source/pythonapi/examples/pandas-dataframes.ipynb rename to docs/source/examples/pandas-dataframes.ipynb diff --git a/docs/source/pythonapi/examples/pandas-dataframes.rst b/docs/source/examples/pandas-dataframes.rst similarity index 100% rename from docs/source/pythonapi/examples/pandas-dataframes.rst rename to docs/source/examples/pandas-dataframes.rst diff --git a/docs/source/pythonapi/examples/post-processing.ipynb b/docs/source/examples/post-processing.ipynb similarity index 100% rename from docs/source/pythonapi/examples/post-processing.ipynb rename to docs/source/examples/post-processing.ipynb diff --git a/docs/source/pythonapi/examples/post-processing.rst b/docs/source/examples/post-processing.rst similarity index 100% rename from docs/source/pythonapi/examples/post-processing.rst rename to docs/source/examples/post-processing.rst diff --git a/docs/source/pythonapi/examples/tally-arithmetic.ipynb b/docs/source/examples/tally-arithmetic.ipynb similarity index 100% rename from docs/source/pythonapi/examples/tally-arithmetic.ipynb rename to docs/source/examples/tally-arithmetic.ipynb diff --git a/docs/source/pythonapi/examples/tally-arithmetic.rst b/docs/source/examples/tally-arithmetic.rst similarity index 100% rename from docs/source/pythonapi/examples/tally-arithmetic.rst rename to docs/source/examples/tally-arithmetic.rst diff --git a/docs/source/index.rst b/docs/source/index.rst index 8fe680a70..a18dd5e87 100644 --- a/docs/source/index.rst +++ b/docs/source/index.rst @@ -32,6 +32,7 @@ the latest developmental version of the develop branch can be found on :maxdepth: 1 quickinstall + examples/index releasenotes methods/index usersguide/index diff --git a/docs/source/pythonapi/examples/mdgxs-part-i.rst b/docs/source/pythonapi/examples/mdgxs-part-i.rst deleted file mode 100644 index 953dcf470..000000000 --- a/docs/source/pythonapi/examples/mdgxs-part-i.rst +++ /dev/null @@ -1,13 +0,0 @@ -.. _notebook_mdgxs_part_i: - -========================== -MDGXS Part I: Introduction -========================== - -.. only:: html - - .. notebook:: mdgxs-part-i.ipynb - -.. only:: latex - - IPython notebooks must be viewed in the online HTML documentation. diff --git a/docs/source/pythonapi/examples/mdgxs-part-ii.rst b/docs/source/pythonapi/examples/mdgxs-part-ii.rst deleted file mode 100644 index a42eb766b..000000000 --- a/docs/source/pythonapi/examples/mdgxs-part-ii.rst +++ /dev/null @@ -1,13 +0,0 @@ -.. _notebook_mdgxs_part_ii: - -================================ -MDGXS Part II: Advanced Features -================================ - -.. only:: html - - .. notebook:: mdgxs-part-ii.ipynb - -.. only:: latex - - IPython notebooks must be viewed in the online HTML documentation. diff --git a/docs/source/pythonapi/examples/mgxs-part-iv.ipynb b/docs/source/pythonapi/examples/mgxs-part-iv.ipynb deleted file mode 100644 index 319a27c16..000000000 --- a/docs/source/pythonapi/examples/mgxs-part-iv.ipynb +++ /dev/null @@ -1,1345 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "This Notebook illustrates the use of the openmc.mgxs.Library class specifically for application in OpenMC's multi-group mode. This example notebook follows the same process as was done in MGXS Part III, but instead uses OpenMC as the multi-group solver. During this process, this notebook will illustrate the following features:\n", - "\n", - " - Calculation of multi-group cross sections for a fuel assembly\n", - " - Automated creation and storage of MGXS with openmc.mgxs.Library\n", - " - Steady-state pin-by-pin fission rates comparison between continuous-energy and multi-group OpenMC." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Generate Input Files" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": { - "collapsed": false - }, - "outputs": [], - "source": [ - "%matplotlib inline\n", - "from IPython.display import Image\n", - "import matplotlib.pyplot as plt\n", - "import numpy as np\n", - "import os\n", - "\n", - "import openmc" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "\n", - "First we need to define materials that will be used in the problem. Before defining a material, we must create nuclides that are used in the material." - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": { - "collapsed": true - }, - "outputs": [], - "source": [ - "# Instantiate some Nuclides\n", - "h1 = openmc.Nuclide('H1')\n", - "b10 = openmc.Nuclide('B10')\n", - "o16 = openmc.Nuclide('O16')\n", - "u235 = openmc.Nuclide('U235')\n", - "u238 = openmc.Nuclide('U238')\n", - "zr90 = openmc.Nuclide('Zr90')" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "With the nuclides we defined, we will now create three materials for the fuel, water, and cladding of the fuel pins." - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": { - "collapsed": false - }, - "outputs": [], - "source": [ - "# 1.6 enriched fuel\n", - "fuel = openmc.Material(name='1.6% Fuel')\n", - "fuel.set_density('g/cm3', 10.31341)\n", - "fuel.add_nuclide(u235, 3.7503e-4)\n", - "fuel.add_nuclide(u238, 2.2625e-2)\n", - "fuel.add_nuclide(o16, 4.6007e-2)\n", - "\n", - "# zircaloy\n", - "zircaloy = openmc.Material(name='Zircaloy')\n", - "zircaloy.set_density('g/cm3', 6.55)\n", - "zircaloy.add_nuclide(zr90, 7.2758e-3)\n", - "\n", - "# borated water\n", - "water = openmc.Material(name='Borated Water')\n", - "water.set_density('g/cm3', 0.740582)\n", - "water.add_nuclide(h1, 4.9457e-2)\n", - "water.add_nuclide(o16, 2.4732e-2)\n", - "water.add_nuclide(b10, 8.0042e-6)\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "With our three materials, we can now create a Materials object that can be exported to an actual XML file." - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": { - "collapsed": true - }, - "outputs": [], - "source": [ - "# Instantiate a Materials object\n", - "materials_file = openmc.Materials((fuel, zircaloy, water))\n", - "\n", - "# Export to \"materials.xml\"\n", - "materials_file.export_to_xml()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Now let's move on to the geometry. This problem will be a square array of fuel pins and control rod guide tubes for which we can use OpenMC's lattice/universe feature. The basic universe will have three regions for the fuel, the clad, and the surrounding coolant. The first step is to create the bounding surfaces for fuel and clad, as well as the outer bounding surfaces of the problem." - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": { - "collapsed": true - }, - "outputs": [], - "source": [ - "# Create cylinders for the fuel and clad\n", - "fuel_outer_radius = openmc.ZCylinder(x0=0.0, y0=0.0, R=0.39218)\n", - "clad_outer_radius = openmc.ZCylinder(x0=0.0, y0=0.0, R=0.45720)\n", - "\n", - "# Create boundary planes to surround the geometry\n", - "min_x = openmc.XPlane(x0=-10.71, boundary_type='reflective')\n", - "max_x = openmc.XPlane(x0=+10.71, boundary_type='reflective')\n", - "min_y = openmc.YPlane(y0=-10.71, boundary_type='reflective')\n", - "max_y = openmc.YPlane(y0=+10.71, boundary_type='reflective')\n", - "min_z = openmc.ZPlane(z0=-10., boundary_type='reflective')\n", - "max_z = openmc.ZPlane(z0=+10., boundary_type='reflective')" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "With the surfaces defined, we can now construct a fuel pin cell from cells that are defined by intersections of half-spaces created by the surfaces." - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": { - "collapsed": false - }, - "outputs": [], - "source": [ - "# Create a Universe to encapsulate a fuel pin\n", - "fuel_pin_universe = openmc.Universe(name='1.6% Fuel Pin')\n", - "\n", - "# Create fuel Cell\n", - "fuel_cell = openmc.Cell(name='1.6% Fuel')\n", - "fuel_cell.fill = fuel\n", - "fuel_cell.region = -fuel_outer_radius\n", - "fuel_pin_universe.add_cell(fuel_cell)\n", - "\n", - "# Create a clad Cell\n", - "clad_cell = openmc.Cell(name='1.6% Clad')\n", - "clad_cell.fill = zircaloy\n", - "clad_cell.region = +fuel_outer_radius & -clad_outer_radius\n", - "fuel_pin_universe.add_cell(clad_cell)\n", - "\n", - "# Create a moderator Cell\n", - "moderator_cell = openmc.Cell(name='1.6% Moderator')\n", - "moderator_cell.fill = water\n", - "moderator_cell.region = +clad_outer_radius\n", - "fuel_pin_universe.add_cell(moderator_cell)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Likewise, we can construct a control rod guide tube with the same surfaces." - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": { - "collapsed": false - }, - "outputs": [], - "source": [ - "# Create a Universe to encapsulate a control rod guide tube\n", - "guide_tube_universe = openmc.Universe(name='Guide Tube')\n", - "\n", - "# Create guide tube Cell\n", - "guide_tube_cell = openmc.Cell(name='Guide Tube Water')\n", - "guide_tube_cell.fill = water\n", - "guide_tube_cell.region = -fuel_outer_radius\n", - "guide_tube_universe.add_cell(guide_tube_cell)\n", - "\n", - "# Create a clad Cell\n", - "clad_cell = openmc.Cell(name='Guide Clad')\n", - "clad_cell.fill = zircaloy\n", - "clad_cell.region = +fuel_outer_radius & -clad_outer_radius\n", - "guide_tube_universe.add_cell(clad_cell)\n", - "\n", - "# Create a moderator Cell\n", - "moderator_cell = openmc.Cell(name='Guide Tube Moderator')\n", - "moderator_cell.fill = water\n", - "moderator_cell.region = +clad_outer_radius\n", - "guide_tube_universe.add_cell(moderator_cell)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Using the pin cell universe, we can construct a 17x17 rectangular lattice with a 1.26 cm pitch." - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": { - "collapsed": false - }, - "outputs": [], - "source": [ - "# Create fuel assembly Lattice\n", - "assembly = openmc.RectLattice(name='1.6% Fuel Assembly')\n", - "assembly.pitch = (1.26, 1.26)\n", - "assembly.lower_left = [-1.26 * 17. / 2.0] * 2" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Next, we create a NumPy array of fuel pin and guide tube universes for the lattice." - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": { - "collapsed": true - }, - "outputs": [], - "source": [ - "# Create array indices for guide tube locations in lattice\n", - "template_x = np.array([5, 8, 11, 3, 13, 2, 5, 8, 11, 14, 2, 5, 8,\n", - " 11, 14, 2, 5, 8, 11, 14, 3, 13, 5, 8, 11])\n", - "template_y = np.array([2, 2, 2, 3, 3, 5, 5, 5, 5, 5, 8, 8, 8, 8,\n", - " 8, 11, 11, 11, 11, 11, 13, 13, 14, 14, 14])\n", - "\n", - "# Initialize an empty 17x17 array of the lattice universes\n", - "universes = np.empty((17, 17), dtype=openmc.Universe)\n", - "\n", - "# Fill the array with the fuel pin and guide tube universes\n", - "universes[:,:] = fuel_pin_universe\n", - "universes[template_x, template_y] = guide_tube_universe\n", - "\n", - "# Store the array of universes in the lattice\n", - "assembly.universes = universes" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "OpenMC requires that there is a \"root\" universe. Let us create a root cell that is filled by the pin cell universe and then assign it to the root universe." - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": { - "collapsed": false - }, - "outputs": [], - "source": [ - "# Create root Cell\n", - "root_cell = openmc.Cell(name='root cell')\n", - "root_cell.fill = assembly\n", - "\n", - "# Add boundary planes\n", - "root_cell.region = +min_x & -max_x & +min_y & -max_y & +min_z & -max_z\n", - "\n", - "# Create root Universe\n", - "root_universe = openmc.Universe(name='root universe', universe_id=0)\n", - "root_universe.add_cell(root_cell)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We now must create a geometry that is assigned a root universe and export it to XML." - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": { - "collapsed": false - }, - "outputs": [], - "source": [ - "# Create Geometry and set root Universe\n", - "geometry = openmc.Geometry()\n", - "geometry.root_universe = root_universe\n", - "# Export to \"geometry.xml\"\n", - "geometry.export_to_xml()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "With the geometry and materials finished, we now just need to define simulation parameters. In this case, we will use 10 inactive batches and 40 active batches each with 5000 particles." - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": { - "collapsed": true - }, - "outputs": [], - "source": [ - "# OpenMC simulation parameters\n", - "batches = 500\n", - "inactive = 10\n", - "particles = 5000\n", - "\n", - "# Instantiate a Settings object\n", - "settings_file = openmc.Settings()\n", - "settings_file.batches = batches\n", - "settings_file.inactive = inactive\n", - "settings_file.particles = particles\n", - "settings_file.output = {'tallies': False}\n", - "settings_file.verbosity = 4 # only show results\n", - "\n", - "# Create an initial uniform spatial source distribution over fissionable zones\n", - "bounds = [-10.71, -10.71, -10, 10.71, 10.71, 10.]\n", - "uniform_dist = openmc.stats.Box(bounds[:3], bounds[3:], only_fissionable=True)\n", - "settings_file.source = openmc.source.Source(space=uniform_dist)\n", - "\n", - "# Export to \"settings.xml\"\n", - "settings_file.export_to_xml()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Let us also create a Plots file that we can use to verify that our fuel assembly geometry was created successfully." - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": { - "collapsed": true - }, - "outputs": [], - "source": [ - "# Instantiate a Plot\n", - "plot = openmc.Plot()\n", - "plot.filename = 'materials-xy'\n", - "plot.origin = [0, 0, 0]\n", - "plot.pixels = [250, 250]\n", - "plot.width = [-10.71*2, -10.71*2]\n", - "plot.color = 'mat'\n", - "\n", - "# Instantiate a Plots object, add Plot, and export to \"plots.xml\"\n", - "plot_file = openmc.Plots([plot])\n", - "plot_file.export_to_xml()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "With the plots.xml file, we can now generate and view the plot. OpenMC outputs plots in .ppm format, which can be converted into a compressed format like .png with the convert utility." - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "0" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Run openmc in plotting mode\n", - "openmc.plot_geometry(output=False)" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAPoAAAD6AgMAAAD1grKuAAAABGdBTUEAALGPC/xhBQAAACBjSFJN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\nVDExOjI3OjI3LTA2OjAwxJJlgAAAAABJRU5ErkJggg==\n", - "text/plain": [ - "" - ] - }, - "execution_count": 15, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Convert OpenMC's funky ppm to png\n", - "!convert materials-xy.ppm materials-xy.png\n", - "\n", - "# Display the materials plot inline\n", - "Image(filename='materials-xy.png')" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "As we can see from the plot, we have a nice array of fuel and guide tube pin cells with fuel, cladding, and water!\n", - "\n", - "# Create an MGXS Library\n", - "\n", - "Now we are ready to generate multi-group cross sections! First, let's define a 2-group structure using the built-in EnergyGroups class." - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": { - "collapsed": false - }, - "outputs": [], - "source": [ - "# Instantiate a 2-group EnergyGroups object\n", - "groups = openmc.mgxs.EnergyGroups()\n", - "groups.group_edges = np.array([0., 0.625, 20.0e6])" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Next, we will instantiate an openmc.mgxs.Library for the energy groups with our the fuel assembly geometry." - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": { - "collapsed": true - }, - "outputs": [], - "source": [ - "# Initialize a 2-group MGXS Library for OpenMOC\n", - "mgxs_lib = openmc.mgxs.Library(geometry)\n", - "mgxs_lib.energy_groups = groups" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Now, we must specify to the Library which types of cross sections to compute. OpenMC's multi-group mode can accept isotropic flux-weighted cross sections or angle-dependent cross sections, as well as supporting anisotropic scattering represented by either Legendre polynomials, histogram, or tabular angular distributions. At this time the MGXS Library class only supports the generation of isotropic flux-weighted cross sections and P0 scattering, so that is what will be used for this example. Therefore, we will create the following multi-group cross sections needed to run an OpenMC simulation to verify the accuracy of our cross sections: \"total\", \"absorption\", \"nu-fission\", '\"fission\", \"nu-scatter matrix\", \"multiplicity matrix\", and \"chi\".\n", - "\"multiplicity matrix\" is needed to provide OpenMC's multi-group mode with additional information needed to accurately treat scattering multiplication (i.e., (n,xn) reactions)) explicitly." - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": { - "collapsed": true - }, - "outputs": [], - "source": [ - "# Specify multi-group cross section types to compute\n", - "mgxs_lib.mgxs_types = ['total', 'absorption', 'nu-fission', 'fission',\n", - " 'nu-scatter matrix', 'multiplicity matrix', 'chi']" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Now we must specify the type of domain over which we would like the `Library` to compute multi-group cross sections. The domain type corresponds to the type of tally filter to be used in the tallies created to compute multi-group cross sections. At the present time, the `Library` supports \"material\" \"cell\", \"universe\", and \"mesh\" domain types. In this simple example, we wish to compute multi-group cross sections only for each material and therefore will use a \"material\" domain type.\n", - "\n", - "**Note:** By default, the `Library` class will instantiate `MGXS` objects for each and every domain (material, cell, universe, or mesh) in the geometry of interest. However, one may specify a subset of these domains to the `Library.domains` property." - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "metadata": { - "collapsed": false - }, - "outputs": [], - "source": [ - "# Specify a \"cell\" domain type for the cross section tally filters\n", - "mgxs_lib.domain_type = \"material\"\n", - "\n", - "# Specify the cell domains over which to compute multi-group cross sections\n", - "mgxs_lib.domains = geometry.get_all_materials().values()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We will instruct the library to not compute cross sections on a nuclide-by-nuclide basis, and instead to focus on generating material-specific macroscopic cross sections.\n", - "\n", - "**NOTE:** The default value of the `by_nuclide` parameter is `False`, so the following step is not necessary but is included for illustrative purposes." - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "metadata": { - "collapsed": false - }, - "outputs": [], - "source": [ - "# Do not compute cross sections on a nuclide-by-nuclide basis\n", - "mgxs_lib.by_nuclide = False" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Now we will set the scattering order that we wish to use. For this problem we will use P3 scattering. A warning is expected telling us that the default behavior (a P0 correction on the scattering data) is over-ridden by our choice of using a Legendre expansion to treat anisotropic scattering." - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/romano/openmc/openmc/mgxs/library.py:412: RuntimeWarning: The P0 correction will be ignored since the scattering order 0 is greater than zero\n", - " warn(msg, RuntimeWarning)\n" - ] - } - ], - "source": [ - "# Set the Legendre order to 3 for P3 scattering\n", - "mgxs_lib.legendre_order = 3" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Now that the `Library` has been setup, lets make sure it contains the types of cross sections which meet the needs of OpenMC's multi-group solver. Note that this step is done automatically when writing the Multi-Group Library file later in the process (as part of the `mgxs_lib.write_mg_library()`), but it is a good practice to also run this before spending all the time running OpenMC to generate the cross sections." - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "metadata": { - "collapsed": false - }, - "outputs": [], - "source": [ - "# Check the library - if no errors are raised, then the library is satisfactory.\n", - "mgxs_lib.check_library_for_openmc_mgxs()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Lastly, we use the `Library` to construct the tallies needed to compute all of the requested multi-group cross sections in each domain and nuclide." - ] - }, - { - "cell_type": "code", - "execution_count": 23, - "metadata": { - "collapsed": false - }, - "outputs": [], - "source": [ - "# Construct all tallies needed for the multi-group cross section library\n", - "mgxs_lib.build_library()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The tallies can now be export to a \"tallies.xml\" input file for OpenMC.\n", - "\n", - "**NOTE:** At this point the `Library` has constructed nearly 100 distinct Tally objects. The overhead to tally in OpenMC scales as O(N) for N tallies, which can become a bottleneck for large tally datasets. To compensate for this, the Python API's `Tally`, `Filter` and `Tallies` classes allow for the smart merging of tallies when possible. The `Library` class supports this runtime optimization with the use of the optional `merge` parameter (`False` by default) for the `Library.add_to_tallies_file(...)` method, as shown below." - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "metadata": { - "collapsed": true - }, - "outputs": [], - "source": [ - "# Create a \"tallies.xml\" file for the MGXS Library\n", - "tallies_file = openmc.Tallies()\n", - "mgxs_lib.add_to_tallies_file(tallies_file, merge=True)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "In addition, we instantiate a fission rate mesh tally to compare with the multi-group result." - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "metadata": { - "collapsed": true - }, - "outputs": [], - "source": [ - "# Instantiate a tally Mesh\n", - "mesh = openmc.Mesh()\n", - "mesh.type = 'regular'\n", - "mesh.dimension = [17, 17]\n", - "mesh.lower_left = [-10.71, -10.71]\n", - "mesh.upper_right = [+10.71, +10.71]\n", - "\n", - "# Instantiate tally Filter\n", - "mesh_filter = openmc.MeshFilter(mesh)\n", - "\n", - "# Instantiate the Tally\n", - "tally = openmc.Tally(name='mesh tally')\n", - "tally.filters = [mesh_filter]\n", - "tally.scores = ['fission']\n", - "\n", - "# Add tally to collection\n", - "tallies_file.append(tally, merge=True)\n", - "\n", - "# Export all tallies to a \"tallies.xml\" file\n", - "tallies_file.export_to_xml()" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "collapsed": true - }, - "source": [ - "Time to run the calculation and get our results! This time we will suppress the OpenMC output except for the summary information." - ] - }, - { - "cell_type": "code", - "execution_count": 26, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - " %%%%%%%%%%%%%%%\n", - " %%%%%%%%%%%%%%%%%%%%%%%%\n", - " %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n", - " %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n", - " %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n", - " %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n", - " %%%%%%%%%%%%%%%%%%%%%%%%\n", - " %%%%%%%%%%%%%%%%%%%%%%%%\n", - " ############### %%%%%%%%%%%%%%%%%%%%%%%%\n", - " ################## %%%%%%%%%%%%%%%%%%%%%%%\n", - " ################### %%%%%%%%%%%%%%%%%%%%%%%\n", - " #################### %%%%%%%%%%%%%%%%%%%%%%\n", - " ##################### %%%%%%%%%%%%%%%%%%%%%\n", - " ###################### %%%%%%%%%%%%%%%%%%%%\n", - " ####################### %%%%%%%%%%%%%%%%%%\n", - " ####################### %%%%%%%%%%%%%%%%%\n", - " ###################### %%%%%%%%%%%%%%%%%\n", - " #################### %%%%%%%%%%%%%%%%%\n", - " ################# %%%%%%%%%%%%%%%%%\n", - " ############### %%%%%%%%%%%%%%%%\n", - " ############ %%%%%%%%%%%%%%%\n", - " ######## %%%%%%%%%%%%%%\n", - " %%%%%%%%%%%\n", - "\n", - " | The OpenMC Monte Carlo Code\n", - " Copyright | 2011-2017 Massachusetts Institute of Technology\n", - " License | http://openmc.readthedocs.io/en/latest/license.html\n", - " Version | 0.8.0\n", - " Git SHA1 | 5e9b06a861d4f596314eff490ad63c051f833f3a\n", - " Date/Time | 2017-03-02 11:27:28\n", - " OpenMP Threads | 4\n", - "\n", - "\n", - " ====================> K EIGENVALUE SIMULATION <====================\n", - "\n", - "\n", - " ============================> RESULTS <============================\n", - "\n", - " k-effective (Collision) = 1.02519 +/- 0.00068\n", - " k-effective (Track-length) = 1.02548 +/- 0.00075\n", - " k-effective (Absorption) = 1.02621 +/- 0.00064\n", - " Combined k-effective = 1.02580 +/- 0.00053\n", - " Leakage Fraction = 0.00000 +/- 0.00000\n", - "\n" - ] - }, - { - "data": { - "text/plain": [ - "0" - ] - }, - "execution_count": 26, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Run OpenMC\n", - "openmc.run(output='summary')" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "To make the files available and not be over-written when running the multi-group calculation, we will now rename the statepoint and summary files." - ] - }, - { - "cell_type": "code", - "execution_count": 27, - "metadata": { - "collapsed": false - }, - "outputs": [], - "source": [ - "# Move the StatePoint File\n", - "ce_spfile = './ce_statepoint.h5'\n", - "os.rename('statepoint.' + str(batches) + '.h5', ce_spfile)\n", - "# Move the Summary file\n", - "ce_sumfile = './ce_summary.h5'\n", - "os.rename('summary.h5', ce_sumfile)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Tally Data Processing\n", - "\n", - "Our simulation ran successfully and created statepoint and summary output files. Let's begin by loading the StatePoint file, but not automatically linking the summary file." - ] - }, - { - "cell_type": "code", - "execution_count": 28, - "metadata": { - "collapsed": false - }, - "outputs": [], - "source": [ - "# Load the statepoint file, but not the summary file, as it is a different filename than expected.\n", - "sp = openmc.StatePoint(ce_spfile, autolink=False)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "In addition to the statepoint file, our simulation also created a summary file which encapsulates information about the materials and geometry. This is necessary for the `openmc.mgxs` module to properly process the tally data. We first create a `Summary` object and link it with the statepoint. Normally this would not need to be performed, but since we have renamed our summary file to avoid conflicts with the Multi-Group calculation's summary file, we will load this in explicitly." - ] - }, - { - "cell_type": "code", - "execution_count": 29, - "metadata": { - "collapsed": false - }, - "outputs": [], - "source": [ - "su = openmc.Summary(ce_sumfile)\n", - "sp.link_with_summary(su)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The statepoint is now ready to be analyzed by the `Library`. We simply have to load the tallies from the statepoint into the `Library` and our `MGXS` objects will compute the cross sections for us under-the-hood." - ] - }, - { - "cell_type": "code", - "execution_count": 30, - "metadata": { - "collapsed": false - }, - "outputs": [], - "source": [ - "# Initialize MGXS Library with OpenMC statepoint data\n", - "mgxs_lib.load_from_statepoint(sp)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The next step will be to prepare the input for OpenMC to use our newly created multi-group data." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Multi-Group OpenMC Calculation" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We will now use the `Library` to produce a multi-group cross section data set for use by the OpenMC multi-group solver. \n", - "Note that since this simulation included so few histories, it is reasonable to expect some divisions by zero errors. This will show up as a runtime warning in the following step." - ] - }, - { - "cell_type": "code", - "execution_count": 31, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/romano/openmc/openmc/tallies.py:1835: RuntimeWarning: invalid value encountered in true_divide\n", - " self_rel_err = data['self']['std. dev.'] / data['self']['mean']\n", - "/home/romano/openmc/openmc/tallies.py:1836: RuntimeWarning: invalid value encountered in true_divide\n", - " other_rel_err = data['other']['std. dev.'] / data['other']['mean']\n", - "/home/romano/openmc/openmc/tallies.py:1837: RuntimeWarning: invalid value encountered in true_divide\n", - " new_tally._mean = data['self']['mean'] / data['other']['mean']\n" - ] - } - ], - "source": [ - "# Create a MGXS File which can then be written to disk\n", - "mgxs_file = mgxs_lib.create_mg_library(xs_type='macro', xsdata_names=['fuel', 'zircaloy', 'water'])\n", - "\n", - "# Write the file to disk using the default filename of `mgxs.h5`\n", - "mgxs_file.export_to_hdf5()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "OpenMC's multi-group mode uses the same input files as does the continuous-energy mode (materials, geometry, settings, plots ,and tallies file). Differences would include the use of a flag to tell the code to use multi-group transport, a location of the multi-group library file, and any changes needed in the materials.xml and geometry.xml files to re-define materials as necessary (for example, if using a macroscopic cross section library instead of individual microscopic nuclide cross sections as is done in continuous-energy, or if multiple cross sections exist for the same material due to the material existing in varied spectral regions).\n", - "\n", - "Since this example is using material-wise macroscopic cross sections without considering that the neutron energy spectra and thus cross sections may be changing in space, we only need to modify the materials.xml and settings.xml files. If the material names and ids are not otherwise changed, then the geometry.xml file does not need to be modified from its continuous-energy form. The tallies.xml file will be left untouched as it currently contains the tally types that we will need to perform our comparison. \n", - "\n", - "First we will create the new materials.xml file." - ] - }, - { - "cell_type": "code", - "execution_count": 32, - "metadata": { - "collapsed": false - }, - "outputs": [], - "source": [ - "# Instantiate our Macroscopic Data\n", - "fuel_macro = openmc.Macroscopic('fuel')\n", - "zircaloy_macro = openmc.Macroscopic('zircaloy')\n", - "water_macro = openmc.Macroscopic('water')\n", - "\n", - "# Now re-define our materials to use the Multi-Group macroscopic data\n", - "# instead of the continuous-energy data.\n", - "# 1.6 enriched fuel UO2\n", - "fuel_mg = openmc.Material(name='UO2')\n", - "fuel_mg.add_macroscopic(fuel_macro)\n", - "\n", - "# cladding\n", - "zircaloy_mg = openmc.Material(name='Clad')\n", - "zircaloy_mg.add_macroscopic(zircaloy_macro)\n", - "\n", - "# moderator\n", - "water_mg = openmc.Material(name='Water')\n", - "water_mg.add_macroscopic(water_macro)\n", - "\n", - "# Finally, instantiate our Materials object\n", - "materials_file = openmc.Materials((fuel_mg, zircaloy_mg, water_mg))\n", - "\n", - "# Set the location of the cross sections file\n", - "materials_file.cross_sections = './mgxs.h5'\n", - "\n", - "# Export to \"materials.xml\"\n", - "materials_file.export_to_xml()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "No geometry file neeeds to be written as the continuous-energy file is correctly defined for the multi-group case as well." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Next, we can make the changes we need to the settings file.\n", - "These changes are limited to telling OpenMC we will be running a multi-group calculation and pointing to the location of our multi-group cross section file." - ] - }, - { - "cell_type": "code", - "execution_count": 33, - "metadata": { - "collapsed": true - }, - "outputs": [], - "source": [ - "# Set the energy mode\n", - "settings_file.energy_mode = 'multi-group'\n", - "\n", - "# Export to \"settings.xml\"\n", - "settings_file.export_to_xml()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Finally, since we want similar tally data in the end, we will leave our pre-existing `tallies.xml` file for this calculation.\n", - "\n", - "Before running the calculation let's visually compare a subset of the newly-generated multi-group cross section data to the continuous-energy data. We will do this using the cross section plotting functionality built-in to the OpenMC Python API." - ] - }, - { - "cell_type": "code", - "execution_count": 34, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAY4AAAEaCAYAAAAG87ApAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nH7Zthvm1Mq06AAAAAElFTkSuQmCC\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAY4AAAEaCAYAAAAG87ApAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n4nDOOZeU/w9zzMXxVRzsNwAAAABJRU5ErkJggg==\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAY4AAAEaCAYAAAAG87ApAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\ncVHiEBGRuPw/HPy/MBdqV5sAAAAASUVORK5CYII=\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# First lets plot the fuel data\n", - "# We will first add the continuous-energy data\n", - "fig = openmc.plot_xs(fuel, ['total'])\n", - "\n", - "# We will now add in the corresponding multi-group data and show the result\n", - "openmc.plot_xs(fuel_mg, ['total'], plot_CE=False, mg_cross_sections='./mgxs.h5', axis=fig.axes[0])\n", - "fig.axes[0].legend().set_visible(False)\n", - "plt.show()\n", - "plt.close()\n", - "\n", - "# Then repeat for the zircaloy data\n", - "fig = openmc.plot_xs(zircaloy, ['total'])\n", - "openmc.plot_xs(zircaloy_mg, ['total'], plot_CE=False, mg_cross_sections='./mgxs.h5', axis=fig.axes[0])\n", - "fig.axes[0].legend().set_visible(False)\n", - "plt.show()\n", - "plt.close()\n", - "\n", - "# And finally repeat for the water data\n", - "fig = openmc.plot_xs(water, ['total'])\n", - "openmc.plot_xs(water_mg, ['total'], plot_CE=False, mg_cross_sections='./mgxs.h5', axis=fig.axes[0])\n", - "fig.axes[0].legend().set_visible(False)\n", - "plt.show()\n", - "plt.close()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "At this point, the problem is set up and we can run the multi-group calculation, again with only summary information being displayed." - ] - }, - { - "cell_type": "code", - "execution_count": 35, - "metadata": { - "collapsed": false, - "scrolled": true - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - " %%%%%%%%%%%%%%%\n", - " %%%%%%%%%%%%%%%%%%%%%%%%\n", - " %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n", - " %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n", - " %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n", - " %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n", - " %%%%%%%%%%%%%%%%%%%%%%%%\n", - " %%%%%%%%%%%%%%%%%%%%%%%%\n", - " ############### %%%%%%%%%%%%%%%%%%%%%%%%\n", - " ################## %%%%%%%%%%%%%%%%%%%%%%%\n", - " ################### %%%%%%%%%%%%%%%%%%%%%%%\n", - " #################### %%%%%%%%%%%%%%%%%%%%%%\n", - " ##################### %%%%%%%%%%%%%%%%%%%%%\n", - " ###################### %%%%%%%%%%%%%%%%%%%%\n", - " ####################### %%%%%%%%%%%%%%%%%%\n", - " ####################### %%%%%%%%%%%%%%%%%\n", - " ###################### %%%%%%%%%%%%%%%%%\n", - " #################### %%%%%%%%%%%%%%%%%\n", - " ################# %%%%%%%%%%%%%%%%%\n", - " ############### %%%%%%%%%%%%%%%%\n", - " ############ %%%%%%%%%%%%%%%\n", - " ######## %%%%%%%%%%%%%%\n", - " %%%%%%%%%%%\n", - "\n", - " | The OpenMC Monte Carlo Code\n", - " Copyright | 2011-2017 Massachusetts Institute of Technology\n", - " License | http://openmc.readthedocs.io/en/latest/license.html\n", - " Version | 0.8.0\n", - " Git SHA1 | 5e9b06a861d4f596314eff490ad63c051f833f3a\n", - " Date/Time | 2017-03-02 11:31:01\n", - " OpenMP Threads | 4\n", - "\n", - "\n", - " ====================> K EIGENVALUE SIMULATION <====================\n", - "\n", - "\n", - " ============================> RESULTS <============================\n", - "\n", - " k-effective (Collision) = 1.02629 +/- 0.00071\n", - " k-effective (Track-length) = 1.02613 +/- 0.00081\n", - " k-effective (Absorption) = 1.02540 +/- 0.00048\n", - " Combined k-effective = 1.02552 +/- 0.00045\n", - " Leakage Fraction = 0.00000 +/- 0.00000\n", - "\n" - ] - }, - { - "data": { - "text/plain": [ - "0" - ] - }, - "execution_count": 35, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Run OpenMC\n", - "openmc.run()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Results Comparison\n", - "Now we can compare the multi-group and continuous-energy results.\n", - "\n", - "We will begin by loading the multi-group statepoint file we just finished writing and extracting the calculated keff.\n", - "Since we did not rename the summary file, we do not need to load it separately this time." - ] - }, - { - "cell_type": "code", - "execution_count": 36, - "metadata": { - "collapsed": false - }, - "outputs": [], - "source": [ - "# Load the last statepoint file and keff value\n", - "mgsp = openmc.StatePoint('statepoint.' + str(batches) + '.h5')\n", - "mg_keff = mgsp.k_combined" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Next, we can load the continuous-energy eigenvalue for comparison." - ] - }, - { - "cell_type": "code", - "execution_count": 37, - "metadata": { - "collapsed": true - }, - "outputs": [], - "source": [ - "ce_keff = sp.k_combined" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Lets compare the two eigenvalues, including their bias" - ] - }, - { - "cell_type": "code", - "execution_count": 38, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Continuous-Energy keff = 1.025799\n", - "Multi-Group keff = 1.025523\n", - "bias [pcm]: 27.6\n" - ] - } - ], - "source": [ - "bias = 1.0E5 * (ce_keff[0] - mg_keff[0])\n", - "\n", - "print('Continuous-Energy keff = {0:1.6f}'.format(ce_keff[0]))\n", - "print('Multi-Group keff = {0:1.6f}'.format(mg_keff[0]))\n", - "print('bias [pcm]: {0:1.1f}'.format(bias))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "This shows a small but nontrivial pcm bias between the two methods. Some degree of mismatch is expected simply to the very few histories being used in these example problems. An additional mismatch is always inherent in the practical application of multi-group theory due to the high degree of approximations inherent in that method." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Flux and Pin Power Visualizations" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Next we will visualize the mesh tally results obtained from both the Continuous-Energy and Multi-Group OpenMC calculations.\n", - "\n", - "First, we extract volume-integrated fission rates from the Multi-Group calculation's mesh fission rate tally for each pin cell in the fuel assembly." - ] - }, - { - "cell_type": "code", - "execution_count": 39, - "metadata": { - "collapsed": false - }, - "outputs": [], - "source": [ - "# Get the OpenMC fission rate mesh tally data\n", - "mg_mesh_tally = mgsp.get_tally(name='mesh tally')\n", - "mg_fission_rates = mg_mesh_tally.get_values(scores=['fission'])\n", - "\n", - "# Reshape array to 2D for plotting\n", - "mg_fission_rates.shape = (17,17)\n", - "\n", - "# Normalize to the average pin power\n", - "mg_fission_rates /= np.mean(mg_fission_rates)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Now we can do the same for the Continuous-Energy results." - ] - }, - { - "cell_type": "code", - "execution_count": 40, - "metadata": { - "collapsed": false - }, - "outputs": [], - "source": [ - "# Get the OpenMC fission rate mesh tally data\n", - "ce_mesh_tally = sp.get_tally(name='mesh tally')\n", - "ce_fission_rates = ce_mesh_tally.get_values(scores=['fission'])\n", - "\n", - "# Reshape array to 2D for plotting\n", - "ce_fission_rates.shape = (17,17)\n", - "\n", - "# Normalize to the average pin power\n", - "ce_fission_rates /= np.mean(ce_fission_rates)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Now we can easily use Matplotlib to visualize the two fission rates side-by-side." - ] - }, - { - "cell_type": "code", - "execution_count": 41, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 41, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Force zeros to be NaNs so their values are not included when matplotlib calculates\n", - "# the color scale\n", - "ce_fission_rates[ce_fission_rates == 0.] = np.nan\n", - "mg_fission_rates[mg_fission_rates == 0.] = np.nan\n", - "\n", - "# Plot the CE fission rates in the left subplot\n", - "fig = plt.subplot(121)\n", - "plt.imshow(ce_fission_rates, interpolation='none', cmap='jet')\n", - "plt.title('Continuous-Energy Fission Rates')\n", - "\n", - "# Plot the MG fission rates in the right subplot\n", - "fig2 = plt.subplot(122)\n", - "plt.imshow(mg_fission_rates, interpolation='none', cmap='jet')\n", - "plt.title('Multi-Group Fission Rates')\n" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "collapsed": true - }, - "source": [ - "We also see good agreement between the fission rate distributions, though these should converge closer together with an increasing number of particle histories in both the continuous-energy run to generate the multi-group cross sections, and in the multi-group calculation itself." - ] - } - ], - "metadata": { - "anaconda-cloud": {}, - "kernelspec": { - "display_name": "Python [default]", - "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.5.2" - } - }, - "nbformat": 4, - "nbformat_minor": 0 -} diff --git a/docs/source/pythonapi/index.rst b/docs/source/pythonapi/index.rst index 0a4feff1d..e9762c4f6 100644 --- a/docs/source/pythonapi/index.rst +++ b/docs/source/pythonapi/index.rst @@ -6,30 +6,13 @@ Python API OpenMC includes a rich Python API that enables programmatic pre- and post-processing. The easiest way to begin using the API is to take a look at the -example Jupyter_ notebooks provided. However, this assumes that you are already -familiar with Python and common third-party packages such as NumPy_. If you have -never programmed in Python before, there are many good tutorials available -online. We recommend going through the modules from Codecademy_ and/or the -`Scipy lectures`_. The full API documentation serves to provide more information -on a given module or class. - -------------------------- -Example Jupyter Notebooks -------------------------- - -.. toctree:: - :maxdepth: 1 - - examples/post-processing - examples/pandas-dataframes - examples/tally-arithmetic - examples/mgxs-part-i - examples/mgxs-part-ii - examples/mgxs-part-iii - examples/mgxs-part-iv - examples/mdgxs-part-i - examples/mdgxs-part-ii - examples/nuclear-data +example Jupyter_ notebooks provided in the :ref:`examples` section of the +documentation. However, this assumes that you are already familiar with Python +and common third-party packages such as NumPy_. If you have never programmed in +Python before, there are many good tutorials available online. We recommend +going through the modules from Codecademy_ and/or the `Scipy lectures`_. The +full API documentation serves to provide more information on a given module or +class. ------------------------------------ :mod:`openmc` -- Basic Functionality diff --git a/openmc/settings.py b/openmc/settings.py index 9a627a5cf..ff8c8a00f 100644 --- a/openmc/settings.py +++ b/openmc/settings.py @@ -60,7 +60,7 @@ class Settings(object): type are 'variance', 'std_dev', and 'rel_err'. The threshold value should be a float indicating the variance, standard deviation, or relative error used. - max_order : int + max_order : None or int Maximum scattering order to apply globally when in multi-group mode. multipole_library : str Indicates the path to a directory containing a windowed multipole @@ -456,8 +456,10 @@ class Settings(object): @max_order.setter def max_order(self, max_order): - cv.check_type('maximum scattering order', max_order, Integral) - cv.check_greater_than('maximum scattering order', max_order, 0, True) + if max_order is not None: + cv.check_type('maximum scattering order', max_order, Integral) + cv.check_greater_than('maximum scattering order', max_order, 0, + True) self._max_order = max_order @source.setter