From 1bdb92ff10bd34f74a52f0f2dc806848a3dd3d63 Mon Sep 17 00:00:00 2001 From: Paul Romano Date: Wed, 15 May 2019 12:57:08 -0500 Subject: [PATCH] Add hexagonal lattice example notebook --- docs/source/examples/hexagonal.rst | 13 + docs/source/examples/index.rst | 19 +- examples/jupyter/hexagonal-lattice.ipynb | 300 +++++++++++++++++++++++ openmc/mgxs/__init__.py | 3 +- 4 files changed, 329 insertions(+), 6 deletions(-) create mode 100644 docs/source/examples/hexagonal.rst create mode 100644 examples/jupyter/hexagonal-lattice.ipynb diff --git a/docs/source/examples/hexagonal.rst b/docs/source/examples/hexagonal.rst new file mode 100644 index 000000000..8955fdb3f --- /dev/null +++ b/docs/source/examples/hexagonal.rst @@ -0,0 +1,13 @@ +.. _notebook_hexagonal: + +=========================== +Modeling Hexagonal Lattices +=========================== + +.. only:: html + + .. notebook:: ../../../examples/jupyter/hexagonal-lattice.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 bcb1b1ad8..dd73706e5 100644 --- a/docs/source/examples/index.rst +++ b/docs/source/examples/index.rst @@ -8,9 +8,9 @@ The following series of `Jupyter `_ Notebooks provide examples for how to use various features of OpenMC by leveraging the :ref:`pythonapi`. ------------ -Basic Usage ------------ +------------- +General Usage +------------- .. toctree:: :maxdepth: 1 @@ -21,11 +21,20 @@ Basic Usage tally-arithmetic expansion-filters search - triso - candu nuclear-data nuclear-data-resonance-covariance +-------- +Geometry +-------- + +.. toctree:: + :maxdepth: 1 + + hexagonal + triso + candu + ------------------------------------ Multi-Group Cross Section Generation ------------------------------------ diff --git a/examples/jupyter/hexagonal-lattice.ipynb b/examples/jupyter/hexagonal-lattice.ipynb new file mode 100644 index 000000000..1865007de --- /dev/null +++ b/examples/jupyter/hexagonal-lattice.ipynb @@ -0,0 +1,300 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In this example, we will create a hexagonal lattice and show how the orientation can be changed via the cell rotation property. Let's first just set up some materials and universes that we will use to fill the lattice." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib inline\n", + "import openmc" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "fuel = openmc.Material(name='fuel')\n", + "fuel.add_nuclide('U235', 1.0)\n", + "fuel.set_density('g/cm3', 10.0)\n", + "\n", + "fuel2 = openmc.Material(name='fuel2')\n", + "fuel2.add_nuclide('U238', 1.0)\n", + "fuel2.set_density('g/cm3', 10.0)\n", + "\n", + "water = openmc.Material(name='water')\n", + "water.add_nuclide('H1', 2.0)\n", + "water.add_nuclide('O16', 1.0)\n", + "water.set_density('g/cm3', 1.0)\n", + "\n", + "mats = openmc.Materials((fuel, fuel2, water))\n", + "mats.export_to_xml()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "With our three materials, we will set up two universes that represent pin-cells: one with a small pin and one with a big pin. Since we will be using these universes in a lattice, it's always a good idea to have an \"outer\" universe as well that is applied outside the defined lattice." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "r_pin = openmc.ZCylinder(r=0.25)\n", + "fuel_cell = openmc.Cell(fill=fuel, region=-r_pin)\n", + "water_cell = openmc.Cell(fill=water, region=+r_pin)\n", + "pin_universe = openmc.Universe(cells=(fuel_cell, water_cell))\n", + "\n", + "r_big_pin = openmc.ZCylinder(r=0.5)\n", + "fuel2_cell = openmc.Cell(fill=fuel2, region=-r_big_pin)\n", + "water2_cell = openmc.Cell(fill=water, region=+r_big_pin)\n", + "big_pin_universe = openmc.Universe(cells=(fuel2_cell, water2_cell))\n", + "\n", + "all_water_cell = openmc.Cell(fill=water)\n", + "outer_universe = openmc.Universe(cells=(all_water_cell,))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now let's create a hexagonal lattice using the `HexLattice` class:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "lat = openmc.HexLattice()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We need to set the `center` of the lattice, the `pitch`, an `outer` universe (which is applied to all lattice elements outside of those that are defined), and a list of `universes`. Let's start with the easy ones first. Note that for a 2D lattice, we only need to specify a single number for the pitch." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "lat.center = (0., 0.)\n", + "lat.pitch = (1.25,)\n", + "lat.outer = outer_universe" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we need to set the `universes` property on our lattice. It needs to be set to a list of lists of Universes, where each list of Universes corresponds to a ring of the lattice. The rings are ordered from outermost to innermost, and within each ring the indexing starts at the \"top\". To help visualize the proper indices, we can use the `show_indices()` helper method." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " (0, 0)\n", + " (0,11) (0, 1)\n", + "(0,10) (1, 0) (0, 2)\n", + " (1, 5) (1, 1)\n", + "(0, 9) (2, 0) (0, 3)\n", + " (1, 4) (1, 2)\n", + "(0, 8) (1, 3) (0, 4)\n", + " (0, 7) (0, 5)\n", + " (0, 6)\n" + ] + } + ], + "source": [ + "print(lat.show_indices(num_rings=3))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's set up a lattice where the first element in each ring is the big pin universe and all other elements are regular pin universes. From the diagram above, we see that the outer ring has 12 elements, the middle ring has 6, and the innermost degenerate ring has a single element." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "HexLattice\n", + "\tID =\t4\n", + "\tName =\t\n", + "\t# Rings =\t3\n", + "\t# Axial =\tNone\n", + "\tCenter =\t(0.0, 0.0)\n", + "\tPitch =\t(1.25,)\n", + "\tOuter =\t3\n", + "\tUniverses \n", + " 2\n", + " 1 1\n", + "1 2 1\n", + " 1 1\n", + "1 2 1\n", + " 1 1\n", + "1 1 1\n", + " 1 1\n", + " 1\n" + ] + } + ], + "source": [ + "outer_ring = [big_pin_universe] + [pin_universe]*11\n", + "middle_ring = [big_pin_universe] + [pin_universe]*5\n", + "inner_ring = [big_pin_universe]\n", + "lat.universes = [outer_ring, middle_ring, inner_ring]\n", + "print(lat)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now let's put our lattice inside a circular cell that will serve as the top-level cell for our geometry." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "outer_surface = openmc.ZCylinder(r=4.0, boundary_type='vacuum')\n", + "main_cell = openmc.Cell(fill=lat, region=-outer_surface)\n", + "geom = openmc.Geometry([main_cell])\n", + "geom.export_to_xml()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now let's create a plot to see what our geometry looks like." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "p = openmc.Plot.from_geometry(geom)\n", + "p.color_by = 'material'\n", + "p.colors = colors = {\n", + " water: 'blue',\n", + " fuel: 'olive',\n", + " fuel2: 'yellow'\n", + "}\n", + "p.to_ipython_image()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "At this point, if we wanted to simulate the model, we would need to create an instance of `openmc.Settings`, export it to XML, and run." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Rotating the lattice\n", + "\n", + "Now let's say we want our hexagonal lattice orientated such that flat sides of each lattice element are parallel to the y-axis instead of the x-axis. This can be achieved by rotating the cell that contains the lattice by 30 degrees." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Rotate the main cell and re-export the geometry\n", + "main_cell.rotation = (0., 0., 30.)\n", + "geom.export_to_xml()\n", + "\n", + "# Run OpenMC in plotting mode\n", + "p.to_ipython_image()" + ] + } + ], + "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.7.0" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/openmc/mgxs/__init__.py b/openmc/mgxs/__init__.py index e505c7ebc..886cc904a 100644 --- a/openmc/mgxs/__init__.py +++ b/openmc/mgxs/__init__.py @@ -7,6 +7,7 @@ from openmc.mgxs.mdgxs import * GROUP_STRUCTURES = {} """Dictionary of commonly used energy group structures: + - "CASMO-X" (where X is 2, 4, 8, 16, 25, 40 or 70) from the CASMO_ lattice physics code - "XMAS-172_" designed for LWR analysis ([SAR1990]_, [SAN2004]_) @@ -19,7 +20,7 @@ GROUP_STRUCTURES = {} .. _XMAS-172: https://www-nds.iaea.org/wimsd/energy.htm .. _SHEM-361: https://www.polymtl.ca/merlin/libraries.htm .. _activation: https://fispact.ukaea.uk/wiki/Keyword:GETXS -.. _CCFE-709: https://fispact.ukaea.uk/wiki/CCFE-709_group_structure +.. _CCFE-709: https://fispact.ukaea.uk/wiki/CCFE-709_group_structure .. _UKAEA-1102: https://fispact.ukaea.uk/wiki/UKAEA-1102_group_structure .. [SAR1990] Sartori, E., OECD/NEA Data Bank: Standard Energy Group Structures of Cross Section Libraries for Reactor Shielding, Reactor Cell and Fusion