mg-mode-part-ii.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Multigroup Mode Part II: MGXS Library Generation with OpenMC\n",
    "The previous Notebook in this series used multi-group mode to perform a calculation with previously defined cross sections.  However, in many circumstances the multi-group data is not given and one must instead generate the cross sections for the specific application (or at least verify the use of cross sections from another application).  \n",
    "\n",
    "This Notebook illustrates the use of the openmc.mgxs.Library class specifically for the calculation of MGXS to be used in OpenMC's multi-group mode. This example notebook is therefore very similar to the MGXS Part III notebook, except OpenMC is used as the multi-group solver instead of OpenMOC.\n",
    "\n",
    "During this process, this notebook will illustrate the following features:\n",
    "\n",
    "   - Calculation of multi-group cross sections for a fuel assembly\n",
    "   - Automated creation and storage of MGXS with openmc.mgxs.Library\n",
    "   - Steady-state pin-by-pin fission rates comparison between continuous-energy and multi-group OpenMC.\n",
    "   - Modification of the scattering data in the library to show the flexibility of the multi-group solver\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Generate Input Files"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import os\n",
    "\n",
    "import openmc\n",
    "\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will begin by creating three materials for the fuel, water, and cladding of the fuel pins."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# create a model to tie togehter materials, geometry, settings, and tallies\n",
    "model = openmc.Model()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "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_element('U', 1., enrichment=1.6)\n",
    "fuel.add_element('O', 2.)\n",
    "\n",
    "# zircaloy\n",
    "zircaloy = openmc.Material(name='Zircaloy')\n",
    "zircaloy.set_density('g/cm3', 6.55)\n",
    "zircaloy.add_element('Zr', 1.)\n",
    "\n",
    "# borated water\n",
    "water = openmc.Material(name='Borated Water')\n",
    "water.set_density('g/cm3', 0.740582)\n",
    "water.add_element('H', 4.9457e-2)\n",
    "water.add_element('O', 2.4732e-2)\n",
    "water.add_element('B', 8.0042e-6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With our three materials, we can now create a Materials object that can be exported to an actual XML file."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Instantiate a Materials object\n",
    "model.materials = openmc.Materials((fuel, zircaloy, water))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let's move on to the geometry. This problem will be a square array of fuel pins and control rod guide tubes for which we can use OpenMC's lattice/universe feature. The basic universe will have three regions for the fuel, the clad, and the surrounding coolant. The first step is to create the bounding surfaces for fuel and clad, as well as the outer bounding surfaces of the problem."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create cylinders for the fuel and clad\n",
    "# The x0 and y0 parameters (0. and 0.) are the default values for an\n",
    "# openmc.ZCylinder object. We could therefore leave them out to no effect\n",
    "fuel_outer_radius = openmc.ZCylinder(x0=0.0, y0=0.0, r=0.39218)\n",
    "clad_outer_radius = openmc.ZCylinder(x0=0.0, y0=0.0, r=0.45720)\n",
    "\n",
    "# Create boundary planes to surround the geometry\n",
    "min_x = openmc.XPlane(x0=-10.71, boundary_type='reflective')\n",
    "max_x = openmc.XPlane(x0=+10.71, boundary_type='reflective')\n",
    "min_y = openmc.YPlane(y0=-10.71, boundary_type='reflective')\n",
    "max_y = openmc.YPlane(y0=+10.71, boundary_type='reflective')\n",
    "min_z = openmc.ZPlane(z0=-10., boundary_type='reflective')\n",
    "max_z = openmc.ZPlane(z0=+10., boundary_type='reflective')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With the surfaces defined, we can now construct a fuel pin cell from cells that are defined by intersections of half-spaces created by the surfaces."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a Universe to encapsulate a fuel pin\n",
    "fuel_pin_universe = openmc.Universe(name='1.6% Fuel Pin')\n",
    "\n",
    "# Create fuel Cell\n",
    "fuel_cell = openmc.Cell(name='1.6% Fuel')\n",
    "fuel_cell.fill = fuel\n",
    "fuel_cell.region = -fuel_outer_radius\n",
    "fuel_pin_universe.add_cell(fuel_cell)\n",
    "\n",
    "# Create a clad Cell\n",
    "clad_cell = openmc.Cell(name='1.6% Clad')\n",
    "clad_cell.fill = zircaloy\n",
    "clad_cell.region = +fuel_outer_radius & -clad_outer_radius\n",
    "fuel_pin_universe.add_cell(clad_cell)\n",
    "\n",
    "# Create a moderator Cell\n",
    "moderator_cell = openmc.Cell(name='1.6% Moderator')\n",
    "moderator_cell.fill = water\n",
    "moderator_cell.region = +clad_outer_radius\n",
    "fuel_pin_universe.add_cell(moderator_cell)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Likewise, we can construct a control rod guide tube with the same surfaces."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a Universe to encapsulate a control rod guide tube\n",
    "guide_tube_universe = openmc.Universe(name='Guide Tube')\n",
    "\n",
    "# Create guide tube Cell\n",
    "guide_tube_cell = openmc.Cell(name='Guide Tube Water')\n",
    "guide_tube_cell.fill = water\n",
    "guide_tube_cell.region = -fuel_outer_radius\n",
    "guide_tube_universe.add_cell(guide_tube_cell)\n",
    "\n",
    "# Create a clad Cell\n",
    "clad_cell = openmc.Cell(name='Guide Clad')\n",
    "clad_cell.fill = zircaloy\n",
    "clad_cell.region = +fuel_outer_radius & -clad_outer_radius\n",
    "guide_tube_universe.add_cell(clad_cell)\n",
    "\n",
    "# Create a moderator Cell\n",
    "moderator_cell = openmc.Cell(name='Guide Tube Moderator')\n",
    "moderator_cell.fill = water\n",
    "moderator_cell.region = +clad_outer_radius\n",
    "guide_tube_universe.add_cell(moderator_cell)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using the pin cell universe, we can construct a 17x17 rectangular lattice with a 1.26 cm pitch."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create fuel assembly Lattice\n",
    "assembly = openmc.RectLattice(name='1.6% Fuel Assembly')\n",
    "assembly.pitch = (1.26, 1.26)\n",
    "assembly.lower_left = [-1.26 * 17. / 2.0] * 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, we create a NumPy array of fuel pin and guide tube universes for the lattice."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create array indices for guide tube locations in lattice\n",
    "template_x = np.array([5, 8, 11, 3, 13, 2, 5, 8, 11, 14, 2, 5, 8,\n",
    "                       11, 14, 2, 5, 8, 11, 14, 3, 13, 5, 8, 11])\n",
    "template_y = np.array([2, 2, 2, 3, 3, 5, 5, 5, 5, 5, 8, 8, 8, 8,\n",
    "                       8, 11, 11, 11, 11, 11, 13, 13, 14, 14, 14])\n",
    "\n",
    "# Initialize an empty 17x17 array of the lattice universes\n",
    "universes = np.empty((17, 17), dtype=openmc.Universe)\n",
    "\n",
    "# Fill the array with the fuel pin and guide tube universes\n",
    "universes[:, :] = fuel_pin_universe\n",
    "universes[template_x, template_y] = guide_tube_universe\n",
    "\n",
    "# Store the array of universes in the lattice\n",
    "assembly.universes = universes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "OpenMC requires that there is a \"root\" universe. Let us create a root cell that is filled by the pin cell universe and then assign it to the root universe."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create root Cell\n",
    "root_cell = openmc.Cell(name='root cell')\n",
    "root_cell.fill = assembly\n",
    "\n",
    "# Add boundary planes\n",
    "root_cell.region = +min_x & -max_x & +min_y & -max_y & +min_z & -max_z\n",
    "\n",
    "# Create root Universe\n",
    "root_universe = openmc.Universe(name='root universe', universe_id=0)\n",
    "root_universe.add_cell(root_cell)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Before proceeding lets check the geometry."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x7fc11fdd0b50>"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAicAAAITCAYAAADcu7xmAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAAsTAAALEwEAmpwYAABP0ElEQVR4nO29f8xuV3Xf+V3mAiNRZH4lBLCVELhFY7fBJVceMkOtJLj8cGqcRKRjNGrJJCPLU5Ca6cx0HEWiERESadRaSpPGcgotHUWBNAmJFZuASTOiUSeQe5ENJkC5cYmw48AUUtNMNMkwXvPH+5z45LznvM/Ze6+91/7x/Uiv7nuf55zzPWvt715nvc+Ps0VVQQghhBBSC1d4nwAhhBBCyBw2J4QQQgipCjYnhBBCCKkKNieEEEIIqQo2J4QQQgipCjYnhBBCCKmKc94nEINcKYqv9z4LQgghhCRxGf9RVb9u+XCTzQm+HrjiTu+TIIQQQkgKT9yM3197nG/rEEIIIaQq2JwQQgghpCrafFsnkP/11surj//Ee186hKaXbm+aXro1aXrpMtZ2Nb10a9L00m1ZU1pcW0fOix77zMlZJlliOYAeurXHyvy2o1t7rMxvO7q1x8r81qH7xM24pKoXlo932ZzMk3fDvXeceayPfNc7//z3lAH00JzrHtOc61pp7tH1iDWHZkld7/yG6LaY37lu7flN1fXOb4hui/md6/Zeg3NpDtOchBhlInXwYjTnurGGSYm1pGaqbsiksNKc63p4KVaXXsqjSy+F67IG16OZqpvTS1vNSVcfiI0dtNDtLTTn+4S8TJaq66GZqrs8RglNby+1FGtLXmop1rkPOG/sNef79O6lVN3lMUpodtOcpAzafL+UgUvRDcEz1pQiEoNHrPRSuGZpL40UawycN+G6IdBL+4mNtZvmxILQJKYO2tqx9pKqGbq/RcGINWnpyWgBvbSN5cVnhFg9vVSa2Pxy3oRptuClrpqTFicjEHbe1n9VhBzPIr8escY0RfRSOCN4KeZ4I3nJKlZ6aZ0RvDTRRXNiaZaS75UuKf1y5l48z8vrJUwL6KWxoZfi8LwA1zpvRvSSSXMiIu8WkS+JyEOzx54jIveLyOcO/z57Y983H7b5nIi82eJ8esfKLCwCxIq9Xsox7nuP2epfnWSdHv5ooie3sXrl5F8CeN3isTsA/IaqngfwG4f//wVE5DkA/iGA/wrA9QD+4VYTUxu8uLYFi8A6zEs4zNk6zEtb1H4NM2lOVPUjAL6yePgWAO85/P4eAN+9sutrAdyvql9R1T8CcD9ONzmEJDO/jwIhxB7OMWJJzs+cPF9VHzv8/ocAnr+yzYsAfGH2/0cOj51CRG4TkYsichGP255oDLnXojiLHoqAZ/7Ik/TgpdIwZ3XQQw3x9FLt+SvygVg9uQ1t0q1oVfVuVb2gqhdwpdGJrTCSWfbGykYsDnrpNDnOa+8xS48H500cLcwbeik/OZuTL4rICwDg8O+XVrZ5FMDVs/9fdXgsiNYHLuQYI8VqzZ7ctZ7fEFqPtXYvWVJ7rPRSPCG5GynWnM3JPQCmb9+8GcCvrmzzQQCvEZFnHz4I+5rDY1FYJX1vAluekFYLUMUQml+rWHPvs0ZpL3nE6umlvdBL4bTgJc/65eElK1rwktVXiX8ewP8J4GUi8oiI/CCAdwL4GyLyOQA3Hv4PEbkgIv8cAFT1KwB+DMDvHH7efngsGAvDxO5roRliAivDxGh65DeFlPyO5KWSY2OZ35IXJ3rpbDy8NMEavI9WvATYfVvnTar6AlV9qqpeparvUtUvq+qrVfW8qt44NR2qelFV/4fZvu9W1Zcefv6FxfmkdPyhCUwxTGqBLW00j1gtNGNoNVavtxtaiNXr4tlarBZeGiVW1uB9mjHIyWdV20LOi15x5/pzMUs7W0zG0Ns3W2ru1U1dlnyp23us9NJxTStdxrqt66GZojtifvfq9hCrtZeeuBmXVPXC8vHumpOJY6ZZdnQWf3Eub2pzTNdDM4duz/ld6jLW8l5a6jK/8Zp7dBlrXs0cui3nd7jmBNh3B7wcL4Mf0/XQ9NJlrP1peuky1v40vXQZa17NEN0hmxNCCCGE1MtWc9LFqsSEEEII6Qc2J4QQQgipCjYnhBBCCKkKNieEEEIIqQo2J4QQQgipCjYnhBBCCKkKNieEEEIIqYpz3idQkunGMSXXH/HU9NLtXdNLl7H2p+mly1jLaHrp9qDZ9U3YPO7Yt0fTS5extqXppVurppduD5peurVqeuky1tMMdYfYPff/B/KusVCTppeut6aFLr1Uhy5jLadpoct5U4eut+Ye3WGak9ZWkk3RDdWc646yUm+KLmPdp8vVVfdrxugy1jBd1mB7zbkuVyU+g63mJMYoEymDF6vroeml21qsreU3Rbe1WJnfenVbi7W1/Kbo1hrrMGvrxCRvvt/e9/AmUgbNQ9NL1zvWknjFmgK9tF+3JPTScVr20kixhtJNcxKa8DVCk2hRAGINUxrPWC0KbIimZayl9pvvGxNrSVqfN/TSOqzBeRmpBgMdNSeA3V8JpU0act5WfxG1MCGtzi3lr4xU9sbQcqwteckq1tz7rDGClyZG8lJIrKVfCfP0UhfNiaeRPV429cIiVs987fGJpZdCY7XMTelYQ6GXwqCXtmndS6Wpfd5MdNGcWNLKwFmwN9bWCw/Jj6eX9h6TXmqDFmpwq69gxOA1HmxOIhnRLJbU/LLtSPTgpdIwZ3XQQw1poRHzgs0JIYQQQqqCzUkkpdekICQHy7s5kuMwZ6QHar+GsTlpEKviuPc4OUy895i8ELQBvUSsGMlL9OQ2XTQnliYNNYuluWrvZC3wnIx78ksvEStG8pKn30a4wI/kpYkumpMJqySWnmgh5219biHHK10ErGKNOe+RvOQRq4Wmx7yJuQU45004LcwbK+ildbpqTlIJTaBlcQ81QaqmR6yxazu0OCFb8lIq9NI2ll7yiJVeOr5fqu5eWvdSKN00J6kmjR00K10PTY+XYr3yGxMrvbRfs4W3keilcF0PzdhYS0Iv5dftpjkB4pNoVWBL6nrEOtcM0Q3d/izdEFrL79pxSuh65zfWSy3GGqMZS4uxpswbeum4ZiwesYqqBu/kjZwXveLO7efnN5c56yY380RbdN9711yw1PWIda+ml27rmnNd5tdX1ztWSy8d0x0xvyV1vWOt1UtP3IxLqnph+XiXzcnE3jvgWb4sWLOml27rml66jLU/TS9dxlqHppduzZpDNicTa8ks8T6lh+4oml66jLV8rMxv+7qMtT9NK92hmxNCCCGE1MdWc9LVB2IJIYQQ0j5sTgghhBBSFWxOCCGEEFIVbE4IIYQQUhVsTgghhBBSFWxOCCGEEFIVbE4IIYQQUhXnvE8gN2fdzS7XTWqO3UHPQ5extqnppVubppduT5peurVpeuky1jC6vQnbMnHzdQCWixdZDd7aYHno1qbppZtLc37cXHczHdlLy+OWynFt+c2p6+Fh1mA/TS/dPZpD3SF276JpgN1iTCELMc11PTRL6rac37nunuPMz7HlWL28dOw4zG+85t7jhPh9z3FYl/Lq1prfuS4X/jsQMmhzUgqQp2aobqpRR8nvXDd0/5QC7x2rh5c88gvExVoyv6m6Hvmd7997jWANttEc4vb1sQmc7xOyuqSX5toxcm0/xzPW0popBXrapxUvxepaeKlkfufExloyvym6Xvm1iNVDkzW4Lk2go+YkJYGppGjGDF5qrCmGsYg1hJSiMdeMyW+JVT0tac1LKfkt+dffhEd+vYhpUKxibakuteYlz+tj6Lh205wA6YkPTWLqhTMFq1j3YhlraH5Lx2pBaHFvtbmO2d/DSxMteim2Lnk01y3X4BG8NNFCDe6iOWm5SQg9hnWsIccrHas1IbG29qrJRCtesshvyDFanzceeOY3BNbgMFqpwVmbExF5mYg8MPv5qoj80GKbbxeRx2fbvC3nOR2jlYErSeuFJwTLWEMvwJaxlh6zFi7ALXsp9Nwtm+uRvMQafBqv8cjanKjqZ1X1OlW9DsC3AvgTAO9f2fTfTtup6ttznpMVPZiFRYC0fMHOecyzaKERGwHW4DRqr8El39Z5NYDfU9XfL6hJCABeUAjJDecYsaRkc3IrgJ/feO7bRORBEfmAiFxb8JzIIKzdMZEQYgfnGLGkSHMiIk8D8AYA/3rl6Y8D+EZVfTmAfwrgVzaOcZuIXBSRi3g826nuxvMDk1ZFwLOYtPqB094o7YEc417aS7wI1wFrcBq11+BSr5y8HsDHVfWLyydU9auq+seH3+8D8FQRed7Kdner6gVVvYAr850ozXKaHorAXjw/SGgZKy/Yp2nZS6Hn7vnB7lRYg08zUg2eKNWcvAkbb+mIyDeIiBx+v/5wTl8OOXjrAxdyDOtYQ45XOlZrWvlqZAqteMkiv55fDS89bzxo5av3rMFhtFKDszcnIvIMAH8DwC/PHrtdRG4//PeNAB4SkQcB/CSAWzVywZ/UpIeuPdDyhGzBoNN2LcYaeiOskbxkGWvosVr00kSolzwabNbgcvun0EINzt6cqOr/rarPVdXHZ4/dpap3HX7/KVW9VlVfrqqvVNV/F6NjlcQYUjRjFmNKjdVDM3bf1OKTEmtrxd1rXEM1J1LyW/p2+UBb8yaVmLvMenqptXkzkpdiFxzs4g6xEymDF5tAD821Y+Tafo5nrKU1LRY/a8VLFrqxmqUXZQTazG+sl7wWvfTwEmvwPt1W6pJEvoPiipwXveLO7edD1gNIXb56qRmq66Fppdt7fue6e44zP8fWYvX20t5jWKwb4x2r17wJ8bDVvOm9RozqJcv8PnEzLqnqheXjXTYnwOm/GJbJtBqwWM1Suh6aXrqlNJfHPfa8hSbzm1+313nD/D5Jz/PGI1YLzeGak4ljL2vm+ECVh+YxXQ9NL92eYmV+fXV7ipX59dXtKVZLzWGbE0IIIYTUyVZz0tUHYgkhhBDSPmxOCCGEEFIVbE4IIYQQUhVsTgghhBBSFWxOCCGEEFIVbE4IIYQQUhVsTgghhBBSFee8T6AEazeMKbGaZa47L4Zoeuky1v40vXQZa3+aXrqMNa+mpW7XN2Hbu+iV5SB6aHrpjqLppctY+9P00mWs/Wl66VprDnWH2L0LFFmvr+Oh66151rGsFsJbO17P+fXSrVnTS7d1TS/dGmItVZtGza+V7jDNSchqjROpq1OGrtY417TQ9Yo1dCVZC12PWEtqeul6e2mUeUMv5dUMOUbrdSlEt+Z5M0RzEpO8iRTDeOh6aqbkiPmtT7c1TS/dljS9dL1jLbnviPnNoTvM2jqxxW7ab+/7aROpRTaGVM3YWFOYjFk6vymxtualmP1a9FIs9FK4rodmbKwlPgC61Gxp3rTkJaCj5sRikEOTaNGYeBX32FhTCkBsg1Ky8QPa9dLyWKVoad607CWPWFvx0kh1qdV5E6rZTXMC2Jml5glp/UpNSKwl/zIB7MYhJlf0Ujg1v3pi7aWQ47XYEAFjzZuQ2kYvhRNz3l00J5ZGDk2ipVlqLu5WlG5w5uzJL71UBotYSxfqUEbykqffPGtKKUby0kQXzcloWJll73FyFJ69x6z9AkROoJeIFSN5iZ7chs1JJLX/ZUrIHlgcw2HOSA/Ufg1jc0IIIYSQqmBzEonn+5zzG+q0ygjvE7dAD14qDXNWBz3UEE8v1Z4/NicLRjLL3ljZiJFjeHpp7zHppTZooQaXPscRa3AXzcmIA+eBxXuUtX+q39JLod6w9FLpWEOxiLX2ixi9VIbW61Jpap83E100JxNWSa/1FQzgyXNLjdVi3Y7cWJ1bTK5Ke2mkWD0YKb8jxeqBZw1u9RWbmPPupjmxSGJoAi1M2kKTAMTfRXFO7N0cLSZkiKaHl1L3m+9bc3MN+M4br+JuEWup/ebUPm8861JpWp83oZrdNCcTqRM5NIFWXXRJzdRYYwpBbAGwirXkvvRSXl2v/Ho0f96xltx3xLpEL23T1arEQNpy0iWXJq95Ces9miHHsPjLxDtWemlbl0u/79cM0aWX4nRD61KKLr10XPOY7taqxN01J8D+wbOYiKG6Hpq5dbeOZzH5t45XKtblX2M1jevyLxLLWDlv7HXppbN1WZfsdVuYN0M1JxN7Xuazfllt70uLHrqMNa+mtS7zW4duD7Eyv3XoMtbTDNmczLHulmvWHUXTS5exltP00u1Z00uXsfanaaE7fHNCCCGEkLrYak66+7YOIYQQQtqGzQkhhBBCqoLNCSGEEEKqgs0JIYQQQqqCzQkhhBBCqoLNCSGEEEKqgs0JIYQQQqrinPcJ5ObYnexy3KymRk0v3V40vXRr1PTSZaztaXrp1qjppduqZrc3YTu2BoD1WhJLzTXdHJpL3WOx5tBc0/XI71LXI79WuozVV3Op23N+l7o9x8oanFdzqbtHc5g7xIau2GhlmtgVGy009+oy1njdWjXnur3nd67LWMM09+oyv3Gae3UZ62mGa05ClrAG0gavJU0vXU9NL93WNL10W9L00m1N00u3BU0v3Vo1h7h9fYpZpn32rvLoqbncv9R+reY3hlZjjfVSad1W8xtDq7HSS/v3L7XfSF7qpjlJSWAqKZoxg5dSNGKPY5Ffz7FpJVYvL5UcG8v8Ws2FXJr0UhlYg/fRSg0GOmpOgPTEhyaxZGFcYhWrB6H59YjVKj8jeckzhmN4esmK0l7ymDeswWVooQZnb05E5PMi8kkReUBELq48LyLykyJyWUQ+ISKvCNVo2aChx7CONeR4pWO1Zk+s9FIZRvDSxAixjuQl1uB4QmIt9crJd6jqdWsfegHwegDnDz+3AfiZQue0SisDV5LWC48XI3lpb6w5zmvvMUuPB+dNHCPNm72M6KUa3ta5BcC/0hN+G8CzROQF3id1jB7MwiJAWr6IecGc1QFrcBq11+ASzYkC+JCIXBKR21aefxGAL8z+/8jhMULM4AWFkLxwjhFLSjQnr1LVV+Dk7Zu3iMgNMQcRkdtE5KKIXMTjticYQ65bPZM8LO+WSE5gXsJhztZhXtqi9mtY9uZEVR89/PslAO8HcP1ik0cBXD37/1WHx5bHuVtVL6jqBVyZ62zbwKoIeBaT2icGCWOvl3KM+95j8uLZF541pIcaXDtZmxMReYaIPHP6HcBrADy02OweAH/n8K2dVwJ4XFUfC9GxNGmoWSzNVesFu4cisBd6iVhBL8XBP5pOM6KXcr9y8nwAvyUiDwL4GIB7VfXXReR2Ebn9sM19AB4GcBnAzwL4u7FirXahIedtPXlCjmeR35Fi9WCk/I4Uqwcj5XekWD2IOe+szYmqPqyqLz/8XKuq7zg8fpeq3nX4XVX1Lar6ElX9q6p66l4opQhde2DazsIwoYZP1Qzd33JC1h6rBZ5eCoVeKrd/iia9dJqRvGQRa0tequGrxCakJtFi1cYU3RA8Y00xaSuxWk1ILy+VjJVeyqsZS6r36KWzaTXWGLxi7aY5AeKTmDLYKQOXYtDUWEtqpuouj1FCMyW/sX5q1Usx0Ev5daf9W4i1RS+xBufVFFUN3skbOS96xZ3bz4cs2526FLqn5lx3zz0GrF4dqj2/c93eY6WX0nR7j7Wl/KbqthQrvfQkT9yMS2t3j++yOQHW7353w713rHZ+li+/h9x1z0rXI1aPOLd0PWL18tJIsa7B/LajW1OsW7Qcay81eLjmZOKsAcz5mYAtXQ9NL93eYmV+/XQZa17NnLrMr59uC7EO25wQQgghpE62mpOuPhBLCCGEkPZhc0IIIYSQqmBzQgghhJCqYHNCCCGEkKpgc0IIIYSQqmBzQgghhJCqYHNCCCGEkKo4530CJajpBjW5F4Nb0/XQzK1bU35z6zLW/jS9dBkra3Armt3ehK2mW/vWouml23qszG89uow1r6alLvNbj27NsQ51h9iYBYpaXIhpqXvWsfZuF6pZ4wJbHvkN3Xbvcbxi9Zg3pfI7P1bt+U3V9c4vwBocul2oZus1eJjmJGSFyInUwQtdMXepG2uYSTdk/5h91vYPiROwi7WV/Mbqenup9vym7Lfcv5X8xurGenGU/FrqtpLfWN2cdWmI29fHGjR0+y3NWN2Ql8mWuqFGm7ZP0YzJl0WsLeU3FY9YW8jvfJ/WYi1Zl+a0UCM88mul20p+U2KdHydm+xjNbpqTFIPO90sZuBTdEFI775TJYVUw9+Ixrl75tYrVQ7P0vInBM9bSmh4ebtVLrMFn4zWu3TQnFoQmP3XQ1o61l9S/0GNfSk8h1qSlJ6MFocXH00upmrHzJsXDscXdK1YLzVAv5f6GSA5Yg7cZrQZ31ZxYJbDmzt363EKO59WxpxIzIVss7EA7XrLIb+xngSyoed5YEZNf1uBwavaSdQ0OoYvmxNIsXu8LA228NJ6KZ373YDkGoRdgeqkvPOuS11dHLai9Rngw4jWui+ZkNKwKz97j5ChOvHj2xd4C5umlES5iI+HppdI1eETYnETCi2tb8MK0DvMSDnO2DvPSFrVfw9ickCGYf8+fEGIP5xixhM1JJJ4vx9Xe8e6BL2fWAS8o4TBnddBDDfGs5bXnj83JAs/CU9ospd9fjYEXgjhKj9neccpxXnuPWdpLtRf/WmmhBpduKkaswV00J60PXMgxRorVmj258/yWw0gXT4viPtJfnaHeKP2tM9aleEJyN1KsXTQnE1ZJ35vAlot7Czdqms4tdVxj9rcq7qW9FBOrVX7pJbt91ijtpZg5MJKXrGqwBy3UpW6aE4viE7uvhWaICTwmrmV+S55/Sn5TikfsviN5ySK/nucfsq1HXSqdX6sGMIRW69JEK17yyG83zcmclL9uYhdxKqk5EVt8UhesaiW/FngsCObhpdSi5bH4WWkvxe7nOW9S8lualmpwaoMdu19rNTilbouqRu/shZwXveLO9edilna26JxDb99sqbn3OKHbHztOC/lN0Y3Jl8Vf9N6x7tG10JzreuQXKBerd12K+aBnq7GyBp+m5hr8xM24pKoXlo9315xMHJsgy47O4iW9PZPSqqivaW4dc882KbpesR4b1xzvvW8d06rorB2v1vzm0PXILzBOjSiV3+UxR8nv1jFZg7cZrjkB9r10luN9xmO6Hppeur3EWmt+c+jWGivz255urbH2kt89urXHOmRzQgghhJB62WpOuvxALCGEEELahc0JIYQQQqqCzQkhhBBCqoLNCSGEEEKqgs0JIYQQQqqCzQkhhBBCqoLNCSGEEEKqgs0JIYQQQqrinPcJ5KTWO/bl0B1F00uXsfpreun2oOmly1j70yyl2+UdYvfc/x/Iu+5ArWsd5NCtNb9euj1oeunWquml24Oml25NsY7qpT26w9y+vrUVMVN0W4uV+Q3TZax1aabotpbfFN3WYmV+w3S5KvEZbDUnocmbkzJ4sboeml66rcUaUwBSNee6sZoxuvRSXl16KUyXXsqjW2usXFvnCFPS9773PZEyaB6aXrrescbSSqwecc73o5fy7E8vHadlL40QayzdNCcWCfQoWrGGKY1lfkNjtZgUIZojecnDd55esoBeWsdiLELPuXUvhTCSl4COmhPArrPbm0QrM3v+dVPzhGw5vxP0Uh1Y/fVHL9nvswa9ZLfPGi14KVtzIiJXi8hvisjvisinROTvrWzz7SLyuIg8cPh5W4yWp5FLv9TVeqyl8zVnT+4s8xsaq2VuSscaCr0UBr20zQhesqSVWHO+cvI1AP+zql4D4JUA3iIi16xs929V9brDz9szns8uWhk4C/bG2nrhIfnx9NLeY9JLbdBCDeYfpfnJ1pyo6mOq+vHD7/8ZwKcBvCiXXmlGNIslNb9sOxI9eKk0zFkd9FBDWmjEvCjymRMR+SYAfw3AR1ee/jYReVBEPiAi155xjNtE5KKIXMTjuc6U9AovKITkhXOMWJK9ORGRvwTglwD8kKp+dfH0xwF8o6q+HMA/BfArW8dR1btV9YKqXsCV2U53NzluCUzysbxrITmBeQmHOVuHeWmL2q9hWZsTEXkqThqTn1PVX14+r6pfVdU/Pvx+H4Cnisjzcp5TD1gVgb3HyWHi2icGCaMFL/Hi2Rc9eIme3Cbnt3UEwLsAfFpV/8nGNt9w2A4icv3hfL4cqmVp0lCzWJprhAt27fmll4gVI3mpl1hrpZf8hsSR85WT/wbA3wbwnbOvCt8kIreLyO2Hbd4I4CEReRDATwK4VRPup2+VxNKFPeS8rc8t5Hili4BVrDHn3WrBi/GSx7yx0PSYNzG3AB/BSyn7rMEavM5INTjnt3V+S1VFVb9l9lXh+1T1LlW967DNT6nqtar6clV9par+u1zns4fQBFoW91ATpGrGxmqhWTrWUDxi9fRSKh7zhl46rkkvhcEafHy/knRzh9hUk8YOWqphYs7XK9YUzVhajDXVS6m6HpotvI1EL4XremjW3hABbXppwstLobrdNCdAfBItJsVHvuudRXU9Yk3RHClWC1qKNVUzRJdeCqelWEt6yVK3Bc0UP3nEKgkf8XBDzotecef28yFLlFt16zGaJXU9NL10vWNlfu01vXR7ipX59dXtKVZLzSduxiVVvbB8vMvmZGLvHfAsX0asWdNLl7H2p+mly1j70/TSZax1aA7ZnEysJTP3+5pbA+ihy1j70/TSZax5Nb10R9H00mWs2wzdnBBCCCGkPraak64+EEsIIYSQ9mFzQgghhJCqYHNCCCGEkKpgc0IIIYSQqmBzQgghhJCqYHNCCCGEkKpgc0IIIYSQqjjnfQK5OetudjlvUOOhO4qmly5jzat5li7z264uY+1Ps4RutzdhW0vctB7AcvGinLf23dK01N3SXNPNpTnX9Yi1pOZZuvRSuuZcd+RYe/PSWbr0UrrmXLclLw11h9i9ixMBdosi1b4Q01y3xUWnQjTnuh75TdVtyUupuiN6aY9uL7H27qW5Lr20rsuF/w6EGGUidfBiNOe6sYYZJdbQSWGhOdf1iJVeOq5LL9WnGatLL4Xr9hLrELevjx20G+69I3ifVM35PiErWqbqxsaZojnfJybW5TFKaHrESi+F6dJLdWmm6NJL+/CMNeY6maLZTXOSMmhrxylFzPmmxppimJT8thKrlZdK4xErvZRX0wt66WxajTWG1GtibKzdNCcWhCbRsvCEDlyqZuj+lk1b6fx6XBg8vRTKCF6aoJfyYpXf0FgtqN1LFrG25KUumpOWJ2PoMaxf2Qk5XulYrSkdqwf00jqtx+qBZ35DoJfCaKHBBjppTixp5eJZktYLTwiWsZZ8331JC29PloZeimMkL7EGn8ZrPNicNIiVWVgESMsX7JzHPIsWGrER6OGCTS9tw+YkEl5c24JFgJC8cI61Re3XMDYnZAjW7l5ICLGDc4xYwuYkkpxrFhzDqgh4FhPP/JEnKe2BHONe2ku8CNcBa3AatddgNicLaJbT9FAEPBjJSy2MUw+N2F5aGI8tRpo3exnRS100J60PXMgxrGMNOV7pWK3ZEyu9VIYRvDQxQqwjeYk1OJ6QWLtoTiZSkx669kDLE7IFg07becRKL4Xv7xFrC16yooVYW/ZSKPTSfmL276Y5sUpiDCmaMYsxWcVaWtNzbDzyG8MIXpoo7aXUC5lXfjlvjuM1bzw0R/AS0FFzAqQNXmwCPTTXjpF7H2Cs/I4U6/IYufcBfGMt/YrASF4aKdZUzRhGyq+oavBO3sh50Svu3H4+5Hb2qUt1LzVDdT00rXT33tdglFjppXhdeimvZqhu7/md6/Yea+1eeuJmXFLVC8vHu2xOgNM3mFkmc9kFWrx36aG51F0zjZU5tzTXdHvNbyndGmLt2UtL3Z5jrSG/pXRriJVeCtMcrjmZOHYXvBwfqPLQPKbroZlLt8b85tJlrP1peuky1ryax3SZ33WGbU4IIYQQUidbzUlXH4glhBBCSPuwOSGEEEJIVbA5IYQQQkhVsDkhhBBCSFWwOSGEEEJIVbA5IYQQQkhVsDkhhBBCSFWc8z6BUixvGlNiNUsPzaWuh2Yp3RryW0q3hlh7zu9St+dYa8hvKd0aYmV+4+j6JmzH7mI3YZlQD829uh6a1ro159dat+ZYe8jvXt0eYq05v9a6NcfK/J5mqDvE7l2gyHq9Aw/dvR26ZSd/bH2FCebXRtcjVq95s3U85tdG16NG1FaDrdecYX7TdIdpTkJXpgRsV6cMXREzRXfSDNk/Zp+1/QGfWEuOa0wxSc3v/BjMr80+W8fwitVj1Vzmd1vTQreVGlyyLu3VHaI5iUneRMrgeeimGDx2X+a33L4esXqNq8fYML959vWOtfca0WN+h1lbJyZ58/32vp82kTJosaR23tN+obGm4JXflHEpnV9PL3nNm5gce+U3NtYUPPKbsh/AGrwH1uDjdNOcWAxyaBItJoVHwQPKduwTsbFaFJ0QTYuxaCm/qcTOm5QLYGxxL3kBA3zH1fozBpbbbtFSDS71LZyJkWowUKA5EZHXichnReSyiJyKUESeLiLvOzz/URH5plgtq8JTc3G3KOxrx9uDV2FPJea8PfJrQUysrc6bEDy91Oq8iZkDrXoppganEtNgt+qlmPPO2pyIyFMA/DSA1wO4BsCbROSaxWY/COCPVPWlAO4E8OOhOpZGDk1iabO0jme+9vjE0kuhxd0yN6VjDcWi+Sv9l+uc0vkN9Ubpr456eok1OAzPa1yIT3K/cnI9gMuq+rCq/hmA9wK4ZbHNLQDec/j9FwG8WkQk83lVyd6Bsyo8MZ/gt2LvMVl42mDvONFL5BgteKmHGlw7uZuTFwH4wuz/jxweW91GVb8G4HEAz818XsmMaBbSH7xgh8OckR6o/Rp2zvsE9iIitwG4DQDwdb7nQgghhJB85H7l5FEAV8/+f9XhsdVtROQcgCsBfHl5IFW9W1UvqOoFXJnpbAPwfL+bECuWd8skx2HOSA/Ufg3L3Zz8DoDzIvJiEXkagFsB3LPY5h4Abz78/kYA/0ZbvDOcAaXffyz9/mrMMXkhaIO940QvkWO04KUeanDtZG1ODp8heSuADwL4NIBfUNVPicjbReQNh83eBeC5InIZwN8HEPyGruXAhRYwFrwwPPO1xyceC2RNWOamdKyhWBT32r9t5FmXSn/rzNNLrMFheF7jQnyS/T4nqnqfqv5lVX2Jqr7j8NjbVPWew+//j6p+n6q+VFWvV9WHY7Wsklh6ooWct/WdBUNiLV0ErMYh5rw97xWRQkysrc6bEDy91Oq8iZkDrXoppganEnPPqla9FHPe3dwh1iKJoQmcNFMMY7EgUwyxd0P0iNViQoZolr6z5lyzRS/FzpuUBjD2ZoRexd1jXEvf6Xi0Gux1V+8RajDQUXMyEZvE2EGzMEwoqcXd+i6ze/DKb8q4lM6vp5e85k1Mjr3y69H8eeQ3ZT+ANXgPrMHH6WpVYiDfss7HCNUdcbluC12vZdhDPyjXqpdaya+FrlesHsvcM7/bmha6rdTgknVpr+7WqsTdNSfA/sGzMKe37t5iYlF01o4FbMfK/NroesTqNW+2jsf82uh61IjaavDyL/kWa0TN+Q3VHao5mfD4mpbXV8P26HpoWuvWnF9r3Zpj7SG/e3V7iLXm/Frr1hwr83uaIZuTOcuElnivz0NzqeuhWUq3hvyW0q0h1p7zu9TtOdYa8ltKt4ZYmd+zGb45IYQQQkhdbDUn3X1bhxBCCCFtw+aEEEIIIVXB5oQQQgghVcHmhBBCCCFVweaEEEIIIVXB5oQQQgghVcHmhBBCCCFVcc77BHJz7G52OW5U46F5TNdDM5dujfnNpctY+9P00mWseTWP6TK/YXR7E7Zj679Yr6/gpbnUXVvvwHp9haXmmm6v+S2lW0OsPXtpqdtzrDXkt5RuDbHSS2GaQ90hNmT1RCvThK4UablKZKimla7Hiph7dT1ipZfidemlvJqhur3nd67be6y1e2mY5iRmWWcgzaieml66vWt66dJLdWt66bai6aXboqaXbm2aQ9y+PjaB8332rrjoqbl2jNz7AGPld6RYl8fIvQ/gG2vJOIGxvDRSrKmaMYyU326ak5QEppKiGTN4VrGW1vQcG4/8xjCClyZKeymlcZtrct6sM+K88dAcwUtAR80JkJ740CSmGjQFq1g9CM2vR6z0Uvj+HrG24CUrWoi1ZS+FQi/tJ2b/LpqTlg0aegzrWEOOVzpWa/bESi+VYQQvTYwQ60heYg2OJyTWLpoTS1oZuJK0Xni8GMlLLYxT6XPkvIljpHmzlxG9xOYkkh7MwiJAerhgsxEbE9bgNGqvwWxOyBDwgkJIXjjHiCVsTiLJdStikoflnQsJIbZwjrVF7dcwNicNYlUEPItJ7RNjFEp7IMe4l/YSL8J14FlDeqjBtcPmZAEv2KfpoQjsxTLW0HO3jJUX7NPQS3GM5CXW4NN4jUcXzck0cB5JtNAMOYa1SUOOVzpWa0rH6gG9tE7rsXrgmd8Q6KUwPK+TIbF20ZxYEZpAy6Yo1PCpmqH7W07I0vltYTK23GC34KUJeikvVvkNjdWC2r1kEWtLXuqmObFKYgsvYabGmrIAVEp+W4nVc0Km4BErvZRX0wt66WxajTWG1GtibKzdNCdAvGE+8l3vjB7wFJOmGDQl1li8Yl0eo4SmR6z0UpguvVSXZoouvbQPz1hjrpMpmqKqwTt5I+dFr7hz+/mQ9QBSl69eau7RtdKc64bEaqW5R9cjv3Ndj/ym6rbkpVTdEb20R7eXWHv30lyXXlrXPab5xM24pKoXlo932ZwA63e/mxK67P4s38pZ6m5pWupuaa7p5tKc63rEWlLzLF16KV1zrjtyrL156Sxdeildc67bkpeGa04mzrpFb87Pl3jojqLppctY82qepcv8tqvLWPvTtNQdtjkhhBBCSJ1sNSddfSCWEEIIIe3D5oQQQgghVcHmhBBCCCFVweaEEEIIIVXB5oQQQgghVcHmhBBCCCFVweaEEEIIIVVxzvsESrB2s5jcC/x53ExqS5ex9qfppctY82p66Y6i6aXLWMPp+iZsZ93Bbk7OW/vWpOmly1j70/TSZaz9aXrpMtY6NIe6Q2zMokgtLsQUouuh6aXrHSvza6/ppdtTrMyvr25PsVpqDtOchKwQOZF6UQldrdFatxVNL92WYh3RSyG69FK4Zqxui/n10m1F00v3LM0hbl8fk7z59iEvza0do6SuR6wpmiPFakFLsaZqhujSS+G0FGtJL1nqtqCZ4iePWLtpTmKTNxGbxJSGZq4bo1k61hTNWFqMNdVLqboemqnzoAT0Uriuh2ZpL7UWa2oN9vJSqG43zYkFoclPHbS1Y+0lVTM2VgvN0rGG4hGrp5dS8Zg39NJxTXopDNbg4/uVJEtzIiI/ISKfEZFPiMj7ReRZG9t9XkQ+KSIPiMjFVF2rBNY8Ia3PLeR4LRZ2IO68PSajBTFe8pg3Fpoe8yamuI/gpZR91mANXmekGpzrlZP7AfwVVf0WAP8ewA+fse13qOp1ax+I2YulWbzeFwbaeGk8ldrzSy8RK0byUi+x1kov+Q2JI0tzoqofUtWvHf772wCuyqEzKqU/KJfjQseLZ1+04KURLmIj0YOX6MltSnzm5AcAfGDjOQXwIRG5JCK3nXUQEblNRC6KyEU8bn6OwfDi2hYsAuswL+EwZ+swL21R+zUsujkRkQ+LyEMrP7fMtvkRAF8D8HMbh3mVqr4CwOsBvEVEbtjSU9W7VfWCql7AlbFnTUZl/j1/Qog9nGPEkujmRFVvVNW/svLzqwAgIt8P4G8C+O90405vqvro4d8vAXg/gOtjz6c0udcsOIseioBn/siT9OCl0jBnddBDDfH0Uu35y/VtndcB+AcA3qCqf7KxzTNE5JnT7wBeA+ChHOcTwkhm2RsrGzFyDE8v7T0mvdQGLdTg0uc4Yg3O9ZmTnwLwTAD3H74mfBcAiMgLReS+wzbPB/BbIvIggI8BuFdVfz1GbKSBaz3W2guPZX5DY7XMTelYQ6GXwqCXthnBS5a0Emuub+u8VFWvPnxF+DpVvf3w+B+o6k2H3x9W1Zcffq5V1Xek6lolfW8CrUwVc96psVotUpeTlvM7QS/VwXRuVrHm3meNEbw0QS/Z7bNGC17q5g6xFoaJ3ddCs+bJCNjmNzRWiwkZojmSlzx85+klC+ildSzGIvScW/dSCCN5CeioOUklNoEphvHQ9NL1jjWWVmL1iHO+H72UZ3966Tgte2mEWGORjS/SVI2cF73izvXnUpZhT+mcQ28FbrmEdYyuR6zMb5guY61LM0W3tfym6LYWK/Mbpmsd6xM349LaHeK7a06A0zeX2UqmhVG2dD00t3SXHW8Pse7R9NLtQdNLt1ZNL90eNL10a4p1VC/t0R2qOZnYcwe8HO8zeuiOoumly1j9Nb10e9D00mWs/Wla6w7ZnBBCCCGkXraaE34glhBCCCFVweaEEEIIIVXB5oQQQgghVcHmhBBCCCFVweaEEEIIIVXB5oQQQgghVcHmhBBCCCFVweaEEEIIIVVxzvsEclLr3fNqv2OfpW4vsdaa3xy6tcbK/LanW2usveR3j26rsXZ7h9hjawD0uNbB1jH3bJOiW+saFlaTcq67dcw928Rq1prfHLoe+QXGqRGl8rs85ij53Toma/A2w9y+vrUVGy009x7HqgCNuPrn3mNM+7Qc6x5dq6IXmi/L/ALlYvWuS6H5TdH1jpU1+DQ11+AhmpOYSTGRMnihg2ap6bVvC/lN0U0pIsxvmG4L+QXGqREW3md+8+/bQo3Y06AMtbZOzMSY9tm7OupEymSM1ZyI7YKn/VqINUXTgpgct5Tf5f6ldFOKs0d+U/bznDcp+S1NSzU49RW81FelWqnBKXW7m+bE4iJWumjN9w0xTOwFKAXL/JY8/5T8phTp2H1H8pJFfj3PP2Rbj7pUOr8ef0i0WpcmWvGSR367aU4Au0mxN4keZp5I/evGs7jvxarYxeyf40OBFtsdo/RfN/P96SW7fdYo7aWYOTCSl6xqsAct1KUumhNPI1sUnpBjjBSrNXtyZ5nf0OJTOjctN9dWx4ildO5CvWGZm9LzJpQR6tLESLF20ZxY0srAWRDzCf7SeI5Hy9R68cxxXnuPOVLz1zIt1ODSjfGINZjNSSSt/9XpDQt3HbD5C4c5q4MeashIr/6FwuaEDAEvKITkhXOMWMLmJJIeXr0YieXdKMkJzEs4zNk6zEtb1H4NY3PSIFYvx3m+v1r7xCBh7L0weXqJF8++8PRS6Ro8Il00J5YmDS1glgVvhAu2Z373UPpbDnPopb7wrEue3zpLpfYa4cGI17gumpMJqyTWPBmtzy3keK02CjG3bW71L5pWvGSR35BjjDRvrIjJL2twODV7yboGh9BVc5JKaAItJ2TK+hcxhO5vYdLYtR1aLO6hN2ry9FKqZuy8SfFw7I2wvGK10Az1UosNNmvwNqPV4G6ak1STWqzamKIbQmrxSbnDoVfnXnJcvfJrFauHZgtvI3nGWlrTw8Oteok1+Gy8xrWb5gSIT2LKYM81Y3U9Fj9L0YzJl0WsLeU3FY9YW8jvfJ/WYvV6r7+FGuGRXyvdVvJr0fyVHFdR1eCdvJHzolfcuf383CzHvntv1a3HaFrrnnWslGXQzzqWR6w15jd0273H8YrVY96Uyu/8WLXnN1XXO78Aa3DodqGardfgJ27GJVW9sHy8y+YE8PuwnMfXcxlrXl3mtx5dxppX01KX+a1Ht+ZYh2tO5mwlM+d7mx6aW7oemrl1a8pvbl3G2p+mly5jZQ2uTXPo5oQQQggh9bHVnHT1gVhCCCGEtA+bE0IIIYRUBZsTQgghhFQFmxNCCCGEVAWbE0IIIYRUBZsTQgghhFQFmxNCCCGEVMU57xPIzVl3s2vhBjUWml66vcXK/PrpMta8mjl1mV8/3ZZj7fYmbGuJu+HeO1YXLqr51r6xmrljrel2zR6xenlppFjXYH7b0a0p1i1ajrWXGjzUHWK9F9iqcSGmuW6Li06FaM51e4+VXkrT7T3WlvKbqttSrPTSkwzTnIQYZSJ18GI057qxhkmJtaRmqm5oY2KhOdell87WjNWll/LqthRri16K1aWX/iJD3L4+dtBCt7fQnO8T8vJcqq6HZqru8hglNFPyG+unVr0UA72UX3fav4VYW/QSa3BezW6ak5RBm++XMnApuiF4xppSRFqJNVVzeZxSeMRKL+XVjCXVe/TS2bQaawxesWZrTkTkR0XkURF54PBz08Z2rxORz4rIZREpm/UFoUm0LDyhA5eqGbq/5YW29lgt8PRSKPRSuf1TNOml04zkJYtYW/JS7ldO7lTV6w4/9y2fFJGnAPhpAK8HcA2AN4nINbFiHgm0IOS8rf8aDzmeRX5HitWDkfI7UqwejJTfkWL1IOa8vd/WuR7AZVV9WFX/DMB7AdwSehBLs5R8r3RJ6bcB9uJ5Xq29HD6HXhobeikOzwtwrfNmRC/lbk7eKiKfEJF3i8izV55/EYAvzP7/yOExcgZWZmERIFbs9VKOcd97zFb/6iTr9PBHEz25TVJzIiIfFpGHVn5uAfAzAF4C4DoAjwH4x4lat4nIRRG5iMdTjmQDL65twSKwDvMSDnO2DvPSFrVfw5JuX6+qN+7ZTkR+FsCvrTz1KICrZ/+/6vDYmtbdAO4GTu5zEnamZHTW7l5ICLHjI9/1TjYoxIyc39Z5wey/3wPgoZXNfgfAeRF5sYg8DcCtAO7JdU6W5Fyz4BhWF1rPC7Zn/siTsGkLhzmrA9bgNGqvwTk/c/KPROSTIvIJAN8B4H8CABF5oYjcBwCq+jUAbwXwQQCfBvALqvqpjOd0FJrlND0UAQ9G8tLeWHOc195jlh4Pzps4Rpo3exnRS9maE1X926r6V1X1W1T1Dar62OHxP1DVm2bb3aeqf1lVX6Kq74jRan3gQo5hHWvI8UrHas2eWOmlMozgpYkRYh3JS6zB8YTE6v1VYlNSkx669kDLE7IFg07becRqlZ+RvFTrX52Ar5esKO0lj3nDGlyGFmpwN82JVRJjSNGMKexWEzJG0yLWkqTk1yNWLy+VHBvL/Ja8ONFLZ8MaHE4rXkohdq5205wAaYMXm0APzeX+pfZrNb8xtBprStHsPVZ6Ka/m2jFK6LIGh2m2kl9Rbe9buXJe9Io7158LXdo5danupe7er9JZFADGelzTSrdWzblu7/md6zLWMM29usxvnOZeXcZ6miduxiVVvbB8vLvmZOJYIpddoMXLdMub2ix1c2gudY/FmkNzTdcjv0tdj/xa6TJWX82lbs/5Xer2HCtrcF7Npe4ezeGak4ljd8HL8Z51jZpeur1oeunWqOmly1jb0/TSrVHTS7d2zWGbE0IIIYTUyVZz0tUHYgkhhBDSPmxOCCGEEFIVbE4IIYQQUhVsTgghhBBSFWxOCCGEEFIVbE4IIYQQUhVsTgghhBBSFee8T6AU85vGlFwszEN3FE0vXcZaTtNLt2dNL13G2p9mTt2ub8Lmcce+PZpeuow1r6a1LvNbh24PsTK/degy1tMMdYfYvQsUWa93sEfXQzO37tbxrDtqj1j3rCVhrbnU3aNpoVuDl2rKr7UuvXS2LuuSvW4L82aY5iR05UTAdsXGUM0U3VDNuW6qZsgxpn1K5hewjZVe2tb1yK+Fbiux0kthuqF1KUWXXjqueUx3iOYkxigTKYPnoesda+z5Mr/16bYWK/Nbr653rKxL9pq5dYdZWycmefP99r6HN5EyaLGkaqbGGmPuaZ/S+U0ZF3rpOB6xeuU3VjcF71hL7jtiXaKXtummObEY5NAkWlxMPEwag8VbM7GFwOJiHaLp4aXU/eb7lvZSS/OmZOMH2MZaar85tc8bz7pUmtbnTahmN80JYFd4ai7uVn9dt9AUWZ1byl/nqeyNYaRYPRgpvyPF6oFnDfZqrlOJOe8umhNPI5c2iycWn/Yu+f37JXt8YumlUG9Yeql0rKFYxOo59+il8G1y0XpdKk3t82aii+bEklYGzoK9sbZ+ESP58fTS3mPSS23QQg1u9RWMGLzGg81JJCOaxZKaX7YdiR68VBrmrA56qCEtNGJesDkhhBBCSFWwOYlkpPcoSb8s7wxKjsOckR6o/RrG5qRBrIrj3uPkMPHeY/JC0Ab0ErFiJC/Rk9t00ZxYmjTULJbmqr2TtaD2T/XTS2WwiLX2wj6Sl2r/Fl7rjOSliS6akwmrJJaeaCHnPZ2bR6yli4DVOMTkil4Kp+aGyNpLIccr3URx3oQTUtvopXBizrub5sQiiaEJtCjuFgsypejuxeIuirF3c2xxQnp4aXmsUrQ0b1r2kkesrXhppLrU6rwJ1eymOZmITWLsoFn/9VlC06Mhii0AnrG25qWY/Vr0Uiz0Uriuh2ZsrCVf2W1x3rTkJaCzVYmB9pawttD1inWUpcm9ln7vPdYR5w29lFcz5Bit16UQ3ZrnzdaqxN01J8D+wbMYMG9db82zjmUx+beO13N+vXRr1vTSbV3TS7eGWEvVplHza6U7VHMysfdlPsuX1jw0vXRH0fTSZaz9aXrpMtb+NL10rTWHbE4m1pJZ4r2+pa6HppcuY+1P00uXsfan6aXLWPNqxugO3ZwQQgghpD62mpPuvq1DCCGEkLZhc0IIIYSQqmBzQgghhJCqYHNCCCGEkKpgc0IIIYSQqmBzQgghhJCqYHNCCCGEkKo4530CuTl2N7scN6rx0Dym66HppdtTrMyvr25PsTK/vro9xVpCs9ubsC2Tt1wHwHrNgVDNUroeml66pTSXx81xZ0bmd//zVrq9zhvm90l6njcesVpoDnWH2JDVE62alNCVIi1XHA3VtNLtPb9z3T3HsVpMbEQvha4k23KsXvMmxMNW86b3GjGqlyzzO0xzErOsM5BmVE/NUN1Uo46S37lu6P4pBd47Vo9xZX7z6Hrkd75/7zWCNdhGc4jb18cmcL7P3hUXPTXXjpFr+zmesZbWTCnQ0z6teMlCN1azZH4nWsxvrJdK59fTS6zB+3RbqUtZmhMReZ+IPHD4+byIPLCx3edF5JOH7S6maKYkMJUUzZjBS43VQzN235SiMdeMibXEqp5LWvPS8jghpOQ39S/dGFqaN6nENCieXmpt3ozkpdgGJUtzoqr/rapep6rXAfglAL98xubfcdj21Ms6oaQmPjSJqcUuBatYPQjNb4uxhhb3kbxkGWvosVr00kSol1prruf7c97kpYUanPVtHRERAH8LwM/n1GnZoKHHsI415HilY7UmJFaPwm5BK16yyG/IMVqfNx545jcE1uAwWqnBuT9z8tcBfFFVP7fxvAL4kIhcEpHbMp/LLloZuJK0XnhCsIw19AJsGWvpMWvhAtyyl0LP3bK5HslLrMGn8RqP6OZERD4sIg+t/Nwy2+xNOPtVk1ep6isAvB7AW0TkhjP0bhORiyJyEY/HnrUdPZiFRYC0fMHOecyzaKERGwHW4DRqr8HRd4hV1RvPel5EzgH4XgDfesYxHj38+yUReT+A6wF8ZGPbuwHcDZx8lTjytMmg3HDvHaduEEQIsYNNG7Ek59s6NwL4jKo+svakiDxDRJ45/Q7gNQAeyng+ZGDYmBCSF84xYknO5uRWLN7SEZEXish9h/8+H8BviciDAD4G4F5V/fWM52OK5wcmrYqAZzFp9QOnvVHaAznGvbSXeBGuA9bgNGqvwdmaE1X9flW9a/HYH6jqTYffH1bVlx9+rlXVd+Q6lxBoltP0UAT24vlBQstYecE+TcteCj13zw92p8IafJqRavBEF3eIbX3gQo5hHWvI8UrHak0rX41MoRUvWeTX86vhpeeNB6189Z41OIxWanAXzclEatJD1x5oeUKG7m8Za2h+S8dqQeiNsKxijWEEL0206KXYuuTRYLdcg0fw0kQLNbib5qTV4h6zGFNqrCkLQFnEGkJq8UnJb2uvnrTmpZT8ptwuv2SsnnUphZi7zFrF2lJdas1LLTTXE900J0Da4MUm0ENz7Ri5tp/jGWtpTYvFz1rxUqyuhZdKL8o4ERtryfym6Hrl1yJWD03W4Lo0AUBU27tliJwXveLO7edD1gNIXb56qRmq66FZUrfl/M519xxnfo4tx+rlpWPHYX7jNfcex2pdHu9Ya69LVrq15neue0zziZtxaW1tvS6bE+D0XwzzZC47QKv3Ldf+SvHQrU3TSzeX5vy4Zz1nqQnUN64l8rvneSvd2vKbU9fDw6zBfppeuns0h2tOJs56WTPXB1qPvZTqoctY29T00q1N00u3J00v3do0vXQZ6zrDNieEEEIIqZOt5qSrD8QSQgghpH3YnBBCCCGkKticEEIIIaQq2JwQQgghpCrYnBBCCCGkKticEEIIIaQq2JwQQgghpCrOeZ9ACdZuFlNiRWEP3VE0vXQZa/lYmd/2dRlrf5q5dbu+CdveRa8sB7FmTS/d1jW9dBlrf5peuoy1Dk0v3Zo1h7pD7N4FiqwWRFrqllp0aq55TNdD00u3dc25LvPrq+sdq6WXjumOmN+Sut6x1uqlYZqTkNUaJ1IHL3S1Rmvd2mO1mJSesdaeX0vd2mMd0Uteui1qhuiOmF8v3bM0h7h9fUzy5tuHvDR31nFK6HrEOtcM0Q3d/izdEFrL79pxSuh65zfWSy3GGqMZS4uxpswbeum4ZiwesXbTnMQmbyI2iVa6HpqpF9AYvPIbEyu9tF/Tw0uh0Evhuh6asbGWhF7Kr9tNc2JBaPJTB23tWHtJ1fSINdakFvkNwaLYteSlVOilbSy95BErvXR8v1TdvbTupVC6ak6sEljzhLQ+t5DjtVjYgbjzHslLHrFaaHrMm5jiznkTTgvzxgp6aZ0umhNLs5R+L29OCy+Np+LRgU/syS+9RKwYyUuefvOsKaUYyUsTXTQno2Fllr3HyVF49h5zhMLTA/QSsWIkL9GT27A5iYR/mZIeYHEMhzkjPVD7NYzNCSGEEEKqgs1JJCXWLdhifkOdVvHMH3mSHrxUGuasDnqoIZ5eqj1/bE4WjGSWvbGyESPH8PTS3mPSS23QQg0ufY4j1uAumpMRB84Di1hrLzyWXgqN1TI3pWMNhV4Kg17apnUvlab2eTPRRXMyYZX0Wl/BAJ48t9RYLReDyoXVucXkqrSXWo61JS9ZxZp7nzVG8NLESF4KibXVV2xizrub5sQiiaEJtDBpC4Ud8I3VYkKGaFrGWmq/+b4xsZak9XlDL63DGpyXkWow0FFzMpE6kUMTmGIYD00vXe9YS+IVawr00n7dktBLx2nZSyPFGoqoatSOnsh50SvuXH8uZenslM459FbgNS9hvUczRLf1/MboMtYw3RY0U3Rby2+K7oixsgZvax7TfeJmXFLVC8vHu2tOgNM3l9lKpoU5t3Rr0vTS9da00KWX6tBlrOU0LXQ5b+rQ9dbcoztUczKx5w541u8z7r3rnocuY21L00u3Vk0v3R40vXRr1fTSZaynGbI5WTIltOQHnzw1vXR71/TSZaz9aXrpMtYyml66LWmyOSGEEEJIVWw1J919W4cQQgghbcPmhBBCCCFVweaEEEIIIVXB5oQQQgghVcHmhBBCCCFVweaEEEIIIVXB5oQQQgghVXHO+wRyUuudGHu5++MeXcban6aXLmPtT9NLl7Hm1bTQ7fYmbMfWALBeS2KpuUfXQzOHbs/5Xeoy1vJeWuoyv/Gae3QZa17NHLot53eYO8S2tmKjheZeXatJOUqs9NJxTStdxrqtW+NKsns09+r2kN+9uj3EylWJz2CrOYm5mEykDF7Mstleml66nppeur1reuky1vo1vXRb0PTSrbUGD3X7+hizTPvsXeVxIsWgsZrL/Uvt5xGrhWYMrcYa66VYWoo1RTOF1mK18NIosbIG79OMIak5EZHvE5FPicgTInJh8dwPi8hlEfmsiLx2Y/8Xi8hHD9u9T0SeFnsuFoWntNHm+4YYxuoCFKPpkd8UUvI7kpdKjo1lfks2Y/TS2Xg1f6marMH59pvvG5qz1FdOHgLwvQA+Mn9QRK4BcCuAawG8DsA/E5GnrOz/4wDuVNWXAvgjAD+YcjJWk2JvEkv/lTonNVavv7RDNK2KXemOf05pL3nE6umlvdBL4bTgJc/65eElK1rwUlJzoqqfVtXPrjx1C4D3quqfqup/AHAZwPXzDUREAHwngF88PPQeAN8dcx4tNwmhxxgpVmv25K71/IbQeqy1e8mS2mOll+IJyd1Iseb6zMmLAHxh9v9HDo/NeS6A/6SqXztjmz9HRG4TkYsichGPm57rX6CVgbNgb6ytFx4v6KXT5Divvcdk89cGLcwbeik/R5sTEfmwiDy08nNLiROcUNW7VfWCql7AlSWV1xnRLJbU/BbASPTgpdIwZ3XQQw1poRHz4ugdYlX1xojjPgrg6tn/rzo8NufLAJ4lIucOr56sbUOICTfce8epmxIRQuxg00YsyfW2zj0AbhWRp4vIiwGcB/Cx+QZ6coOV3wTwxsNDbwbwq5nOx5wctwQm+WBjsg7zEg5ztg7z0ha1X8NSv0r8PSLyCIBvA3CviHwQAFT1UwB+AcDvAvh1AG9R1f/vsM99IvLCwyH+NwB/X0Qu4+QzKO9KOZ9RsCoCnsWk9olBwtjrpRzjvveYvHj2hWcN6aEG107qt3Xer6pXqerTVfX5qvra2XPvUNWXqOrLVPUDs8dvUtU/OPz+sKper6ovVdXvU9U/jTkPS5OGmsXSXLVesHsoAnuhl4gV9FIc/KPpNCN6qas7xLbahYact/XkCTmeRX49Yo25bTO9FM4IXoo53khesoqVXlpnBC9NdNWcpBJ6EbOckKGGT9UM3d9iQsau7dDihKSXtrEs7iPE6uml0sTml/MmTLMFL3XTnKQm0WLVxhTdEDxj9XqbpWSs9FK4ZmkvjRRrDJw34boh0Ev7iY21m+YEiE9iymCnDFyKQVNjLamZqrs8RglNby+1FGtLXmop1rkPOG/sNef79O6lVN3lMUpoysk3ettCzotecef28yHLdu9Z0nkPHppz3T33GLD6y6T2WHNoltT1zm+Ibov5nevWnt9UXe/8hui2mN+5bu81OJfmEzfjkqpeWD7eZXMChN39zvJlRA/d2mNlftvRrT1W5rcd3dpjZX7r0B2uOZmzlcyc723WpOml25uml25Nml66jLVdTS/dmjS9dFvQHLo5IYQQQkh9bDUnXX0glhBCCCHtw+aEEEIIIVXB5oQQQgghVdHmZ05E/i8Av59wiOcB+I9Gp1M7o8TKOPtjlFgZZ3+MEqtFnN+oql+3fLDJ5iQVEbm49gGcHhklVsbZH6PEyjj7Y5RYc8bJt3UIIYQQUhVsTgghhBBSFaM2J3d7n0BBRomVcfbHKLEyzv4YJdZscQ75mRNCCCGE1Muor5wQQgghpFK6bU5E5PtE5FMi8oSIXFg898MicllEPisir93Y/8Ui8tHDdu8TkaeVOfM0Duf6wOHn8yLywMZ2nxeRTx62u1j4NJMRkR8VkUdnsd60sd3rDuN8WUSOLxtaGSLyEyLyGRH5hIi8X0SetbFdk+N5bHxE5OkHT18+zMdvcjjNZETkahH5TRH53UNd+nsr23y7iDw+8/TbPM41lWNelBN+8jCmnxCRV3icZyoi8rLZWD0gIl8VkR9abNPkmIrIu0XkSyLy0Oyx54jI/SLyucO/z97Y982HbT4nIm+OPglV7fIHwH8J4GUA/g8AF2aPXwPgQQBPB/BiAL8H4Ckr+/8CgFsPv98F4H/0jikiB/8YwNs2nvs8gOd5n2NCbD8K4H85ss1TDuP7zQCedhj3a7zPPTDO1wA4d/j9xwH8eC/juWd8APxdAHcdfr8VwPu8zzsy1hcAeMXh92cC+PcrsX47gF/zPleDWM/0IoCbAHwAgAB4JYCPep+zQcxPAfCHOLlnR/NjCuAGAK8A8NDssX8E4I7D73es1SIAzwHw8OHfZx9+f3bMOXT7yomqflpVP7vy1C0A3quqf6qq/wHAZQDXzzcQEQHwnQB+8fDQewB8d8bTNecQw98C8PPe5+LI9QAuq+rDqvpnAN6Lk/FvBlX9kKp+7fDf3wZwlef5GLNnfG7ByfwDTubjqw/ebgpVfUxVP374/T8D+DSAF/melRu3APhXesJvA3iWiLzA+6QSeTWA31PVlJuDVoOqfgTAVxYPz+fi1jXxtQDuV9WvqOofAbgfwOtizqHb5uQMXgTgC7P/P4LTReK5AP7T7KKwtk3t/HUAX1TVz208rwA+JCKXROS2gudlyVsPLwu/e+Mlxj1j3RI/gJO/ONdocTz3jM+fb3OYj4/jZH42y+Gtqb8G4KMrT3+biDwoIh8QkWvLnpkZx7zY27wETl7V2/pDsIcxBYDnq+pjh9//EMDzV7YxG9tzMTvVgoh8GMA3rDz1I6r6q6XPpxQ7434Tzn7V5FWq+qiIfD2A+0XkM4duuRrOihPAzwD4MZwUwh/DyVtYP1Du7OzYM54i8iMAvgbg5zYOU/14EkBE/hKAXwLwQ6r61cXTH8fJ2wJ/fPgM1a8AOF/4FC0YyouHzyO+AcAPrzzdy5j+BVRVRSTrV32bbk5U9caI3R4FcPXs/1cdHpvzZZy81Hju8Nfa2jZuHItbRM4B+F4A33rGMR49/PslEXk/Tl5ir6qA7B1fEflZAL+28tSesXZnx3h+P4C/CeDVenhjd+UY1Y/nCnvGZ9rmkYOvr8TJ/GwOEXkqThqTn1PVX14+P29WVPU+EflnIvI8VW1qjZYdXmxiXgbwegAfV9UvLp/oZUwPfFFEXqCqjx3ehvvSyjaP4uRzNhNX4eRzn8GM+LbOPQBuPXwL4MU46WI/Nt/gcAH4TQBvPDz0ZgAtvRJzI4DPqOoja0+KyDNE5JnT7zj50OVDa9vWyuI96u/B+vn/DoDzcvLNq6fh5KXXe0qcnxUi8joA/wDAG1T1Tza2aXU894zPPTiZf8DJfPw3Ww1azRw+J/MuAJ9W1X+ysc03TJ+nEZHrcVKfm2rEdnrxHgB/5/CtnVcCeHz2dkGLbL5K3cOYzpjPxa1r4gcBvEZEnn14q/01h8fC8f5UcK4fnFywHgHwpwC+COCDs+d+BCffEvgsgNfPHr8PwAsPv38zTpqWywD+NYCne8cUEPu/BHD74rEXArhvFtuDh59P4eTtA/fzDozxfwfwSQCfOEyaFyzjPPz/Jpx8M+L3Go3zMk7ew33g8DN9c6WL8VwbHwBvx0kzBgD/xWH+XT7Mx2/2PufIOF+Fk7cgPzEby5sA3D7NVQBvPYzfgzj58PN/7X3eEXGuenERpwD46cOYfxKzb1O29gPgGThpNq6cPdb8mOKk2XoMwP97uI7+IE4+6/UbAD4H4MMAnnPY9gKAfz7b9wcO8/UygP8+9hx4h1hCCCGEVMWIb+sQQgghpGLYnBBCCCGkKticEEIIIaQq2JwQQgghpCrYnBBCCCGkKticEEIIIaQq2JwQQgghpCrYnBBCCCGkKv5/LHujzNbPzt0AAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 645.161x662.252 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "root_universe.plot(origin=(0., 0., 0.), width=(21.42, 21.42), pixels=(500, 500), color_by='material')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Looks good!\n",
    "\n",
    "We now must create a geometry that is assigned a root universe and export it to XML."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create Geometry and set root universe\n",
    "model.geometry = openmc.Geometry(root_universe)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With the geometry and materials finished, we now just need to define simulation parameters."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "# OpenMC simulation parameters\n",
    "batches = 600\n",
    "inactive = 50\n",
    "particles = 3000\n",
    "\n",
    "# Instantiate a Settings object\n",
    "settings = openmc.Settings()\n",
    "settings.batches = batches\n",
    "settings.inactive = inactive\n",
    "settings.particles = particles\n",
    "settings.output = {'tallies': False}\n",
    "settings.run_mode = 'eigenvalue'\n",
    "settings.verbosity = 4\n",
    "\n",
    "# Create an initial uniform spatial source distribution over fissionable zones\n",
    "bounds = [-10.71, -10.71, -10, 10.71, 10.71, 10.]\n",
    "uniform_dist = openmc.stats.Box(bounds[:3], bounds[3:], only_fissionable=True)\n",
    "settings.source = openmc.IndependentSource(space=uniform_dist)\n",
    "\n",
    "model.settings = settings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Create an MGXS Library\n",
    "\n",
    "Now we are ready to generate multi-group cross sections! First, let's define a 2-group structure using the built-in EnergyGroups class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Instantiate a 2-group EnergyGroups object\n",
    "groups = openmc.mgxs.EnergyGroups([0., 0.625, 20.0e6])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, we will instantiate an openmc.mgxs.Library for the energy groups with our the fuel assembly geometry."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Initialize a 2-group MGXS Library for OpenMC\n",
    "mgxs_lib = openmc.mgxs.Library(model.geometry)\n",
    "mgxs_lib.energy_groups = groups"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, we must specify to the Library which types of cross sections to compute. OpenMC's multi-group mode can accept isotropic flux-weighted cross sections or angle-dependent cross sections, as well as supporting anisotropic scattering represented by either Legendre polynomials, histogram, or tabular angular distributions.  We will create the following multi-group cross sections needed to run an OpenMC simulation to verify the accuracy of our cross sections: \"total\", \"absorption\", \"nu-fission\", '\"fission\", \"nu-scatter matrix\", \"multiplicity matrix\", and \"chi\".\n",
    "\n",
    "The \"multiplicity matrix\" type is a relatively rare cross section type.  This data is needed to provide OpenMC's multi-group mode with additional information needed to accurately treat scattering multiplication (i.e., (n,xn) reactions)), including how this multiplication varies depending on both incoming and outgoing neutron energies."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Specify multi-group cross section types to compute\n",
    "mgxs_lib.mgxs_types = ['total', 'absorption', 'nu-fission', 'fission',\n",
    "                       'nu-scatter matrix', 'multiplicity matrix', 'chi']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we must specify the type of domain over which we would like the `Library` to compute multi-group cross sections. The domain type corresponds to the type of tally filter to be used in the tallies created to compute multi-group cross sections. At the present time, the `Library` supports \"material\", \"cell\", \"universe\", and \"mesh\" domain types. In this simple example, we wish to compute multi-group cross sections only for each material and therefore will use a \"material\" domain type.\n",
    "\n",
    "**NOTE:** By default, the `Library` class will instantiate `MGXS` objects for each and every domain (material, cell, universe, or mesh) in the geometry of interest. However, one may specify a subset of these domains to the `Library.domains` property."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Specify a \"cell\" domain type for the cross section tally filters\n",
    "mgxs_lib.domain_type = \"material\"\n",
    "\n",
    "# Specify the cell domains over which to compute multi-group cross sections\n",
    "mgxs_lib.domains = model.geometry.get_all_materials().values()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will instruct the library to not compute cross sections on a nuclide-by-nuclide basis, and instead to focus on generating material-specific macroscopic cross sections.\n",
    "\n",
    "**NOTE:** The default value of the `by_nuclide` parameter is `False`, so the following step is not necessary but is included for illustrative purposes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Do not compute cross sections on a nuclide-by-nuclide basis\n",
    "mgxs_lib.by_nuclide = False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we will set the scattering order that we wish to use.  For this problem we will use P3 scattering.  A warning is expected telling us that the default behavior (a P0 correction on the scattering data) is over-ridden by our choice of using a Legendre expansion to treat anisotropic scattering."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/pshriwise/.pyenv/versions/3.9.1/lib/python3.9/site-packages/openmc/mgxs/library.py:418: RuntimeWarning: The P0 correction will be ignored since the scattering order 3 is greater than zero\n",
      "  warn(msg, RuntimeWarning)\n"
     ]
    }
   ],
   "source": [
    "# Set the Legendre order to 3 for P3 scattering\n",
    "mgxs_lib.legendre_order = 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now that the `Library` has been setup let's verify that it contains the types of cross sections which meet the needs of OpenMC's multi-group solver.  Note that this step is done automatically when writing the Multi-Group Library file later in the process (as part of `mgxs_lib.write_mg_library()`), but it is a good practice to also run this before spending all the time running OpenMC to generate the cross sections.\n",
    "\n",
    "If no error is raised, then we have a good set of data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Check the library - if no errors are raised, then the library is satisfactory.\n",
    "mgxs_lib.check_library_for_openmc_mgxs()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Great, now we can use the `Library` to construct the tallies needed to compute all of the requested multi-group cross sections in each domain."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Construct all tallies needed for the multi-group cross section library\n",
    "mgxs_lib.build_library()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The tallies can now be exported to a \"tallies.xml\" input file for OpenMC.\n",
    "\n",
    "**NOTE:** At this point the `Library` has constructed nearly 100 distinct Tally objects. The overhead to tally in OpenMC scales as O(N) for N tallies, which can become a bottleneck for large tally datasets. To compensate for this, the Python API's `Tally`, `Filter` and `Tallies` classes allow for the smart merging of tallies when possible. The `Library` class supports this runtime optimization with the use of the optional `merge` parameter (`False` by default) for the `Library.add_to_tallies_file(...)` method, as shown below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a \"tallies.xml\" file for the MGXS Library\n",
    "tallies = openmc.Tallies()\n",
    "mgxs_lib.add_to_tallies_file(tallies, merge=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In addition, we instantiate a fission rate mesh tally that we will eventually use to compare with the corresponding multi-group results."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Instantiate a tally Mesh\n",
    "mesh = openmc.RegularMesh()\n",
    "mesh.dimension = [17, 17]\n",
    "mesh.lower_left = [-10.71, -10.71]\n",
    "mesh.upper_right = [+10.71, +10.71]\n",
    "\n",
    "# Instantiate tally Filter\n",
    "mesh_filter = openmc.MeshFilter(mesh)\n",
    "\n",
    "# Instantiate the Tally\n",
    "tally = openmc.Tally(name='mesh tally')\n",
    "tally.filters = [mesh_filter]\n",
    "tally.scores = ['fission']\n",
    "\n",
    "# Add tally to collection\n",
    "tallies.append(tally, merge=True)\n",
    "\n",
    "model.tallies = tallies"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Time to run the calculation and get our results!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "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=66.\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",
      "/home/pshriwise/.pyenv/versions/3.9.1/lib/python3.9/site-packages/openmc/mixin.py:70: IDWarning: Another Filter instance already exists with id=11.\n",
      "  warn(msg, IDWarning)\n"
     ]
    },
    {
     "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-05 19:18:08\n",
      "   MPI Processes | 1\n",
      "  OpenMP Threads | 2\n",
      "\n",
      " Minimum neutron data temperature: 294 K\n",
      " Maximum neutron data temperature: 294 K\n",
      "\n",
      " ====================>     K EIGENVALUE SIMULATION     <====================\n",
      "\n",
      "\n",
      " ============================>     RESULTS     <============================\n",
      "\n",
      " k-effective (Collision)     = 1.16510 +/- 0.00094\n",
      " k-effective (Track-length)  = 1.16422 +/- 0.00106\n",
      " k-effective (Absorption)    = 1.16519 +/- 0.00081\n",
      " Combined k-effective        = 1.16502 +/- 0.00071\n",
      " Leakage Fraction            = 0.00000 +/- 0.00000\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Run OpenMC\n",
    "statepoint_filename = model.run()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To make sure the results we need are available after running the multi-group calculation, we will now rename the statepoint and summary files."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Move the statepoint File\n",
    "ce_spfile = './statepoint_ce.h5'\n",
    "os.rename(statepoint_filename, ce_spfile)\n",
    "# Move the Summary file\n",
    "ce_sumfile = './summary_ce.h5'\n",
    "os.rename('summary.h5', ce_sumfile)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tally Data Processing\n",
    "\n",
    "Our simulation ran successfully and created statepoint and summary output files.  Let's begin by loading the StatePoint file."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load the statepoint file\n",
    "sp = openmc.StatePoint(ce_spfile, autolink=False)\n",
    "\n",
    "# Load the summary file in its new location\n",
    "su = openmc.Summary(ce_sumfile)\n",
    "sp.link_with_summary(su)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The statepoint is now ready to be analyzed by the `Library`. We simply have to load the tallies from the statepoint into the `Library` and our `MGXS` objects will compute the cross sections for us under-the-hood."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Initialize MGXS Library with OpenMC statepoint data\n",
    "mgxs_lib.load_from_statepoint(sp)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The next step will be to prepare the input for OpenMC to use our newly created multi-group data."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Multi-Group OpenMC Calculation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will now use the `Library` to produce a multi-group cross section data set for use by the OpenMC multi-group solver.  \n",
    "Note that since this simulation included so few histories, it is reasonable to expect some data has not had any scores, and thus we could see division by zero errors.  This will show up as a runtime warning in the following step. The `Library` class is designed to gracefully handle these scenarios."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a MGXS File which can then be written to disk\n",
    "mgxs_file = mgxs_lib.create_mg_library(xs_type='macro', xsdata_names=['fuel', 'zircaloy', 'water'])\n",
    "\n",
    "# Write the file to disk using the default filename of \"mgxs.h5\"\n",
    "mgxs_file.export_to_hdf5()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "OpenMC's multi-group mode uses the same input files as does the continuous-energy mode (materials, geometry, settings, plots, and tallies file).  Differences would include the use of a flag to tell the code to use multi-group transport, a location of the multi-group library file, and any changes needed in the materials.xml and geometry.xml files to re-define materials as necessary. The materials and geometry file changes could be necessary if materials or their nuclide/element/macroscopic constituents need to be renamed.\n",
    "\n",
    "In this example we have created macroscopic cross sections (by material), and thus we will need to change the material definitions accordingly.\n",
    "\n",
    "First we will create the new materials.xml file."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "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 Material instance already exists with id=1.\n",
      "  warn(msg, IDWarning)\n",
      "/home/pshriwise/.pyenv/versions/3.9.1/lib/python3.9/site-packages/openmc/mixin.py:70: IDWarning: Another Material instance already exists with id=2.\n",
      "  warn(msg, IDWarning)\n",
      "/home/pshriwise/.pyenv/versions/3.9.1/lib/python3.9/site-packages/openmc/mixin.py:70: IDWarning: Another Material instance already exists with id=3.\n",
      "  warn(msg, IDWarning)\n"
     ]
    }
   ],
   "source": [
    "# Re-define our materials to use the multi-group macroscopic data\n",
    "# instead of the continuous-energy data.\n",
    "\n",
    "# 1.6% enriched fuel UO2\n",
    "fuel_mg = openmc.Material(name='UO2', material_id=1)\n",
    "fuel_mg.add_macroscopic('fuel')\n",
    "\n",
    "# cladding\n",
    "zircaloy_mg = openmc.Material(name='Clad', material_id=2)\n",
    "zircaloy_mg.add_macroscopic('zircaloy')\n",
    "\n",
    "# moderator\n",
    "water_mg = openmc.Material(name='Water', material_id=3)\n",
    "water_mg.add_macroscopic('water')\n",
    "\n",
    "# Finally, instantiate our Materials object\n",
    "materials = openmc.Materials((fuel_mg, zircaloy_mg, water_mg))\n",
    "\n",
    "# Set the location of the cross sections file\n",
    "materials.cross_sections = 'mgxs.h5'\n",
    "\n",
    "# update the model with the multi-group materials\n",
    "model.materials = materials"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "No geometry file neeeds to be written as the continuous-energy file is correctly defined for the multi-group case as well."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, we can make the changes we need to the simulation parameters.\n",
    "These changes are limited to telling OpenMC to run a multi-group vice contrinuous-energy calculation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Set the energy mode\n",
    "model.settings.energy_mode = 'multi-group'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lets clear the tallies file so it doesn't include tallies for re-generating a multi-group library, but then put back in a tally for the fission mesh."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a \"tallies.xml\" file for the MGXS Library\n",
    "tallies = openmc.Tallies()\n",
    "\n",
    "# Add fission and flux mesh to tally for plotting using the same mesh we've already defined\n",
    "mesh_tally = openmc.Tally(name='mesh tally')\n",
    "mesh_tally.filters = [openmc.MeshFilter(mesh)]\n",
    "mesh_tally.scores = ['fission']\n",
    "tallies.append(mesh_tally)\n",
    "\n",
    "# update the model with new tallies\n",
    "model.tallies = tallies"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "Before running the calculation let's visually compare a subset of the newly-generated multi-group cross section data to the continuous-energy data. We will do this using the cross section plotting functionality built-in to the OpenMC Python API."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# First lets plot the fuel data\n",
    "# We will first add the continuous-energy data\n",
    "fig = openmc.plot_xs(reactions={fuel: ['total']})\n",
    "\n",
    "# We will now add in the corresponding multi-group data and show the result\n",
    "openmc.plot_xs(reactions={fuel_mg: ['total']}, plot_CE=False, mg_cross_sections='mgxs.h5', axis=fig.axes[0])\n",
    "fig.axes[0].legend().set_visible(False)\n",
    "plt.show()\n",
    "plt.close()\n",
    "\n",
    "# Then repeat for the zircaloy data\n",
    "fig = openmc.plot_xs(reactions={zircaloy: ['total']})\n",
    "openmc.plot_xs(reactions={zircaloy_mg: ['total']}, plot_CE=False, mg_cross_sections='mgxs.h5', axis=fig.axes[0])\n",
    "fig.axes[0].legend().set_visible(False)\n",
    "plt.show()\n",
    "plt.close()\n",
    "\n",
    "# And finally repeat for the water data\n",
    "fig = openmc.plot_xs(reactions={water: ['total']})\n",
    "openmc.plot_xs(reactions={water_mg: ['total']}, plot_CE=False, mg_cross_sections='mgxs.h5', axis=fig.axes[0])\n",
    "fig.axes[0].legend().set_visible(False)\n",
    "plt.show()\n",
    "plt.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "At this point, the problem is set up and we can run the multi-group calculation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "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-05 19:19:43\n",
      "   MPI Processes | 1\n",
      "  OpenMP Threads | 2\n",
      "\n",
      "\n",
      " ====================>     K EIGENVALUE SIMULATION     <====================\n",
      "\n",
      "\n",
      " ============================>     RESULTS     <============================\n",
      "\n",
      " k-effective (Collision)     = 1.16358 +/- 0.00095\n",
      " k-effective (Track-length)  = 1.16410 +/- 0.00106\n",
      " k-effective (Absorption)    = 1.16385 +/- 0.00050\n",
      " Combined k-effective        = 1.16392 +/- 0.00049\n",
      " Leakage Fraction            = 0.00000 +/- 0.00000\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Run the Multi-Group OpenMC Simulation\n",
    "statepoint_filename = model.run()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Results Comparison\n",
    "Now we can compare the multi-group and continuous-energy results.\n",
    "\n",
    "We will begin by loading the multi-group statepoint file we just finished writing and extracting the calculated keff."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Move the StatePoint File\n",
    "mg_spfile = './statepoint_mg.h5'\n",
    "os.rename(statepoint_filename, mg_spfile)\n",
    "# Move the Summary file\n",
    "mg_sumfile = './summary_mg.h5'\n",
    "os.rename('summary.h5', mg_sumfile)\n",
    "\n",
    "# Rename and then load the last statepoint file and keff value\n",
    "mgsp = openmc.StatePoint(mg_spfile, autolink=False)\n",
    "\n",
    "# Load the summary file in its new location\n",
    "mgsu = openmc.Summary(mg_sumfile)\n",
    "mgsp.link_with_summary(mgsu)\n",
    "\n",
    "# Get keff\n",
    "mg_keff = mgsp.keff"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, we can load the continuous-energy eigenvalue for comparison."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "ce_keff = sp.keff"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lets compare the two eigenvalues, including their bias"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Continuous-Energy keff = 1.165017+/-0.000706\n",
      "Multi-Group keff = 1.163921+/-0.000495\n",
      "bias [pcm]: 109.6\n"
     ]
    }
   ],
   "source": [
    "bias = 1.0E5 * (ce_keff - mg_keff)\n",
    "\n",
    "print('Continuous-Energy keff = {0:1.6f}'.format(ce_keff))\n",
    "print('Multi-Group keff = {0:1.6f}'.format(mg_keff))\n",
    "print('bias [pcm]: {0:1.1f}'.format(bias.nominal_value))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This shows a small but nontrivial pcm bias between the two methods.  Some degree of mismatch is expected simply to the very few histories being used in these example problems.  An additional mismatch is always inherent in the practical application of multi-group theory due to the high degree of approximations inherent in that method."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Pin Power Visualizations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next we will visualize the pin power results obtained from both the Continuous-Energy and Multi-Group OpenMC calculations.\n",
    "\n",
    "First, we extract volume-integrated fission rates from the Multi-Group calculation's mesh fission rate tally for each pin cell in the fuel assembly."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Get the OpenMC fission rate mesh tally data\n",
    "mg_mesh_tally = mgsp.get_tally(name='mesh tally')\n",
    "mg_fission_rates = mg_mesh_tally.get_values(scores=['fission'])\n",
    "\n",
    "# Reshape array to 2D for plotting\n",
    "mg_fission_rates.shape = (17,17)\n",
    "\n",
    "# Normalize to the average pin power\n",
    "mg_fission_rates /= np.mean(mg_fission_rates[mg_fission_rates > 0.])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can now do the same for the Continuous-Energy results."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Get the OpenMC fission rate mesh tally data\n",
    "ce_mesh_tally = sp.get_tally(name='mesh tally')\n",
    "ce_fission_rates = ce_mesh_tally.get_values(scores=['fission'])\n",
    "\n",
    "# Reshape array to 2D for plotting\n",
    "ce_fission_rates.shape = (17,17)\n",
    "\n",
    "# Normalize to the average pin power\n",
    "ce_fission_rates /= np.mean(ce_fission_rates[ce_fission_rates > 0.])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we can easily use Matplotlib to visualize the two fission rates side-by-side."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5, 1.0, 'Multi-Group Fission Rates')"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Force zeros to be NaNs so their values are not included when matplotlib calculates\n",
    "# the color scale\n",
    "ce_fission_rates[ce_fission_rates == 0.] = np.nan\n",
    "mg_fission_rates[mg_fission_rates == 0.] = np.nan\n",
    "\n",
    "# Plot the CE fission rates in the left subplot\n",
    "fig = plt.subplot(121)\n",
    "plt.imshow(ce_fission_rates, interpolation='none', cmap='jet')\n",
    "plt.title('Continuous-Energy Fission Rates')\n",
    "\n",
    "# Plot the MG fission rates in the right subplot\n",
    "fig2 = plt.subplot(122)\n",
    "plt.imshow(mg_fission_rates, interpolation='none', cmap='jet')\n",
    "plt.title('Multi-Group Fission Rates')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "These figures really indicate that more histories are probably necessary when trying to achieve a fully converged solution, but hey, this is good enough for our example!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Scattering Anisotropy Treatments\n",
    "\n",
    "We will next show how we can work with the scattering angular distributions. OpenMC's MG solver has the capability to use group-to-group angular distributions which are represented as any of the following: a truncated Legendre series of up to the 10th order, a histogram distribution, and a tabular distribution. Any combination of these representations can be used by OpenMC during the transport process, so long as all constituents of a given material use the same representation. This means it is possible to have water represented by a tabular distribution and fuel represented by a Legendre if so desired.\n",
    "\n",
    "*Note*: To have the highest runtime performance OpenMC natively converts Legendre series to a tabular distribution before the transport begins. This default functionality can be turned off with the `tabular_legendre` element of the `settings.xml` file (or for the Python API, the `openmc.Settings.tabular_legendre` attribute).\n",
    "\n",
    "This section will examine the following:\n",
    "- Re-run the MG-mode calculation with P0 scattering everywhere using the `openmc.Settings.max_order` attribute\n",
    "- Re-run the problem with only the water represented with P3 scattering and P0 scattering for the remaining materials using the Python API's ability to convert between formats."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "### Global P0 Scattering\n",
    "First we begin by re-running with P0 scattering (i.e., isotropic) everywhere. If a global maximum order is requested, the most effective way to do this is to use the  `max_order` attribute of our `openmc.Settings` object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Set the maximum scattering order to 0 (i.e., isotropic scattering)\n",
    "model.settings.max_order = 0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we can re-run OpenMC to obtain our results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "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-05 19:20:35\n",
      "   MPI Processes | 1\n",
      "  OpenMP Threads | 2\n",
      "\n",
      "\n",
      " ====================>     K EIGENVALUE SIMULATION     <====================\n",
      "\n",
      "\n",
      " ============================>     RESULTS     <============================\n",
      "\n",
      " k-effective (Collision)     = 1.16298 +/- 0.00091\n",
      " k-effective (Track-length)  = 1.16231 +/- 0.00103\n",
      " k-effective (Absorption)    = 1.16259 +/- 0.00052\n",
      " Combined k-effective        = 1.16248 +/- 0.00050\n",
      " Leakage Fraction            = 0.00000 +/- 0.00000\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Run the Multi-Group OpenMC Simulation\n",
    "statepoint_filename = model.run()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And then get the eigenvalue differences from the Continuous-Energy and P3 MG solution"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "P3 bias [pcm]: 109.6\n",
      "P0 bias [pcm]: 253.4\n"
     ]
    }
   ],
   "source": [
    "# Move the statepoint File\n",
    "mgp0_spfile = './statepoint_mg_p0.h5'\n",
    "os.rename(statepoint_filename, mgp0_spfile)\n",
    "# Move the Summary file\n",
    "mgp0_sumfile = './summary_mg_p0.h5'\n",
    "os.rename('summary.h5', mgp0_sumfile)\n",
    "\n",
    "# Load the last statepoint file and keff value\n",
    "mgsp_p0 = openmc.StatePoint(mgp0_spfile, autolink=False)\n",
    "\n",
    "# Get keff\n",
    "mg_p0_keff = mgsp_p0.keff\n",
    "\n",
    "bias_p0 = 1.0E5 * (ce_keff - mg_p0_keff)\n",
    "\n",
    "print('P3 bias [pcm]: {0:1.1f}'.format(bias.nominal_value))\n",
    "print('P0 bias [pcm]: {0:1.1f}'.format(bias_p0.nominal_value))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Mixed Scattering Representations\n",
    "OpenMC's Multi-Group mode also includes a feature where not every data in the library is required to have the same scattering treatment. For example,  we could represent the water with P3 scattering, and the fuel and cladding with P0 scattering. This series will show how this can be done.\n",
    "\n",
    "First we will convert the data to P0 scattering, unless its water, then we will leave that as P3 data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Convert the zircaloy and fuel data to P0 scattering\n",
    "for i, xsdata in enumerate(mgxs_file.xsdatas):\n",
    "    if xsdata.name != 'water':\n",
    "        mgxs_file.xsdatas[i] = xsdata.convert_scatter_format('legendre', 0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also use whatever scattering format that we want for the materials in the library. As an example, we will take this P0 data and convert zircaloy to a histogram anisotropic scattering format and the fuel to a tabular anisotropic scattering format"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Convert the formats as discussed\n",
    "for i, xsdata in enumerate(mgxs_file.xsdatas):\n",
    "    if xsdata.name == 'zircaloy':\n",
    "        mgxs_file.xsdatas[i] = xsdata.convert_scatter_format('histogram', 2)\n",
    "    elif xsdata.name == 'fuel':\n",
    "        mgxs_file.xsdatas[i] = xsdata.convert_scatter_format('tabular', 2)\n",
    "        \n",
    "mgxs_file.export_to_hdf5('mgxs.h5')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally we will re-set our `max_order` parameter of our `openmc.Settings` object to our maximum order so that OpenMC will use whatever scattering data is available in the library.\n",
    "\n",
    "After we do this we can re-run the simulation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 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-05 19:21:21\n",
      "   MPI Processes | 1\n",
      "  OpenMP Threads | 2\n",
      "\n",
      "\n",
      " ====================>     K EIGENVALUE SIMULATION     <====================\n",
      "\n",
      "\n",
      " ============================>     RESULTS     <============================\n",
      "\n",
      " k-effective (Collision)     = 1.16534 +/- 0.00089\n",
      " k-effective (Track-length)  = 1.16469 +/- 0.00103\n",
      " k-effective (Absorption)    = 1.16419 +/- 0.00053\n",
      " Combined k-effective        = 1.16417 +/- 0.00051\n",
      " Leakage Fraction            = 0.00000 +/- 0.00000\n",
      "\n"
     ]
    }
   ],
   "source": [
    "model.settings.max_order = None\n",
    "\n",
    "# Run the Multi-Group OpenMC Simulation\n",
    "statepoint_filename = model.run()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For a final step we can again obtain the eigenvalue differences from this case and compare with the same from the P3 MG solution"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "P3 bias [pcm]: 109.6\n",
      "Mixed Scattering bias [pcm]: 84.2\n"
     ]
    }
   ],
   "source": [
    "# Load the last statepoint file and keff value\n",
    "mgsp_mixed = openmc.StatePoint(statepoint_filename)\n",
    "\n",
    "mg_mixed_keff = mgsp_mixed.keff\n",
    "bias_mixed = 1.0E5 * (ce_keff - mg_mixed_keff)\n",
    "\n",
    "print('P3 bias [pcm]: {0:1.1f}'.format(bias.nominal_value))\n",
    "print('Mixed Scattering bias [pcm]: {0:1.1f}'.format(bias_mixed.nominal_value))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "Our tests in this section showed the flexibility of data formatting within OpenMC's multi-group mode: every material can be represented with its own format with the approximations that make the most sense. Now, as you'll see above, the runtimes from our P3, P0, and mixed cases are not significantly different and therefore this might not be a useful strategy for multi-group Monte Carlo.  However, this capability provides a useful benchmark for the accuracy hit one may expect due to these scattering approximations before implementing this generality in a deterministic solver where the runtime savings are more significant.\n",
    "\n",
    "**NOTE**: The biases obtained above with P3, P0, and mixed representations do not necessarily reflect the inherent accuracies of the options. These cases were *not* run with a sufficient number of histories to truly differentiate methods improvement from statistical noise."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Close all StatePoint files as a matter of best practice\n",
    "sp.close()\n",
    "mgsp_p0.close()\n",
    "mgsp.close()\n",
    "mgsp_mixed.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
}