pincell.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Modeling a Pin-Cell\n",
    "This notebook is intended to demonstrate the basic features of the Python API for constructing input files and running OpenMC. In it, we will show how to create a basic reflective pin-cell model that is equivalent to modeling an infinite array of fuel pins. If you have never used OpenMC, this can serve as a good starting point to learn the Python API. We highly recommend having a copy of the [Python API reference documentation](https://docs.openmc.org/en/stable/pythonapi/index.html) open in another browser tab that you can refer to."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import openmc"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Defining Materials\n",
    "\n",
    "Materials in OpenMC are defined as a set of nuclides with specified atom/weight fractions. To begin, we will create a material by making an instance of the `Material` class. In OpenMC, many objects, including materials, are identified by a \"unique ID\" that is simply just a positive integer. These IDs are used when exporting XML files that the solver reads in. They also appear in the output and can be used for identification. Since an integer ID is not very useful by itself, you can also give a material a `name` as well."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Material\n",
      "\tID             =\t1\n",
      "\tName           =\tuo2\n",
      "\tTemperature    =\tNone\n",
      "\tDensity        =\tNone [sum]\n",
      "\tS(a,b) Tables  \n",
      "\tNuclides       \n",
      "\n"
     ]
    }
   ],
   "source": [
    "uo2 = openmc.Material(1, \"uo2\")\n",
    "print(uo2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On the XML side, you have no choice but to supply an ID. However, in the Python API, if you don't give an ID, one will be automatically generated for you:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Material\n",
      "\tID             =\t2\n",
      "\tName           =\t\n",
      "\tTemperature    =\tNone\n",
      "\tDensity        =\tNone [sum]\n",
      "\tS(a,b) Tables  \n",
      "\tNuclides       \n",
      "\n"
     ]
    }
   ],
   "source": [
    "mat = openmc.Material()\n",
    "print(mat)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We see that an ID of 2 was automatically assigned. Let's now move on to adding nuclides to our `uo2` material. The `Material` object has a method `add_nuclide()` whose first argument is the name of the nuclide and second argument is the atom or weight fraction."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on method add_nuclide in module openmc.material:\n",
      "\n",
      "add_nuclide(nuclide: str, percent: float, percent_type: str = 'ao') method of openmc.material.Material instance\n",
      "    Add a nuclide to the material\n",
      "    \n",
      "    Parameters\n",
      "    ----------\n",
      "    nuclide : str\n",
      "        Nuclide to add, e.g., 'Mo95'\n",
      "    percent : float\n",
      "        Atom or weight percent\n",
      "    percent_type : {'ao', 'wo'}\n",
      "        'ao' for atom percent and 'wo' for weight percent\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(uo2.add_nuclide)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We see that by default it assumes we want an atom fraction."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Add nuclides to uo2\n",
    "uo2.add_nuclide('U235', 0.03)\n",
    "uo2.add_nuclide('U238', 0.97)\n",
    "uo2.add_nuclide('O16', 2.0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we need to assign a total density to the material. We'll use the `set_density` for this."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "uo2.set_density('g/cm3', 10.0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You may sometimes be given a material specification where all the nuclide densities are in units of atom/b-cm. In this case, you just want the density to be the sum of the constituents. In that case, you can simply run `mat.set_density('sum')`.\n",
    "\n",
    "With UO2 finished, let's now create materials for the clad and coolant. Note the use of `add_element()` for zirconium."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "zirconium = openmc.Material(name=\"zirconium\")\n",
    "zirconium.add_element('Zr', 1.0)\n",
    "zirconium.set_density('g/cm3', 6.6)\n",
    "\n",
    "water = openmc.Material(name=\"h2o\")\n",
    "water.add_nuclide('H1', 2.0)\n",
    "water.add_nuclide('O16', 1.0)\n",
    "water.set_density('g/cm3', 1.0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An astute observer might now point out that this water material we just created will only use free-atom cross sections. We need to tell it to use an $S(\\alpha,\\beta)$ table so that the bound atom cross section is used at thermal energies. To do this, there's an `add_s_alpha_beta()` method. Note the use of the GND-style name \"c_H_in_H2O\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "water.add_s_alpha_beta('c_H_in_H2O')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When we go to run the transport solver in OpenMC, it is going to look for a `materials.xml` file. Thus far, we have only created objects in memory. To actually create a `materials.xml` file, we need to instantiate a `Materials` collection and export it to XML."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "materials = openmc.Materials([uo2, zirconium, water])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that `Materials` is actually a subclass of Python's built-in `list`, so we can use methods like `append()`, `insert()`, `pop()`, etc."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "materials = openmc.Materials()\n",
    "materials.append(uo2)\n",
    "materials += [zirconium, water]\n",
    "isinstance(materials, list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, we can create the XML file with the `export_to_xml()` method. In a Jupyter notebook, we can run a shell command by putting `!` before it, so in this case we are going to display the `materials.xml` file that we created."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<?xml version='1.0' encoding='utf-8'?>\n",
      "<materials>\n",
      "  <material depletable=\"true\" id=\"1\" name=\"uo2\">\n",
      "    <density units=\"g/cm3\" value=\"10.0\" />\n",
      "    <nuclide ao=\"0.03\" name=\"U235\" />\n",
      "    <nuclide ao=\"0.97\" name=\"U238\" />\n",
      "    <nuclide ao=\"2.0\" name=\"O16\" />\n",
      "  </material>\n",
      "  <material id=\"3\" name=\"zirconium\">\n",
      "    <density units=\"g/cm3\" value=\"6.6\" />\n",
      "    <nuclide ao=\"0.5145\" name=\"Zr90\" />\n",
      "    <nuclide ao=\"0.1122\" name=\"Zr91\" />\n",
      "    <nuclide ao=\"0.1715\" name=\"Zr92\" />\n",
      "    <nuclide ao=\"0.1738\" name=\"Zr94\" />\n",
      "    <nuclide ao=\"0.028\" name=\"Zr96\" />\n",
      "  </material>\n",
      "  <material id=\"4\" name=\"h2o\">\n",
      "    <density units=\"g/cm3\" value=\"1.0\" />\n",
      "    <nuclide ao=\"2.0\" name=\"H1\" />\n",
      "    <nuclide ao=\"1.0\" name=\"O16\" />\n",
      "    <sab name=\"c_H_in_H2O\" />\n",
      "  </material>\n",
      "</materials>\n"
     ]
    }
   ],
   "source": [
    "materials.export_to_xml()\n",
    "!cat materials.xml"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Element Expansion\n",
    "\n",
    "Did you notice something really cool that happened to our Zr element? OpenMC automatically turned it into a list of nuclides when it exported it! The way this feature works is as follows:\n",
    "\n",
    "- First, it checks whether `Materials.cross_sections` has been set, indicating the path to a `cross_sections.xml` file.\n",
    "- If `Materials.cross_sections` isn't set, it looks for the `OPENMC_CROSS_SECTIONS` environment variable.\n",
    "- If either of these are found, it scans the file to see what nuclides are actually available and will expand elements accordingly.\n",
    "\n",
    "Let's see what happens if we change O16 in water to elemental O."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<?xml version='1.0' encoding='utf-8'?>\n",
      "<materials>\n",
      "  <material depletable=\"true\" id=\"1\" name=\"uo2\">\n",
      "    <density units=\"g/cm3\" value=\"10.0\" />\n",
      "    <nuclide ao=\"0.03\" name=\"U235\" />\n",
      "    <nuclide ao=\"0.97\" name=\"U238\" />\n",
      "    <nuclide ao=\"2.0\" name=\"O16\" />\n",
      "  </material>\n",
      "  <material id=\"3\" name=\"zirconium\">\n",
      "    <density units=\"g/cm3\" value=\"6.6\" />\n",
      "    <nuclide ao=\"0.5145\" name=\"Zr90\" />\n",
      "    <nuclide ao=\"0.1122\" name=\"Zr91\" />\n",
      "    <nuclide ao=\"0.1715\" name=\"Zr92\" />\n",
      "    <nuclide ao=\"0.1738\" name=\"Zr94\" />\n",
      "    <nuclide ao=\"0.028\" name=\"Zr96\" />\n",
      "  </material>\n",
      "  <material id=\"4\" name=\"h2o\">\n",
      "    <density units=\"g/cm3\" value=\"1.0\" />\n",
      "    <nuclide ao=\"2.0\" name=\"H1\" />\n",
      "    <nuclide ao=\"0.999621\" name=\"O16\" />\n",
      "    <nuclide ao=\"0.000379\" name=\"O17\" />\n",
      "    <sab name=\"c_H_in_H2O\" />\n",
      "  </material>\n",
      "</materials>\n"
     ]
    }
   ],
   "source": [
    "water.remove_nuclide('O16')\n",
    "water.add_element('O', 1.0)\n",
    "\n",
    "materials.export_to_xml()\n",
    "!cat materials.xml"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We see that now O16 and O17 were automatically added. O18 is missing because our cross sections file (which is based on ENDF/B-VII.1) doesn't have O18. If OpenMC didn't know about the cross sections file, it would have assumed that all isotopes exist."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The `cross_sections.xml` file\n",
    "\n",
    "The `cross_sections.xml` tells OpenMC where it can find nuclide cross sections and $S(\\alpha,\\beta)$ tables. It serves the same purpose as MCNP's `xsdir` file and Serpent's `xsdata` file. As we mentioned, this can be set either by the `OPENMC_CROSS_SECTIONS` environment variable or the `Materials.cross_sections` attribute.\n",
    "\n",
    "Let's have a look at what's inside this file:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<?xml version='1.0' encoding='utf-8'?>\n",
      "<cross_sections>\n",
      "  <library materials=\"Ac225\" path=\"Ac225.h5\" type=\"neutron\" />\n",
      "  <library materials=\"Ac226\" path=\"Ac226.h5\" type=\"neutron\" />\n",
      "  <library materials=\"Ac227\" path=\"Ac227.h5\" type=\"neutron\" />\n",
      "  <library materials=\"Ag107\" path=\"Ag107.h5\" type=\"neutron\" />\n",
      "  <library materials=\"Ag109\" path=\"Ag109.h5\" type=\"neutron\" />\n",
      "  <library materials=\"Ag110_m1\" path=\"Ag110_m1.h5\" type=\"neutron\" />\n",
      "  <library materials=\"Ag111\" path=\"Ag111.h5\" type=\"neutron\" />\n",
      "  <library materials=\"Al27\" path=\"Al27.h5\" type=\"neutron\" />\n",
      "    ...\n",
      "  <library materials=\"Cf253\" path=\"wmp/098253.h5\" type=\"wmp\" />\n",
      "  <library materials=\"Cf254\" path=\"wmp/098254.h5\" type=\"wmp\" />\n",
      "  <library materials=\"Es251\" path=\"wmp/099251.h5\" type=\"wmp\" />\n",
      "  <library materials=\"Es252\" path=\"wmp/099252.h5\" type=\"wmp\" />\n",
      "  <library materials=\"Es253\" path=\"wmp/099253.h5\" type=\"wmp\" />\n",
      "  <library materials=\"Es254\" path=\"wmp/099254.h5\" type=\"wmp\" />\n",
      "  <library materials=\"Es254_m1\" path=\"wmp/099254m1.h5\" type=\"wmp\" />\n",
      "  <library materials=\"Es255\" path=\"wmp/099255.h5\" type=\"wmp\" />\n",
      "  <library materials=\"Fm255\" path=\"wmp/100255.h5\" type=\"wmp\" />\n",
      "</cross_sections>\n"
     ]
    }
   ],
   "source": [
    "!cat $OPENMC_CROSS_SECTIONS | head -n 10\n",
    "print('    ...')\n",
    "!cat $OPENMC_CROSS_SECTIONS | tail -n 10"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Enrichment\n",
    "\n",
    "Note that the `add_element()` method has a special argument `enrichment` that can be used for Uranium. For example, if we know that we want to create 3% enriched UO2, the following would work:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "uo2_three = openmc.Material()\n",
    "uo2_three.add_element('U', 1.0, enrichment=3.0)\n",
    "uo2_three.add_element('O', 2.0)\n",
    "uo2_three.set_density('g/cc', 10.0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Mixtures\n",
    "\n",
    "In OpenMC it is also possible to define materials by mixing existing materials. For example, if we wanted to create MOX fuel out of a mixture of UO2 (97 wt%) and PuO2 (3 wt%) we could do the following:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create PuO2 material\n",
    "puo2 = openmc.Material()\n",
    "puo2.add_nuclide('Pu239', 0.94)\n",
    "puo2.add_nuclide('Pu240', 0.06)\n",
    "puo2.add_nuclide('O16', 2.0)\n",
    "puo2.set_density('g/cm3', 11.5)\n",
    "\n",
    "# Create the mixture\n",
    "mox = openmc.Material.mix_materials([uo2, puo2], [0.97, 0.03], 'wo')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The 'wo' argument in the `mix_materials()` method specifies that the fractions are weight fractions. Materials can also be mixed by atomic and volume fractions with 'ao' and 'vo', respectively. For 'ao' and 'wo' the fractions must sum to one. For 'vo', if fractions do not sum to one, the remaining fraction is set as void."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Defining Geometry\n",
    "\n",
    "At this point, we have three materials defined, exported to XML, and ready to be used in our model. To finish our model, we need to define the geometric arrangement of materials. OpenMC represents physical volumes using constructive solid geometry (CSG), also known as combinatorial geometry. The object that allows us to assign a material to a region of space is called a `Cell` (same concept in MCNP, for those familiar). In order to define a region that we can assign to a cell, we must first define surfaces which bound the region. A *surface* is a locus of zeros of a function of Cartesian coordinates $x$, $y$, and $z$, e.g.\n",
    "\n",
    "- A plane perpendicular to the x axis: $x - x_0 = 0$\n",
    "- A cylinder parallel to the z axis: $(x - x_0)^2 + (y - y_0)^2 - R^2 = 0$\n",
    "- A sphere: $(x - x_0)^2 + (y - y_0)^2 + (z - z_0)^2 - R^2 = 0$\n",
    "\n",
    "Between those three classes of surfaces (planes, cylinders, spheres), one can construct a wide variety of models. It is also possible to define cones and general second-order surfaces (tori are not currently supported).\n",
    "\n",
    "Note that defining a surface is not sufficient to specify a volume -- in order to define an actual volume, one must reference the half-space of a surface. A surface *half-space* is the region whose points satisfy a positive or negative inequality of the surface equation. For example, for a sphere of radius one centered at the origin, the surface equation is $f(x,y,z) = x^2 + y^2 + z^2 - 1 = 0$. Thus, we say that the negative half-space of the sphere, is defined as the collection of points satisfying $f(x,y,z) < 0$, which one can reason is the inside of the sphere. Conversely, the positive half-space of the sphere would correspond to all points outside of the sphere.\n",
    "\n",
    "Let's go ahead and create a sphere and confirm that what we've told you is true."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "sphere = openmc.Sphere(r=1.0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that by default the sphere is centered at the origin so we didn't have to supply `x0`, `y0`, or `z0` arguments. Strictly speaking, we could have omitted `r` as well since it defaults to one. To get the negative or positive half-space, we simply need to apply the `-` or `+` unary operators, respectively.\n",
    "\n",
    "(NOTE: Those unary operators are defined by special methods: `__pos__` and `__neg__` in this case)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "inside_sphere = -sphere\n",
    "outside_sphere = +sphere"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let's see if `inside_sphere` actually contains points inside the sphere:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True False\n",
      "False True\n"
     ]
    }
   ],
   "source": [
    "print((0,0,0) in inside_sphere, (0,0,2) in inside_sphere)\n",
    "print((0,0,0) in outside_sphere, (0,0,2) in outside_sphere)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Everything works as expected! Now that we understand how to create half-spaces, we can create more complex volumes by combining half-spaces using Boolean operators: `&` (intersection), `|` (union), and `~` (complement). For example, let's say we want to define a region that is the top part of the sphere (all points inside the sphere that have $z > 0$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "z_plane = openmc.ZPlane(0)\n",
    "northern_hemisphere = -sphere & +z_plane"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For many regions, OpenMC can automatically determine a bounding box. To get the bounding box, we use the `bounding_box` property of a region, which returns a tuple of the lower-left and upper-right Cartesian coordinates for the bounding box:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([-1., -1.,  0.]), array([1., 1., 1.]))"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "northern_hemisphere.bounding_box"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now that we see how to create volumes, we can use them to create a cell."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "cell = openmc.Cell()\n",
    "cell.region = northern_hemisphere\n",
    "\n",
    "# or...\n",
    "cell = openmc.Cell(region=northern_hemisphere)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "By default, the cell is not filled by any material (void). In order to assign a material, we set the `fill` property of a `Cell`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "cell.fill = water"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Universes and in-line plotting"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A collection of cells is known as a universe (again, this will be familiar to MCNP/Serpent users) and can be used as a repeatable unit when creating a model. Although we don't need it yet, the benefit of creating a universe is that we can visualize our geometry while we're creating it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "universe = openmc.Universe()\n",
    "universe.add_cell(cell)\n",
    "\n",
    "# this also works\n",
    "universe = openmc.Universe(cells=[cell])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `Universe` object has a `plot` method that will display our the universe as current constructed:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x7fe7dfdc5490>"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 258.065x264.901 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "universe.plot(width=(2.0, 2.0), origin=(0.0, 0.0, 0.1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "By default, the plot will appear in the $x$-$y$ plane. We can change that with the `basis` argument."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x7fe7d7edbeb0>"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAQMAAADrCAYAAABtsfOQAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAAsTAAALEwEAmpwYAAARDUlEQVR4nO3dbawc1X3H8e+vUBuJtmAwog4PBgcUcJXKJlckLRJpeYYXhjSEmKqKqYxo2tJIRYnAQiqSk7SQvnAUNW2KgABRxJMr2hvFFnWwqV80Jr6oBmMj8MW0ih0HEwxWKlMndv59MWdhWHb37t2ZnZ3d/X2k1d2dh71n17u/e86Z8fwVEZiZ/dqgG2Bm9eAwMDPAYWBmicPAzACHgZklDgMzA0oKA0kPSNov6cU26yXpG5KmJb0g6YLcuhWSdqXbijLaY2azV1bP4EHgqg7rrwbOTbdbgH8CkHQScBfwceBC4C5J80pqk5nNQilhEBGbgQMdNrkWeDgyW4ATJS0ArgQ2RMSBiHgL2EDnUDGzPqlqzuA04Me5x3vSsnbLzaxixw66Ad2SdAvZEIPjjz/+Y+edd96AWzT6Dv58d6nPd8JvLir1+ay155577mcRccps96sqDPYCZ+Qen56W7QX+oGn5M62eICLuBe4FmJiYiKmpqX60c6S1+n8o6zff0GGPs/vXmCZXX/z4B5ZJquz3jxJJ/9PLflWFwSRwq6RHySYLD0bEPklPAX+bmzS8AlhVUZtGXvOXv/MXf7Bata05IBwO/VVKGEh6hOwv/HxJe8iOEPw6QER8C1gHXANMA4eAP03rDkj6MrA1PdXqiOg0EWkdDNOXvxvN7Xc49JeG8b8we5jwnvy/37B/+WcrHw4OhvdIei4iJma739BMINr7NUJg3AIgL//aG8HgUOidw2CIjHMvYCaN98O9hd45DIaAewHdc2+hdw6DmnIvoDj3FmbHYVAz7gWUz72F7jgMasIhUI3m3oJD4T0OgxqICIdAxfKh4EDI+OImAxQRDoIBW7/5hnf/HcadewYD4CFBvXjokHEYVMw9gfoa96GDhwkV8ZBgeIzr0ME9gz7zkGA4jePQwWHQR+4JDL9xGjp4mNAnDoLR0hg6jDKHQck8NzC6Rn0uwcOEEjkERt8oDxvKKqJylaSXU5GUO1qsXyNpW7q9Iunt3LqjuXWTZbRnEBwE42UUhw2FewaSjgG+CVxOdqnzrZImI2JnY5uI+Ovc9n8FLM09xTsRsaRoOwbJQTCe1m++YaR6CGX0DC4EpiNid0T8AniUrGhKOzcCj5TwewfO8wM2SvMIZcwZtCqE8vFWG0paSHb97Y25xcdJmgKOAHdHxL+W0Ka+cwhYw6jMI1R9NGE5sDYijuaWLUwXb/xj4OuSPtxqR0m3SJqSNPXGG29U0da2HATWyrDPI5QRBu0KpLSynKYhQkTsTT93kxVQWfrB3bIiKhExERETp5wy62IxpXEQWCfDHAhlhMFW4FxJZ0uaQ/aF/8BRAUnnAfOAH+aWzZM0N92fD1wE7Gzety4cBNaNYQ2EwmEQEUeAW4GngJeAxyNih6TVkpblNl0OPBrvf5fOB6YkPQ9sIpszqGUYOAhsNoYxEFxEpQsOAuvVICYVey2i4tORZ+AgsCKGqYfgMOjAQWBlGJZAcBi04SCwMg1DIDgMWnAQWD/UPRAcBk0cBNZPdf5sOQzMKlbX3oHDIMe9AqtCXYcLDoPEQWBVqmMgOAxwENhg1C0Qxj4MHAQ2SHX67I19GJgNWl16B2MdBu4VWB3UZbgwtmHgILA6qUMgjGUYOAisjgb9mRzLMDCrq0H2DsYuDNwrsDob5GezqiIqN0l6I1cs5ebcuhWSdqXbijLaYzbMBtU7KBwGuSIqVwOLgRslLW6x6WMRsSTd7kv7ngTcRXZp9QuBuyTNK9qmdtwrsGEwqMnEQRRRybsS2BARByLiLWADcFUJbfoAB4ENk0F8VssIg1ZFVE5rsd2nJb0gaa2kxqXVu93XbOxU3TuoagLxe8BZEfG7ZH/9H5rtExQpouJegQ2jqj+zlRRRiYg3I+Jwengf8LFu9809Ry2KqJhVqcreQSVFVCQtyD1cRlZfAbJaC1ekYirzgCvSstK4V2DDrMrJxKqKqHxB0o5ULOULwE1p3wPAl8kCZSuwOi0rhYPARkFVn+EyqjATEeuAdU3L/iZ3fxWwqs2+DwAPlNEOs1EVEX0vxjKyZyC6V2CjpIrP8siGgdmo6ffcwUiGgXsFNor6/ZkeyTAws9lzGJgNkX4OFUYuDDxEsFHWz8/2yIWB2ajrV+9gpMLAvQIbB/36jI9UGJhZ7xwGZkOoH0OFkQkDDxFsnPTjsz4yYWA2bsruHYxEGLhXYOOo7M/8SISBmRXnMDAbYmUOFYY+DDxEsHFW5me/qiIqt0nama6O/LSkhbl1R3PFVSab9zWzahS+0lGuiMrlZJc63yppMiJ25jb7L2AiIg5J+nPga8Bn07p3ImJJ0XaYWTGVFFGJiE0RcSg93EJ2FWQzK0FZ8wZVFlFpWAmszz0+LtVD2CLputn8Ys8XmJU3b1DKBVG7JelPgAngk7nFCyNir6RFwEZJ2yPi1Rb73gLcAnDmmWdW0l6zcVJJERUASZcBdwLLcgVViIi96edu4Blgaatf4iIqZv1VVRGVpcA/kwXB/tzyeZLmpvvzgYuA/MSjmXWhjHmDqoqo/D3wG8ATTYcQzwemUnGVTcDdTUchOv1ezxeYJWV8F6oqonJZm/3+E/hoGW0ws2KG/gxEMyuHw8DMAIeB2cgoOok4tGHgyUOz9yv6nRjaMDCzcjkMzAxwGJhZ4jAwM8BhYGaJw8BshBQ5vDiUYXDw57sH3QSzWipyeHEow8DMyucwMDPAYWBmicPAzACHgZklVRVRmSvpsbT+WUln5datSstflnRlGe0xs9krHAa5IipXA4uBGyUtbtpsJfBWRJwDrAHuSfsuJrtm4u8AVwH/mJ7PzCpWSRGV9PihdH8tcKkkpeWPRsThiHgNmE7PZ2YVq6qIyrvbpAuoHgRO7nJfM6tApUVUimguonLNJ58YcIvM6ko97VVVEZV3t5F0LHAC8GaX+wIuomLWb5UUUUmPV6T71wMbI/sfFZPA8nS04WzgXOBHJbTJzGap8DAhIo5IahRROQZ4oFFEBZiKiEngfuA7kqaBA2SBQdrucbIqSkeAv4yIo0XbZGazp7LKOVdpYmIipqamBt0Ms1qS9FxETMx2P5+BaGaAw8DMEoeBmQEOAzNLHAZmBjgMzCxxGJgZ4DAws8RhYGaAw8DMEoeBmQEOAzNLHAZmBjgMzCxxGJgZ4DAws6RQGEg6SdIGSbvSz3kttlki6YeSdkh6QdJnc+selPSapG3ptqRIe8ysd0V7BncAT0fEucDT6XGzQ8DnIqJRKOXrkk7Mrf9SRCxJt20F22NmPSoaBvniKA8B1zVvEBGvRMSudP8nwH7Alzc2q5miYXBqROxL938KnNppY0kXAnOAV3OLv5qGD2skzS3YHjPr0YxXR5b0A+C3W6y6M/8gIkJS26urSloAfAdYERG/SotXkYXIHOBe4HZgdZv931dExczKNWMYRMRl7dZJel3SgojYl77s+9ts91vA94E7I2JL7rkbvYrDkr4NfLFDO+4lCwwmJiaG75LOZjVXdJiQL46yAvi35g1SYZUngYcjYm3TugXpp8jmG14s2B4z61HRMLgbuFzSLuCy9BhJE5LuS9vcAFwM3NTiEOJ3JW0HtgPzga8UbI+Z9chFVMxGjIuomFkhDgMzAxwGZpY4DMwMcBiYWeIwMDPAYWBmicPAzACHgZklDgMzAxwGZpY4DMwMcBiYWeIwMDPAYWBmicPAzIAKiqik7Y7mrnI0mVt+tqRnJU1LeixdIs3MBqCKIioA7+QKpSzLLb8HWBMR5wBvASsLtsfMetT3IirtpIugXgI0LpI6q/3NrFxVFVE5TtKUpC2SrkvLTgbejogj6fEe4LSC7TGzHlVVRGVhROyVtAjYmK6IfHA2DXURFbP+qqSISkTsTT93S3oGWAr8C3CipGNT7+B0YG+HdriIilkfVVFEZV6jhqKk+cBFwM7IrtG+Cbi+0/5mVo0qiqicD0xJep7sy393ROxM624HbpM0TTaHcH/B9phZj1xExWzEuIiKmRXiMDAzwGFgZonDwMwAh4GZJQ4DMwMcBmaWOAzMDHAYmFniMDAzwGFgZonDwMwAh4GZJQ4DMwMcBmaWOAzMDKigiIqkP8wVUNkm6f8aV0iW9KCk13LrlhRpj5n1ru9FVCJiU6OAClmdhEPAv+c2+VKuwMq2gu0xsx5VXUTlemB9RBwq+HvNrGRVFVFpWA480rTsq5JekLSmcRVlM6teVUVUSHUVPgo8lVu8iixE5pDVRLgdWN1mfxdRMeujSoqoJDcAT0bEL3PP3ehVHJb0beCLHdrhIipmfdT3Iio5N9I0REgB0ijCeh3wYsH2mFmPqiiigqSzgDOA/2ja/7up7uJ2YD7wlYLtMbMezThM6CQi3gQubbF8Crg59/i/aVFhOSIuKfL7zaw8PgPRzACHgZklDgMzAxwGZpY4DMwMcBiYWeIwMDPAYWBmicPAzACHgZklDgMzAxwGZpY4DMwMcBiYWeIwMDPAYWBmSdEiKp+RtEPSryRNdNjuKkkvS5qWdEdu+dmSnk3LH5M0p0h7zKx3RXsGLwJ/BGxut4GkY4BvAlcDi4EbJS1Oq+8B1kTEOcBbwMqC7TGzHhUKg4h4KSJenmGzC4HpiNgdEb8AHgWuTRdBvQRYm7brpgiLmfVJFXMGpwE/zj3ek5adDLwdEUealpvZABQqohIRnS6NXqp8ERWyOgujcFn1+cDPBt2IEvh11MtHetmpUBGVLu0lu0x6w+lp2ZvAiZKOTb2DxvJ27Xi3iIqkqYhoO2E5LPw66mWUXkcv+1UxTNgKnJuOHMwhq7c4GREBbCIrxgozF2Exsz4qemjxU5L2AL8HfF/SU2n5hyStA0h/9W8lq7H4EvB4ROxIT3E7cJukabI5hPuLtMfMele0iMqTwJMtlv8EuCb3eB2wrsV2u8mONszWvT3sU0d+HfUy1q9DWW/dzMadT0c2M2BIwqDoac91IekkSRsk7Uo/57XZ7qikbek2WXU725np/ZU0N51WPp1OMz9rAM2cURev4yZJb+T+DW5u9TyDJOkBSfvbHWJX5hvpNb4g6YIZnzQian8Dzic7dvoMMNFmm2OAV4FFwBzgeWDxoNve1MavAXek+3cA97TZ7n8H3dZe3l/gL4BvpfvLgccG3e4eX8dNwD8Muq0zvI6LgQuAF9usvwZYDwj4BPDsTM85FD2DKHDac/9bNyvXkp12DcN3+nU372/+9a0FLk2nndfJMHxOZhQRm4EDHTa5Fng4MlvIzulZ0Ok5hyIMutTutOc6OTUi9qX7PwVObbPdcZKmJG2RdF01TZtRN+/vu9tEdkj5INkh4zrp9nPy6dS9XivpjBbr627W34dChxbLVJfTnovq9DryDyIiJLU7lLMwIvZKWgRslLQ9Il4tu63W1veARyLisKQ/I+vtXDLgNvVdbcIg+nfac6U6vQ5Jr0taEBH7Updtf5vn2Jt+7pb0DLCUbJw7SN28v41t9kg6FjiB7LTzOpnxdUREvs33kc31DJtZfx9GaZjQ8rTnAbep2STZadfQ5vRrSfMkzU335wMXATsra2F73by/+dd3PbAx0mxWjcz4OprG1svIzpwdNpPA59JRhU8AB3ND1NYGPSva5czpp8jGPIeB14Gn0vIPAeuaZlBfIfsreueg293idZwMPA3sAn4AnJSWTwD3pfu/D2wnm+XeDqwcdLs7vb/AamBZun8c8AQwDfwIWDToNvf4Ov4O2JH+DTYB5w26zS1ewyPAPuCX6buxEvg88Pm0XmQXFXo1fY5aHoXL33wGopkBozVMMLMCHAZmBjgMzCxxGJgZ4DAws8RhYGaAw8DMEoeBmQHw/wrRPoE8fR+2AAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 258.065x264.901 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "universe.plot(width=(2.0, 2.0), basis='xz')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we have particular fondness for, say, fuchsia, we can tell the `plot()` method to make our cell that color."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x7fe7d550f130>"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 258.065x264.901 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "universe.plot(width=(2.0, 2.0), basis='xz',\n",
    "              colors={cell: 'fuchsia'})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Pin cell geometry\n",
    "\n",
    "We now have enough knowledge to create our pin-cell. We need three surfaces to define the fuel and clad:\n",
    "\n",
    "1. The outer surface of the fuel -- a cylinder parallel to the z axis\n",
    "2. The inner surface of the clad -- same as above\n",
    "3. The outer surface of the clad -- same as above\n",
    "\n",
    "These three surfaces will all be instances of `openmc.ZCylinder`, each with a different radius according to the specification."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "fuel_outer_radius = openmc.ZCylinder(r=0.39)\n",
    "clad_inner_radius = openmc.ZCylinder(r=0.40)\n",
    "clad_outer_radius = openmc.ZCylinder(r=0.46)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With the surfaces created, we can now take advantage of the built-in operators on surfaces to create regions for the fuel, the gap, and the clad:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "fuel_region = -fuel_outer_radius\n",
    "gap_region = +fuel_outer_radius & -clad_inner_radius\n",
    "clad_region = +clad_inner_radius & -clad_outer_radius"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we can create corresponding cells that assign materials to these regions. As with materials, cells have unique IDs that are assigned either manually or automatically. Note that the gap cell doesn't have any material assigned (it is void by default)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "fuel = openmc.Cell(name='fuel')\n",
    "fuel.fill = uo2\n",
    "fuel.region = fuel_region\n",
    "\n",
    "gap = openmc.Cell(name='air gap')\n",
    "gap.region = gap_region\n",
    "\n",
    "clad = openmc.Cell(name='clad')\n",
    "clad.fill = zirconium\n",
    "clad.region = clad_region"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, we need to handle the coolant outside of our fuel pin. To do this, we create x- and y-planes that bound the geometry."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "pitch = 1.26\n",
    "left = openmc.XPlane(-pitch/2, boundary_type='reflective')\n",
    "right = openmc.XPlane(pitch/2, boundary_type='reflective')\n",
    "bottom = openmc.YPlane(-pitch/2, boundary_type='reflective')\n",
    "top = openmc.YPlane(pitch/2, boundary_type='reflective')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The water region is going to be everything outside of the clad outer radius and within the box formed as the intersection of four half-spaces."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "water_region = +left & -right & +bottom & -top & +clad_outer_radius\n",
    "\n",
    "moderator = openmc.Cell(name='moderator')\n",
    "moderator.fill = water\n",
    "moderator.region = water_region"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "OpenMC also includes a factory function that generates a rectangular prism that could have made our lives easier."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "openmc.region.Intersection"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "box = openmc.model.RectangularPrism(width=pitch, height=pitch,\n",
    "                                    boundary_type='reflective')\n",
    "type(box)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pay attention here -- the object that was returned is NOT a surface. It is actually the intersection of four surface half-spaces, just like we created manually before. Thus, we don't need to apply the unary operator (`-box`). Instead, we can directly combine it with `+clad_or`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "water_region = -box & +clad_outer_radius"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The final step is to assign the cells we created to a universe and tell OpenMC that this universe is the \"root\" universe in our geometry. The `Geometry` is the final object that is actually exported to XML."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<?xml version='1.0' encoding='utf-8'?>\n",
      "<geometry>\n",
      "  <cell id=\"3\" material=\"1\" name=\"fuel\" region=\"-3\" universe=\"3\" />\n",
      "  <cell id=\"4\" material=\"void\" name=\"air gap\" region=\"3 -4\" universe=\"3\" />\n",
      "  <cell id=\"5\" material=\"3\" name=\"clad\" region=\"4 -5\" universe=\"3\" />\n",
      "  <cell id=\"6\" material=\"4\" name=\"moderator\" region=\"6 -7 8 -9 5\" universe=\"3\" />\n",
      "  <surface coeffs=\"0.0 0.0 0.39\" id=\"3\" type=\"z-cylinder\" />\n",
      "  <surface coeffs=\"0.0 0.0 0.4\" id=\"4\" type=\"z-cylinder\" />\n",
      "  <surface coeffs=\"0.0 0.0 0.46\" id=\"5\" type=\"z-cylinder\" />\n",
      "  <surface boundary=\"reflective\" coeffs=\"-0.63\" id=\"6\" type=\"x-plane\" />\n",
      "  <surface boundary=\"reflective\" coeffs=\"0.63\" id=\"7\" type=\"x-plane\" />\n",
      "  <surface boundary=\"reflective\" coeffs=\"-0.63\" id=\"8\" type=\"y-plane\" />\n",
      "  <surface boundary=\"reflective\" coeffs=\"0.63\" id=\"9\" type=\"y-plane\" />\n",
      "</geometry>\n"
     ]
    }
   ],
   "source": [
    "root_universe = openmc.Universe(cells=(fuel, gap, clad, moderator))\n",
    "\n",
    "geometry = openmc.Geometry()\n",
    "geometry.root_universe = root_universe\n",
    "\n",
    "# or...\n",
    "geometry = openmc.Geometry(root_universe)\n",
    "geometry.export_to_xml()\n",
    "!cat geometry.xml"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Starting source and settings\n",
    "\n",
    "The Python API has a module ``openmc.stats`` with various univariate and multivariate probability distributions. We can use these distributions to create a starting source using the ``openmc.IndependentSource`` object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a point source\n",
    "point = openmc.stats.Point((0, 0, 0))\n",
    "source = openmc.IndependentSource(space=point)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let's create a `Settings` object and give it the source we created along with specifying how many batches and particles we want to run."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "settings = openmc.Settings()\n",
    "settings.source = source\n",
    "settings.batches = 100\n",
    "settings.inactive = 10\n",
    "settings.particles = 1000"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<?xml version='1.0' encoding='utf-8'?>\n",
      "<settings>\n",
      "  <run_mode>eigenvalue</run_mode>\n",
      "  <particles>1000</particles>\n",
      "  <batches>100</batches>\n",
      "  <inactive>10</inactive>\n",
      "  <source strength=\"1.0\">\n",
      "    <space type=\"point\">\n",
      "      <parameters>0 0 0</parameters>\n",
      "    </space>\n",
      "  </source>\n",
      "</settings>\n"
     ]
    }
   ],
   "source": [
    "settings.export_to_xml()\n",
    "!cat settings.xml"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## User-defined tallies\n",
    "\n",
    "We actually have all the *required* files needed to run a simulation. Before we do that though, let's give a quick example of how to create tallies. We will show how one would tally the total, fission, absorption, and (n,$\\gamma$) reaction rates for $^{235}$U in the cell containing fuel. Recall that filters allow us to specify *where* in phase-space we want events to be tallied and scores tell us *what* we want to tally:\n",
    "\n",
    "$$X = \\underbrace{\\int d\\mathbf{r} \\int d\\mathbf{\\Omega} \\int dE}_{\\text{filters}} \\; \\underbrace{f(\\mathbf{r},\\mathbf{\\Omega},E)}_{\\text{scores}} \\psi (\\mathbf{r},\\mathbf{\\Omega},E)$$\n",
    "\n",
    "In this case, the *where* is \"the fuel cell\". So, we will create a cell filter specifying the fuel cell."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "cell_filter = openmc.CellFilter(fuel)\n",
    "\n",
    "tally = openmc.Tally(1)\n",
    "tally.filters = [cell_filter]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The *what* is the total, fission, absorption, and (n,$\\gamma$) reaction rates in $^{235}$U. By default, if we only specify what reactions, it will gives us tallies over all nuclides. We can use the `nuclides` attribute to name specific nuclides we're interested in."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "tally.nuclides = ['U235']\n",
    "tally.scores = ['total', 'fission', 'absorption', '(n,gamma)']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Similar to the other files, we need to create a `Tallies` collection and export it to XML."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<?xml version='1.0' encoding='utf-8'?>\n",
      "<tallies>\n",
      "  <filter id=\"1\" type=\"cell\">\n",
      "    <bins>3</bins>\n",
      "  </filter>\n",
      "  <tally id=\"1\">\n",
      "    <filters>1</filters>\n",
      "    <nuclides>U235</nuclides>\n",
      "    <scores>total fission absorption (n,gamma)</scores>\n",
      "  </tally>\n",
      "</tallies>\n"
     ]
    }
   ],
   "source": [
    "tallies = openmc.Tallies([tally])\n",
    "tallies.export_to_xml()\n",
    "!cat tallies.xml"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Running OpenMC\n",
    "\n",
    "Running OpenMC from Python can be done using the `openmc.run()` function. This function allows you to set the number of MPI processes and OpenMP threads, if need be."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "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",
      "                 | The OpenMC Monte Carlo Code\n",
      "       Copyright | 2011-2022 MIT, UChicago Argonne LLC, and contributors\n",
      "         License | https://docs.openmc.org/en/latest/license.html\n",
      "         Version | 0.13.1\n",
      "        Git SHA1 | 33bc948f4b855c037975f16d16091fe4ecd12de3\n",
      "       Date/Time | 2022-10-04 13:41:58\n",
      "  OpenMP Threads | 2\n",
      "\n",
      " Reading settings XML file...\n",
      " Reading cross sections XML file...\n",
      " Reading materials XML file...\n",
      " Reading geometry XML file...\n",
      " Reading U235 from /home/pshriwise/data/xs/openmc/nndc_hdf5/U235.h5\n",
      " Reading U238 from /home/pshriwise/data/xs/openmc/nndc_hdf5/U238.h5\n",
      " Reading O16 from /home/pshriwise/data/xs/openmc/nndc_hdf5/O16.h5\n",
      " Reading Zr90 from /home/pshriwise/data/xs/openmc/nndc_hdf5/Zr90.h5\n",
      " Reading Zr91 from /home/pshriwise/data/xs/openmc/nndc_hdf5/Zr91.h5\n",
      " Reading Zr92 from /home/pshriwise/data/xs/openmc/nndc_hdf5/Zr92.h5\n",
      " Reading Zr94 from /home/pshriwise/data/xs/openmc/nndc_hdf5/Zr94.h5\n",
      " Reading Zr96 from /home/pshriwise/data/xs/openmc/nndc_hdf5/Zr96.h5\n",
      " Reading H1 from /home/pshriwise/data/xs/openmc/nndc_hdf5/H1.h5\n",
      " Reading O17 from /home/pshriwise/data/xs/openmc/nndc_hdf5/O17.h5\n",
      " Reading c_H_in_H2O from /home/pshriwise/data/xs/openmc/nndc_hdf5/c_H_in_H2O.h5\n",
      " Minimum neutron data temperature: 294 K\n",
      " Maximum neutron data temperature: 294 K\n",
      " Reading tallies XML file...\n",
      " Preparing distributed cell instances...\n",
      " Reading plot XML file...\n",
      " Writing summary.h5 file...\n",
      " Maximum neutron transport energy: 20000000 eV for U235\n",
      " Initializing source particles...\n",
      "\n",
      " ====================>     K EIGENVALUE SIMULATION     <====================\n",
      "\n",
      "  Bat./Gen.      k            Average k\n",
      "  =========   ========   ====================\n",
      "        1/1    1.40026\n",
      "        2/1    1.45321\n",
      "        3/1    1.34098\n",
      "        4/1    1.36425\n",
      "        5/1    1.42225\n",
      "        6/1    1.37529\n",
      "        7/1    1.38197\n",
      "        8/1    1.44688\n",
      "        9/1    1.40427\n",
      "       10/1    1.40456\n",
      "       11/1    1.36640\n",
      "       12/1    1.39125    1.37882 +/- 0.01243\n",
      "       13/1    1.45403    1.40389 +/- 0.02608\n",
      "       14/1    1.39302    1.40117 +/- 0.01864\n",
      "       15/1    1.34153    1.38924 +/- 0.01873\n",
      "       16/1    1.39034    1.38943 +/- 0.01529\n",
      "       17/1    1.36353    1.38573 +/- 0.01344\n",
      "       18/1    1.30980    1.37624 +/- 0.01502\n",
      "       19/1    1.34877    1.37318 +/- 0.01359\n",
      "       20/1    1.41439    1.37730 +/- 0.01284\n",
      "       21/1    1.41695    1.38091 +/- 0.01216\n",
      "       22/1    1.33334    1.37694 +/- 0.01179\n",
      "       23/1    1.38863    1.37784 +/- 0.01088\n",
      "       24/1    1.37182    1.37741 +/- 0.01008\n",
      "       25/1    1.44857    1.38216 +/- 0.01052\n",
      "       26/1    1.37250    1.38155 +/- 0.00986\n",
      "       27/1    1.38933    1.38201 +/- 0.00927\n",
      "       28/1    1.38796    1.38234 +/- 0.00874\n",
      "       29/1    1.41205    1.38390 +/- 0.00842\n",
      "       30/1    1.29854    1.37964 +/- 0.00906\n",
      "       31/1    1.33041    1.37729 +/- 0.00893\n",
      "       32/1    1.33484    1.37536 +/- 0.00873\n",
      "       33/1    1.41818    1.37722 +/- 0.00854\n",
      "       34/1    1.34015    1.37568 +/- 0.00833\n",
      "       35/1    1.37602    1.37569 +/- 0.00799\n",
      "       36/1    1.34516    1.37452 +/- 0.00776\n",
      "       37/1    1.44145    1.37700 +/- 0.00787\n",
      "       38/1    1.47618    1.38054 +/- 0.00837\n",
      "       39/1    1.40590    1.38141 +/- 0.00812\n",
      "       40/1    1.44112    1.38340 +/- 0.00810\n",
      "       41/1    1.47602    1.38639 +/- 0.00838\n",
      "       42/1    1.34668    1.38515 +/- 0.00821\n",
      "       43/1    1.40106    1.38563 +/- 0.00797\n",
      "       44/1    1.35355    1.38469 +/- 0.00779\n",
      "       45/1    1.35236    1.38377 +/- 0.00762\n",
      "       46/1    1.37841    1.38362 +/- 0.00741\n",
      "       47/1    1.48521    1.38636 +/- 0.00771\n",
      "       48/1    1.34912    1.38538 +/- 0.00757\n",
      "       49/1    1.38579    1.38539 +/- 0.00737\n",
      "       50/1    1.37628    1.38516 +/- 0.00719\n",
      "       51/1    1.45863    1.38696 +/- 0.00724\n",
      "       52/1    1.46987    1.38893 +/- 0.00733\n",
      "       53/1    1.39011    1.38896 +/- 0.00716\n",
      "       54/1    1.46214    1.39062 +/- 0.00719\n",
      "       55/1    1.39540    1.39073 +/- 0.00703\n",
      "       56/1    1.42968    1.39157 +/- 0.00693\n",
      "       57/1    1.40848    1.39193 +/- 0.00679\n",
      "       58/1    1.46630    1.39348 +/- 0.00682\n",
      "       59/1    1.42602    1.39415 +/- 0.00672\n",
      "       60/1    1.43031    1.39487 +/- 0.00662\n",
      "       61/1    1.37934    1.39457 +/- 0.00650\n",
      "       62/1    1.41366    1.39493 +/- 0.00638\n",
      "       63/1    1.33133    1.39373 +/- 0.00637\n",
      "       64/1    1.32888    1.39253 +/- 0.00637\n",
      "       65/1    1.41176    1.39288 +/- 0.00626\n",
      "       66/1    1.39418    1.39290 +/- 0.00615\n",
      "       67/1    1.44874    1.39388 +/- 0.00612\n",
      "       68/1    1.51719    1.39601 +/- 0.00638\n",
      "       69/1    1.30328    1.39444 +/- 0.00646\n",
      "       70/1    1.49383    1.39610 +/- 0.00657\n",
      "       71/1    1.48548    1.39756 +/- 0.00662\n",
      "       72/1    1.35073    1.39681 +/- 0.00656\n",
      "       73/1    1.26807    1.39476 +/- 0.00677\n",
      "       74/1    1.40339    1.39490 +/- 0.00666\n",
      "       75/1    1.42471    1.39536 +/- 0.00658\n",
      "       76/1    1.31608    1.39415 +/- 0.00659\n",
      "       77/1    1.31429    1.39296 +/- 0.00659\n",
      "       78/1    1.35579    1.39242 +/- 0.00652\n",
      "       79/1    1.40558    1.39261 +/- 0.00643\n",
      "       80/1    1.45121    1.39344 +/- 0.00639\n",
      "       81/1    1.48841    1.39478 +/- 0.00644\n",
      "       82/1    1.42474    1.39520 +/- 0.00636\n",
      "       83/1    1.42245    1.39557 +/- 0.00629\n",
      "       84/1    1.45461    1.39637 +/- 0.00625\n",
      "       85/1    1.40745    1.39652 +/- 0.00617\n",
      "       86/1    1.42791    1.39693 +/- 0.00610\n",
      "       87/1    1.47831    1.39799 +/- 0.00611\n",
      "       88/1    1.36950    1.39762 +/- 0.00605\n",
      "       89/1    1.40043    1.39766 +/- 0.00597\n",
      "       90/1    1.35277    1.39710 +/- 0.00592\n",
      "       91/1    1.46321    1.39791 +/- 0.00590\n",
      "       92/1    1.49950    1.39915 +/- 0.00596\n",
      "       93/1    1.46649    1.39996 +/- 0.00595\n",
      "       94/1    1.36392    1.39953 +/- 0.00589\n",
      "       95/1    1.35214    1.39898 +/- 0.00585\n",
      "       96/1    1.39164    1.39889 +/- 0.00578\n",
      "       97/1    1.40895    1.39901 +/- 0.00571\n",
      "       98/1    1.43429    1.39941 +/- 0.00566\n",
      "       99/1    1.47610    1.40027 +/- 0.00566\n",
      "      100/1    1.44518    1.40077 +/- 0.00562\n",
      " Creating state point statepoint.100.h5...\n",
      "\n",
      " =======================>     TIMING STATISTICS     <=======================\n",
      "\n",
      " Total time for initialization     = 1.0530e+00 seconds\n",
      "   Reading cross sections          = 1.0453e+00 seconds\n",
      " Total time in simulation          = 2.0599e+01 seconds\n",
      "   Time in transport only          = 2.0580e+01 seconds\n",
      "   Time in inactive batches        = 1.6682e+00 seconds\n",
      "   Time in active batches          = 1.8931e+01 seconds\n",
      "   Time synchronizing fission bank = 8.3413e-03 seconds\n",
      "     Sampling source sites         = 7.6383e-03 seconds\n",
      "     SEND/RECV source sites        = 6.4672e-04 seconds\n",
      "   Time accumulating tallies       = 4.0019e-04 seconds\n",
      "   Time writing statepoints        = 1.8284e-03 seconds\n",
      " Total time for finalization       = 1.0948e-04 seconds\n",
      " Total time elapsed                = 2.1662e+01 seconds\n",
      " Calculation Rate (inactive)       = 5994.49 particles/second\n",
      " Calculation Rate (active)         = 4754.23 particles/second\n",
      "\n",
      " ============================>     RESULTS     <============================\n",
      "\n",
      " k-effective (Collision)     = 1.40349 +/- 0.00437\n",
      " k-effective (Track-length)  = 1.40077 +/- 0.00562\n",
      " k-effective (Absorption)    = 1.40672 +/- 0.00326\n",
      " Combined k-effective        = 1.40544 +/- 0.00302\n",
      " Leakage Fraction            = 0.00000 +/- 0.00000\n",
      "\n"
     ]
    }
   ],
   "source": [
    "openmc.run()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Great! OpenMC already told us our k-effective. It also spit out a file called `tallies.out` that shows our tallies. This is a very basic method to look at tally data; for more sophisticated methods, see other example notebooks."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " ============================>     TALLY 1     <============================\n",
      "\n",
      " Cell 3\n",
      "   U235\n",
      "     Total Reaction Rate                  0.730682 +/- 0.00279166\n",
      "     Fission Rate                         0.5477 +/- 0.00230053\n",
      "     Absorption Rate                      0.657455 +/- 0.00272209\n",
      "     (n,gamma)                            0.109755 +/- 0.000435716\n"
     ]
    }
   ],
   "source": [
    "!cat tallies.out"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Geometry plotting\n",
    "\n",
    "We saw before that we could call the `Universe.plot()` method to show a universe while we were creating our geometry. There is also a built-in plotter in the codebase that is much faster than the Python plotter and has more options. The interface looks somewhat similar to the `Universe.plot()` method. Instead though, we create `Plot` instances, assign them to a `Plots` collection, export it to XML, and then run OpenMC in geometry plotting mode. As an example, let's specify that we want the plot to be colored by material (rather than by cell) and we assign yellow to fuel and blue to water."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "plot = openmc.Plot()\n",
    "plot.filename = 'pinplot'\n",
    "plot.width = (pitch, pitch)\n",
    "plot.pixels = (200, 200)\n",
    "plot.color_by = 'material'\n",
    "plot.colors = {uo2: 'yellow', water: 'blue'}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With our plot created, we need to add it to a `Plots` collection which can be exported to XML."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<?xml version='1.0' encoding='utf-8'?>\n",
      "<plots>\n",
      "  <plot basis=\"xy\" color_by=\"material\" filename=\"pinplot\" id=\"4\" type=\"slice\">\n",
      "    <origin>0.0 0.0 0.0</origin>\n",
      "    <width>1.26 1.26</width>\n",
      "    <pixels>200 200</pixels>\n",
      "    <color id=\"1\" rgb=\"255 255 0\" />\n",
      "    <color id=\"4\" rgb=\"0 0 255\" />\n",
      "  </plot>\n",
      "</plots>\n"
     ]
    }
   ],
   "source": [
    "plots = openmc.Plots([plot])\n",
    "plots.export_to_xml()\n",
    "!cat plots.xml"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we can run OpenMC in plotting mode by calling the `plot_geometry()` function. Under the hood this is calling `openmc --plot`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "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",
      "                 | The OpenMC Monte Carlo Code\n",
      "       Copyright | 2011-2022 MIT, UChicago Argonne LLC, and contributors\n",
      "         License | https://docs.openmc.org/en/latest/license.html\n",
      "         Version | 0.13.1\n",
      "        Git SHA1 | 33bc948f4b855c037975f16d16091fe4ecd12de3\n",
      "       Date/Time | 2022-10-04 13:42:20\n",
      "  OpenMP Threads | 2\n",
      "\n",
      " Reading settings XML file...\n",
      " Reading cross sections XML file...\n",
      " Reading materials XML file...\n",
      " Reading geometry XML file...\n",
      " Reading tallies XML file...\n",
      " Preparing distributed cell instances...\n",
      " Reading plot XML file...\n",
      "\n",
      " =======================>     PLOTTING SUMMARY     <========================\n",
      "\n",
      "Plot ID: 4\n",
      "Plot file: pinplot.png\n",
      "Universe depth: -1\n",
      "Plot Type: Slice\n",
      "Origin: 0 0 0\n",
      "Width: 1.26 1.26\n",
      "Coloring: Materials\n",
      "Basis: XY\n",
      "Pixels: 200 200\n",
      "\n",
      " Processing plot 4: pinplot.png...\n"
     ]
    }
   ],
   "source": [
    "openmc.plot_geometry()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, we can use functionality from IPython to display the `.png` image inline in our notebook:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from IPython.display import Image\n",
    "Image(\"pinplot.png\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "OpenMC also provides us with a method on the `Plot` class that simplifies the workflow."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "plot.to_ipython_image()"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}