OpenMC/examples/jupyter/nuclear-data.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this notebook, we will go through the salient features of the `openmc.data` package in the Python API. This package enables inspection, analysis, and conversion of nuclear data from ACE files. Most importantly, the package provides a mean to generate HDF5 nuclear data libraries that are used by the transport solver."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import os\n",
    "from pprint import pprint\n",
    "import shutil\n",
    "import subprocess\n",
    "import urllib.request\n",
    "\n",
    "import h5py\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.cm\n",
    "from matplotlib.patches import Rectangle\n",
    "\n",
    "import openmc.data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Physical Data\n",
    "\n",
    "Some very helpful physical data is available as part of `openmc.data`: atomic masses, natural abundances, and atomic weights."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "53.939608986"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "openmc.data.atomic_mass('Fe54')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.00015574"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "openmc.data.NATURAL_ABUNDANCE['H2']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "12.011115164862904"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "openmc.data.atomic_weight('C')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The IncidentNeutron class\n",
    "\n",
    "The most useful class within the `openmc.data` API is `IncidentNeutron`, which stores to continuous-energy incident neutron data. This class has factory methods `from_ace`, `from_endf`, and `from_hdf5` which take a data file on disk and parse it into a hierarchy of classes in memory. To demonstrate this feature, we will download an ACE file (which can be produced with [NJOY 2016](https://github.com/njoy/NJOY2016)) and then load it in using the `IncidentNeutron.from_ace` method. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "url = 'https://anl.box.com/shared/static/kxm7s57z3xgfbeq29h54n7q6js8rd11c.ace'\n",
    "filename, headers = urllib.request.urlretrieve(url, 'gd157.ace')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<IncidentNeutron: Gd157>"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Load ACE data into object\n",
    "gd157 = openmc.data.IncidentNeutron.from_ace('gd157.ace')\n",
    "gd157"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Cross sections"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "From Python, it's easy to explore (and modify) the nuclear data. Let's start off by reading the total cross section. Reactions are indexed using their \"MT\" number -- a unique identifier for each reaction defined by the ENDF-6 format. The MT number for the total cross section is 1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Reaction: MT=1 (n,total)>"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "total = gd157[1]\n",
    "total"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Cross sections for each reaction can be stored at multiple temperatures. To see what temperatures are available, we can look at the reaction's `xs` attribute."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'294K': <openmc.data.function.Tabulated1D at 0x7f60230c5320>}"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "total.xs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To find the cross section at a particular energy, 1 eV for example, simply get the cross section at the appropriate temperature and then call it as a function. Note that our nuclear data uses eV as the unit of energy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "142.64747"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "total.xs['294K'](1.0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `xs` attribute can also be called on an array of energies."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 142.64747   ,   38.6541761 ,  175.40019642])"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "total.xs['294K']([1.0, 2.0, 3.0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A quick way to plot cross sections is to use the `energy` attribute of `IncidentNeutron`. This gives an array of all the energy values used in cross section interpolation for each temperature present."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'294K': array([  1.00000000e-05,   1.03250000e-05,   1.06500000e-05, ...,\n",
       "          1.95000000e+07,   1.99000000e+07,   2.00000000e+07])}"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gd157.energy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.text.Text at 0x7f60205634a8>"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiYAAAGBCAYAAABSP3qNAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n6EREJK6UmEhBrbsu/OY
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f60225bc160>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "energies = gd157.energy['294K']\n",
    "total_xs = total.xs['294K'](energies)\n",
    "plt.loglog(energies, total_xs)\n",
    "plt.xlabel('Energy (eV)')\n",
    "plt.ylabel('Cross section (b)')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Reaction Data\n",
    "\n",
    "Most of the interesting data for an `IncidentNeutron` instance is contained within the `reactions` attribute, which is a dictionary mapping MT values to `Reaction` objects."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[<Reaction: MT=2 (n,elastic)>,\n",
      " <Reaction: MT=16 (n,2n)>,\n",
      " <Reaction: MT=17 (n,3n)>,\n",
      " <Reaction: MT=22 (n,na)>,\n",
      " <Reaction: MT=24 (n,2na)>,\n",
      " <Reaction: MT=28 (n,np)>,\n",
      " <Reaction: MT=41 (n,2np)>,\n",
      " <Reaction: MT=51 (n,n1)>,\n",
      " <Reaction: MT=52 (n,n2)>,\n",
      " <Reaction: MT=53 (n,n3)>]\n"
     ]
    }
   ],
   "source": [
    "pprint(list(gd157.reactions.values())[:10])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's suppose we want to look more closely at the (n,2n) reaction. This reaction has an energy threshold"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Threshold = 6400881.0 eV\n"
     ]
    }
   ],
   "source": [
    "n2n = gd157[16]\n",
    "print('Threshold = {} eV'.format(n2n.xs['294K'].x[0]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The (n,2n) cross section, like all basic cross sections, is represented by the `Tabulated1D` class. The energy and cross section values in the table can be directly accessed with the `x` and `y` attributes. Using the `x` and `y` has the nice benefit of automatically acounting for reaction thresholds."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'294K': <openmc.data.function.Tabulated1D at 0x7f60230f1128>}"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n2n.xs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(6400881.0, 20000000.0)"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiAAAAF5CAYAAACm4JG+AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nKELOPz/M6LruutiJJBV
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f60204240b8>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "xs = n2n.xs['294K']\n",
    "plt.plot(xs.x, xs.y)\n",
    "plt.xlabel('Energy (eV)')\n",
    "plt.ylabel('Cross section (b)')\n",
    "plt.xlim((xs.x[0], xs.x[-1]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To get information on the energy and angle distribution of the neutrons emitted in the reaction, we need to look at the `products` attribute."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<Product: neutron, emission=prompt, yield=polynomial>,\n",
       " <Product: photon, emission=prompt, yield=tabulated>]"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n2n.products"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<openmc.data.correlated.CorrelatedAngleEnergy at 0x7f6022803080>]"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "neutron = n2n.products[0]\n",
    "neutron.distribution"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We see that the neutrons emitted have a correlated angle-energy distribution. Let's look at the `energy_out` attribute to see what the outgoing energy distributions are."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<openmc.stats.univariate.Tabular at 0x7f60230f1208>,\n",
       " <openmc.stats.univariate.Tabular at 0x7f60230f12b0>,\n",
       " <openmc.stats.univariate.Tabular at 0x7f60230f1358>,\n",
       " <openmc.stats.univariate.Tabular at 0x7f60230f14a8>,\n",
       " <openmc.stats.univariate.Tabular at 0x7f60230f16a0>,\n",
       " <openmc.stats.univariate.Tabular at 0x7f60230f1908>,\n",
       " <openmc.stats.univariate.Tabular at 0x7f60230f1c18>,\n",
       " <openmc.stats.univariate.Tabular at 0x7f60230f1f98>,\n",
       " <openmc.stats.univariate.Tabular at 0x7f60228413c8>,\n",
       " <openmc.stats.univariate.Tabular at 0x7f6022841828>,\n",
       " <openmc.stats.univariate.Tabular at 0x7f60230d76d8>,\n",
       " <openmc.stats.univariate.Tabular at 0x7f6022841cc0>,\n",
       " <openmc.stats.univariate.Tabular at 0x7f6022849278>,\n",
       " <openmc.stats.univariate.Tabular at 0x7f6022849828>,\n",
       " <openmc.stats.univariate.Tabular at 0x7f6022849e48>,\n",
       " <openmc.stats.univariate.Tabular at 0x7f602284f4e0>,\n",
       " <openmc.stats.univariate.Tabular at 0x7f602284fba8>,\n",
       " <openmc.stats.univariate.Tabular at 0x7f60228562e8>,\n",
       " <openmc.stats.univariate.Tabular at 0x7f60228569e8>,\n",
       " <openmc.stats.univariate.Tabular at 0x7f602285c198>,\n",
       " <openmc.stats.univariate.Tabular at 0x7f602285c940>,\n",
       " <openmc.stats.univariate.Tabular at 0x7f6022864160>,\n",
       " <openmc.stats.univariate.Tabular at 0x7f6022864978>,\n",
       " <openmc.stats.univariate.Tabular at 0x7f602286a208>,\n",
       " <openmc.stats.univariate.Tabular at 0x7f602286aa90>,\n",
       " <openmc.stats.univariate.Tabular at 0x7f6022870390>,\n",
       " <openmc.stats.univariate.Tabular at 0x7f6022870ba8>,\n",
       " <openmc.stats.univariate.Tabular at 0x7f60228774a8>,\n",
       " <openmc.stats.univariate.Tabular at 0x7f6022877da0>,\n",
       " <openmc.stats.univariate.Tabular at 0x7f602287d710>]"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dist = neutron.distribution[0]\n",
    "dist.energy_out"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here we see we have a tabulated outgoing energy distribution for each incoming energy. Note that the same probability distribution classes that we could use to create a source definition are also used within the `openmc.data` package. Let's plot every fifth distribution to get an idea of what they look like."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAi4AAAF8CAYAAADo5DC+AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nHr9+/To7d+5k7NixmJm
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f60203a2748>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "for e_in, e_out_dist in zip(dist.energy[::5], dist.energy_out[::5]):\n",
    "    plt.semilogy(e_out_dist.x, e_out_dist.p, label='E={:.2f} MeV'.format(e_in/1e6))\n",
    "plt.ylim(ymax=1e-6)\n",
    "plt.legend()\n",
    "plt.xlabel('Outgoing energy (eV)')\n",
    "plt.ylabel('Probability/eV')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There is also `summed_reactions` attribute for cross sections (like total) which are built from summing up other cross sections."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[<Reaction: MT=1 (n,total)>, <Reaction: MT=27 (n,absorption)>]\n"
     ]
    }
   ],
   "source": [
    "pprint(list(gd157.summed_reactions.values()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that the cross sections for these reactions are represented by the `Sum` class rather than `Tabulated1D`. They do not support the `x` and `y` attributes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'294K': <openmc.data.function.Tabulated1D at 0x7f603c930198>}"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gd157[27].xs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Unresolved resonance probability tables\n",
    "\n",
    "We can also look at unresolved resonance probability tables which are stored in a `ProbabilityTables` object. In the following example, we'll create a plot showing what the total cross section probability tables look like as a function of incoming energy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.text.Text at 0x7f60202807f0>"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAikAAAGBCAYAAACjNCEAAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n+lyoWQHXa63zts3cvHk
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f6020421320>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plt.figure()\n",
    "ax = fig.add_subplot(111)\n",
    "cm = matplotlib.cm.Spectral_r\n",
    "\n",
    "# Determine size of probability tables\n",
    "urr = gd157.urr['294K']\n",
    "n_energy = urr.table.shape[0]\n",
    "n_band = urr.table.shape[2]\n",
    "\n",
    "for i in range(n_energy):\n",
    "    # Get bounds on energy\n",
    "    if i > 0:\n",
    "        e_left = urr.energy[i] - 0.5*(urr.energy[i] - urr.energy[i-1])\n",
    "    else:\n",
    "        e_left = urr.energy[i] - 0.5*(urr.energy[i+1] - urr.energy[i])\n",
    "\n",
    "    if i < n_energy - 1:\n",
    "        e_right = urr.energy[i] + 0.5*(urr.energy[i+1] - urr.energy[i])\n",
    "    else:\n",
    "        e_right = urr.energy[i] + 0.5*(urr.energy[i] - urr.energy[i-1])\n",
    "        \n",
    "    for j in range(n_band):\n",
    "        # Determine maximum probability for a single band\n",
    "        max_prob = np.diff(urr.table[i,0,:]).max()\n",
    "        \n",
    "        # Determine bottom of band\n",
    "        if j > 0:\n",
    "            xs_bottom = urr.table[i,1,j] - 0.5*(urr.table[i,1,j] - urr.table[i,1,j-1])\n",
    "            value = (urr.table[i,0,j] - urr.table[i,0,j-1])/max_prob\n",
    "        else:\n",
    "            xs_bottom = urr.table[i,1,j] - 0.5*(urr.table[i,1,j+1] - urr.table[i,1,j])\n",
    "            value = urr.table[i,0,j]/max_prob\n",
    "\n",
    "        # Determine top of band\n",
    "        if j < n_band - 1:\n",
    "            xs_top = urr.table[i,1,j] + 0.5*(urr.table[i,1,j+1] - urr.table[i,1,j])\n",
    "        else:\n",
    "            xs_top = urr.table[i,1,j] + 0.5*(urr.table[i,1,j] - urr.table[i,1,j-1])\n",
    "    \n",
    "        # Draw rectangle with appropriate color\n",
    "        ax.add_patch(Rectangle((e_left, xs_bottom), e_right - e_left, xs_top - xs_bottom,\n",
    "                     color=cm(value)))\n",
    "\n",
    "# Overlay total cross section\n",
    "ax.plot(gd157.energy['294K'], total.xs['294K'](gd157.energy['294K']), 'k')\n",
    "\n",
    "# Make plot pretty and labeled\n",
    "ax.set_xlim(1.0, 1.0e5)\n",
    "ax.set_ylim(1e-1, 1e4)\n",
    "ax.set_xscale('log')\n",
    "ax.set_yscale('log')\n",
    "ax.set_xlabel('Energy (eV)')\n",
    "ax.set_ylabel('Cross section(b)')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exporting HDF5 data\n",
    "\n",
    "If you have an instance `IncidentNeutron` that was created from ACE or HDF5 data, you can easily write it to disk using the `export_to_hdf5()` method. This can be used to convert ACE to HDF5 or to take an existing data set and actually modify cross sections."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "gd157.export_to_hdf5('gd157.h5', 'w')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With few exceptions, the HDF5 file encodes the same data as the ACE file."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gd157_reconstructed = openmc.data.IncidentNeutron.from_hdf5('gd157.h5')\n",
    "np.all(gd157[16].xs['294K'].y == gd157_reconstructed[16].xs['294K'].y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And one of the best parts of using HDF5 is that it is a widely used format with lots of third-party support. You can use `h5py`, for example, to inspect the data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "reaction_002, (n,elastic)\n",
      "reaction_016, (n,2n)\n",
      "reaction_017, (n,3n)\n",
      "reaction_022, (n,na)\n",
      "reaction_024, (n,2na)\n",
      "reaction_028, (n,np)\n",
      "reaction_041, (n,2np)\n",
      "reaction_051, (n,n1)\n",
      "reaction_052, (n,n2)\n",
      "reaction_053, (n,n3)\n"
     ]
    }
   ],
   "source": [
    "h5file = h5py.File('gd157.h5', 'r')\n",
    "main_group = h5file['Gd157/reactions']\n",
    "for name, obj in sorted(list(main_group.items()))[:10]:\n",
    "    if 'reaction_' in name:\n",
    "        print('{}, {}'.format(name, obj.attrs['label'].decode()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[<HDF5 group \"/Gd157/reactions/reaction_016/294K\" (1 members)>,\n",
      " <HDF5 group \"/Gd157/reactions/reaction_016/product_0\" (2 members)>,\n",
      " <HDF5 group \"/Gd157/reactions/reaction_016/product_1\" (2 members)>]\n"
     ]
    }
   ],
   "source": [
    "n2n_group = main_group['reaction_016']\n",
    "pprint(list(n2n_group.values()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So we see that the hierarchy of data within the HDF5 mirrors the hierarchy of Python objects that we manipulated before."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([  0.00000000e+00,   3.02679600e-13,   1.29110100e-02,\n",
       "         6.51111000e-02,   3.92627000e-01,   5.75226800e-01,\n",
       "         6.96960000e-01,   7.39937800e-01,   9.63545000e-01,\n",
       "         1.14213000e+00,   1.30802000e+00,   1.46350000e+00,\n",
       "         1.55760000e+00,   1.64055000e+00,   1.68896000e+00,\n",
       "         1.71140000e+00,   1.73945000e+00,   1.78207000e+00,\n",
       "         1.81665000e+00,   1.84528000e+00,   1.86540900e+00,\n",
       "         1.86724000e+00,   1.88155800e+00,   1.88156000e+00,\n",
       "         1.88180000e+00,   1.89447000e+00,   1.86957000e+00,\n",
       "         1.82120000e+00,   1.71600000e+00,   1.60054000e+00,\n",
       "         1.43162000e+00,   1.28346000e+00,   1.10166000e+00,\n",
       "         1.06530000e+00,   9.30730000e-01,   8.02980000e-01,\n",
       "         7.77740000e-01])"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n2n_group['294K/xs'].value"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Working with ENDF files\n",
    "\n",
    "In addition to being able to load ACE and HDF5 data, we can also load ENDF data directly into an `IncidentNeutron` instance using the `from_endf()` factory method. Let's download the ENDF/B-VII.1 evaluation for $^{157}$Gd and load it in:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<IncidentNeutron: Gd157>"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Download ENDF file\n",
    "url = 'https://t2.lanl.gov/nis/data/data/ENDFB-VII.1-neutron/Gd/157'\n",
    "filename, headers = urllib.request.urlretrieve(url, 'gd157.endf')\n",
    "\n",
    "# Load into memory\n",
    "gd157_endf = openmc.data.IncidentNeutron.from_endf(filename)\n",
    "gd157_endf"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Just as before, we can get a reaction by indexing the object directly:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "elastic = gd157_endf[2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "However, if we look at the cross section now, we see that it isn't represented as tabulated data anymore."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'0K': <openmc.data.function.ResonancesWithBackground at 0x7f601ec47ba8>}"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "elastic.xs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If had [Cython](http://cython.org/) installed when you built/installed OpenMC, you should be able to evaluate resonant cross sections from ENDF data directly, i.e., OpenMC will reconstruct resonances behind the scenes for you."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "998.78711745214866"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "elastic.xs['0K'](0.0253)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When data is loaded from an ENDF file, there is also a special `resonances` attribute that contains resolved and unresolved resonance region data (from MF=2 in an ENDF file)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<openmc.data.resonance.ReichMoore at 0x7f60230e5208>,\n",
       " <openmc.data.resonance.Unresolved at 0x7f601f9850b8>]"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gd157_endf.resonances.ranges"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We see that $^{157}$Gd has a resolved resonance region represented in the Reich-Moore format as well as an unresolved resonance region. We can look at the min/max energy of each region by doing the following:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(1e-05, 306.6), (306.6, 54881.1)]"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[(r.energy_min, r.energy_max) for r in gd157_endf.resonances.ranges]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With knowledge of the energy bounds, let's create an array of energies over the entire resolved resonance range and plot the elastic scattering cross section."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.text.Text at 0x7f601ebdd748>"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiYAAAGBCAYAAABSP3qNAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\njkgkGepjkl9DJyaTJ7c
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f601ebc7b70>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Create log-spaced array of energies\n",
    "resolved = gd157_endf.resonances.resolved\n",
    "energies = np.logspace(np.log10(resolved.energy_min),\n",
    "                       np.log10(resolved.energy_max), 1000)\n",
    "\n",
    "# Evaluate elastic scattering xs at energies\n",
    "xs = elastic.xs['0K'](energies)\n",
    "\n",
    "# Plot cross section vs energies\n",
    "plt.loglog(energies, xs)\n",
    "plt.xlabel('Energy (eV)')\n",
    "plt.ylabel('Cross section (b)')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Resonance ranges also have a useful `parameters` attribute that shows the energies and widths for resonances."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>energy</th>\n",
       "      <th>L</th>\n",
       "      <th>J</th>\n",
       "      <th>neutronWidth</th>\n",
       "      <th>captureWidth</th>\n",
       "      <th>fissionWidthA</th>\n",
       "      <th>fissionWidthB</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.0314</td>\n",
       "      <td>0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>0.000474</td>\n",
       "      <td>0.1072</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2.8250</td>\n",
       "      <td>0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>0.000345</td>\n",
       "      <td>0.0970</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>16.2400</td>\n",
       "      <td>0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.000400</td>\n",
       "      <td>0.0910</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>16.7700</td>\n",
       "      <td>0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>0.012800</td>\n",
       "      <td>0.0805</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>20.5600</td>\n",
       "      <td>0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>0.011360</td>\n",
       "      <td>0.0880</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>21.6500</td>\n",
       "      <td>0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>0.000376</td>\n",
       "      <td>0.1140</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>23.3300</td>\n",
       "      <td>0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.000813</td>\n",
       "      <td>0.1210</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>25.4000</td>\n",
       "      <td>0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>0.001840</td>\n",
       "      <td>0.0850</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>40.1700</td>\n",
       "      <td>0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.001307</td>\n",
       "      <td>0.1100</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>44.2200</td>\n",
       "      <td>0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>0.008960</td>\n",
       "      <td>0.0960</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "    energy  L    J  neutronWidth  captureWidth  fissionWidthA  fissionWidthB\n",
       "0   0.0314  0  2.0      0.000474        0.1072            0.0            0.0\n",
       "1   2.8250  0  2.0      0.000345        0.0970            0.0            0.0\n",
       "2  16.2400  0  1.0      0.000400        0.0910            0.0            0.0\n",
       "3  16.7700  0  2.0      0.012800        0.0805            0.0            0.0\n",
       "4  20.5600  0  2.0      0.011360        0.0880            0.0            0.0\n",
       "5  21.6500  0  2.0      0.000376        0.1140            0.0            0.0\n",
       "6  23.3300  0  1.0      0.000813        0.1210            0.0            0.0\n",
       "7  25.4000  0  2.0      0.001840        0.0850            0.0            0.0\n",
       "8  40.1700  0  1.0      0.001307        0.1100            0.0            0.0\n",
       "9  44.2200  0  2.0      0.008960        0.0960            0.0            0.0"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "resolved.parameters.head(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Heavy-nuclide resonance scattering\n",
    "\n",
    "OpenMC has two methods for accounting for resonance upscattering in heavy nuclides, DBRC and ARES. These methods rely on 0 K elastic scattering data being present. If you have an existing ACE/HDF5 dataset and you need to add 0 K elastic scattering data to it, this can be done using the `IncidentNeutron.add_elastic_0K_from_endf()` method. Let's do this with our original `gd157` object that we instantiated from an ACE file."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "gd157.add_elastic_0K_from_endf('gd157.endf')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's check to make sure that we have both the room temperature elastic scattering cross section as well as a 0K cross section."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'0K': <openmc.data.function.Tabulated1D at 0x7f601eb805c0>,\n",
       " '294K': <openmc.data.function.Tabulated1D at 0x7f60230d7cf8>}"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gd157[2].xs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Generating data from NJOY\n",
    "\n",
    "To run OpenMC in continuous-energy mode, you generally need to have ACE files already available that can be converted to OpenMC's native HDF5 format. If you don't already have suitable ACE files or need to generate new data, both the `IncidentNeutron` and `ThermalScattering` classes include `from_njoy()` methods that will run [NJOY](https://njoy.github.io/NJOY2016/) to generate ACE files and then read those files to create OpenMC class instances. The `from_njoy()` methods take as input the name of an ENDF file on disk. By default, it is assumed that you have an executable named `njoy` available on your path. This can be configured with the optional `njoy_exec` argument. Additionally, if you want to show the progress of NJOY as it is running, you can pass `stdout=True`.\n",
    "\n",
    "Let's use `IncidentNeutron.from_njoy()` to run NJOY to create data for $^2$H using an ENDF file. We'll specify that we want data specifically at 300, 400, and 500 K."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      " njoy 2016.12  02Apr17                                       05/01/17 12:33:17\n",
      " *****************************************************************************\n",
      "\n",
      " reconr...                                                                0.0s\n",
      "\n",
      " broadr...                                                                0.0s\n",
      "      300.0 deg                                                           0.0s\n",
      "      400.0 deg                                                           0.2s\n",
      "      500.0 deg                                                           0.3s\n",
      "\n",
      " heatr...                                                                 0.4s\n",
      "\n",
      " purr...                                                                  0.6s\n",
      "\n",
      " mat =  128                                                               0.6s\n",
      "\n",
      " ---message from purr---mat  128 has no resonance parameters\n",
      "                          copy as is to nout\n",
      "\n",
      " acer...                                                                  0.6s\n",
      "\n",
      " acer...                                                                  0.7s\n",
      "\n",
      " acer...                                                                  0.8s\n",
      "                                                                          0.8s\n",
      " *****************************************************************************\n"
     ]
    }
   ],
   "source": [
    "# Download ENDF file\n",
    "url = 'https://t2.lanl.gov/nis/data/data/ENDFB-VII.1-neutron/H/2'\n",
    "filename, headers = urllib.request.urlretrieve(url, 'h2.endf')\n",
    "\n",
    "# Run NJOY to create deuterium data\n",
    "h2 = openmc.data.IncidentNeutron.from_njoy('h2.endf', temperatures=[300., 400., 500.], stdout=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we can use our `h2` object just as we did before."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'0K': <openmc.data.function.Tabulated1D at 0x7ffa93130d30>,\n",
       " '300K': <openmc.data.function.Tabulated1D at 0x7ffa919485c0>,\n",
       " '400K': <openmc.data.function.Tabulated1D at 0x7ffa92fcb630>,\n",
       " '500K': <openmc.data.function.Tabulated1D at 0x7ffa91805240>}"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "h2[2].xs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that 0 K elastic scattering data is automatically added when using `from_njoy()` so that resonance elastic scattering treatments can be used."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Windowed multipole\n",
    "\n",
    "OpenMC can also be used with an experimental format called windowed multipole.  Windowed multipole allows for analytic on-the-fly Doppler broadening of the resolved resonance range.  Windowed multipole data can be downloaded with the `openmc-get-multipole-data` script.  This data can be used in the transport solver, but it can also be used directly in the Python API."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "url = 'https://anl.box.com/shared/static/ulhcoohm12gduwdalknmf8dpnepzkxj0.h5'\n",
    "filename, headers = urllib.request.urlretrieve(url, '092238.h5')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "u238_multipole = openmc.data.WindowedMultipole.from_hdf5('092238.h5')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `WindowedMultipole` object can be called with energy and temperature values.  Calling the object gives a tuple of 3 cross sections: total, radiative capture, and fission."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array(9.638243132516015),\n",
       " array(0.5053244245010787),\n",
       " array(2.931753364280356e-06))"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "u238_multipole(1.0, 294)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An array can be passed for the energy argument."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7f601eb44f60>]"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAhAAAAFnCAYAAAD3z3BtAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nZbWPqWWAICICjh4FDh+
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f601ea5ec18>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "E = np.linspace(5, 25, 1000)\n",
    "plt.semilogy(E, u238_multipole(E, 293.606)[1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The real advantage to multipole is that it can be used to generate cross sections at any temperature.  For example, this plot shows the Doppler broadening of the 6.67 eV resonance between 0 K and 900 K."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7f601e973780>]"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAg8AAAFnCAYAAAAhaqoIAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nO3ZAYCDce2/yxilcGDJ
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f601eb320f0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "E = np.linspace(6.1, 7.1, 1000)\n",
    "plt.semilogy(E, u238_multipole(E, 0)[1])\n",
    "plt.semilogy(E, u238_multipole(E, 900)[1])"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}