tally-arithmetic.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Tally Arithmetic\n",
    "This notebook shows the how tallies can be combined (added, subtracted, multiplied, etc.) using the Python API in order to create derived tallies. Since no covariance information is obtained, it is assumed that tallies are completely independent of one another when propagating uncertainties. The target problem is a simple pin cell."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import glob\n",
    "\n",
    "from IPython.display import Image\n",
    "import numpy as np\n",
    "import openmc"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Generate Input Files"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First we need to define materials that will be used in the problem. We'll create three materials for the fuel, water, and cladding of the fuel pin."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "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",
    "# 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",
    "\n",
    "# zircaloy\n",
    "zircaloy = openmc.Material(name='Zircaloy')\n",
    "zircaloy.set_density('g/cm3', 6.55)\n",
    "zircaloy.add_nuclide('Zr90', 7.2758e-3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With our three materials, we can now create a materials file object that can be exported to an actual XML file."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Instantiate a Materials collection\n",
    "materials_file = openmc.Materials([fuel, water, zircaloy])\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. Our problem will have three regions for the fuel, the clad, and the surrounding coolant. The first step is to create the bounding surfaces -- in this case two cylinders and six planes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "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",
    "# Use both reflective and vacuum boundaries to make life interesting\n",
    "min_x = openmc.XPlane(x0=-0.63, boundary_type='reflective')\n",
    "max_x = openmc.XPlane(x0=+0.63, boundary_type='reflective')\n",
    "min_y = openmc.YPlane(y0=-0.63, boundary_type='reflective')\n",
    "max_y = openmc.YPlane(y0=+0.63, boundary_type='reflective')\n",
    "min_z = openmc.ZPlane(z0=-100., boundary_type='vacuum')\n",
    "max_z = openmc.ZPlane(z0=+100., boundary_type='vacuum')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With the surfaces defined, we can now create cells that are defined by intersections of half-spaces created by the surfaces."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a Universe to encapsulate a fuel pin\n",
    "pin_cell_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",
    "pin_cell_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",
    "pin_cell_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",
    "pin_cell_universe.add_cell(moderator_cell)"
   ]
  },
  {
   "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": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create root Cell\n",
    "root_cell = openmc.Cell(name='root cell')\n",
    "root_cell.fill = pin_cell_universe\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(universe_id=0, name='root universe')\n",
    "root_universe.add_cell(root_cell)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We now must create a geometry that is assigned a root universe, put the geometry into a geometry file, and export it to XML."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create Geometry and set root Universe\n",
    "geometry = openmc.Geometry(root_universe)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 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 5 inactive batches and 15 active batches each with 2500 particles."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# OpenMC simulation parameters\n",
    "batches = 20\n",
    "inactive = 5\n",
    "particles = 2500\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': True}\n",
    "\n",
    "# Create an initial uniform spatial source distribution over fissionable zones\n",
    "bounds = [-0.63, -0.63, -100., 0.63, 0.63, 100.]\n",
    "uniform_dist = openmc.stats.Box(bounds[:3], bounds[3:], only_fissionable=True)\n",
    "settings_file.source = openmc.IndependentSource(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 plot file that we can use to verify that our pin cell geometry was created successfully."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAPoAAAD6CAIAAAAHjs1qAAAHQklEQVR4nO3dTY4TWRBF4ahWzxC7YDvMGLARxCLYCANmbIddsAEGKVmJXWUyX76fG3HPN6aF+8Vx+GWVJV6+vvsVgIf/Vr8AYB5yhxFyhxFyhxFyhxFyhxFyhxFyhxFyhxFyhxFyhxFyhxFyhxFyhxFyhxFyhxFyhxFyhxFyhxFyhxFyhxFyhxFyhxFyhxFyhxFyhxFyhxFyhxFyhxFyhxFyhxFyhxFyh5H/V78AC9++f/jnn/nymX9GZbgX/rGaXo403YZ3Qi/k3m5c389RfzNyP2dV4m8h/VPI/RC1yh/R/RHk/ox+5Y/o/glyf0XGyh/R/SNy/0uN0PeIfo/cIypW/ojug9wdQt8zj943d7fQ92yjd8zdOfQ9w+jtviJG6zeGR2G03VdN9+f7Twf/5MffP4a+krf4rHmL3KeFfrzs46a9Bxyir5/70NZH9P3c0PrLF18593Ghz6/80bjuC0dfNvfurSsk/pbu6VctvmDuVqHvEf0/Vcu9Y+tZKn/UsftixZfKvVfreUPf6xV9peLr5N6l9Rqh73WJvkzxRXK/3nq90PeuR1+j+PS5E/pxRJ/7OzO0fsr1/9nsX7NJvN0vHr1V6Hcurvm8Oz5r7ldadw5970r0SYtPeZmh9S6uHEXSW02+3Gm9I7fik11mmo+Y0J9rvtjkutVk2u60Pk7zEeXa8Zlyb0PrBzkcVJrc27aIwwg7ajuuRAs+R+60Pk3t4hM8qjYcJaFf1/Dwqv/Yqr7daX2VhmPU3/HSudP6WvWKl879LFrvrtiR6uYuvifwFuXBiebONUZHpSuNaO5n0fpQZY5XMfezu6HMMJSdPWTNBS+XO63LKlC8XO6n0Ppk2Q9cK3fBfYAr1Aaqlfsp2TdNUqmPXSj3U5sg9aFnd+rwpRa8Su60nkvS4lVyByaQyJ3VnlHGBS+ROzDH+txZ7XmlW/Drcz+O1gXlGsri3BXe8Zhm+bjTbPdcW8RKotGkyR24bmXuxz/aEu0PT8cHtPY+w3aHkWW5s9qLSbHg2e4wop47qz0R/WGtyX35z1+x1qoA1Lc70JF07vofjrgjPrIFuXOTQSzKQHe7i+8JvEV5cLq5A93Nzp2bDG7mx8B2hxHR3JXvf/gn2fGJ5g6MMDV3Lu64MzkJxe0u+1GI4zSHqJg7MAi5wwi5w8i83HlOxatmhiG33TUfcdBAcJRyuQPjkDuMkDuMkDuMkDuMkDuMaOUu+KMrXKE20Em58zsmPDEtD63tDgxF7jBC7jBC7jBC7jBC7jBC7jBC7jBC7jBC7jBC7jAyKfcvn3/N+YuQ0bQ8tLb7x98/Vr8E9KQ2UK3cgaHIHUbIHUbIHUbIHUbIHUbkclf70RWaCY5yXu78pgmvmhmG3HYHxiF3GCF3GFHMXfARB2dpDnFq7jyt4s7kJBS3OzCIaO6aH4U4SHZ8orkDI8zOnes7bubHwHaHEd3cZe9/eE55cAty5z6DWJSB7nYP7T2BV4mPTDp3oK81uXOfMbcqAPXtLv7hiD39YannDnS0LPfjH2f6OwNxZkwLr7JsdxhZmTsLvowUqz3Y7rCSJncWvKxEo1mcOz+At7J83Gm2e6TaIj5yDWV97qfe8bkOt7xT41i+2kMhd2AaidxZ8BmlW+0hkjswh0ruLPhcMq720Mk9KD6PpK2HVO5nUfwSqY9dK3epTYDr1AaqlftZqTdNRtkPXC73s/sg+wASOXvUaqs9BHMPipdUoPXQzL0BxQ9V5nhFc2/YDWVGoqbhYDVXe8jmHsJHhueUB6ebewMWfHfFjlQ6d640a1W6xmykcw+KX6de6xHx8vWd+kuMiG/fPzT8Vz/ff+r+Shy07Qv91kN/u2/ajpI136Bw65El96D4KWq3Holyb0bxBzkcVKbcm7eIwyAvaj6iRKs9sjyq7rU9tm54eH10ZRfkaj1ybffNlSNmzd+xaj0y5h4U34lb65HxMnNz5VYT3hebi+/5pK1H6tzjcvHhF/31D7e8rUfSy8zN9aO3utuYtx7Zt/sNa/45Qt8UyT16FB8Vo+/y8VWj9aiUe3QqPqpE3+ueVqb1KJZ79Cs+Mkff8YGkUutRL/foWvwmS/fdH7uLtR4lc99YRU/oB5XNPQYUf6OQ/rgfoVZtPWrnvhkXfazofugvCgqHvqmfewwufm9E/dN+EVa+9TDJfTMt+jvH3wOrfsXrEPrGKPfNqug1+YS+yf2dmQZuA37C8CjstvuN85o3DH3jm/vGLXrb0DfuuW8cojcPfUPuf6nXPZXvkfsrakRP6I/I/ZmM3VP5E+R+iH73VH4EuZ+j1j2Vn0Lu7ValT+LNyL2bcfXTdy/kPsORdwJNT0DuMGL3FTE4I3cYIXcYIXcYIXcYIXcYIXcYIXcYIXcYIXcYIXcYIXcYIXcYIXcYIXcYIXcYIXcYIXcYIXcYIXcYIXcYIXcYIXcYIXcYIXcYIXcYIXcYIXcYIXcYIXcYIXcYIXcYIXcY+QNZjJ2zr72bSAAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Instantiate a Plot\n",
    "plot = openmc.Plot(plot_id=1)\n",
    "plot.filename = 'materials-xy'\n",
    "plot.origin = [0, 0, 0]\n",
    "plot.width = [1.26, 1.26]\n",
    "plot.pixels = [250, 250]\n",
    "plot.color_by = 'material'\n",
    "\n",
    "# Show plot\n",
    "openmc.plot_inline(plot)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As we can see from the plot, we have a nice pin cell with fuel, cladding, and water! Before we run our simulation, we need to tell the code what we want to tally. The following code shows how to create a variety of tallies."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Instantiate an empty Tallies object\n",
    "tallies_file = openmc.Tallies()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create Tallies to compute microscopic multi-group cross-sections\n",
    "\n",
    "# Instantiate energy filter for multi-group cross-section Tallies\n",
    "energy_filter = openmc.EnergyFilter([0., 0.625, 20.0e6])\n",
    "\n",
    "# Instantiate flux Tally in moderator and fuel\n",
    "tally = openmc.Tally(name='flux')\n",
    "tally.filters = [openmc.CellFilter([fuel_cell, moderator_cell])]\n",
    "tally.filters.append(energy_filter)\n",
    "tally.scores = ['flux']\n",
    "tallies_file.append(tally)\n",
    "\n",
    "# Instantiate reaction rate Tally in fuel\n",
    "tally = openmc.Tally(name='fuel rxn rates')\n",
    "tally.filters = [openmc.CellFilter(fuel_cell)]\n",
    "tally.filters.append(energy_filter)\n",
    "tally.scores = ['nu-fission', 'scatter']\n",
    "tally.nuclides = ['U238', 'U235']\n",
    "tallies_file.append(tally)\n",
    "\n",
    "# Instantiate reaction rate Tally in moderator\n",
    "tally = openmc.Tally(name='moderator rxn rates')\n",
    "tally.filters = [openmc.CellFilter(moderator_cell)]\n",
    "tally.filters.append(energy_filter)\n",
    "tally.scores = ['absorption', 'total']\n",
    "tally.nuclides = ['O16', 'H1']\n",
    "tallies_file.append(tally)\n",
    "\n",
    "# Instantiate a tally mesh\n",
    "mesh = openmc.RegularMesh(mesh_id=1)\n",
    "mesh.dimension = [1, 1, 1]\n",
    "mesh.lower_left = [-0.63, -0.63, -100.]\n",
    "mesh.width = [1.26, 1.26, 200.]\n",
    "meshsurface_filter = openmc.MeshSurfaceFilter(mesh)\n",
    "\n",
    "# Instantiate thermal, fast, and total leakage tallies\n",
    "leak = openmc.Tally(name='leakage')\n",
    "leak.filters = [meshsurface_filter]\n",
    "leak.scores = ['current']\n",
    "tallies_file.append(leak)\n",
    "\n",
    "thermal_leak = openmc.Tally(name='thermal leakage')\n",
    "thermal_leak.filters = [meshsurface_filter, openmc.EnergyFilter([0., 0.625])]\n",
    "thermal_leak.scores = ['current']\n",
    "tallies_file.append(thermal_leak)\n",
    "\n",
    "fast_leak = openmc.Tally(name='fast leakage')\n",
    "fast_leak.filters = [meshsurface_filter, openmc.EnergyFilter([0.625, 20.0e6])]\n",
    "fast_leak.scores = ['current']\n",
    "tallies_file.append(fast_leak)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "# K-Eigenvalue (infinity) tallies\n",
    "fiss_rate = openmc.Tally(name='fiss. rate')\n",
    "abs_rate = openmc.Tally(name='abs. rate')\n",
    "fiss_rate.scores = ['nu-fission']\n",
    "abs_rate.scores = ['absorption']\n",
    "tallies_file += (fiss_rate, abs_rate)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Resonance Escape Probability tallies\n",
    "therm_abs_rate = openmc.Tally(name='therm. abs. rate')\n",
    "therm_abs_rate.scores = ['absorption']\n",
    "therm_abs_rate.filters = [openmc.EnergyFilter([0., 0.625])]\n",
    "tallies_file.append(therm_abs_rate)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Thermal Flux Utilization tallies\n",
    "fuel_therm_abs_rate = openmc.Tally(name='fuel therm. abs. rate')\n",
    "fuel_therm_abs_rate.scores = ['absorption']\n",
    "fuel_therm_abs_rate.filters = [openmc.EnergyFilter([0., 0.625]),\n",
    "                               openmc.CellFilter([fuel_cell])]\n",
    "tallies_file.append(fuel_therm_abs_rate)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Fast Fission Factor tallies\n",
    "therm_fiss_rate = openmc.Tally(name='therm. fiss. rate')\n",
    "therm_fiss_rate.scores = ['nu-fission']\n",
    "therm_fiss_rate.filters = [openmc.EnergyFilter([0., 0.625])]\n",
    "tallies_file.append(therm_fiss_rate)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Instantiate energy filter to illustrate Tally slicing\n",
    "fine_energy_filter = openmc.EnergyFilter(np.logspace(np.log10(1e-2), np.log10(20.0e6), 10))\n",
    "\n",
    "# Instantiate flux Tally in moderator and fuel\n",
    "tally = openmc.Tally(name='need-to-slice')\n",
    "tally.filters = [openmc.CellFilter([fuel_cell, moderator_cell])]\n",
    "tally.filters.append(fine_energy_filter)\n",
    "tally.scores = ['nu-fission', 'scatter']\n",
    "tally.nuclides = ['H1', 'U238']\n",
    "tallies_file.append(tally)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/pshriwise/.pyenv/versions/3.9.1/lib/python3.9/site-packages/openmc/mixin.py:70: IDWarning: Another Filter instance already exists with id=6.\n",
      "  warn(msg, IDWarning)\n",
      "/home/pshriwise/.pyenv/versions/3.9.1/lib/python3.9/site-packages/openmc/mixin.py:70: IDWarning: Another Filter instance already exists with id=3.\n",
      "  warn(msg, IDWarning)\n",
      "/home/pshriwise/.pyenv/versions/3.9.1/lib/python3.9/site-packages/openmc/mixin.py:70: IDWarning: Another Filter instance already exists with id=2.\n",
      "  warn(msg, IDWarning)\n"
     ]
    }
   ],
   "source": [
    "# Export to \"tallies.xml\"\n",
    "tallies_file.export_to_xml()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we a have a complete set of inputs, so we can go ahead and run our simulation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "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 14:37:07\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 H1 from /home/pshriwise/data/xs/openmc/nndc_hdf5/H1.h5\n",
      " Reading B10 from /home/pshriwise/data/xs/openmc/nndc_hdf5/B10.h5\n",
      " Reading Zr90 from /home/pshriwise/data/xs/openmc/nndc_hdf5/Zr90.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    0.99327\n",
      "        2/1    1.05535\n",
      "        3/1    1.02165\n",
      "        4/1    1.02898\n",
      "        5/1    1.02521\n",
      "        6/1    1.04782\n",
      "        7/1    1.07014    1.05898 +/- 0.01116\n",
      "        8/1    1.07724    1.06507 +/- 0.00886\n",
      "        9/1    1.06268    1.06447 +/- 0.00630\n",
      "       10/1    0.99628    1.05083 +/- 0.01448\n",
      "       11/1    1.07257    1.05446 +/- 0.01237\n",
      "       12/1    1.01603    1.04897 +/- 0.01181\n",
      "       13/1    1.01047    1.04415 +/- 0.01130\n",
      "       14/1    1.03639    1.04329 +/- 0.01000\n",
      "       15/1    1.00699    1.03966 +/- 0.00966\n",
      "       16/1    0.99098    1.03524 +/- 0.00979\n",
      "       17/1    1.03990    1.03562 +/- 0.00895\n",
      "       18/1    1.02076    1.03448 +/- 0.00831\n",
      "       19/1    0.99685    1.03179 +/- 0.00815\n",
      "       20/1    1.04833    1.03290 +/- 0.00767\n",
      " Creating state point statepoint.20.h5...\n",
      "\n",
      " =======================>     TIMING STATISTICS     <=======================\n",
      "\n",
      " Total time for initialization     = 6.8232e-01 seconds\n",
      "   Reading cross sections          = 6.7336e-01 seconds\n",
      " Total time in simulation          = 1.9133e+01 seconds\n",
      "   Time in transport only          = 1.9121e+01 seconds\n",
      "   Time in inactive batches        = 2.1299e+00 seconds\n",
      "   Time in active batches          = 1.7003e+01 seconds\n",
      "   Time synchronizing fission bank = 4.6541e-03 seconds\n",
      "     Sampling source sites         = 4.3236e-03 seconds\n",
      "     SEND/RECV source sites        = 3.1748e-04 seconds\n",
      "   Time accumulating tallies       = 4.4903e-04 seconds\n",
      "   Time writing statepoints        = 4.5395e-03 seconds\n",
      " Total time for finalization       = 6.4286e-04 seconds\n",
      " Total time elapsed                = 1.9837e+01 seconds\n",
      " Calculation Rate (inactive)       = 5868.78 particles/second\n",
      " Calculation Rate (active)         = 2205.45 particles/second\n",
      "\n",
      " ============================>     RESULTS     <============================\n",
      "\n",
      " k-effective (Collision)     = 1.03497 +/- 0.00681\n",
      " k-effective (Track-length)  = 1.03290 +/- 0.00767\n",
      " k-effective (Absorption)    = 1.02663 +/- 0.00590\n",
      " Combined k-effective        = 1.03085 +/- 0.00535\n",
      " Leakage Fraction            = 0.01728 +/- 0.00077\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Run OpenMC!\n",
    "openmc.run()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tally Data Processing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Our simulation ran successfully and created a statepoint file with all the tally data in it. We begin our analysis here loading the statepoint file and 'reading' the results. By default, the tally results are not read into memory because they might be large, even large enough to exceed the available memory on a computer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Load the statepoint file\n",
    "sp = openmc.StatePoint('statepoint.20.h5')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We have a tally of the total fission rate and the total absorption rate, so we can calculate k-eff as:\n",
    "$$k_{eff} = \\frac{\\langle \\nu \\Sigma_f \\phi \\rangle}{\\langle \\Sigma_a \\phi \\rangle + \\langle L \\rangle}$$\n",
    "In this notation, $\\langle \\cdot \\rangle^a_b$ represents an OpenMC that is integrated over region $a$ and energy range $b$. If $a$ or $b$ is not reported, it means the value represents an integral over all space or all energy, respectively."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>nuclide</th>\n",
       "      <th>score</th>\n",
       "      <th>mean</th>\n",
       "      <th>std. dev.</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>total</td>\n",
       "      <td>(nu-fission / (absorption + current))</td>\n",
       "      <td>1.025847</td>\n",
       "      <td>0.009998</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  nuclide                                  score     mean  std. dev.\n",
       "0   total  (nu-fission / (absorption + current)) 1.03e+00   1.00e-02"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Get the fission and absorption rate tallies\n",
    "fiss_rate = sp.get_tally(name='fiss. rate')\n",
    "abs_rate = sp.get_tally(name='abs. rate')\n",
    "\n",
    "# Get the leakage tally\n",
    "leak = sp.get_tally(name='leakage')\n",
    "leak = leak.summation(filter_type=openmc.MeshSurfaceFilter, remove_filter=True)\n",
    "\n",
    "# Compute k-infinity using tally arithmetic\n",
    "keff = fiss_rate / (abs_rate + leak)\n",
    "keff.get_pandas_dataframe()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that even though the neutron production rate, absorption rate, and current are separate tallies, we still get a first-order estimate of the uncertainty on the quotient of them automatically!\n",
    "\n",
    "Often in textbooks you'll see k-eff represented using the six-factor formula $$k_{eff} = p \\epsilon f \\eta P_{FNL} P_{TNL}.$$ Let's analyze each of these factors, starting with the resonance escape probability which is defined as $$p=\\frac{\\langle\\Sigma_a\\phi\\rangle_T + \\langle L \\rangle_T}{\\langle\\Sigma_a\\phi\\rangle + \\langle L \\rangle_T}$$ where the subscript $T$ means thermal energies."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>energy low [eV]</th>\n",
       "      <th>energy high [eV]</th>\n",
       "      <th>nuclide</th>\n",
       "      <th>score</th>\n",
       "      <th>mean</th>\n",
       "      <th>std. dev.</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.0</td>\n",
       "      <td>0.625</td>\n",
       "      <td>total</td>\n",
       "      <td>((absorption + current) / (absorption + current))</td>\n",
       "      <td>0.695924</td>\n",
       "      <td>0.007275</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   energy low [eV]  energy high [eV] nuclide  \\\n",
       "0         0.00e+00          6.25e-01   total   \n",
       "\n",
       "                                               score     mean  std. dev.  \n",
       "0  ((absorption + current) / (absorption + current)) 6.96e-01   7.27e-03  "
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Compute resonance escape probability using tally arithmetic\n",
    "therm_abs_rate = sp.get_tally(name='therm. abs. rate')\n",
    "thermal_leak = sp.get_tally(name='thermal leakage')\n",
    "thermal_leak = thermal_leak.summation(filter_type=openmc.MeshSurfaceFilter, remove_filter=True)\n",
    "res_esc = (therm_abs_rate + thermal_leak) / (abs_rate + thermal_leak)\n",
    "res_esc.get_pandas_dataframe()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The fast fission factor can be calculated as\n",
    "$$\\epsilon=\\frac{\\langle\\nu\\Sigma_f\\phi\\rangle}{\\langle\\nu\\Sigma_f\\phi\\rangle_T}$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>energy low [eV]</th>\n",
       "      <th>energy high [eV]</th>\n",
       "      <th>nuclide</th>\n",
       "      <th>score</th>\n",
       "      <th>mean</th>\n",
       "      <th>std. dev.</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.0</td>\n",
       "      <td>0.625</td>\n",
       "      <td>total</td>\n",
       "      <td>(nu-fission / nu-fission)</td>\n",
       "      <td>1.203449</td>\n",
       "      <td>0.01381</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   energy low [eV]  energy high [eV] nuclide                      score  \\\n",
       "0         0.00e+00          6.25e-01   total  (nu-fission / nu-fission)   \n",
       "\n",
       "      mean  std. dev.  \n",
       "0 1.20e+00   1.38e-02  "
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Compute fast fission factor factor using tally arithmetic\n",
    "therm_fiss_rate = sp.get_tally(name='therm. fiss. rate')\n",
    "fast_fiss = fiss_rate / therm_fiss_rate\n",
    "fast_fiss.get_pandas_dataframe()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The thermal flux utilization is calculated as\n",
    "$$f=\\frac{\\langle\\Sigma_a\\phi\\rangle^F_T}{\\langle\\Sigma_a\\phi\\rangle_T}$$\n",
    "where the superscript $F$ denotes fuel."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>energy low [eV]</th>\n",
       "      <th>energy high [eV]</th>\n",
       "      <th>cell</th>\n",
       "      <th>nuclide</th>\n",
       "      <th>score</th>\n",
       "      <th>mean</th>\n",
       "      <th>std. dev.</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.0</td>\n",
       "      <td>0.625</td>\n",
       "      <td>1</td>\n",
       "      <td>total</td>\n",
       "      <td>(absorption / absorption)</td>\n",
       "      <td>0.74975</td>\n",
       "      <td>0.009032</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   energy low [eV]  energy high [eV]  cell nuclide                      score  \\\n",
       "0         0.00e+00          6.25e-01     1   total  (absorption / absorption)   \n",
       "\n",
       "      mean  std. dev.  \n",
       "0 7.50e-01   9.03e-03  "
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Compute thermal flux utilization factor using tally arithmetic\n",
    "fuel_therm_abs_rate = sp.get_tally(name='fuel therm. abs. rate')\n",
    "therm_util = fuel_therm_abs_rate / therm_abs_rate\n",
    "therm_util.get_pandas_dataframe()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The next factor is the number of fission neutrons produced per absorption in fuel, calculated as $$\\eta = \\frac{\\langle \\nu\\Sigma_f\\phi \\rangle_T}{\\langle \\Sigma_a \\phi \\rangle^F_T}$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>energy low [eV]</th>\n",
       "      <th>energy high [eV]</th>\n",
       "      <th>cell</th>\n",
       "      <th>nuclide</th>\n",
       "      <th>score</th>\n",
       "      <th>mean</th>\n",
       "      <th>std. dev.</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.0</td>\n",
       "      <td>0.625</td>\n",
       "      <td>1</td>\n",
       "      <td>total</td>\n",
       "      <td>(nu-fission / absorption)</td>\n",
       "      <td>1.663575</td>\n",
       "      <td>0.020557</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   energy low [eV]  energy high [eV]  cell nuclide                      score  \\\n",
       "0         0.00e+00          6.25e-01     1   total  (nu-fission / absorption)   \n",
       "\n",
       "      mean  std. dev.  \n",
       "0 1.66e+00   2.06e-02  "
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Compute neutrons produced per absorption (eta) using tally arithmetic\n",
    "eta = therm_fiss_rate / fuel_therm_abs_rate\n",
    "eta.get_pandas_dataframe()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are two leakage factors to account for fast and thermal leakage. The fast non-leakage probability is computed as $$P_{FNL} = \\frac{\\langle \\Sigma_a\\phi \\rangle + \\langle L \\rangle_T}{\\langle \\Sigma_a \\phi \\rangle + \\langle L \\rangle}$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>energy low [eV]</th>\n",
       "      <th>energy high [eV]</th>\n",
       "      <th>nuclide</th>\n",
       "      <th>score</th>\n",
       "      <th>mean</th>\n",
       "      <th>std. dev.</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.0</td>\n",
       "      <td>0.625</td>\n",
       "      <td>total</td>\n",
       "      <td>((absorption + current) / (absorption + current))</td>\n",
       "      <td>0.984639</td>\n",
       "      <td>0.00883</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   energy low [eV]  energy high [eV] nuclide  \\\n",
       "0         0.00e+00          6.25e-01   total   \n",
       "\n",
       "                                               score     mean  std. dev.  \n",
       "0  ((absorption + current) / (absorption + current)) 9.85e-01   8.83e-03  "
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p_fnl = (abs_rate + thermal_leak) / (abs_rate + leak)\n",
    "p_fnl.get_pandas_dataframe()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The final factor is the thermal non-leakage probability and is computed as $$P_{TNL} = \\frac{\\langle \\Sigma_a\\phi \\rangle_T}{\\langle \\Sigma_a \\phi \\rangle_T + \\langle L \\rangle_T}$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>energy low [eV]</th>\n",
       "      <th>energy high [eV]</th>\n",
       "      <th>nuclide</th>\n",
       "      <th>score</th>\n",
       "      <th>mean</th>\n",
       "      <th>std. dev.</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.0</td>\n",
       "      <td>0.625</td>\n",
       "      <td>total</td>\n",
       "      <td>(absorption / (absorption + current))</td>\n",
       "      <td>0.997372</td>\n",
       "      <td>0.011707</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   energy low [eV]  energy high [eV] nuclide  \\\n",
       "0         0.00e+00          6.25e-01   total   \n",
       "\n",
       "                                   score     mean  std. dev.  \n",
       "0  (absorption / (absorption + current)) 9.97e-01   1.17e-02  "
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p_tnl = therm_abs_rate / (therm_abs_rate + thermal_leak)\n",
    "p_tnl.get_pandas_dataframe()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we can calculate $k_{eff}$ using the product of the factors form the four-factor formula."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>energy low [eV]</th>\n",
       "      <th>energy high [eV]</th>\n",
       "      <th>cell</th>\n",
       "      <th>nuclide</th>\n",
       "      <th>score</th>\n",
       "      <th>mean</th>\n",
       "      <th>std. dev.</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.0</td>\n",
       "      <td>0.625</td>\n",
       "      <td>1</td>\n",
       "      <td>total</td>\n",
       "      <td>(((((((absorption + current) / (absorption + c...</td>\n",
       "      <td>1.025847</td>\n",
       "      <td>0.028224</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   energy low [eV]  energy high [eV]  cell nuclide  \\\n",
       "0         0.00e+00          6.25e-01     1   total   \n",
       "\n",
       "                                               score     mean  std. dev.  \n",
       "0  (((((((absorption + current) / (absorption + c... 1.03e+00   2.82e-02  "
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "keff = res_esc * fast_fiss * therm_util * eta * p_fnl * p_tnl\n",
    "keff.get_pandas_dataframe()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We see that the value we've obtained here has exactly the same mean as before. However, because of the way it was calculated, the standard deviation appears to be larger.\n",
    "\n",
    "Let's move on to a more complicated example now. Before we set up tallies to get reaction rates in the fuel and moderator in two energy groups for two different nuclides. We can use tally arithmetic to divide each of these reaction rates by the flux to get microscopic multi-group cross sections."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Compute microscopic multi-group cross-sections\n",
    "flux = sp.get_tally(name='flux')\n",
    "flux = flux.get_slice(filters=[openmc.CellFilter], filter_bins=[(fuel_cell.id,)])\n",
    "fuel_rxn_rates = sp.get_tally(name='fuel rxn rates')\n",
    "mod_rxn_rates = sp.get_tally(name='moderator rxn rates')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>cell</th>\n",
       "      <th>energy low [eV]</th>\n",
       "      <th>energy high [eV]</th>\n",
       "      <th>nuclide</th>\n",
       "      <th>score</th>\n",
       "      <th>mean</th>\n",
       "      <th>std. dev.</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>0.000</td>\n",
       "      <td>6.250000e-01</td>\n",
       "      <td>(U238 / total)</td>\n",
       "      <td>(nu-fission / flux)</td>\n",
       "      <td>6.670761e-07</td>\n",
       "      <td>7.788171e-09</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1</td>\n",
       "      <td>0.000</td>\n",
       "      <td>6.250000e-01</td>\n",
       "      <td>(U238 / total)</td>\n",
       "      <td>(scatter / flux)</td>\n",
       "      <td>2.099931e-01</td>\n",
       "      <td>2.336727e-03</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>1</td>\n",
       "      <td>0.000</td>\n",
       "      <td>6.250000e-01</td>\n",
       "      <td>(U235 / total)</td>\n",
       "      <td>(nu-fission / flux)</td>\n",
       "      <td>3.571972e-01</td>\n",
       "      <td>4.203420e-03</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>1</td>\n",
       "      <td>0.000</td>\n",
       "      <td>6.250000e-01</td>\n",
       "      <td>(U235 / total)</td>\n",
       "      <td>(scatter / flux)</td>\n",
       "      <td>5.555637e-03</td>\n",
       "      <td>6.200519e-05</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>1</td>\n",
       "      <td>0.625</td>\n",
       "      <td>2.000000e+07</td>\n",
       "      <td>(U238 / total)</td>\n",
       "      <td>(nu-fission / flux)</td>\n",
       "      <td>7.269233e-03</td>\n",
       "      <td>6.814579e-05</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>1</td>\n",
       "      <td>0.625</td>\n",
       "      <td>2.000000e+07</td>\n",
       "      <td>(U238 / total)</td>\n",
       "      <td>(scatter / flux)</td>\n",
       "      <td>2.276519e-01</td>\n",
       "      <td>7.674381e-04</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>1</td>\n",
       "      <td>0.625</td>\n",
       "      <td>2.000000e+07</td>\n",
       "      <td>(U235 / total)</td>\n",
       "      <td>(nu-fission / flux)</td>\n",
       "      <td>8.069479e-03</td>\n",
       "      <td>5.324215e-05</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>1</td>\n",
       "      <td>0.625</td>\n",
       "      <td>2.000000e+07</td>\n",
       "      <td>(U235 / total)</td>\n",
       "      <td>(scatter / flux)</td>\n",
       "      <td>3.363165e-03</td>\n",
       "      <td>1.147434e-05</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   cell  energy low [eV]  energy high [eV]         nuclide  \\\n",
       "0     1         0.00e+00          6.25e-01  (U238 / total)   \n",
       "1     1         0.00e+00          6.25e-01  (U238 / total)   \n",
       "2     1         0.00e+00          6.25e-01  (U235 / total)   \n",
       "3     1         0.00e+00          6.25e-01  (U235 / total)   \n",
       "4     1         6.25e-01          2.00e+07  (U238 / total)   \n",
       "5     1         6.25e-01          2.00e+07  (U238 / total)   \n",
       "6     1         6.25e-01          2.00e+07  (U235 / total)   \n",
       "7     1         6.25e-01          2.00e+07  (U235 / total)   \n",
       "\n",
       "                 score     mean  std. dev.  \n",
       "0  (nu-fission / flux) 6.67e-07   7.79e-09  \n",
       "1     (scatter / flux) 2.10e-01   2.34e-03  \n",
       "2  (nu-fission / flux) 3.57e-01   4.20e-03  \n",
       "3     (scatter / flux) 5.56e-03   6.20e-05  \n",
       "4  (nu-fission / flux) 7.27e-03   6.81e-05  \n",
       "5     (scatter / flux) 2.28e-01   7.67e-04  \n",
       "6  (nu-fission / flux) 8.07e-03   5.32e-05  \n",
       "7     (scatter / flux) 3.36e-03   1.15e-05  "
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fuel_xs = fuel_rxn_rates / flux\n",
    "fuel_xs.get_pandas_dataframe()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We see that when the two tallies with multiple bins were divided, the derived tally contains the outer product of the combinations. If the filters/scores are the same, no outer product is needed. The `get_values(...)` method allows us to obtain a subset of tally scores. In the following example, we obtain just the neutron production microscopic cross sections."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[[6.67076123e-07]\n",
      "  [3.57197248e-01]]\n",
      "\n",
      " [[7.26923324e-03]\n",
      "  [8.06947893e-03]]]\n"
     ]
    }
   ],
   "source": [
    "# Show how to use Tally.get_values(...) with a CrossScore\n",
    "nu_fiss_xs = fuel_xs.get_values(scores=['(nu-fission / flux)'])\n",
    "print(nu_fiss_xs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The same idea can be used not only for scores but also for filters and nuclides."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[[0.00555564]]\n",
      "\n",
      " [[0.00336316]]]\n"
     ]
    }
   ],
   "source": [
    "# Show how to use Tally.get_values(...) with a CrossScore and CrossNuclide\n",
    "u235_scatter_xs = fuel_xs.get_values(nuclides=['(U235 / total)'], \n",
    "                                scores=['(scatter / flux)'])\n",
    "print(u235_scatter_xs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[[0.22765194]\n",
      "  [0.00336316]]]\n"
     ]
    }
   ],
   "source": [
    "# Show how to use Tally.get_values(...) with a CrossFilter and CrossScore\n",
    "fast_scatter_xs = fuel_xs.get_values(filters=[openmc.EnergyFilter], \n",
    "                                     filter_bins=[((0.625, 20.0e6),)], \n",
    "                                     scores=['(scatter / flux)'])\n",
    "print(fast_scatter_xs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A more advanced method is to use `get_slice(...)` to create a new derived tally that is a subset of an existing tally. This has the benefit that we can use `get_pandas_dataframe()` to see the tallies in a more human-readable format."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>cell</th>\n",
       "      <th>energy low [eV]</th>\n",
       "      <th>energy high [eV]</th>\n",
       "      <th>nuclide</th>\n",
       "      <th>score</th>\n",
       "      <th>mean</th>\n",
       "      <th>std. dev.</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>0.000</td>\n",
       "      <td>6.250000e-01</td>\n",
       "      <td>U238</td>\n",
       "      <td>nu-fission</td>\n",
       "      <td>0.000002</td>\n",
       "      <td>1.382881e-08</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1</td>\n",
       "      <td>0.000</td>\n",
       "      <td>6.250000e-01</td>\n",
       "      <td>U235</td>\n",
       "      <td>nu-fission</td>\n",
       "      <td>0.858278</td>\n",
       "      <td>7.512185e-03</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>1</td>\n",
       "      <td>0.625</td>\n",
       "      <td>2.000000e+07</td>\n",
       "      <td>U238</td>\n",
       "      <td>nu-fission</td>\n",
       "      <td>0.082753</td>\n",
       "      <td>7.469156e-04</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>1</td>\n",
       "      <td>0.625</td>\n",
       "      <td>2.000000e+07</td>\n",
       "      <td>U235</td>\n",
       "      <td>nu-fission</td>\n",
       "      <td>0.091863</td>\n",
       "      <td>5.596607e-04</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   cell  energy low [eV]  energy high [eV] nuclide       score     mean  \\\n",
       "0     1         0.00e+00          6.25e-01    U238  nu-fission 1.60e-06   \n",
       "1     1         0.00e+00          6.25e-01    U235  nu-fission 8.58e-01   \n",
       "2     1         6.25e-01          2.00e+07    U238  nu-fission 8.28e-02   \n",
       "3     1         6.25e-01          2.00e+07    U235  nu-fission 9.19e-02   \n",
       "\n",
       "   std. dev.  \n",
       "0   1.38e-08  \n",
       "1   7.51e-03  \n",
       "2   7.47e-04  \n",
       "3   5.60e-04  "
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# \"Slice\" the nu-fission data into a new derived Tally\n",
    "nu_fission_rates = fuel_rxn_rates.get_slice(scores=['nu-fission'])\n",
    "nu_fission_rates.get_pandas_dataframe()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>cell</th>\n",
       "      <th>energy low [eV]</th>\n",
       "      <th>energy high [eV]</th>\n",
       "      <th>nuclide</th>\n",
       "      <th>score</th>\n",
       "      <th>mean</th>\n",
       "      <th>std. dev.</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>3</td>\n",
       "      <td>1.000000e-02</td>\n",
       "      <td>1.080060e-01</td>\n",
       "      <td>H1</td>\n",
       "      <td>scatter</td>\n",
       "      <td>4.542677</td>\n",
       "      <td>0.037555</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>3</td>\n",
       "      <td>1.080060e-01</td>\n",
       "      <td>1.166529e+00</td>\n",
       "      <td>H1</td>\n",
       "      <td>scatter</td>\n",
       "      <td>2.019002</td>\n",
       "      <td>0.011992</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>3</td>\n",
       "      <td>1.166529e+00</td>\n",
       "      <td>1.259921e+01</td>\n",
       "      <td>H1</td>\n",
       "      <td>scatter</td>\n",
       "      <td>1.622688</td>\n",
       "      <td>0.011889</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>3</td>\n",
       "      <td>1.259921e+01</td>\n",
       "      <td>1.360790e+02</td>\n",
       "      <td>H1</td>\n",
       "      <td>scatter</td>\n",
       "      <td>1.834317</td>\n",
       "      <td>0.012322</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>3</td>\n",
       "      <td>1.360790e+02</td>\n",
       "      <td>1.469734e+03</td>\n",
       "      <td>H1</td>\n",
       "      <td>scatter</td>\n",
       "      <td>2.040064</td>\n",
       "      <td>0.012967</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>3</td>\n",
       "      <td>1.469734e+03</td>\n",
       "      <td>1.587401e+04</td>\n",
       "      <td>H1</td>\n",
       "      <td>scatter</td>\n",
       "      <td>2.107758</td>\n",
       "      <td>0.012781</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>3</td>\n",
       "      <td>1.587401e+04</td>\n",
       "      <td>1.714488e+05</td>\n",
       "      <td>H1</td>\n",
       "      <td>scatter</td>\n",
       "      <td>2.175480</td>\n",
       "      <td>0.014165</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>3</td>\n",
       "      <td>1.714488e+05</td>\n",
       "      <td>1.851749e+06</td>\n",
       "      <td>H1</td>\n",
       "      <td>scatter</td>\n",
       "      <td>1.983382</td>\n",
       "      <td>0.012931</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>3</td>\n",
       "      <td>1.851749e+06</td>\n",
       "      <td>2.000000e+07</td>\n",
       "      <td>H1</td>\n",
       "      <td>scatter</td>\n",
       "      <td>0.372359</td>\n",
       "      <td>0.003689</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   cell  energy low [eV]  energy high [eV] nuclide    score     mean  \\\n",
       "0     3         1.00e-02          1.08e-01      H1  scatter 4.54e+00   \n",
       "1     3         1.08e-01          1.17e+00      H1  scatter 2.02e+00   \n",
       "2     3         1.17e+00          1.26e+01      H1  scatter 1.62e+00   \n",
       "3     3         1.26e+01          1.36e+02      H1  scatter 1.83e+00   \n",
       "4     3         1.36e+02          1.47e+03      H1  scatter 2.04e+00   \n",
       "5     3         1.47e+03          1.59e+04      H1  scatter 2.11e+00   \n",
       "6     3         1.59e+04          1.71e+05      H1  scatter 2.18e+00   \n",
       "7     3         1.71e+05          1.85e+06      H1  scatter 1.98e+00   \n",
       "8     3         1.85e+06          2.00e+07      H1  scatter 3.72e-01   \n",
       "\n",
       "   std. dev.  \n",
       "0   3.76e-02  \n",
       "1   1.20e-02  \n",
       "2   1.19e-02  \n",
       "3   1.23e-02  \n",
       "4   1.30e-02  \n",
       "5   1.28e-02  \n",
       "6   1.42e-02  \n",
       "7   1.29e-02  \n",
       "8   3.69e-03  "
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# \"Slice\" the H-1 scatter data in the moderator Cell into a new derived Tally\n",
    "need_to_slice = sp.get_tally(name='need-to-slice')\n",
    "slice_test = need_to_slice.get_slice(scores=['scatter'], nuclides=['H1'],\n",
    "                                     filters=[openmc.CellFilter], filter_bins=[(moderator_cell.id,)])\n",
    "slice_test.get_pandas_dataframe()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Close the statepoint file as a matter of best practice\n",
    "sp.close()"
   ]
  }
 ],
 "metadata": {
  "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
}