diff --git a/docs/source/examples/candu.ipynb b/docs/source/examples/candu.ipynb new file mode 100644 index 0000000000..f58d254f9e --- /dev/null +++ b/docs/source/examples/candu.ipynb @@ -0,0 +1,1113 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In this example, we will create a typical CANDU bundle with rings of fuel pins. At present, OpenMC does not have a specialized lattice for this type of fuel arrangement, so we must resort to manual creation of the array of fuel pins." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "%matplotlib inline\n", + "from math import pi, sin, cos\n", + "import numpy as np\n", + "import openmc" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's begin by creating the materials that will be used in our model." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "fuel = openmc.Material(name='fuel')\n", + "fuel.add_element('U', 1.0)\n", + "fuel.add_element('O', 2.0)\n", + "fuel.set_density('g/cm3', 10.0)\n", + "\n", + "clad = openmc.Material(name='zircaloy')\n", + "clad.add_element('Zr', 1.0)\n", + "clad.set_density('g/cm3', 6.0)\n", + "\n", + "heavy_water = openmc.Material(name='heavy water')\n", + "heavy_water.add_nuclide('H2', 2.0)\n", + "heavy_water.add_nuclide('O16', 1.0)\n", + "heavy_water.add_s_alpha_beta('c_D_in_D2O')\n", + "heavy_water.set_density('g/cm3', 1.1)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "With out materials created, we'll now define key dimensions in our model. These dimensions are taken from the example in section 11.1.3 of the [Serpent manual](http://montecarlo.vtt.fi/download/Serpent_manual.pdf)." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# Outer radius of fuel and clad\n", + "r_fuel = 0.6122\n", + "r_clad = 0.6540\n", + "\n", + "# Pressure tube and calendria radii\n", + "pressure_tube_ir = 5.16890\n", + "pressure_tube_or = 5.60320\n", + "calendria_ir = 6.44780\n", + "calendria_or = 6.58750\n", + "\n", + "# Radius to center of each ring of fuel pins\n", + "ring_radii = np.array([0.0, 1.4885, 2.8755, 4.3305])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To begin creating the bundle, we'll first create annular regions completely filled with heavy water and add in the fuel pins later. The radii that we've specified above correspond to the center of each ring. We actually need to create cylindrical surfaces at radii that are half-way between the centers." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "# These are the surfaces that will divide each of the rings\n", + "radial_surf = [openmc.ZCylinder(R=r) for r in\n", + " (ring_radii[:-1] + ring_radii[1:])/2]\n", + "\n", + "water_cells = []\n", + "for i in range(ring_radii.size):\n", + " # Create annular region\n", + " if i == 0:\n", + " water_region = -radial_surf[i]\n", + " elif i == ring_radii.size - 1:\n", + " water_region = +radial_surf[i-1]\n", + " else:\n", + " water_region = +radial_surf[i-1] & -radial_surf[i]\n", + " \n", + " water_cells.append(openmc.Cell(fill=heavy_water, region=water_region))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's see what our geometry looks like so far. In order to plot the geometry, we create a universe that contains the annular water cells and then use the `Universe.plot()` method. While we're at it, we'll set some keyword arguments that can be reused for later plots." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAQEAAAD8CAYAAAB3lxGOAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nAABJRU5ErkJggg==\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_args = {\n", + " 'width': (2*calendria_or, 2*calendria_or),\n", + " 'colors': {\n", + " fuel: 'black',\n", + " clad: 'silver',\n", + " heavy_water: 'blue'\n", + " }\n", + " }\n", + "bundle_universe = openmc.Universe(cells=water_cells)\n", + "bundle_universe.plot(**plot_args)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we need to create a universe that contains a fuel pin. Note that we don't actually need to put water outside of the cladding in this universe because it will be truncated by a higher universe." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "surf_fuel = openmc.ZCylinder(R=r_fuel)\n", + "\n", + "fuel_cell = openmc.Cell(fill=fuel, region=-surf_fuel)\n", + "clad_cell = openmc.Cell(fill=clad, region=+surf_fuel)\n", + "\n", + "pin_universe = openmc.Universe(cells=(fuel_cell, clad_cell))" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAQEAAAD8CAYAAAB3lxGOAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nCY6OTgAAAABJRU5ErkJggg==\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "pin_universe.plot(**plot_args)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The code below works through each ring to create a cell containing the fuel pin universe. As each fuel pin is created, we modify the region of the water cell to include everything outside the fuel pin." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "num_pins = [1, 6, 12, 18]\n", + "angles = [0, 0, 15, 0]\n", + "\n", + "for i, (r, n, a) in enumerate(zip(ring_radii, num_pins, angles)):\n", + " for j in range(n):\n", + " # Determine location of center of pin\n", + " theta = (a + j/n*360.) * pi/180.\n", + " x = r*cos(theta)\n", + " y = r*sin(theta)\n", + " \n", + " pin_boundary = openmc.ZCylinder(x0=x, y0=y, R=r_clad)\n", + " water_cells[i].region &= +pin_boundary\n", + " \n", + " # Create each fuel pin -- note that we explicitly assign an ID so \n", + " # that we can identify the pin later when looking at tallies\n", + " pin = openmc.Cell(fill=pin_universe, region=-pin_boundary)\n", + " pin.translation = (x, y, 0)\n", + " pin.id = (i + 1)*100 + j\n", + " bundle_universe.add_cell(pin)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAQEAAAD8CAYAAAB3lxGOAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nRUBREkdFQFESR0VAURJHRUBREuf/AS8hidxMgei8AAAAAElFTkSuQmCC\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "bundle_universe.plot(**plot_args)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Looking pretty good! Finally, we create cells for the pressure tube and calendria and then put our bundle in the middle of the pressure tube." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "pt_inner = openmc.ZCylinder(R=pressure_tube_ir)\n", + "pt_outer = openmc.ZCylinder(R=pressure_tube_or)\n", + "calendria_inner = openmc.ZCylinder(R=calendria_ir)\n", + "calendria_outer = openmc.ZCylinder(R=calendria_or, boundary_type='vacuum')\n", + "\n", + "bundle = openmc.Cell(fill=bundle_universe, region=-pt_inner)\n", + "pressure_tube = openmc.Cell(fill=clad, region=+pt_inner & -pt_outer)\n", + "v1 = openmc.Cell(region=+pt_outer & -calendria_inner)\n", + "calendria = openmc.Cell(fill=clad, region=+calendria_inner & -calendria_outer)\n", + "\n", + "root_universe = openmc.Universe(cells=[bundle, pressure_tube, v1, calendria])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's look at the final product. We'll export our geometry and materials and then use `plot_inline()` to get a nice-looking plot." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "geom = openmc.Geometry(root_universe)\n", + "geom.export_to_xml()\n", + "\n", + "mats = openmc.Materials(geom.get_all_materials().values())\n", + "mats.export_to_xml()" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZAAAAGQAgMAAAD90d5fAAAABGdBTUEAALGPC/xhBQAAACBjSFJN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\nYII=\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "p = openmc.Plot.from_geometry(geom)\n", + "p.color_by = 'material'\n", + "p.colors = plot_args['colors']\n", + "openmc.plot_inline(p)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Interpreting Results\n", + "\n", + "One of the difficulties of a geometry like this is identifying tally results when there was no lattice involved. To address this, we specifically gave an ID to each fuel pin of the form 100\\*ring + azimuthal position. Consequently, we can use a distribcell tally and then look at our `DataFrame` which will show these cell IDs." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "settings = openmc.Settings()\n", + "settings.particles = 1000\n", + "settings.batches = 20\n", + "settings.inactive = 10\n", + "settings.source = openmc.Source(space=openmc.stats.Point())\n", + "settings.export_to_xml()" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "fuel_tally = openmc.Tally()\n", + "fuel_tally.filters = [openmc.DistribcellFilter(fuel_cell.id)]\n", + "fuel_tally.scores = ['flux']\n", + "\n", + "tallies = openmc.Tallies([fuel_tally])\n", + "tallies.export_to_xml()" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "0" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "openmc.run(output=False)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The return code of `0` indicates that OpenMC ran successfully. Now let's load the statepoint into a `openmc.StatePoint` object and use the `Tally.get_pandas_dataframe(...)` method to see our results." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "sp = openmc.StatePoint('statepoint.{}.h5'.format(settings.batches))" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
level 1level 2level 3distribcellnuclidescoremeanstd. dev.
univcellunivcellunivcell
idididididid
010002100431000010010001100040totalflux0.2078050.007037
110002100431000020010001100041totalflux0.1971970.005272
210002100431000020110001100042totalflux0.1903100.007816
310002100431000020210001100043totalflux0.1947360.006469
410002100431000020310001100044totalflux0.1910970.006431
510002100431000020410001100045totalflux0.1899100.004891
610002100431000020510001100046totalflux0.1822030.003851
710002100431000030010001100047totalflux0.1659220.005815
810002100431000030110001100048totalflux0.1689330.008300
910002100431000030210001100049totalflux0.1595870.003085
10100021004310000303100011000410totalflux0.1591580.005910
11100021004310000304100011000411totalflux0.1485370.005308
12100021004310000305100011000412totalflux0.1509450.006654
13100021004310000306100011000413totalflux0.1542370.003665
14100021004310000307100011000414totalflux0.1658880.004733
15100021004310000308100011000415totalflux0.1567770.006540
16100021004310000309100011000416totalflux0.1652770.005935
17100021004310000310100011000417totalflux0.1565280.005732
18100021004310000311100011000418totalflux0.1596100.004584
19100021004310000400100011000419totalflux0.0965970.004466
20100021004310000401100011000420totalflux0.1182140.005451
21100021004310000402100011000421totalflux0.1061670.004722
22100021004310000403100011000422totalflux0.1108140.004208
23100021004310000404100011000423totalflux0.1123190.005079
24100021004310000405100011000424totalflux0.1102320.004153
25100021004310000406100011000425totalflux0.0999670.005085
26100021004310000407100011000426totalflux0.0954440.003615
27100021004310000408100011000427totalflux0.0926200.003997
28100021004310000409100011000428totalflux0.0955170.004022
29100021004310000410100011000429totalflux0.1137370.009530
30100021004310000411100011000430totalflux0.1083680.007241
31100021004310000412100011000431totalflux0.1069900.005716
32100021004310000413100011000432totalflux0.1120500.005002
33100021004310000414100011000433totalflux0.1150540.006239
34100021004310000415100011000434totalflux0.1143940.004919
35100021004310000416100011000435totalflux0.1143520.005322
36100021004310000417100011000436totalflux0.1108900.005051
\n", + "
" + ], + "text/plain": [ + " level 1 level 2 level 3 distribcell nuclide score \\\n", + " univ cell univ cell univ cell \n", + " id id id id id id \n", + "0 10002 10043 10000 100 10001 10004 0 total flux \n", + "1 10002 10043 10000 200 10001 10004 1 total flux \n", + "2 10002 10043 10000 201 10001 10004 2 total flux \n", + "3 10002 10043 10000 202 10001 10004 3 total flux \n", + "4 10002 10043 10000 203 10001 10004 4 total flux \n", + "5 10002 10043 10000 204 10001 10004 5 total flux \n", + "6 10002 10043 10000 205 10001 10004 6 total flux \n", + "7 10002 10043 10000 300 10001 10004 7 total flux \n", + "8 10002 10043 10000 301 10001 10004 8 total flux \n", + "9 10002 10043 10000 302 10001 10004 9 total flux \n", + "10 10002 10043 10000 303 10001 10004 10 total flux \n", + "11 10002 10043 10000 304 10001 10004 11 total flux \n", + "12 10002 10043 10000 305 10001 10004 12 total flux \n", + "13 10002 10043 10000 306 10001 10004 13 total flux \n", + "14 10002 10043 10000 307 10001 10004 14 total flux \n", + "15 10002 10043 10000 308 10001 10004 15 total flux \n", + "16 10002 10043 10000 309 10001 10004 16 total flux \n", + "17 10002 10043 10000 310 10001 10004 17 total flux \n", + "18 10002 10043 10000 311 10001 10004 18 total flux \n", + "19 10002 10043 10000 400 10001 10004 19 total flux \n", + "20 10002 10043 10000 401 10001 10004 20 total flux \n", + "21 10002 10043 10000 402 10001 10004 21 total flux \n", + "22 10002 10043 10000 403 10001 10004 22 total flux \n", + "23 10002 10043 10000 404 10001 10004 23 total flux \n", + "24 10002 10043 10000 405 10001 10004 24 total flux \n", + "25 10002 10043 10000 406 10001 10004 25 total flux \n", + "26 10002 10043 10000 407 10001 10004 26 total flux \n", + "27 10002 10043 10000 408 10001 10004 27 total flux \n", + "28 10002 10043 10000 409 10001 10004 28 total flux \n", + "29 10002 10043 10000 410 10001 10004 29 total flux \n", + "30 10002 10043 10000 411 10001 10004 30 total flux \n", + "31 10002 10043 10000 412 10001 10004 31 total flux \n", + "32 10002 10043 10000 413 10001 10004 32 total flux \n", + "33 10002 10043 10000 414 10001 10004 33 total flux \n", + "34 10002 10043 10000 415 10001 10004 34 total flux \n", + "35 10002 10043 10000 416 10001 10004 35 total flux \n", + "36 10002 10043 10000 417 10001 10004 36 total flux \n", + "\n", + " mean std. dev. \n", + " \n", + " \n", + "0 2.08e-01 7.04e-03 \n", + "1 1.97e-01 5.27e-03 \n", + "2 1.90e-01 7.82e-03 \n", + "3 1.95e-01 6.47e-03 \n", + "4 1.91e-01 6.43e-03 \n", + "5 1.90e-01 4.89e-03 \n", + "6 1.82e-01 3.85e-03 \n", + "7 1.66e-01 5.82e-03 \n", + "8 1.69e-01 8.30e-03 \n", + "9 1.60e-01 3.09e-03 \n", + "10 1.59e-01 5.91e-03 \n", + "11 1.49e-01 5.31e-03 \n", + "12 1.51e-01 6.65e-03 \n", + "13 1.54e-01 3.67e-03 \n", + "14 1.66e-01 4.73e-03 \n", + "15 1.57e-01 6.54e-03 \n", + "16 1.65e-01 5.94e-03 \n", + "17 1.57e-01 5.73e-03 \n", + "18 1.60e-01 4.58e-03 \n", + "19 9.66e-02 4.47e-03 \n", + "20 1.18e-01 5.45e-03 \n", + "21 1.06e-01 4.72e-03 \n", + "22 1.11e-01 4.21e-03 \n", + "23 1.12e-01 5.08e-03 \n", + "24 1.10e-01 4.15e-03 \n", + "25 1.00e-01 5.08e-03 \n", + "26 9.54e-02 3.62e-03 \n", + "27 9.26e-02 4.00e-03 \n", + "28 9.55e-02 4.02e-03 \n", + "29 1.14e-01 9.53e-03 \n", + "30 1.08e-01 7.24e-03 \n", + "31 1.07e-01 5.72e-03 \n", + "32 1.12e-01 5.00e-03 \n", + "33 1.15e-01 6.24e-03 \n", + "34 1.14e-01 4.92e-03 \n", + "35 1.14e-01 5.32e-03 \n", + "36 1.11e-01 5.05e-03 " + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "t = sp.get_tally()\n", + "t.get_pandas_dataframe()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can see that in the 'level 2' column, the 'cell id' tells us how each row corresponds to a ring and azimuthal position." + ] + } + ], + "metadata": { + "anaconda-cloud": {}, + "kernelspec": { + "display_name": "Python [default]", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.5.2" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/docs/source/examples/candu.rst b/docs/source/examples/candu.rst new file mode 100644 index 0000000000..791e0073be --- /dev/null +++ b/docs/source/examples/candu.rst @@ -0,0 +1,13 @@ +.. _notebook_candu: + +======================= +Modeling a CANDU Bundle +======================= + +.. only:: html + + .. notebook:: candu.ipynb + +.. only:: latex + + IPython notebooks must be viewed in the online HTML documentation. diff --git a/docs/source/examples/index.rst b/docs/source/examples/index.rst index 720909284c..5c1efb57ce 100644 --- a/docs/source/examples/index.rst +++ b/docs/source/examples/index.rst @@ -9,19 +9,42 @@ features via the :ref:`pythonapi`. .. _Jupyter: https://jupyter.org/ +----------- +Basic Usage +----------- + .. toctree:: :maxdepth: 1 + pincell post-processing pandas-dataframes tally-arithmetic + search + triso + candu + nuclear-data + +------------------------------------ +Multi-Group Cross Section Generation +------------------------------------ + +.. toctree:: + :maxdepth: 1 + mgxs-part-i mgxs-part-ii mgxs-part-iii + mdgxs-part-i + mdgxs-part-ii + +---------------- +Multi-Group Mode +---------------- + +.. toctree:: + :maxdepth: 1 + mg-mode-part-i mg-mode-part-ii mg-mode-part-iii - mdgxs-part-i - mdgxs-part-ii - search - nuclear-data diff --git a/docs/source/examples/pincell.ipynb b/docs/source/examples/pincell.ipynb new file mode 100644 index 0000000000..a731045420 --- /dev/null +++ b/docs/source/examples/pincell.ipynb @@ -0,0 +1,1666 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This notebook is intended to demonstrate the basic features of the Python API for constructing input files and running OpenMC. In it, we will show how to create a basic reflective pin-cell model that is equivalent to modeling an infinite array of fuel pins. If you have never used OpenMC, this can serve as a good starting point to learn the Python API. We highly recommend having a copy of the [Python API reference documentation](http://openmc.readthedocs.org/en/latest/pythonapi/index.html) open in another browser tab that you can refer to." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "%matplotlib inline\n", + "import openmc" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Defining Materials\n", + "\n", + "Materials in OpenMC are defined as a set of nuclides or elements with specified atom/weight fractions. There are two ways we can go about adding nuclides or elements to materials. The first way involves creating `Nuclide` or `Element` objects explicitly." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "u235 = openmc.Nuclide('U235')\n", + "u238 = openmc.Nuclide('U238')\n", + "o16 = openmc.Nuclide('O16')\n", + "zr = openmc.Element('Zr')\n", + "h1 = openmc.Nuclide('H1')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now that we have all the nuclides/elements that we need, we can start creating materials. In OpenMC, many objects are identified by a \"unique ID\" that is simply just a positive integer. These IDs are used when exporting XML files that the solver reads in. They also appear in the output and can be used for identification. Assigning an ID is required -- we can also give a `name` as well." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Material\n", + "\tID =\t1\n", + "\tName =\tuo2\n", + "\tTemperature =\tNone\n", + "\tDensity =\tNone []\n", + "\tS(a,b) Tables \n", + "\tNuclides \n", + "\tElements \n", + "\n" + ] + } + ], + "source": [ + "uo2 = openmc.Material(1, \"uo2\")\n", + "print(uo2)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "On the XML side, you have no choice but to supply an ID. However, in the Python API, if you don't give an ID, one will be automatically generated for you:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Material\n", + "\tID =\t10000\n", + "\tName =\t\n", + "\tTemperature =\tNone\n", + "\tDensity =\tNone []\n", + "\tS(a,b) Tables \n", + "\tNuclides \n", + "\tElements \n", + "\n" + ] + } + ], + "source": [ + "mat = openmc.Material()\n", + "print(mat)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We see that an ID of 10000 was automatically assigned. Let's now move on to adding nuclides to our `uo2` material. The `Material` object has a method `add_nuclide()` whose first argument is the nuclide and second argument is the atom or weight fraction." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Help on method add_nuclide in module openmc.material:\n", + "\n", + "add_nuclide(nuclide, percent, percent_type='ao') method of openmc.material.Material instance\n", + " Add a nuclide to the material\n", + " \n", + " Parameters\n", + " ----------\n", + " nuclide : str or openmc.Nuclide\n", + " Nuclide to add\n", + " percent : float\n", + " Atom or weight percent\n", + " percent_type : {'ao', 'wo'}\n", + " 'ao' for atom percent and 'wo' for weight percent\n", + "\n" + ] + } + ], + "source": [ + "help(uo2.add_nuclide)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We see that by default it assumes we want an atom fraction." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# Add nuclides to uo2\n", + "uo2.add_nuclide(u235, 0.03)\n", + "uo2.add_nuclide(u238, 0.97)\n", + "uo2.add_nuclide(o16, 2.0)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we need to assign a total density to the material. We'll use the `set_density` for this." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "uo2.set_density('g/cm3', 10.0)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You may sometimes be given a material specification where all the nuclide densities are in units of atom/b-cm. In this case, you just want the density to be the sum of the constituents. In that case, you can simply run `mat.set_density('sum')`.\n", + "\n", + "With UO2 finished, let's now create materials for the clad and coolant. Note the use of `add_element()` for zirconium." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "zirconium = openmc.Material(2, \"zirconium\")\n", + "zirconium.add_element(zr, 1.0)\n", + "zirconium.set_density('g/cm3', 6.6)\n", + "\n", + "water = openmc.Material(3, \"h2o\")\n", + "water.add_nuclide(h1, 2.0)\n", + "water.add_nuclide(o16, 1.0)\n", + "water.set_density('g/cm3', 1.0)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "An astute observer might now point out that this water material we just created will only use free-atom cross sections. We need to tell it to use an $S(\\alpha,\\beta)$ table so that the bound atom cross section is used at thermal energies. To do this, there's an `add_s_alpha_beta()` method. Note the use of the GND-style name \"c_H_in_H2O\"." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "water.add_s_alpha_beta('c_H_in_H2O')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "So far you've seen the \"hard\" way to create a material. The \"easy\" way is to just pass strings to `add_nuclide()` and `add_element()` -- they are implicitly coverted to `Nuclide` and `Element` objects. For example, we could have created our UO2 material as follows:" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "uo2 = openmc.Material(1, \"uo2\")\n", + "uo2.add_nuclide('U235', 0.03)\n", + "uo2.add_nuclide('U238', 0.97)\n", + "uo2.add_nuclide('O16', 2.0)\n", + "uo2.set_density('g/cm3', 10.0)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "When we go to run the transport solver in OpenMC, it is going to look for a `materials.xml` file. Thus far, we have only created objects in memory. To actually create a `materials.xml` file, we need to instantiate a `Materials` collection and export it to XML." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "mats = openmc.Materials([uo2, zirconium, water])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Note that `Materials` is actually a subclass of Python's built-in `list`, so we can use methods like `append()`, `insert()`, `pop()`, etc." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "mats = openmc.Materials()\n", + "mats.append(uo2)\n", + "mats += [zirconium, water]\n", + "isinstance(mats, list)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Finally, we can create the XML file with the `export_to_xml()` method. In a Jupyter notebook, we can run a shell command by putting `!` before it, so in this case we are going to display the `materials.xml` file that we created." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r\n", + "\r\n", + " \r\n", + " \r\n", + " \r\n", + " \r\n", + " \r\n", + " \r\n", + " \r\n", + " \r\n", + " \r\n", + " \r\n", + " \r\n", + " \r\n", + " \r\n", + " \r\n", + " \r\n", + " \r\n", + " \r\n", + " \r\n", + " \r\n", + " \r\n", + "\r\n" + ] + } + ], + "source": [ + "mats.export_to_xml()\n", + "!cat materials.xml" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Element Expansion\n", + "\n", + "Did you notice something really cool that happened to our Zr element? OpenMC automatically turned it into a list of nuclides when it exported it! The way this feature works is as follows:\n", + "\n", + "- First, it checks whether `Materials.cross_sections` has been set, indicating the path to a `cross_sections.xml` file.\n", + "- If `Materials.cross_sections` isn't set, it looks for the `OPENMC_CROSS_SECTIONS` environment variable.\n", + "- If either of these are found, it scans the file to see what nuclides are actually available and will expand elements accordingly.\n", + "\n", + "Let's see what happens if we change O16 in water to elemental O." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r\n", + "\r\n", + " \r\n", + " \r\n", + " \r\n", + " \r\n", + " \r\n", + " \r\n", + " \r\n", + " \r\n", + " \r\n", + " \r\n", + " \r\n", + " \r\n", + " \r\n", + " \r\n", + " \r\n", + " \r\n", + " \r\n", + " \r\n", + " \r\n", + " \r\n", + " \r\n", + "\r\n" + ] + } + ], + "source": [ + "water.remove_nuclide(openmc.Nuclide('O16'))\n", + "water.add_element('O', 1.0)\n", + "\n", + "mats.export_to_xml()\n", + "!cat materials.xml" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We see that now O16 and O17 were automatically added. O18 is missing because our cross sections file (which is based on ENDF/B-VII.1) doesn't have O18. If OpenMC didn't know about the cross sections file, it would have assumed that all isotopes exist." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### The `cross_sections.xml` file\n", + "\n", + "The `cross_sections.xml` tells OpenMC where it can find nuclide cross sections and $S(\\alpha,\\beta)$ tables. It serves the same purpose as MCNP's `xsdir` file and Serpent's `xsdata` file. As we mentioned, this can be set either by the `OPENMC_CROSS_SECTIONS` environment variable or the `Materials.cross_sections` attribute.\n", + "\n", + "Let's have a look at what's inside this file:" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " ...\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n" + ] + } + ], + "source": [ + "!cat $OPENMC_CROSS_SECTIONS | head -n 10\n", + "print(' ...')\n", + "!cat $OPENMC_CROSS_SECTIONS | tail -n 10" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Enrichment\n", + "\n", + "Note that the `add_element()` method has a special argument `enrichment` that can be used for Uranium. For example, if we know that we want to create 3% enriched UO2, the following would work:" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "uo2_three = openmc.Material()\n", + "uo2_three.add_element('U', 1.0, enrichment=3.0)\n", + "uo2_three.add_element('O', 2.0)\n", + "uo2_three.set_density('g/cc', 10.0)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Defining Geometry\n", + "\n", + "At this point, we have three materials defined, exported to XML, and ready to be used in our model. To finish our model, we need to define the geometric arrangement of materials. OpenMC represents physical volumes using constructive solid geometry (CSG), also known as combinatorial geometry. The object that allows us to assign a material to a region of space is called a `Cell` (same concept in MCNP, for those familiar). In order to define a region that we can assign to a cell, we must first define surfaces which bound the region. A *surface* is a locus of zeros of a function of Cartesian coordinates $x$, $y$, and $z$, e.g.\n", + "\n", + "- A plane perpendicular to the x axis: $x - x_0 = 0$\n", + "- A cylinder perpendicular to the z axis: $(x - x_0)^2 + (y - y_0)^2 - R^2 = 0$\n", + "- A sphere: $(x - x_0)^2 + (y - y_0)^2 + (z - z_0)^2 - R^2 = 0$\n", + "\n", + "Between those three classes of surfaces (planes, cylinders, spheres), one can construct a wide variety of models. It is also possible to define cones and general second-order surfaces (torii are not currently supported).\n", + "\n", + "Note that defining a surface is not sufficient to specify a volume -- in order to define an actual volume, one must reference the half-space of a surface. A surface *half-space* is the region whose points satisfy a positive of negative inequality of the surface equation. For example, for a sphere of radius one centered at the origin, the surface equation is $f(x,y,z) = x^2 + y^2 + z^2 - 1 = 0$. Thus, we say that the negative half-space of the sphere, is defined as the collection of points satisfying $f(x,y,z) < 0$, which one can reason is the inside of the sphere. Conversely, the positive half-space of the sphere would correspond to all points outside of the sphere.\n", + "\n", + "Let's go ahead and create a sphere and confirm that we've told you is true." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "sph = openmc.Sphere(R=1.0)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Note that by default the sphere is centered at the origin so we didn't have to supply `x0`, `y0`, or `z0` arguments. Strictly speaking, we could have omitted `R` as well since it defaults to one. To get the negative or positive half-space, we simply need to apply the `-` or `+` unary operators, respectively.\n", + "\n", + "(NOTE: Those unary operators are defined by special methods: `__pos__` and `__neg__` in this case)." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "inside_sphere = -sph\n", + "outside_sphere = +sph" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now let's see if `inside_sphere` actually contains points inside the sphere:" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "True False\n", + "False True\n" + ] + } + ], + "source": [ + "print((0,0,0) in inside_sphere, (0,0,2) in inside_sphere)\n", + "print((0,0,0) in outside_sphere, (0,0,2) in outside_sphere)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Everything works as expected! Now that we understand how to create half-spaces, we can create more complex volumes by combining half-spaces using Boolean operators: `&` (intersection), `|` (union), and `~` (complement). For example, let's say we want to define a region that is the top part of the sphere (all points inside the sphere that have $z > 0$." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "z_plane = openmc.ZPlane(z0=0)\n", + "northern_hemisphere = -sph & +z_plane" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "For many regions, OpenMC can automatically determine a bounding box. To get the bounding box, we use the `bounding_box` property of a region, which returns a tuple of the lower-left and upper-right Cartesian coordinates for the bounding box:" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "(array([-1., -1., 0.]), array([ 1., 1., 1.]))" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "northern_hemisphere.bounding_box" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now that we see how to create volumes, we can use them to create a cell." + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "cell = openmc.Cell()\n", + "cell.region = northern_hemisphere\n", + "\n", + "# or...\n", + "cell = openmc.Cell(region=northern_hemisphere)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "By default, the cell is not filled by any material (void). In order to assign a material, we set the `fill` property of a `Cell`." + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "cell.fill = water" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Universes and in-line plotting" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "A collection of cells is known as a universe (again, this will be familiar to MCNP/Serpent users) and can be used as a repeatable unit when creating a model. Although we don't need it yet, the benefit of creating a universe is that we can visualize our geometry while we're creating it." + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "universe = openmc.Universe()\n", + "universe.add_cell(cell)\n", + "\n", + "# this also works\n", + "universe = openmc.Universe(cells=[cell])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The `Universe` object has a `plot` method that will display our the universe as current constructed:" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAARUAAAD8CAYAAABZ0jAcAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\nAAALEgAACxIB0t1+/AAAEiJJREFUeJzt3X2sHNV9xvHvUweU1EUlDuYlBESQLMBU4MKVoRQldgMI\nrLYOVVNBKxJFiSwqiJqooqVCovyZgtKoVAnUTVFBaqGpAokFBopRU0ojEmwEfsEQDHUUXIPNi6AJ\nJNTtr3/srFnWu/fO7p6dOTP7fKTV3Z2XvWfunHnumdmXnyICM7NUfqHuBphZuzhUzCwph4qZJeVQ\nMbOkHCpmlpRDxcySShIqkm6TtE/S9iHzJelmSbskbZV0Vs+8iyU9W8y7NkV7zKw+qUYqfw9cPM/8\nS4BlxW0dcAuApEXA14r5y4HLJS1P1CYzq0GSUImIR4DX5llkLXBHdDwGHCnpOGAlsCsiXoiId4C7\nimXNrKHeV9HvOR74cc/jF4tpg6afM+gJJK2jM8ph8eLFZ5966qnTaamV9tLP3p7K8x77/g9M5Xmt\nvC1btrwSEUvHWbeqUJlYRKwH1gPMzc3F5s2ba25R+920c2vdTRjomtPOqLsJrSfpR+OuW1Wo7AFO\n6Hn8kWLaYUOmW8VyDZBBBrXVQZOPqkJlA3C1pLvonN68ERF7Je0Hlkn6KJ0wuQz4/YraNNOaFCJl\n9G+PQ6Y+SUJF0p3AKuAoSS8Cf05nFEJE3ApsBNYAu4C3gM8W8w5Iuhp4EFgE3BYRO1K0yd7VtgAp\nw6OZ+qiJX33gayoLm8UgGYUDZn6StkTE3Djr+h21ZpZUY179sXI8Qimn+3fyiCU9h0oLOEjG1/u3\nc8Ck4VBpKAdJeg6YNBwqDeIgqY4DZnwOlQZwmNTL119G41DJmMMkLw6XcvyScqYcKPnyvpmfRyoZ\ncWdtDo9ahnOoZMBh0ly+oHson/7UzIHSHt6XHR6p1MQdsJ18WuSRipkl5pFKxTxCmQ2zPGLxSKVC\nDpTZM4v73KFSkVnsXNYxa/vepz9TNmsdygabpdMhh8qUOExskFkIl1RlT+ctXSrpGklPFrftkv5X\n0pJi3m5J24p5rfiOSAeKLaTNfWTiUClTujQiboqIFRGxAvgz4N8iorei4epi/ljfiZmTNncWS6ut\nfSXF6c/B0qUARRmOtcDTQ5a/HLgzwe/NSls7iE1XG0+HUpz+DCtpeghJv0inkPu3eiYHsEnSlqK0\naeM4UGxSbepDVb+k/FvAf/Sd+pxfnBZdAlwl6WODVpS0TtJmSZv3799fRVtLaVNnsHq1pS+lCJVh\nJU0HuYy+U5+I2FP83AfcQ+d06hARsT4i5iJibunSsepGJ9eWTmD5aEOfShEqj1OULpV0OJ3g2NC/\nkKRfBj4OfKdn2mJJR3TvAxcB2xO0ycxqMnGoRMQBoFu6dCfwzYjYIelKSVf2LHop8C8R8dOeaccA\nj0p6CvgBcF9EPDBpm6rQhv8olqem9y2XPR1D03e6NUOdrwi57GmFHChWlab2Nb9Nv6Sm7mBrtia+\nj8UjlRIcKFa3JvVBh8oCmrQzrd2a0hcdKvNoyk602dGEPulQMbOkHCpDNOE/gs2m3PumQ2WA3Hea\nWc591KHSJ+edZdYr177qUDGzpBwqPXJNfrNhcuyzDhUzS8qhUsgx8c3KyK3vOlTIb6eYjSqnPjzz\noZLTzjCbRC59eeZDxczSmtmvPsgl1c1SyuGrEjxSMbOkZjJUPEqxtquzj1dVS3mVpDd66ilfX3bd\n1BwoNivq6usTX1PpqaV8IZ3qhI9L2hAR/WVP/z0ifnPMdc2sIVKMVA7WUo6Id4BuLeVprzsyj1Js\n1tTR56uspXyepK2S7pd0+ojrZlv21Mzeq6oLtU8AJ0bEGcBfA98e9QlyLHtqZoeqpJZyRLwZET8p\n7m8EDpN0VJl1U/Gpj82qqvt+JbWUJR0rScX9lcXvfbXMuik4UGzWVXkMTPzqT0QckNStpbwIuK1b\nS7mYfyvwu8AfSjoAvA1cFp16qwPXnbRNZlaf1tdS9ijF7F1l377vWspmlo1Wh4pHKWbvVcUx0epQ\nMbPqOVTMLKnWhopPfcwGm/ax0dpQMbN6OFTMLKlWhopPfczmN81jpJWhYmb1caiYWVKtCxWf+piV\nM61jpXWhYmb1ak3dH49QzEY3jTpBHqmYWVIOFTNLqhWh4lMfs8mkPIZaESpmlg+HipklVVXZ0z8o\nav5sk/Q9SWf2zNtdTH9SUrnviDSzbFVV9vQ/gY9HxOuSLgHWA+f0zF8dEa9M2hYzq18lZU8j4nsR\n8Xrx8DE69X2S8EVaszRSHUtVlj3t+hxwf8/jADZJ2iJp3bCVXPbUrBkqfUetpNV0QuX8nsnnR8Qe\nSUcDD0l6JiIe6V83ItbTOW1ibm6ueXVFzGZEJWVPASSdAXwDWBsRr3anR8Se4uc+4B46p1Nm1lBV\nlT09EbgbuCIiftgzfbGkI7r3gYuA7WV/sa+nmKWV4piqquzp9cCHgK8XJZUPFNXPjgHuKaa9D/jH\niHhg0jaZWX2SXFOJiI3Axr5pt/bc/zzw+QHrvQCc2T/dzJrL76g1s6QcKmaWVGNDxRdpzaZj0mOr\nsaFiZnlyqJhZUg4VM0vKoWJmSTlUzCwph4qZJeVQMbOkGhkqL/3s7bqbYNZqx5++/Oxx121kqJhZ\nvhwqZpaUQ8XMknKomFlSDhUzS8qhYmZJOVTMLKmqyp5K0s3F/K2Sziq7rpk1y8Sh0lP29BJgOXC5\npOV9i10CLCtu64BbRljXzBqkkrKnxeM7ouMx4EhJx5Vc18wapKqyp8OWKV0ytbfs6U9fe33QImaW\ngcZcqI2I9RExFxFzi5d8sO7mmNkQKer+lCl7OmyZw0qsa2YNUknZ0+Lxp4tXgc4F3oiIvSXXNbMG\nqars6UZgDbALeAv47HzrTtomM6tPVWVPA7iq7Lpm1lyNuVBrZs3gUDGzpBwqZpaUQ8XMknKomFlS\njQyVY9//gbqbYNZqe3Y8vWXcdRsZKmaWL4eKmSXlUDGzpBwqZpaUQ8XMknKomFlSDhUzS6qxoXLN\naWfU3QSzVpr02GpsqJhZnhwqZpaUQ8XMknKomFlSE4WKpCWSHpL0XPHzkNoZkk6Q9K+Snpa0Q9If\n9cy7QdIeSU8WtzWj/H5frDVLK8UxNelI5Vrg4YhYBjxcPO53APjjiFgOnAtc1Vfa9KsRsaK4+btq\nzRpu0lBZC9xe3L8d+GT/AhGxNyKeKO7/N7CTIVUIzaz5Jg2VY4r6PQAvAcfMt7Ckk4BfBb7fM/kL\nkrZKum3Q6VPPugfLnu7fv3/CZpvZtCwYKpI2Sdo+4PaeQupFGY6Y53l+CfgW8MWIeLOYfAtwMrAC\n2At8Zdj6vWVPly5denC6r6uYpZHqWFqw7k9EXDBsnqSXJR0XEXslHQfsG7LcYXQC5R8i4u6e5365\nZ5m/Be4dpfFmlp9JT382AJ8p7n8G+E7/ApIE/B2wMyL+sm/ecT0PLwW2T9geM6vZpKHyZeBCSc8B\nFxSPkfRhSd1Xcn4duAL4jQEvHd8oaZukrcBq4EsTtsfMajZR2dOIeBX4xIDp/0WndjIR8SigIetf\nMcnvN7P8tOIdtb5YazaZlMdQK0LFzPLhUDGzpCa6ppKT7vDtpp1ba26JWXNM49KBRypmllTrQsUX\nbc3Kmdax0rpQMbN6OVTMLKlWhopPgczmN81jpJWhYmb1caiYWVKtDRWfApkNNu1jo7WhYmb1cKiY\nWVKtDhWfApm9VxXHRKtDxcyq1/pQ8WjFrKOqY6H1oWJm1Zp62dNiud3Fd9E+KWnzqOtPyqMVm3VV\nHgNVlD3tWl2UNp0bc/2JOFhsVlXd96de9nTK65tZZqoqexrAJklbJK0bY/0kZU89WrFZU0efX/Dr\nJCVtAo4dMOu63gcREZKGlT09PyL2SDoaeEjSMxHxyAjrExHrgfUAc3NzQ5czs3pVUvY0IvYUP/dJ\nugdYCTwClFrfzJqjirKniyUd0b0PXMS75U0XXD81nwLZrKirr1dR9vQY4FFJTwE/AO6LiAfmW3/a\nHCzWdnX28SrKnr4AnDnK+mbWXK2p+zMq1wmyNsphFO636ZtZUjMfKjkku1kKufTlmQ8VyGdnmI0r\npz7sUCnktFPMRpFb33WomFlSDpUeuSW+2UJy7LMOFTNLyqHSJ8fkNxsk177qUBkg151l1pVzH3Wo\nDJHzTrPZlnvfdKiYWVIOlXnk/h/BZk8T+qRDZQFN2Ik2G5rSFx0qJTRlZ1p7NakPzuxXH4zKX5Vg\ndWhSmHR5pDKiJu5ka6am9jWHyhiaurOtOZrcx6Ze9lTSKUW50+7tTUlfLObdIGlPz7w1k7SnSk3e\n6Za3pvetqZc9jYhni3KnK4CzgbeAe3oW+Wp3fkRs7F/fzJql6rKnnwCej4gfTfh7s9D0/yiWnzb0\nqarKnnZdBtzZN+0LkrZKum3Q6VPu2tAJLA9t6UsLhoqkTZK2D7it7V0uIoJOzeRhz3M48NvAP/dM\nvgU4GVgB7AW+Ms/6E9dSnpa2dAarT5v6kDpZMObK0rPAqp6ypd+NiFOGLLsWuCoiLhoy/yTg3oj4\nlYV+79zcXGzevHnsdk+T38dio8g1TCRtiYi5cdadetnTHpfTd+pTBFHXpbxbDrWxcu0klp+29pUq\nyp52ayhfCNzdt/6NkrZJ2gqsBr40YXuy0NbOYum0uY9MdPpTl5xPf/r5dMh6NSVMJjn98Wd/psyf\nGTJoTpik4LfpV2SWOpW916zte4dKhWatc9ls7nOf/lTMp0OzYRbDpMsjFTNLyiOVmnjE0k6zPELp\n8kilZu6E7eF92eGRSgY8amkuB8mhHCoZ6e2gDpi8OUyG8+lPptxp8+V9Mz+PVDLm06K8OEzKcag0\ngMOlXg6T0ThUGsTXXKrjIBmfQ6WhHDDpOUjScKi0gANmfA6S9BwqLePrL+U4TKbHLymbWVIeqbSU\nT4kO5dFJNRwqM2DQwdT2oHGA1GeiUJH0KeAG4DRgZUQM/OJYSRcDfwUsAr4REd0vyF4C/BNwErAb\n+L2IeH2SNlk5/Qdd00PGIZKPSUcq24HfAf5m2AKSFgFfo/Nt+i8Cj0vaEBFP824t5i9LurZ4/KcT\ntsnG0KTRjAMkbxOFSkTsBJA032IrgV0R8UKx7F10ajA/XfxcVSx3O/BdHCrZWOjgnVboODSarYpr\nKscDP+55/CJwTnG/dC1mSeuAdcXDn0tqfOGxAY4CXqm7EVNSetv+ZMoNSayt+2xgpdEyFgwVSZuA\nYwfMui4i5qtIOJKICElDixBFxHpgfdGmzePWJMlZW7cL2rttbd6ucdddMFQi4oJxn7ywBzih5/FH\nimkAL0s6rqcW874Jf5eZ1ayKN789DiyT9FFJhwOX0anBDKPVYjazBpgoVCRdKulF4NeA+yQ9WEw/\nWEs5Ig4AVwMPAjuBb0bEjuIpBtZiLmH9JO3OWFu3C9q7bd6uPo2spWxm+fJnf8wsKYeKmSXViFCR\n9ClJOyT9n6ShL99JuljSs5J2Fe/QzZqkJZIekvRc8fODQ5bbLWmbpCcnealv2hb6+6vj5mL+Vkln\n1dHOcZTYtlWS3ij20ZOSrq+jnaOSdJukfcPe9zXWPouI7G90Plt0Cp133M4NWWYR8DxwMnA48BSw\nvO62L7BdNwLXFvevBf5iyHK7gaPqbu8C27Lg3x9YA9wPCDgX+H7d7U64bauAe+tu6xjb9jHgLGD7\nkPkj77NGjFQiYmdEPLvAYgc/DhAR7wDdjwPkbC2djydQ/PxkjW2ZVJm//1rgjuh4DDiyeH9S7prY\nt0qJiEeA1+ZZZOR91ohQKWnQxwGOr6ktZZX9mEIAmyRtKT6ukKMyf/8m7iMo3+7zilOE+yWdXk3T\npm7kfZbN96lU9XGAqs23Xb0PIub9mML5EbFH0tHAQ5KeKf7DWD6eAE6MiJ9IWgN8G1hWc5tqkU2o\nxHQ/DlCb+bZLUqmPKUTEnuLnPkn30BmO5xYqZf7+We6jEhZsd0S82XN/o6SvSzoqIpr+YcOR91mb\nTn/m+zhArhb8mIKkxZKO6N4HLqLzPTa5KfP33wB8unhF4VzgjZ7Tv5wtuG2SjlXxHSCSVtI5tl6t\nvKXpjb7P6r76XPIK9aV0zuV+DrwMPFhM/zCwse9K9Q/pXKm/ru52l9iuDwEPA88Bm4Al/dtF5xWH\np4rbjpy3a9DfH7gSuLK4Lzpf2PU8sI0hr+TleCuxbVcX++cp4DHgvLrbXHK77gT2Av9THGOfm3Sf\n+W36ZpZUm05/zCwDDhUzS8qhYmZJOVTMLCmHipkl5VAxs6QcKmaW1P8DRoZPsByu29gAAAAASUVO\nRK5CYII=\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "universe.plot(width=(2.0, 2.0))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "By default, the plot will appear in the $x$-$y$ plane. We can change that with the `basis` argument." + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAARUAAAD8CAYAAABZ0jAcAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nAElFTkSuQmCC\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "universe.plot(width=(2.0, 2.0), basis='xz')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "If we have particular fondness for, say, fuchsia, we can tell the `plot()` method to make our cell that color." + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAARUAAAD8CAYAAABZ0jAcAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n/h+9QcZO3frUoAAAAABJRU5ErkJggg==\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "universe.plot(width=(2.0, 2.0), basis='xz',\n", + " colors={cell: 'fuchsia'})" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Pin cell geometry\n", + "\n", + "We now have enough knowledge to create our pin-cell. We need three surfaces to define the fuel and clad:\n", + "\n", + "1. The outer surface of the fuel -- a cylinder perpendicular to the z axis\n", + "2. The inner surface of the clad -- same as above\n", + "3. The outer surface of the clad -- same as above\n", + "\n", + "These three surfaces will all be instances of `openmc.ZCylinder`, each with a different radius according to the specification." + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "fuel_or = openmc.ZCylinder(R=0.39)\n", + "clad_ir = openmc.ZCylinder(R=0.40)\n", + "clad_or = openmc.ZCylinder(R=0.46)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "With the surfaces created, we can now take advantage of the built-in operators on surfaces to create regions for the fuel, the gap, and the clad:" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "fuel_region = -fuel_or\n", + "gap_region = +fuel_or & -clad_ir\n", + "clad_region = +clad_ir & -clad_or" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we can create corresponding cells that assign materials to these regions. As with materials, cells have unique IDs that are assigned either manually or automatically. Note that the gap cell doesn't have any material assigned (it is void by default)." + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "fuel = openmc.Cell(1, 'fuel')\n", + "fuel.fill = uo2\n", + "fuel.region = fuel_region\n", + "\n", + "gap = openmc.Cell(2, 'air gap')\n", + "gap.region = gap_region\n", + "\n", + "clad = openmc.Cell(3, 'clad')\n", + "clad.fill = zirconium\n", + "clad.region = clad_region" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Finally, we need to handle the coolant outside of our fuel pin. To do this, we create x- and y-planes that bound the geometry." + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "pitch = 1.26\n", + "left = openmc.XPlane(x0=-pitch/2, boundary_type='reflective')\n", + "right = openmc.XPlane(x0=pitch/2, boundary_type='reflective')\n", + "bottom = openmc.YPlane(y0=-pitch/2, boundary_type='reflective')\n", + "top = openmc.YPlane(y0=pitch/2, boundary_type='reflective')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The water region is going to be everything outside of the clad outer radius and within the box formed as the intersection of four half-spaces." + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "water_region = +left & -right & +bottom & -top & +clad_or\n", + "\n", + "moderator = openmc.Cell(4, 'moderator')\n", + "moderator.fill = water\n", + "moderator.region = water_region" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "OpenMC also includes a factory function that generates a rectangular prism that could have made our lives easier." + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "openmc.region.Intersection" + ] + }, + "execution_count": 33, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "box = openmc.get_rectangular_prism(width=pitch, height=pitch,\n", + " boundary_type='reflective')\n", + "type(box)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Pay attention here -- the object that was returned is NOT a surface. It is actually the intersection of four surface half-spaces, just like we created manually before. Thus, we don't need to apply the unary operator (`-box`). Instead, we can directly combine it with `+clad_or`." + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "water_region = box & +clad_or" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The final step is to assign the cells we created to a universe and tell OpenMC that this universe is the \"root\" universe in our geometry. The `Geometry` is the final object that is actually exported to XML." + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r\n", + "\r\n", + " \r\n", + " \r\n", + " \r\n", + " \r\n", + " \r\n", + " \r\n", + " \r\n", + " \r\n", + " \r\n", + " \r\n", + " \r\n", + "\r\n" + ] + } + ], + "source": [ + "root = openmc.Universe(cells=(fuel, gap, clad, moderator))\n", + "\n", + "geom = openmc.Geometry()\n", + "geom.root_universe = root\n", + "\n", + "# or...\n", + "geom = openmc.Geometry(root)\n", + "geom.export_to_xml()\n", + "!cat geometry.xml" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Starting source and settings\n", + "\n", + "The Python API has a module ``openmc.stats`` with various univariate and multivariate probability distributions. We can use these distributions to create a starting source using the ``openmc.Source`` object." + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "point = openmc.stats.Point((0, 0, 0))\n", + "src = openmc.Source(space=point)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now let's create a `Settings` object and give it the source we created along with specifying how many batches and particles we want to run." + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "settings = openmc.Settings()\n", + "settings.source = src\n", + "settings.batches = 100\n", + "settings.inactive = 10\n", + "settings.particles = 1000" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r\n", + "\r\n", + " eigenvalue\r\n", + " 1000\r\n", + " 100\r\n", + " 10\r\n", + " \r\n", + " \r\n", + " 0 0 0\r\n", + " \r\n", + " \r\n", + "\r\n" + ] + } + ], + "source": [ + "settings.export_to_xml()\n", + "!cat settings.xml" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## User-defined tallies\n", + "\n", + "We actually have all the *required* files needed to run a simulation. Before we do that though, let's give a quick example of how to create tallies. We will show how one would tally the total, fission, absorption, and (n,$\\gamma$) reaction rates for $^{235}$U in the cell containing fuel. Recall that filters allow us to specify *where* in phase-space we want events to be tallied and scores tell us *what* we want to tally:\n", + "\n", + "$$X = \\underbrace{\\int d\\mathbf{r} \\int d\\mathbf{\\Omega} \\int dE}_{\\text{filters}} \\; \\underbrace{f(\\mathbf{r},\\mathbf{\\Omega},E)}_{\\text{scores}} \\psi (\\mathbf{r},\\mathbf{\\Omega},E)$$\n", + "\n", + "In this case, the *where* is \"the fuel cell\". So, we will create a cell filter specifying the fuel cell." + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "cell_filter = openmc.CellFilter(fuel.id)\n", + "\n", + "t = openmc.Tally(1)\n", + "t.filters = [cell_filter]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "One oddity to point out -- we have to give the ID of the fuel cell, not the `Cell` object itself (this may change in the future).\n", + "\n", + "The *what* is the total, fission, absorption, and (n,$\\gamma$) reaction rates in $^{235}$U. By default, if we only specify what reactions, it will gives us tallies over all nuclides. We can use the `nuclides` attribute to name specific nuclides we're interested in." + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "t.nuclides = ['U235']\n", + "t.scores = ['total', 'fission', 'absorption', '(n,gamma)']" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Similar to the other files, we need to create a `Tallies` collection and export it to XML." + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r\n", + "\r\n", + " \r\n", + " \r\n", + " U235\r\n", + " total fission absorption (n,gamma)\r\n", + " \r\n", + "\r\n" + ] + } + ], + "source": [ + "tallies = openmc.Tallies([t])\n", + "tallies.export_to_xml()\n", + "!cat tallies.xml" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Running OpenMC\n", + "\n", + "Running OpenMC from Python can be done using the `openmc.run()` function. This function allows you to set the number of MPI processes and OpenMP threads, if need be." + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": { + "collapsed": false, + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + " %%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%\n", + " ############### %%%%%%%%%%%%%%%%%%%%%%%%\n", + " ################## %%%%%%%%%%%%%%%%%%%%%%%\n", + " ################### %%%%%%%%%%%%%%%%%%%%%%%\n", + " #################### %%%%%%%%%%%%%%%%%%%%%%\n", + " ##################### %%%%%%%%%%%%%%%%%%%%%\n", + " ###################### %%%%%%%%%%%%%%%%%%%%\n", + " ####################### %%%%%%%%%%%%%%%%%%\n", + " ####################### %%%%%%%%%%%%%%%%%\n", + " ###################### %%%%%%%%%%%%%%%%%\n", + " #################### %%%%%%%%%%%%%%%%%\n", + " ################# %%%%%%%%%%%%%%%%%\n", + " ############### %%%%%%%%%%%%%%%%\n", + " ############ %%%%%%%%%%%%%%%\n", + " ######## %%%%%%%%%%%%%%\n", + " %%%%%%%%%%%\n", + "\n", + " | The OpenMC Monte Carlo Code\n", + " Copyright | 2011-2017 Massachusetts Institute of Technology\n", + " License | http://openmc.readthedocs.io/en/latest/license.html\n", + " Version | 0.8.0\n", + " Git SHA1 | f7edad68f0654d775ed363bfdcbe4aa5d3cfba23\n", + " Date/Time | 2017-04-03 14:32:56\n", + "\n", + " Reading settings XML file...\n", + " Reading geometry XML file...\n", + " Reading materials XML file...\n", + " Reading cross sections XML file...\n", + " Reading U235 from /home/romano/openmc/scripts/nndc_hdf5/U235.h5\n", + " Reading U238 from /home/romano/openmc/scripts/nndc_hdf5/U238.h5\n", + " Reading O16 from /home/romano/openmc/scripts/nndc_hdf5/O16.h5\n", + " Reading Zr90 from /home/romano/openmc/scripts/nndc_hdf5/Zr90.h5\n", + " Reading Zr91 from /home/romano/openmc/scripts/nndc_hdf5/Zr91.h5\n", + " Reading Zr92 from /home/romano/openmc/scripts/nndc_hdf5/Zr92.h5\n", + " Reading Zr94 from /home/romano/openmc/scripts/nndc_hdf5/Zr94.h5\n", + " Reading Zr96 from /home/romano/openmc/scripts/nndc_hdf5/Zr96.h5\n", + " Reading H1 from /home/romano/openmc/scripts/nndc_hdf5/H1.h5\n", + " Reading O17 from /home/romano/openmc/scripts/nndc_hdf5/O17.h5\n", + " Reading c_H_in_H2O from /home/romano/openmc/scripts/nndc_hdf5/c_H_in_H2O.h5\n", + " Maximum neutron transport energy: 2.00000E+07 eV for U235\n", + " Reading tallies XML file...\n", + " Building neighboring cells lists for each surface...\n", + " Initializing source particles...\n", + "\n", + " ====================> K EIGENVALUE SIMULATION <====================\n", + "\n", + " Bat./Gen. k Average k \n", + " ========= ======== ==================== \n", + " 1/1 1.32572 \n", + " 2/1 1.46138 \n", + " 3/1 1.46068 \n", + " 4/1 1.39592 \n", + " 5/1 1.37519 \n", + " 6/1 1.38777 \n", + " 7/1 1.50242 \n", + " 8/1 1.42042 \n", + " 9/1 1.47458 \n", + " 10/1 1.49148 \n", + " 11/1 1.39339 \n", + " 12/1 1.40637 1.39988 +/- 0.00649\n", + " 13/1 1.42972 1.40983 +/- 0.01063\n", + " 14/1 1.46319 1.42317 +/- 0.01531\n", + " 15/1 1.41538 1.42161 +/- 0.01196\n", + " 16/1 1.38163 1.41494 +/- 0.01182\n", + " 17/1 1.41257 1.41461 +/- 0.01000\n", + " 18/1 1.43455 1.41710 +/- 0.00901\n", + " 19/1 1.33136 1.40757 +/- 0.01241\n", + " 20/1 1.41560 1.40837 +/- 0.01113\n", + " 21/1 1.38911 1.40662 +/- 0.01021\n", + " 22/1 1.28621 1.39659 +/- 0.01370\n", + " 23/1 1.45693 1.40123 +/- 0.01343\n", + " 24/1 1.46839 1.40603 +/- 0.01333\n", + " 25/1 1.46738 1.41012 +/- 0.01306\n", + " 26/1 1.43977 1.41197 +/- 0.01236\n", + " 27/1 1.44066 1.41366 +/- 0.01173\n", + " 28/1 1.39358 1.41254 +/- 0.01112\n", + " 29/1 1.39142 1.41143 +/- 0.01057\n", + " 30/1 1.38525 1.41012 +/- 0.01012\n", + " 31/1 1.38025 1.40870 +/- 0.00973\n", + " 32/1 1.45348 1.41074 +/- 0.00949\n", + " 33/1 1.35893 1.40848 +/- 0.00935\n", + " 34/1 1.32332 1.40493 +/- 0.00963\n", + " 35/1 1.46285 1.40725 +/- 0.00952\n", + " 36/1 1.33760 1.40457 +/- 0.00953\n", + " 37/1 1.41117 1.40482 +/- 0.00917\n", + " 38/1 1.45574 1.40664 +/- 0.00903\n", + " 39/1 1.43472 1.40760 +/- 0.00876\n", + " 40/1 1.30110 1.40405 +/- 0.00918\n", + " 41/1 1.41765 1.40449 +/- 0.00889\n", + " 42/1 1.45300 1.40601 +/- 0.00874\n", + " 43/1 1.40491 1.40597 +/- 0.00847\n", + " 44/1 1.42053 1.40640 +/- 0.00823\n", + " 45/1 1.38805 1.40588 +/- 0.00801\n", + " 46/1 1.34293 1.40413 +/- 0.00798\n", + " 47/1 1.35441 1.40279 +/- 0.00787\n", + " 48/1 1.29370 1.39991 +/- 0.00818\n", + " 49/1 1.48467 1.40209 +/- 0.00826\n", + " 50/1 1.41759 1.40248 +/- 0.00806\n", + " 51/1 1.37151 1.40172 +/- 0.00790\n", + " 52/1 1.42403 1.40225 +/- 0.00773\n", + " 53/1 1.38826 1.40193 +/- 0.00755\n", + " 54/1 1.48944 1.40392 +/- 0.00764\n", + " 55/1 1.41452 1.40415 +/- 0.00747\n", + " 56/1 1.47337 1.40566 +/- 0.00746\n", + " 57/1 1.35700 1.40462 +/- 0.00738\n", + " 58/1 1.40305 1.40459 +/- 0.00722\n", + " 59/1 1.41608 1.40482 +/- 0.00708\n", + " 60/1 1.47254 1.40618 +/- 0.00706\n", + " 61/1 1.36847 1.40544 +/- 0.00696\n", + " 62/1 1.34103 1.40420 +/- 0.00694\n", + " 63/1 1.39510 1.40403 +/- 0.00681\n", + " 64/1 1.40228 1.40399 +/- 0.00668\n", + " 65/1 1.29401 1.40200 +/- 0.00686\n", + " 66/1 1.42693 1.40244 +/- 0.00675\n", + " 67/1 1.36447 1.40177 +/- 0.00666\n", + " 68/1 1.37498 1.40131 +/- 0.00656\n", + " 69/1 1.36958 1.40077 +/- 0.00647\n", + " 70/1 1.38585 1.40053 +/- 0.00637\n", + " 71/1 1.42133 1.40087 +/- 0.00627\n", + " 72/1 1.44900 1.40164 +/- 0.00622\n", + " 73/1 1.37696 1.40125 +/- 0.00613\n", + " 74/1 1.48851 1.40261 +/- 0.00619\n", + " 75/1 1.38933 1.40241 +/- 0.00610\n", + " 76/1 1.41780 1.40264 +/- 0.00601\n", + " 77/1 1.41054 1.40276 +/- 0.00592\n", + " 78/1 1.38194 1.40246 +/- 0.00584\n", + " 79/1 1.38446 1.40219 +/- 0.00576\n", + " 80/1 1.37504 1.40181 +/- 0.00569\n", + " 81/1 1.40550 1.40186 +/- 0.00561\n", + " 82/1 1.49785 1.40319 +/- 0.00569\n", + " 83/1 1.35613 1.40255 +/- 0.00565\n", + " 84/1 1.41786 1.40275 +/- 0.00557\n", + " 85/1 1.38444 1.40251 +/- 0.00550\n", + " 86/1 1.40459 1.40254 +/- 0.00543\n", + " 87/1 1.39923 1.40249 +/- 0.00536\n", + " 88/1 1.44540 1.40304 +/- 0.00532\n", + " 89/1 1.45962 1.40376 +/- 0.00530\n", + " 90/1 1.37057 1.40335 +/- 0.00525\n", + " 91/1 1.38115 1.40307 +/- 0.00519\n", + " 92/1 1.35758 1.40252 +/- 0.00516\n", + " 93/1 1.34508 1.40182 +/- 0.00514\n", + " 94/1 1.31471 1.40079 +/- 0.00519\n", + " 95/1 1.41434 1.40095 +/- 0.00513\n", + " 96/1 1.33895 1.40023 +/- 0.00512\n", + " 97/1 1.44716 1.40077 +/- 0.00509\n", + " 98/1 1.38455 1.40058 +/- 0.00503\n", + " 99/1 1.52127 1.40194 +/- 0.00516\n", + " 100/1 1.35488 1.40141 +/- 0.00513\n", + " Creating state point statepoint.100.h5...\n", + "\n", + " =======================> TIMING STATISTICS <=======================\n", + "\n", + " Total time for initialization = 8.8597E-01 seconds\n", + " Reading cross sections = 8.3612E-01 seconds\n", + " Total time in simulation = 1.7084E+01 seconds\n", + " Time in transport only = 1.7074E+01 seconds\n", + " Time in inactive batches = 2.0984E+00 seconds\n", + " Time in active batches = 1.4986E+01 seconds\n", + " Time synchronizing fission bank = 2.5280E-03 seconds\n", + " Sampling source sites = 1.8110E-03 seconds\n", + " SEND/RECV source sites = 5.9664E-04 seconds\n", + " Time accumulating tallies = 6.1651E-05 seconds\n", + " Total time for finalization = 1.3478E-04 seconds\n", + " Total time elapsed = 1.7974E+01 seconds\n", + " Calculation Rate (inactive) = 4765.45 neutrons/second\n", + " Calculation Rate (active) = 6005.68 neutrons/second\n", + "\n", + " ============================> RESULTS <============================\n", + "\n", + " k-effective (Collision) = 1.39737 +/- 0.00470\n", + " k-effective (Track-length) = 1.40141 +/- 0.00513\n", + " k-effective (Absorption) = 1.39596 +/- 0.00308\n", + " Combined k-effective = 1.39719 +/- 0.00286\n", + " Leakage Fraction = 0.00000 +/- 0.00000\n", + "\n" + ] + }, + { + "data": { + "text/plain": [ + "0" + ] + }, + "execution_count": 42, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "openmc.run()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Great! OpenMC already told us our k-effective. It also spit out a file called `tallies.out` that shows our tallies. This is a very basic method to look at tally data; for more sophisticated methods, see other example notebooks." + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r\n", + " ============================> TALLY 1 <============================\r\n", + "\r\n", + " Cell 1\r\n", + " U235\r\n", + " Total Reaction Rate 0.731003 +/- 2.53759E-03\r\n", + " Fission Rate 0.547587 +/- 2.10114E-03\r\n", + " Absorption Rate 0.657406 +/- 2.45390E-03\r\n", + " (n,gamma) 0.109821 +/- 3.68054E-04\r\n" + ] + } + ], + "source": [ + "!cat tallies.out" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Geometry plotting\n", + "\n", + "We saw before that we could call the `Universe.plot()` method to show a universe while we were creating out geometry. There is also a built-in plotter in the Fortran codebase that is much faster than the Python plotter and has more options. The interface looks somewhat similar to the `Universe.plot()` method. Instead though, we create `Plot` instances, assign them to a `Plots` collection, export it to XML, and then run OpenMC in geometry plotting mode. As an example, let's specify that we want the plot to be colored by material (rather than by cell) and we assign yellow to fuel and blue to water." + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "p = openmc.Plot()\n", + "p.filename = 'pinplot'\n", + "p.width = (pitch, pitch)\n", + "p.pixels = (200, 200)\n", + "p.color_by = 'material'\n", + "p.colors = {uo2: 'yellow', water: 'blue'}" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "With our plot created, we need to add it to a `Plots` collection which can be exported to XML." + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r\n", + "\r\n", + " \r\n", + " 0.0 0.0 0.0\r\n", + " 1.26 1.26\r\n", + " 200 200\r\n", + " \r\n", + " \r\n", + " \r\n", + "\r\n" + ] + } + ], + "source": [ + "plots = openmc.Plots([p])\n", + "plots.export_to_xml()\n", + "!cat plots.xml" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we can run OpenMC in plotting mode by calling the `plot_geometry()` function. Under the hood this is calling `openmc --plot`." + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + " %%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%\n", + " ############### %%%%%%%%%%%%%%%%%%%%%%%%\n", + " ################## %%%%%%%%%%%%%%%%%%%%%%%\n", + " ################### %%%%%%%%%%%%%%%%%%%%%%%\n", + " #################### %%%%%%%%%%%%%%%%%%%%%%\n", + " ##################### %%%%%%%%%%%%%%%%%%%%%\n", + " ###################### %%%%%%%%%%%%%%%%%%%%\n", + " ####################### %%%%%%%%%%%%%%%%%%\n", + " ####################### %%%%%%%%%%%%%%%%%\n", + " ###################### %%%%%%%%%%%%%%%%%\n", + " #################### %%%%%%%%%%%%%%%%%\n", + " ################# %%%%%%%%%%%%%%%%%\n", + " ############### %%%%%%%%%%%%%%%%\n", + " ############ %%%%%%%%%%%%%%%\n", + " ######## %%%%%%%%%%%%%%\n", + " %%%%%%%%%%%\n", + "\n", + " | The OpenMC Monte Carlo Code\n", + " Copyright | 2011-2017 Massachusetts Institute of Technology\n", + " License | http://openmc.readthedocs.io/en/latest/license.html\n", + " Version | 0.8.0\n", + " Git SHA1 | f7edad68f0654d775ed363bfdcbe4aa5d3cfba23\n", + " Date/Time | 2017-04-03 14:33:15\n", + "\n", + " Reading settings XML file...\n", + " Reading geometry XML file...\n", + " Reading materials XML file...\n", + " Reading cross sections XML file...\n", + " Reading tallies XML file...\n", + " Reading plot XML file...\n", + " Building neighboring cells lists for each surface...\n", + "\n", + " =======================> PLOTTING SUMMARY <========================\n", + "\n", + " Plot ID: 10000\n", + " Plot file: pinplot.ppm\n", + " Universe depth: -1\n", + " Plot Type: Slice\n", + " Origin: 0.0 0.0 0.0\n", + " Width: 1.26000 1.26000\n", + " Coloring: Materials\n", + " Basis: xy\n", + " Pixels: 200 200\n", + "\n", + " Processing plot 10000: pinplot.ppm ...\n" + ] + }, + { + "data": { + "text/plain": [ + "0" + ] + }, + "execution_count": 46, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "openmc.plot_geometry()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "OpenMC writes out a peculiar image with a `.ppm` extension. If you have ImageMagick installed, this can be converted into a more normal `.png` file." + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "!convert pinplot.ppm pinplot.png" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can use functionality from IPython to display the image inline in our notebook:" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "metadata": { + "collapsed": false, + "scrolled": false + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAMgAAADIAgMAAADQNkYNAAAABGdBTUEAALGPC/xhBQAAACBjSFJN\nAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAAADFBMVEX///8AAP9yEhL//wDh\n3HbeAAAAAWJLR0QAiAUdSAAAAAd0SU1FB+EEAxMhD/S5fvIAAAKHSURBVGje7dlLjoJAEAZgMrNj\n4z28hKcYFhzBU5hwAFfsTQwJcIqJyzkNcU3SAw2j/agq4Zegk3Rv9Ut3VSt0V0XR/PE1ewQSSCCB\nBHIfSTGT1Hrk00lSj6OYTOrbyCeS/Z3U00hqiLqaQpLaGsUEsrdJ/Zg4kxDTRI8m8afxyPi9Q/ca\nZRLtkiFd5fDqjcmkRdQkZbRR3WhHk4tkCD7aqWFEWyIBDtHBHzaj6OYhEuAQvaxPdRtN7K/MJnpd\nB2WMb39lNunzVW5M0sZezmziTTJOk7Mk8SYZpylY0q/rtLOJ+nBXZpE+xZ+OUM3WSbNF+nW5kygV\nO8GYJPGD/0tAwZCUWtewsoohe3Jdw8p4ciKEuvCk+ySjSGPHb5A++g1F2q0Vv0FSJhQdTEUSLhQ3\nGJtkNGk4woUyBJMTJGFD0cEUNGFC0cFQJJVJRZOMIw1N9mz0Q/wE6RLGRa+UmTKTlDyJKSIlzE7Z\nM0RKmJ0ykxx50lJEyrGdZZPwCdNZJkgpkZgg3bYIQv3cN8YgJ4lcSHKWyNUnibgtemOKRchRIq1P\nUnEn9V5WixBpJ/vtd8mDzTe3/zkiiv4XswQ5yeTikXoCyRcgZ5lcX0YymTSBWOTR08J8XqxK3jZj\n70ze9l+5xkMJeFqu9Rhf45UEvCvXeYkDp4t1jj3AeQw79c0+WwInWOicPPs0Dpz5gZvFOlce4C6G\n3PiAeyVwewXuyMBNHLjvA1UFpHYBVEiAOgxQ7QFqSkjlCqiPAVU4oNYHVBSRuiVQHQVqsEClF6kn\nA1VroDaOVOCBOj/QTUB6FkBnBOm/AF0eoJeEdKyAvhjSfUN6fEgnEehX6pkK7pP/1+ENJJBAAnkF\n+QXfoOhE52QgVwAAACV0RVh0ZGF0ZTpjcmVhdGUAMjAxNy0wNC0wM1QxNDozMzoxNS0wNTowMI92\nsmsAAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTctMDQtMDNUMTQ6MzM6MTUtMDU6MDD+KwrXAAAAAElF\nTkSuQmCC\n", + "text/plain": [ + "" + ] + }, + "execution_count": 48, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from IPython.display import Image\n", + "Image(\"pinplot.png\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "That was a little bit cumbersome. Thankfully, OpenMC provides us with a function that does all that \"boilerplate\" work." + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAMgAAADIAgMAAADQNkYNAAAABGdBTUEAALGPC/xhBQAAACBjSFJN\nAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAAADFBMVEX///8AAP9yEhL//wDh\n3HbeAAAAAWJLR0QAiAUdSAAAAAd0SU1FB+EEAxMhD/S5fvIAAAKHSURBVGje7dlLjoJAEAZgMrNj\n4z28hKcYFhzBU5hwAFfsTQwJcIqJyzkNcU3SAw2j/agq4Zegk3Rv9Ut3VSt0V0XR/PE1ewQSSCCB\nBHIfSTGT1Hrk00lSj6OYTOrbyCeS/Z3U00hqiLqaQpLaGsUEsrdJ/Zg4kxDTRI8m8afxyPi9Q/ca\nZRLtkiFd5fDqjcmkRdQkZbRR3WhHk4tkCD7aqWFEWyIBDtHBHzaj6OYhEuAQvaxPdRtN7K/MJnpd\nB2WMb39lNunzVW5M0sZezmziTTJOk7Mk8SYZpylY0q/rtLOJ+nBXZpE+xZ+OUM3WSbNF+nW5kygV\nO8GYJPGD/0tAwZCUWtewsoohe3Jdw8p4ciKEuvCk+ySjSGPHb5A++g1F2q0Vv0FSJhQdTEUSLhQ3\nGJtkNGk4woUyBJMTJGFD0cEUNGFC0cFQJJVJRZOMIw1N9mz0Q/wE6RLGRa+UmTKTlDyJKSIlzE7Z\nM0RKmJ0ykxx50lJEyrGdZZPwCdNZJkgpkZgg3bYIQv3cN8YgJ4lcSHKWyNUnibgtemOKRchRIq1P\nUnEn9V5WixBpJ/vtd8mDzTe3/zkiiv4XswQ5yeTikXoCyRcgZ5lcX0YymTSBWOTR08J8XqxK3jZj\n70ze9l+5xkMJeFqu9Rhf45UEvCvXeYkDp4t1jj3AeQw79c0+WwInWOicPPs0Dpz5gZvFOlce4C6G\n3PiAeyVwewXuyMBNHLjvA1UFpHYBVEiAOgxQ7QFqSkjlCqiPAVU4oNYHVBSRuiVQHQVqsEClF6kn\nA1VroDaOVOCBOj/QTUB6FkBnBOm/AF0eoJeEdKyAvhjSfUN6fEgnEehX6pkK7pP/1+ENJJBAAnkF\n+QXfoOhE52QgVwAAACV0RVh0ZGF0ZTpjcmVhdGUAMjAxNy0wNC0wM1QxNDozMzoxNS0wNTowMI92\nsmsAAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTctMDQtMDNUMTQ6MzM6MTUtMDU6MDD+KwrXAAAAAElF\nTkSuQmCC\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "openmc.plot_inline(p)" + ] + } + ], + "metadata": { + "anaconda-cloud": {}, + "kernelspec": { + "display_name": "Python [default]", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.5.2" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/docs/source/examples/pincell.rst b/docs/source/examples/pincell.rst new file mode 100644 index 0000000000..242b545d80 --- /dev/null +++ b/docs/source/examples/pincell.rst @@ -0,0 +1,13 @@ +.. _notebook_pincell: + +=================== +Modeling a Pin-Cell +=================== + +.. only:: html + + .. notebook:: pincell.ipynb + +.. only:: latex + + IPython notebooks must be viewed in the online HTML documentation. diff --git a/docs/source/examples/triso.ipynb b/docs/source/examples/triso.ipynb new file mode 100644 index 0000000000..67be63a527 --- /dev/null +++ b/docs/source/examples/triso.ipynb @@ -0,0 +1,378 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "OpenMC includes a few convenience functions for generationing TRISO particle locations and placing them in a lattice. To be clear, this capability is not a stochastic geometry capability like that included in MCNP. It's also important to note that OpenMC does not use delta tracking, which would normally speed up calculations in geometries with tons of surfaces and cells. However, the computational burden can be eased by placing TRISO particles in a lattice." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "%matplotlib inline\n", + "from math import pi\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import openmc\n", + "import openmc.model" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's first start by creating materials that will be used in our TRISO particles and the background material." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "fuel = openmc.Material(name='Fuel')\n", + "fuel.set_density('g/cm3', 10.5)\n", + "fuel.add_nuclide('U235', 4.6716e-02)\n", + "fuel.add_nuclide('U238', 2.8697e-01)\n", + "fuel.add_nuclide('O16', 5.0000e-01)\n", + "fuel.add_element('C', 1.6667e-01)\n", + "\n", + "buff = openmc.Material(name='Buffer')\n", + "buff.set_density('g/cm3', 1.0)\n", + "buff.add_element('C', 1.0)\n", + "buff.add_s_alpha_beta('c_Graphite')\n", + "\n", + "PyC1 = openmc.Material(name='PyC1')\n", + "PyC1.set_density('g/cm3', 1.9)\n", + "PyC1.add_element('C', 1.0)\n", + "PyC1.add_s_alpha_beta('c_Graphite')\n", + "\n", + "PyC2 = openmc.Material(name='PyC2')\n", + "PyC2.set_density('g/cm3', 1.87)\n", + "PyC2.add_element('C', 1.0)\n", + "PyC2.add_s_alpha_beta('c_Graphite')\n", + "\n", + "SiC = openmc.Material(name='SiC')\n", + "SiC.set_density('g/cm3', 3.2)\n", + "SiC.add_element('C', 0.5)\n", + "SiC.add_element('Si', 0.5)\n", + "\n", + "graphite = openmc.Material()\n", + "graphite.set_density('g/cm3', 1.1995)\n", + "graphite.add_element('C', 1.0)\n", + "graphite.add_s_alpha_beta('c_Graphite')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To actually create individual TRISO particles, we first need to create a universe that will be used within each particle. The reason we use the same universe for each TRISO particle is to reduce the total number of cells/surfaces needed which can improve performance by a factor of two over using unique cells/surfaces in each." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "# Create TRISO universe\n", + "spheres = [openmc.Sphere(R=r*1e-4)\n", + " for r in [215., 315., 350., 385.]]\n", + "cells = [openmc.Cell(fill=fuel, region=-spheres[0]),\n", + " openmc.Cell(fill=buff, region=+spheres[0] & -spheres[1]),\n", + " openmc.Cell(fill=PyC1, region=+spheres[1] & -spheres[2]),\n", + " openmc.Cell(fill=SiC, region=+spheres[2] & -spheres[3]),\n", + " openmc.Cell(fill=PyC2, region=+spheres[3])]\n", + "triso_univ = openmc.Universe(cells=cells)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now that we have a universe that can be used for each TRISO particle, we need to randomly select locations. In this example, we will select locations at random within in a 1 cm x 1 cm x 1 cm box centered at the origin with a packing fraction of 30%. Note that `pack_trisos` can handle up to the theoretical maximum of 60% (it will just be slow)." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "outer_radius = 425.*1e-4\n", + "\n", + "trisos = openmc.model.pack_trisos(\n", + " radius=outer_radius,\n", + " fill=triso_univ,\n", + " domain_shape='cube',\n", + " domain_length=1,\n", + " packing_fraction=0.3\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Each TRISO object actually **is** a Cell, in fact; we can look at the properties of the TRISO just as we would a cell:" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Cell\n", + "\tID =\t10005\n", + "\tName =\t\n", + "\tFill =\t10000\n", + "\tRegion =\t-10004\n", + "\tRotation =\tNone\n", + "\tTranslation =\t[-0.33455672 0.31790187 0.24135378]\n", + "\n" + ] + } + ], + "source": [ + "print(trisos[0])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's confirm that all our TRISO particles are within the box." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[-0.45718713 -0.45730405 -0.45725048]\n", + "[ 0.45705454 0.45743843 0.45741142]\n" + ] + } + ], + "source": [ + "centers = np.vstack([t.center for t in trisos])\n", + "print(centers.min(axis=0))\n", + "print(centers.max(axis=0))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can also look at what the actual packing fraction turned out to be:" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "0.2996893513959326" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "len(trisos)*4/3*pi*outer_radius**3" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now that we have our TRISO particles created, we need to place them in a lattice to provide optimal tracking performance in OpenMC. We'll start by creating a box that the lattice will be placed within." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "collapsed": false, + "scrolled": true + }, + "outputs": [], + "source": [ + "min_x = openmc.XPlane(x0=-0.5, boundary_type='reflective')\n", + "max_x = openmc.XPlane(x0=0.5, boundary_type='reflective')\n", + "min_y = openmc.YPlane(y0=-0.5, boundary_type='reflective')\n", + "max_y = openmc.YPlane(y0=0.5, boundary_type='reflective')\n", + "min_z = openmc.ZPlane(z0=-0.5, boundary_type='reflective')\n", + "max_z = openmc.ZPlane(z0=0.5, boundary_type='reflective')\n", + "box = openmc.Cell(region=+min_x & -max_x & +min_y & -max_y & +min_z & -max_z)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Our last step is to actually create a lattice containing TRISO particles which can be done with `model.create_triso_lattice()` function. This function requires that we give it a list of TRISO particles, the lower-left coordinates of the lattice, the pitch of each lattice cell, the overall shape of the lattice (number of cells in each direction), and a background material." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "lower_left, upper_right = box.region.bounding_box\n", + "shape = (3, 3, 3)\n", + "pitch = (upper_right - lower_left)/shape\n", + "lattice = openmc.model.create_triso_lattice(\n", + " trisos, lower_left, pitch, shape, graphite)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we can set the fill of our box cell to be the lattice:" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "box.fill = lattice" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Finally, let's take a look at our geometry by putting the box in a universe and plotting it. We're going to use the Fortran-side plotter since it's much faster." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZAAAAGQBAMAAABykSv/AAAABGdBTUEAALGPC/xhBQAAACBjSFJN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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "univ = openmc.Universe(cells=[box])\n", + "\n", + "geom = openmc.Geometry(univ)\n", + "geom.export_to_xml()\n", + "\n", + "mats = list(geom.get_all_materials().values())\n", + "openmc.Materials(mats).export_to_xml()\n", + "\n", + "settings = openmc.Settings()\n", + "settings.run_mode = 'plot'\n", + "settings.export_to_xml()\n", + "\n", + "p = openmc.Plot.from_geometry(geom)\n", + "openmc.plot_inline(p)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "If we plot the universe by material rather than by cell, we can see that the entire background is just graphite." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZAAAAGQBAMAAABykSv/AAAABGdBTUEAALGPC/xhBQAAACBjSFJN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\nNy0wNC0wM1QxNDoxMDowMi0wNTowMER9NgUAAAAASUVORK5CYII=\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "p.color_by = 'material'\n", + "p.colors = {graphite: 'gray'}\n", + "openmc.plot_inline(p)" + ] + } + ], + "metadata": { + "anaconda-cloud": {}, + "kernelspec": { + "display_name": "Python [default]", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.5.2" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/docs/source/examples/triso.rst b/docs/source/examples/triso.rst new file mode 100644 index 0000000000..d4b3744a4f --- /dev/null +++ b/docs/source/examples/triso.rst @@ -0,0 +1,13 @@ +.. _notebook_triso: + +======================== +Modeling TRISO Particles +======================== + +.. only:: html + + .. notebook:: triso.ipynb + +.. only:: latex + + IPython notebooks must be viewed in the online HTML documentation.