diff --git a/BWR.ipynb b/BWR.ipynb new file mode 100644 index 0000000..8860762 --- /dev/null +++ b/BWR.ipynb @@ -0,0 +1,1014 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# A BWR geometry \n", + "This notebook can be used as a template for modeling BWR reactors." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "id": "EChOeJ7qVUB7" + }, + "outputs": [], + "source": [ + "%matplotlib inline\n", + "import openmc" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "id": "-0xO897aWbft" + }, + "outputs": [], + "source": [ + "# Materials definitions\n", + "\n", + "uo2 = openmc.Material(name='UO2')\n", + "uo2.add_element('U', 1.0, enrichment=1.5)\n", + "uo2.add_element('O', 2.0)\n", + "uo2.set_density('g/cc', 10.0)\n", + "\n", + "zircaloy = openmc.Material(name='Zircaloy')\n", + "zircaloy.set_density('g/cm3', 6.55)\n", + "zircaloy.add_nuclide('Zr90', 7.2758e-3)\n", + "\n", + "steel = openmc.Material(name='Stainless Steel')\n", + "steel.set_density('g/cm3', 8.00)\n", + "steel.add_element('C', 0.08, percent_type='wo')\n", + "steel.add_element('Si', 1.00, percent_type='wo')\n", + "steel.add_element('Mn', 2.00, percent_type='wo')\n", + "steel.add_element('P', 0.045, percent_type='wo')\n", + "steel.add_element('S', 0.030, percent_type='wo')\n", + "steel.add_element('Cr', 20.0, percent_type='wo')\n", + "steel.add_element('Ni', 11.0, percent_type='wo')\n", + "steel.add_element('Fe', 65.845, percent_type='wo')\n", + "\n", + "water = openmc.Material(name='Water')\n", + "water.set_density('g/cm3', 0.76)\n", + "water.add_element('H', 2)\n", + "water.add_element('O', 1)\n", + "water.add_s_alpha_beta('c_H_in_H2O')\n", + "\n", + "# Instantiate a Materials collection and export to xml\n", + "materials_file = openmc.Materials([uo2, water, zircaloy, steel])\n", + "materials_file.export_to_xml()" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# Geometry definitions" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "id": "J90KA6zdol04" + }, + "outputs": [], + "source": [ + "bottom = openmc.ZPlane(z0=-1.0, boundary_type = 'reflective')\n", + "top = openmc.ZPlane(z0=1.0, boundary_type = 'reflective')" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "id": "7UFi6yivaxDS" + }, + "outputs": [], + "source": [ + "pitch = 1.6256\n", + "pin_cell_box = openmc.rectangular_prism(width=pitch, height=pitch)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "# Geometry definitions for the fuel rod\n", + "\n", + "fuel_or = openmc.ZCylinder(r=1.0414/2, name='Fuel OR')\n", + "fclad_ir = openmc.ZCylinder(r=1.06426/2, name='Clad IR')\n", + "fclad_or = openmc.ZCylinder(r=1.22682/2, name='Clad OR')\n", + "\n", + "fuel_region = -fuel_or \n", + "gap_region = +fuel_or & -fclad_ir\n", + "fclad_region = +fclad_ir & -fclad_or\n", + "fwater_region = pin_cell_box & +fclad_or\n", + "\n", + "fuel_cell = openmc.Cell(name='fuel')\n", + "fuel_cell.fill = uo2\n", + "fuel_cell.region = fuel_region \n", + "\n", + "gap_cell = openmc.Cell(name='air gap')\n", + "gap_cell.region = gap_region\n", + "\n", + "clad_cell = openmc.Cell(name='clad')\n", + "clad_cell.fill = zircaloy\n", + "clad_cell.region = fclad_region\n", + "\n", + "fwater_cell = openmc.Cell(name='fwater')\n", + "fwater_cell.fill = water\n", + "fwater_cell.region = fwater_region\n", + "\n", + "fuel_pin_universe = openmc.Universe(cells=[fuel_cell, gap_cell, clad_cell, fwater_cell])" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fuel_pin_universe.plot(width=(2.5, 2.5), colors = {fuel_cell: 'orange', gap_cell: 'white', clad_cell: 'grey', fwater_cell: 'blue'})" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "# Geometry definitions for the water rod\n", + "\n", + "water_or = openmc.ZCylinder(r=1.34874/2)\n", + "wclad_or = openmc.ZCylinder(r=1.50114/2)\n", + "\n", + "wwater_inner_region = -water_or\n", + "wclad_region = -wclad_or & +water_or \n", + "wwater_outer_region = pin_cell_box & +wclad_or\n", + "\n", + "wwater_inner_cell = openmc.Cell(name='wwater_inner')\n", + "wwater_inner_cell.region = wwater_inner_region\n", + "wwater_inner_cell.fill = water\n", + "\n", + "wclad_cell = openmc.Cell(name='wclad')\n", + "wclad_cell.fill = zircaloy\n", + "wclad_cell.region = wclad_region \n", + "\n", + "wwater_outer_cell = openmc.Cell(name='wwater_outer')\n", + "wwater_outer_cell.fill = water\n", + "wwater_outer_cell.region = wwater_outer_region\n", + "\n", + "water_pin_universe = openmc.Universe(cells=[wwater_inner_cell, wclad_cell, wwater_outer_cell])" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 282 + }, + "id": "FklxPQ-1xvNs", + "outputId": "9e4cb490-0ba5-4838-9f47-0442493b9f6d" + }, + "outputs": [], + "source": [ + "# Geometry definitions for the corner rod\n", + "\n", + "corner_fuel_or = openmc.ZCylinder(r=1.0414/2, name = 'Corner Cell: Fuel OR')\n", + "corner_clad_ir = openmc.ZCylinder(r=1.06426/2, name = 'Corner Cell: Clad IR')\n", + "corner_clad_or = openmc.ZCylinder(r=1.22682/2, name = 'Corner Cell: Clad OR')\n", + "\n", + "corner_fuel_cell = openmc.Cell(name='fuel')\n", + "corner_fuel_cell.fill = uo2\n", + "corner_fuel_cell.region = -corner_fuel_or \n", + "\n", + "corner_gap_cell = openmc.Cell(name='air gap')\n", + "corner_gap_cell.region = -corner_clad_ir & +corner_fuel_or\n", + "\n", + "corner_clad_cell = openmc.Cell(name='clad')\n", + "corner_clad_cell.fill = zircaloy\n", + "corner_clad_cell.region = +corner_clad_ir & -corner_clad_or" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "# Defining an Assembly" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "margin = 1e-8\n", + "sleave_thickness = 0.2032\n", + "sleave_inner_radius = 0.9652 + margin" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 282 + }, + "id": "FklxPQ-1xvNs", + "outputId": "9e4cb490-0ba5-4838-9f47-0442493b9f6d" + }, + "outputs": [], + "source": [ + "ur_corner_fuel_or = openmc.ZCylinder(r=1.0414/2, name='ur Corner Cell: Fuel OR')\n", + "ur_corner_clad_ir = openmc.ZCylinder(r=1.06426/2, name='ur Corner Cell: Clad IR')\n", + "ur_corner_clad_or = openmc.ZCylinder(r=1.22682/2, name='ur Corner Cell: Clad OR')\n", + "\n", + "ur_corner_fuel_cell = openmc.Cell(name='ur fuel')\n", + "ur_corner_fuel_cell.fill = uo2\n", + "ur_corner_fuel_cell.region = -ur_corner_fuel_or \n", + "\n", + "ur_corner_gap_cell = openmc.Cell(name='ul air gap')\n", + "ur_corner_gap_cell.region = -ur_corner_clad_ir & +ur_corner_fuel_or\n", + "\n", + "ur_corner_clad_cell = openmc.Cell(name='ul clad')\n", + "ur_corner_clad_cell.fill = zircaloy\n", + "ur_corner_clad_cell.region = +ur_corner_clad_ir & -ur_corner_clad_or\n", + "\n", + "ur_sleave_ir = openmc.ZCylinder(x0=pitch/2-sleave_inner_radius-margin, y0=pitch/2-sleave_inner_radius+margin, r=sleave_inner_radius)\n", + "ur_sleave_or = openmc.ZCylinder(x0=pitch/2-sleave_inner_radius-margin, y0=pitch/2-sleave_inner_radius+margin, r=sleave_inner_radius+sleave_thickness)\n", + "\n", + "ur_sleave_hor_bound = openmc.XPlane(x0=pitch/2 - sleave_inner_radius - margin)\n", + "ur_sleave_ver_bound = openmc.YPlane(y0=pitch/2 - sleave_inner_radius + margin)\n", + "\n", + "ur_sleave_cell = openmc.Cell(name='ur sleave cell')\n", + "ur_sleave_cell.region = -ur_sleave_or & +ur_sleave_ir & +ur_sleave_hor_bound & +ur_sleave_ver_bound & pin_cell_box\n", + "ur_sleave_cell.fill = zircaloy\n", + "\n", + "ur_sleave_water_cell = openmc.Cell(name = 'ur sleave water')\n", + "ur_sleave_water_cell.region = pin_cell_box & +ur_sleave_hor_bound & +ur_sleave_ver_bound & +ur_sleave_or\n", + "ur_sleave_water_cell.fill = water\n", + "\n", + "ur_sleave_ver_water_cell = openmc.Cell(name='ur vertically-equivalent sleave water')\n", + "ur_sleave_ver_water_cell.region = pin_cell_box & -ur_sleave_hor_bound & +ur_sleave_ver_bound & +ur_sleave_ir\n", + "ur_sleave_ver_water_cell.fill = water \n", + "\n", + "ur_opposite_water_cell = openmc.Cell(name='ur opposite water')\n", + "ur_opposite_water_cell.region = pin_cell_box & -ur_sleave_hor_bound & -ur_sleave_ver_bound & +ur_sleave_ir\n", + "ur_opposite_water_cell.fill = water \n", + "\n", + "ur_sleave_hor_water_cell = openmc.Cell(name='ur horizontally-equivalent sleave water')\n", + "ur_sleave_hor_water_cell.region = pin_cell_box & +ur_sleave_hor_bound & -ur_sleave_ver_bound & +ur_sleave_ir\n", + "ur_sleave_hor_water_cell.fill = water \n", + "\n", + "ur_inner_water_cell = openmc.Cell(name='ur inner water cell')\n", + "ur_inner_water_cell.region = pin_cell_box & -ur_sleave_ir & +ur_corner_clad_or\n", + "ur_inner_water_cell.fill = water\n", + "\n", + "ur_corner_pin_universe = openmc.Universe(cells=[ur_corner_fuel_cell, ur_corner_gap_cell, ur_corner_clad_cell, ur_sleave_cell, ur_inner_water_cell, ur_sleave_water_cell, ur_sleave_ver_water_cell, ur_opposite_water_cell, ur_sleave_hor_water_cell])" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "ur_corner_pin_universe.plot(width=(2.5, 2.5), basis = 'xy', colors = {ur_corner_fuel_cell: 'orange', ur_corner_gap_cell: 'white', ur_corner_clad_cell: 'grey', ur_sleave_cell:'brown', ur_inner_water_cell: 'blue', ur_sleave_water_cell: 'blue', ur_sleave_ver_water_cell: 'blue', ur_opposite_water_cell: 'blue', ur_sleave_hor_water_cell: 'blue'})" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "ul_corner_fuel_or = openmc.ZCylinder(r=(1.0414/2), name='ul Corner Cell: Fuel OR')\n", + "ul_corner_clad_ir = openmc.ZCylinder(r=(1.06426/2), name='ul Corner Cell: Clad IR')\n", + "ul_corner_clad_or = openmc.ZCylinder(r=(1.22682/2), name='ul Corner Cell: Clad OR')\n", + "\n", + "ul_corner_fuel_cell = openmc.Cell(name='ul fuel')\n", + "ul_corner_fuel_cell.fill = uo2\n", + "ul_corner_fuel_cell.region = -ul_corner_fuel_or \n", + "\n", + "ul_corner_gap_cell = openmc.Cell(name='ul air gap')\n", + "ul_corner_gap_cell.region = -ul_corner_clad_ir & +ul_corner_fuel_or\n", + "\n", + "ul_corner_clad_cell = openmc.Cell(name='ul clad')\n", + "ul_corner_clad_cell.fill = zircaloy\n", + "ul_corner_clad_cell.region = +ul_corner_clad_ir & -ul_corner_clad_or\n", + "\n", + "ul_sleave_ir = openmc.ZCylinder(x0=-pitch/2+sleave_inner_radius+margin, y0=pitch/2-sleave_inner_radius+margin, r=sleave_inner_radius) #Shouldn't have margin\n", + "ul_sleave_or = openmc.ZCylinder(x0=-pitch/2+sleave_inner_radius+margin, y0=pitch/2-sleave_inner_radius+margin, r=sleave_inner_radius + sleave_thickness)\n", + "\n", + "ul_sleave_hor_bound = openmc.XPlane(x0=-pitch/2+sleave_inner_radius+margin)\n", + "ul_sleave_ver_bound = openmc.YPlane(y0=pitch/2-sleave_inner_radius+margin)\n", + "\n", + "ul_sleave_cell = openmc.Cell(name='ul sleave cell')\n", + "ul_sleave_cell.region = -ul_sleave_or & +ul_sleave_ir & -ul_sleave_hor_bound & +ul_sleave_ver_bound & pin_cell_box\n", + "ul_sleave_cell.fill = zircaloy\n", + "\n", + "ul_sleave_water_cell = openmc.Cell(name='ul sleave water')\n", + "ul_sleave_water_cell.region = pin_cell_box & -ul_sleave_hor_bound & +ul_sleave_ver_bound & +ul_sleave_or\n", + "ul_sleave_water_cell.fill = water\n", + "\n", + "ul_sleave_ver_water_cell = openmc.Cell(name='ul vertically-equivalent sleave water')\n", + "ul_sleave_ver_water_cell.region = pin_cell_box & +ul_sleave_hor_bound & +ul_sleave_ver_bound & +ul_sleave_ir\n", + "ul_sleave_ver_water_cell.fill = water \n", + "\n", + "ul_opposite_water_cell = openmc.Cell(name='ul opposite water')\n", + "ul_opposite_water_cell.region = pin_cell_box & +ul_sleave_hor_bound & -ul_sleave_ver_bound & +ul_sleave_ir\n", + "ul_opposite_water_cell.fill = water \n", + "\n", + "ul_sleave_hor_water_cell = openmc.Cell(name='ul horizontally-equivalent sleave water')\n", + "ul_sleave_hor_water_cell.region = pin_cell_box & -ul_sleave_hor_bound & -ul_sleave_ver_bound & +ul_sleave_ir\n", + "ul_sleave_hor_water_cell.fill = water \n", + "\n", + "ul_inner_water_cell = openmc.Cell(name='ul inner water cell')\n", + "ul_inner_water_cell.region = pin_cell_box & -ul_sleave_ir & +ul_corner_clad_or\n", + "ul_inner_water_cell.fill = water\n", + "\n", + "ul_corner_pin_universe = openmc.Universe(cells=[ul_corner_fuel_cell, ul_corner_gap_cell, ul_corner_clad_cell, ul_sleave_cell, ul_inner_water_cell, ul_sleave_water_cell, ul_sleave_ver_water_cell, ul_opposite_water_cell, ul_sleave_hor_water_cell])" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAQcAAAD4CAYAAADhGCPfAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Il7ecAAAACXBIWXMAAAsTAAALEwEAmpwYAAAQIUlEQVR4nO3dXaxl5V2A8ecvCL0wKR8zKRSYDkRSpVfSE8SaNE2pCXDBUFsM0KRgaKZEiYleKAmJA9xI2wu1KbESSjpN5EuS2qmOISISbgQ5JLUwQ2gHIjIjlikgSdNIpfy9OOvAnjPvPvtjfe59nl8ymf2xZq/3rHP2M+9aa+99IjORpI1+oe8BSBom4yCpyDhIKjIOkoqMg6SiE/sewDjbtm3LnTt39j0Maak9/fTTP87M7aX7BhuHnTt3srq62vcwpKUWES+Nu8/dCklFxkFSkXGQVGQcJBUZB0lFxkFSkXGQVGQcJBUZB0lFxkFSkXGQVGQcJBUZB0lFxkFSkXGQVGQcJBUZB0lFjcQhIu6JiFcj4tkx90dEfDUiDkXE9yPiwibWK6k9Tc0cvglcusn9lwHnV392A3/V0HoltaSROGTm48DrmyyyC/hWrnkCOCUizmxi3ZLa0dUxh7OAl0euH65uO0ZE7I6I1YhYPXr0aEdDk1QyqAOSmXlXZq5k5sr27cVPy5bUka7icAQ4Z+T62dVtkgaqqzjsAz5fnbW4GHgzM1/paN2S5tDIL7WJiPuATwDbIuIwsAf4RYDM/DqwH7gcOAT8FPjdJtYrqT2NxCEzr5lwfwK/38S6JHVjUAckJQ2HcZBUZBwkFRkHSUXGQVKRcZBUZBwkFRkHSUXGQVKRcZBU1MjLp7eSiG7W8zcXfKSbFbXkcwcP9D2EQcnsewSzMw4Ds2hRMALLyzgMyNDDYAi2FuMwEEMMgzHY2jwgKanImUPPhjZjcLagdcahR0MKg1HQRsahJ32HwRhoEuPQMaOgRWEcOtRnGIyCZmUcOtJXGIyC5mUcOtBHGIyC6jIOLes6DEZBTTEOLeoyDEZBTfMVki0xDFp0zhxa0FUYjILa5MyhYYZBy8I4SCpyt6JBXcwa+pwx3HrrbTX//Z6GRqIuGIeGLFsY6oZg2sc0GMNlHBqwDGFoIwbzrNdYDIdxGLg2o9BXEDYzOiZD0S/jUEPbM4Y2wjDEIIxjKPplHOa0aGFYpCiUrI/fSHSnkThExKXAXwInAHdn5h0b7r8e+ApwpLrpa5l5dxPr7sMihaGLKOzZc+wT9rbb2lunkehOZM3fthERJwA/AH4LOAw8BVyTmQdHlrkeWMnMm6Z93JWVlVxdXa01tjZEtBuHIYZh45P/XfdO+A0/15Z/tpqKxyIFYqi/1CYins7MldJ9TcwcLgIOZeaL1cruB3YBBzf9Vwtq6GFoIgjHxODegHtvne+BxsRjz/kcE455Y+ExiXY1EYezgJdHrh8Gfr2w3Gci4uOszTL+MDNfLiyzZfUdhuOC0LaRdezZ00woDESzujog+V3gvsx8KyK+COwFPrlxoYjYDewG2LFjR0dD619fYeg8COM0FAoD0awm3ltxBDhn5PrZvHfgEYDMfC0z36qu3g18tPRAmXlXZq5k5sr27dsbGJqkeTUxc3gKOD8izmUtClcD144uEBFnZuYr1dUrgOcaWO9SqDtrqDVj6HO2ME5hFjHLDMKzGc2pHYfMfDsibgIeZu1U5j2ZeSAibgdWM3Mf8AcRcQXwNvA6cH3d9S6DrsMw6CiUVOOcNxIGop7apzLbMtRTmfd+pJmzFb2EYVGiMM61OcdxiGEEYqBPs9ZPZapjs4Rh4WYLm7k3Zp5FOIOYnx/20rHPHTxQa9YwcxjujeUIw7rq6xn7wqyCRX/peF+MQ4e63JVYit2IzRiI1rlbsSCm+eEezOsWujKymwGTdzXcxZiNM4eOtP1hLcccW9gKYVg38vXOMpPQZJ6tmNE8ZyvaPsawVAcd67h2+oOVXc8gBvo02/RshTOHATMMM5phBuExiMmMQ8vmnTXM9MNrGN4zw7YwEJszDpKKjEOLOjkI6azheDOe5lSZcRigqY81GIbxpgyEuxbjGYeWtHmswTBMyUDUYhwkFRmHFjhrGBBnD3MzDgvEMMzJA5RzMQ4N6+R1DWqF34NjGYcF4ayhJmcPMzMODWr7dQ1Sl3zL9gBsNp31vRMNmuKTpHxb93ucOUgqMg6SioxDQ9o4S7GUnwHZtyk+g9KzFmuMg6Qi49AAz1JoGRmHgfJ1DS3zdQ8TGYceuW87XH5vfJ1DLe5OaJk5cxgqdyna5zbelHEYIPeFu+O2Hs84SCoyDnPq8vdeqh9b/XtkHCQVGQdJRcZBUpFxGCJPsXXHbT1WI3GIiEsj4vmIOBQRNxfuPzkiHqjufzIidjax3r744idtBbXjEBEnAHcClwEXANdExAUbFrsBeCMzfxn4c+BLdde7rDzv3j23eVkTM4eLgEOZ+WJm/gy4H9i1YZldwN7q8kPAJRHhfE4asCbicBbw8sj1w9VtxWUy823gTeD0jQ8UEbsjYjUiVo8ePdrA0CTNa1AHJDPzrsxcycyV7du39z0caUtrIg5HgHNGrp9d3VZcJiJOBN4PvNbAupfOuE9FVnvc5mVNxOEp4PyIODciTgKuBvZtWGYfcF11+bPAo5mZDay7c56p0FZROw7VMYSbgIeB54AHM/NARNweEVdUi30DOD0iDgF/BBx3ulMjrl3Ibi4mt/VYjXzYS2buB/ZvuO1PRy7/L3BVE+uS1I1BHZCUNBzGQVKRceiJv49x+Lb698g4SCoyDgPkeffuuK3HMw5D5Sm29rmNN2UcJBUZhx5t9QNeQ+b3xjgM1m233ea0t03XpscbJjAOkoqMg6Qi49CzzfZt3921cPeiOdX23GyXwuMNa4yDpCLjIKkohvqZKysrK7m6utr3MI7T1sfiTvq9jHv27PF3LNQ1xRmKtnYpBvo0IyKezsyV0n3OHCQVGYcF4eseavJ1DTMzDgPhEfL++T04lnFYIM4e5uSsYS7GYUCm+Z/LQMxoyjA4aziecZBUZBwGxtlDg5w11GIcBshANMAw1GYcFpiBGMMDkI0wDpKKjMNAzTTddfbwnhm2hbsUmzMOAzb1sQcwEPDuNvBYQzN849WM2nrj1SRTvTELtu6bs6YMQ19RGOjTzDdebQXHzCC20ixi5Ov1IGSznDnMqK+ZA0yePYzaEm/xnvGsRJ+7EgN9mjlzWBaz/HAv/WnOBQrDojIOC2auQCxTJKb4DMiNDMN83K2YUZ+7FaNm2cWAJdnNmOPFTUMJw0CfZu5WLKNZf+gXehYxx2wBhhOGRVVr5hARpwEPADuB/wB+JzPfKCz3c+CZ6up/ZuYVkx7bmcN0Zp1BwAKd9qxxFmJoYVjEmUPdOHwZeD0z74iIm4FTM/NPCsv9JDN/aZbHNg6zqRUJGE4oRmY2yxCFdYsYh7q7FbuAvdXlvcCVNR9P0kDUnTn8T2aeUl0O4I316xuWexv4HvA2cEdm/t2kx3bmMLt5Zg/rep1F1JwtrBvqrAEWc+YwMQ4R8QhwRuGuW4C9ozGIiDcy89TCY5yVmUci4jzgUeCSzHyhsNxuYDfAjh07PvrSSy9tOrY+DDkOUC8Q6zoJRUNBWDfkMMCSxmHCAz8PfCIzX4mIM4HHMvPDE/7NN4G/z8yHNlvOmUN9TYQCNsRi1KRwjDkz0tTLnIcehFFbMQ5fAV4bOSB5Wmb+8YZlTgV+mplvRcQ24F+BXZl5cLPHNg7NaCoQm9kYjy7e47BIYYCtGYfTgQeBHcBLrJ3KfD0iVoAbM/MLEfEx4K+Bd1g7APoXmfmNSY9tHJrVRSS6sGhRWLfl4tAm49CORY3EokZh3UCfZpvG4cSuB6N+jT7Jhh6KRQ/CojMOW9gQQ2EQhsM4CDj+SdlVLIzBcBkHFZWetHWDYQgWi3HQ1Hxyby2+ZVtSkXGQVGQcJBUZB0lFxkFSkXGQVGQcJBUZB0lFxkFSkXGQVGQcJBUZB0lFxkFSkXGQVGQcJBUZB0lFxkFSkZ8ENaOhfsS41DRnDpKKjIOkIuMgqcg4SCoyDpKKjIOkIuMgqcg4SCoyDpKKjIOkIuMgqcg4SCqqFYeIuCoiDkTEOxGxsslyl0bE8xFxKCJurrNOSd2oO3N4Fvht4PFxC0TECcCdwGXABcA1EXFBzfVKalmtt2xn5nMAEbHZYhcBhzLzxWrZ+4FdwME665bUri6OOZwFvDxy/XB123EiYndErEbE6tGjRzsYmqRxJs4cIuIR4IzCXbdk5neaHExm3gXcBbCysuLHqkg9mhiHzPxUzXUcAc4ZuX52dZukAetit+Ip4PyIODciTgKuBvZ1sF5JNdQ9lfnpiDgM/AbwDxHxcHX7ByNiP0Bmvg3cBDwMPAc8mJkH6g1bUtvqnq34NvDtwu3/BVw+cn0/sL/OuiR1y1dISioyDpKKjIOkIuMgqcg4SCoyDpKKjIOkIuMgqcg4SCoyDpKKjIOkIuMgqcg4SCoyDpKKjIOkIuMgqSgyh/k5rhFxFHiphYfeBvy4hcdtyyKNd5HGCos13rbG+qHM3F66Y7BxaEtErGbm2N/ONTSLNN5FGiss1nj7GKu7FZKKjIOkoq0Yh7v6HsCMFmm8izRWWKzxdj7WLXfMQdJ0tuLMQdIUjIOkoqWPQ0RcFREHIuKdiBh7KigiLo2I5yPiUETc3OUYN4zjtIj4p4j4YfX3qWOW+3lEfK/60+mvF5y0rSLi5Ih4oLr/yYjY2eX4Noxl0livj4ijI9vyC32MsxrLPRHxakQ8O+b+iIivVl/L9yPiwlYHlJlL/Qf4VeDDwGPAyphlTgBeAM4DTgL+Hbigp/F+Gbi5unwz8KUxy/2kp/FN3FbA7wFfry5fDTww4LFeD3ytj/EVxvtx4ELg2TH3Xw78IxDAxcCTbY5n6WcOmflcZj4/YbGLgEOZ+WJm/gy4H9jV/uiKdgF7q8t7gSt7Gsc402yr0a/hIeCSiIgOx7huSN/XiTLzceD1TRbZBXwr1zwBnBIRZ7Y1nqWPw5TOAl4euX64uq0PH8jMV6rL/w18YMxy74uI1Yh4IiKu7GZowHTb6t1lcu0XKb8JnN7J6MaMozLu+/qZapr+UESc083Q5tLpz2mtX6Q7FBHxCHBG4a5bMvM7XY9nks3GO3olMzMixp1r/lBmHomI84BHI+KZzHyh6bFuAd8F7svMtyLii6zNeD7Z85gGYSnikJmfqvkQR4DR/zHOrm5rxWbjjYgfRcSZmflKNWV8dcxjHKn+fjEiHgN+jbX967ZNs63WlzkcEScC7wde62BsG00ca2aOjutu1o75DFWnP6fuVqx5Cjg/Is6NiJNYO4jW6RmAEfuA66rL1wHHzXwi4tSIOLm6vA34TeBgR+ObZluNfg2fBR7N6ohaxyaOdcM++xXAcx2Ob1b7gM9XZy0uBt4c2QVtXt9HaDs4Avxp1vbN3gJ+BDxc3f5BYP+GI8E/YO1/31t6HO/pwD8DPwQeAU6rbl8B7q4ufwx4hrWj788AN3Q8xuO2FXA7cEV1+X3A3wKHgH8Dzutxe04a658BB6pt+S/Ar/Q41vuAV4D/q35mbwBuBG6s7g/gzupreYYxZ9+a+uPLpyUVuVshqcg4SCoyDpKKjIOkIuMgqcg4SCoyDpKK/h+Vd/LuTpiBKAAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "ul_corner_pin_universe.plot(width=(2.5, 2.5), basis = 'xy', colors = {ul_corner_fuel_cell: 'orange', ul_corner_gap_cell: 'white', ul_corner_clad_cell: 'grey', ul_sleave_cell:'brown', ul_inner_water_cell: 'blue', ul_sleave_water_cell: 'blue', ul_sleave_ver_water_cell: 'blue', ul_opposite_water_cell: 'blue', ul_sleave_hor_water_cell: 'blue'})" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "ll_corner_fuel_or = openmc.ZCylinder(r=1.0414/2, name='ll Corner Cell: Fuel OR')\n", + "ll_corner_clad_ir = openmc.ZCylinder(r=1.06426/2, name='ll Corner Cell: Clad IR')\n", + "ll_corner_clad_or = openmc.ZCylinder(r=1.22682/2, name='ll Corner Cell: Clad OR')\n", + "\n", + "ll_corner_fuel_cell = openmc.Cell(name='ll fuel')\n", + "ll_corner_fuel_cell.fill = uo2\n", + "ll_corner_fuel_cell.region = -ll_corner_fuel_or \n", + "\n", + "ll_corner_gap_cell = openmc.Cell(name='ll air gap')\n", + "ll_corner_gap_cell.region = -ll_corner_clad_ir & +ll_corner_fuel_or\n", + "\n", + "ll_corner_clad_cell = openmc.Cell(name='ll clad')\n", + "ll_corner_clad_cell.fill = zircaloy\n", + "ll_corner_clad_cell.region = +ll_corner_clad_ir & -ll_corner_clad_or\n", + "\n", + "ll_sleave_ir = openmc.ZCylinder(x0=-pitch/2+sleave_inner_radius+margin, y0=-pitch/2+sleave_inner_radius-margin, r=sleave_inner_radius)\n", + "ll_sleave_or = openmc.ZCylinder(x0=-pitch/2+sleave_inner_radius+margin, y0=-pitch/2+sleave_inner_radius-margin, r=sleave_inner_radius+sleave_thickness)\n", + "\n", + "ll_sleave_hor_bound = openmc.XPlane(x0=-pitch/2+sleave_inner_radius+margin)\n", + "ll_sleave_ver_bound = openmc.YPlane(y0=-pitch/2+sleave_inner_radius-margin)\n", + "\n", + "ll_sleave_cell = openmc.Cell(name='ul sleave cell')\n", + "ll_sleave_cell.region = -ll_sleave_or & +ll_sleave_ir & -ll_sleave_hor_bound & -ll_sleave_ver_bound & pin_cell_box\n", + "ll_sleave_cell.fill = zircaloy\n", + "\n", + "ll_sleave_water_cell = openmc.Cell(name='ul sleave water')\n", + "ll_sleave_water_cell.region = pin_cell_box & -ll_sleave_hor_bound & -ll_sleave_ver_bound & +ll_sleave_or\n", + "ll_sleave_water_cell.fill = water\n", + "\n", + "ll_sleave_ver_water_cell = openmc.Cell(name='ul vertically-equivalent sleave water')\n", + "ll_sleave_ver_water_cell.region = pin_cell_box & +ll_sleave_hor_bound & -ll_sleave_ver_bound & +ll_sleave_ir\n", + "ll_sleave_ver_water_cell.fill = water \n", + "\n", + "ll_opposite_water_cell = openmc.Cell(name='ul opposite water')\n", + "ll_opposite_water_cell.region = pin_cell_box & +ll_sleave_hor_bound & +ll_sleave_ver_bound & +ll_sleave_ir\n", + "ll_opposite_water_cell.fill = water \n", + "\n", + "ll_sleave_hor_water_cell = openmc.Cell(name='ul horizontally-equivalent sleave water')\n", + "ll_sleave_hor_water_cell.region = pin_cell_box & -ll_sleave_hor_bound & +ll_sleave_ver_bound & +ll_sleave_ir\n", + "ll_sleave_hor_water_cell.fill = water \n", + "\n", + "ll_inner_water_cell = openmc.Cell(name='ul inner water cell')\n", + "ll_inner_water_cell.region = pin_cell_box & -ll_sleave_ir & +ll_corner_clad_or\n", + "ll_inner_water_cell.fill = water\n", + "\n", + "ll_corner_pin_universe = openmc.Universe(cells=[ll_corner_fuel_cell, ll_corner_gap_cell, ll_corner_clad_cell, ll_sleave_cell, ll_inner_water_cell, ll_sleave_water_cell, ll_sleave_ver_water_cell, ll_opposite_water_cell, ll_sleave_hor_water_cell])" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAQcAAAD4CAYAAADhGCPfAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Il7ecAAAACXBIWXMAAAsTAAALEwEAmpwYAAAQdElEQVR4nO3dXaxlZX2A8edfKHrRRIGZKALjSEpsx6vqCaU2MUZsglwwWrURTJRGM9rWm/aikpD0gEnj10Wt0dQSNI6JfFgS69hOQ0qp8aZaDokVZig6klJmSnUESmJMsei/F2cd2LPn3Xufvff63Pv5JRP2x2Kvd9Y5+5l3rbU/IjORpHG/1PUAJPWTcZBUZBwkFRkHSUXGQVLRuV0PYJI9e/bk/v37ux6GtNIeeOCBH2fm3tJ9vY3D/v372dra6noY0kqLiMcm3eduhaQi4yCpyDhIKjIOkoqMg6Qi4yCpyDhIKjIOkoqMg6Qi4yCpyDhIKjIOkoqMg6Qi4yCpyDhIKjIOkoqMg6SiWuIQEV+IiB9FxEMT7o+I+HREnIiI70bEa+tYr6Tm1DVz+CJw9ZT73wJcXv05BPxVTeuV1JBa4pCZ3wSemrLIQeBLue1bwEsj4qI61i2pGW0dc7gYeHzk+snqtjNExKGI2IqIrdOnT7c0NEklvTogmZm3ZuZGZm7s3Vv8tGxJLWkrDqeAS0euX1LdJqmn2orDEeA91VmLK4FnMvOJltYtaQG1fKlNRNwBvBHYExEngU3glwEy83PAUeAa4ATwU+D361ivpObUEofMvG7G/Qn8UR3rktSOXh2QlNQfxkFSkXGQVGQcJBUZB0lFxkFSkXGQVGQcJBUZB0lFxkFSUS0vn14nEV2PQEOU2fUI5ufMQVKRcZBUZBwkFRkHSUXGQVKRcZBUZBwkFRkHSUXGQVKRcZBUZBwkFRkHSUXGQVKRcZBUZBwkFRkHSUXGQVKRnwSlXbv55luW/P83axqJ2mAcVLRsCHb7mAajv4yDgGZisMh6jUV/GIc11lUQphkdk6HolnFYM30MwiSGolvGYU0MKQolO+M3Eu2pJQ4RcTXwl8A5wG2Z+bGx+28APgmcqm76TGbeVse6NV0bUdjcPPMJe8stza3TSLQncslv24iIc4DvAb8DnATuB67LzOMjy9wAbGTmh3b7uBsbG7m1tbXU2JowpC+1qSsM40/+590+Y2NcX/7dqiseQwpEX7/UJiIeyMyN0n11zByuAE5k5qPVyu4EDgLHp/5fakQdQTgjBrcH3H7zYg80IR6bl3NGOBaNhcckmlVHHC4GHh+5fhL4zcJyb4+IN7A9y/jjzHy8sIyWsEwYzgpC00bWsblZTygMRL3aOiD5deCOzHw2Ij4AHAbeNL5QRBwCDgHs27evpaGthkXC0HoQJqkpFAaiXnW8t+IUcOnI9Ut44cAjAJn5ZGY+W129DXhd6YEy89bM3MjMjb1799YwNEmLquOA5Lls7ypcxXYU7geuz8xjI8tclJlPVJffBnw4M6+c9rgekNydpWYMXc4WdqM6LrHIrkbfZhBDPCC5dByqFVwDfIrtU5lfyMw/j4iPAFuZeSQiPgpcCzwHPAX8QWb++7THNA6zzRuGwURh3IKR6FMg1jYOTTAO0y0UhqFFYdz1OdhA9PRpZhzq1Ic4zBOGwc4WJllgFtGHQPT0aTY1Dn7Yy8DMHYbbY3XCAM//fSa+MKtg6C8d74pxGJCFwrCqDETj3K2YU1e7Fbv55e7N6xbaNOcrLbvaxejp08zdinVwxrGFdQkDnPH3nWcmodmcOcyp7ZnDXDOGdYpCyRwHK9ueQfT0aebMYagMw5zmmEF4DGI249BTc/3yGoYXzLEtDMR0xkFSkXEYsJU/XbmoOU9zqsw49NCujzUYhsl2GQh3LSYzDj1jGGpkIJZiHCQVGYcecdbQAGcPCzMOA2IYFuQByoUYh57wX67u+TM4k3EYCGcNS3L2MDfjIKnIN17NqYk3Xk2bzvreiZrt4s1ZTbwpq6dPM994JWl+xkFSkXHo2MxdinX78Jam7eIzKD1rsc04SCoyDpKKjENP+bqGhvm6h5mMQ4fct+0vfzbGQdIExqGv3KVontt4KuPQQ+4Lt8dtPZlxkFRkHDriAa/+W/efkXGQVGQcJBUZB0lFxqGPPMXWHrf1RLXEISKujohHIuJERNxYuP9FEXFXdf+3I2J/HevtwpcPvKbrIUitWDoOEXEO8FngLcAB4LqIODC22PuApzPzV4G/AD6+7HpXlefd2+c2L6tj5nAFcCIzH83MnwF3AgfHljkIHK4u3w1cFdHEB65JqksdcbgYeHzk+snqtuIymfkc8Axw4fgDRcShiNiKiK3Tp0/XMDRJi+rVAcnMvDUzNzJzY+/evV0PR1prdcThFHDpyPVLqtuKy0TEucBLgCdrWPfKmfapyGqG27ysjjjcD1weEa+KiPOAdwFHxpY5Ary3uvwO4L7s62fi74JnLLQOlo5DdQzhQ8A9wMPAVzLzWER8JCKurRb7PHBhRJwA/gQ463SnRlw/2G4Oj9t6onPreJDMPAocHbvtz0Yu/y/wzjrWJakdvTogKak/jIOkIuOwoGUPSjbxfYyq17r/jIyDpCLj0EOed2+P23oy49BXnmJrntt4KuOwhC8feI0viNLKMg4dWvcDXn3mz8Y49NYtt9zitLdJ16fHG2YwDjVw10KryDhIKjIONVl09jBt3/b5XQt3L+pTbc9puxQeb9hmHCQVGQdJRbW8ZVvLufnmzYnfy7gz/d3cTL9jYVm7OEPhLsULnDnUyLMWWiXGYSB83cOSfF3D3IxDzZo4a6F2+DM4k3EYEGcPC3LWsBDj0IAmZw8GYk67DIOzhrMZB0lFxqEhzh56wFnDUoxDDxmIGhiGpRmHBjX9ugcDMYEHIGthHCQVGYeGtfK6B2cPL5hjW7hLMZ1x6LFdH3sAAwHPbwOPNdQj+vpl1xsbG7m1tdX1MM5y+2sWmwm8+/ixpdY76Y1ZOzY3q1/2dX1z1i7D0FUUevo0IyIeyMyN0n3OHFrSysFJWL8Phxn5+3oQsl6+ZXsgpr2te8fok2Mt3uI951kJdyXm48yhRW1+v+bKn+Y0DI0zDi1b9otwFgrEKkViF58BOc4wLMbdigHazS7GjpX6JKkFXtxkGBbnzKEjbe5iwMBnEQvMFsAwLGupU5kRcQFwF7Af+A/g9zLz6cJyPwcerK7+Z2ZeO+uxV+1U5iRNn+IsGcxpzyXOQvQtDEM8lblsHD4BPJWZH4uIG4HzM/PDheV+kpm/Ms9jr0scYPlAwJKRgP6EYmRmswpR2DHEOCy7W3EQOFxdPgy8dcnHk9QTy84c/iczX1pdDuDpnetjyz0HfAd4DvhYZv7trMdep5kDdDd72NHpLGLJ2cKOvs4aYJgzh5lxiIh7gZcX7roJODwag4h4OjPPLzzGxZl5KiIuA+4DrsrMHxSWOwQcAti3b9/rHnvssalj60JTcYDuA7GjlVDUFIQdfQ4DrGgcZjzwI8AbM/OJiLgI+EZmvnrG//NF4O8y8+5py/V15hDR7Euh6wjEjjpCAWOxGDUrHBPOjNT1Mue+B2HUOsbhk8CTIwckL8jMPx1b5nzgp5n5bETsAf4FOJiZx6c99rrGAfoZiGnG49HGexyGFAZYzzhcCHwF2Ac8xvapzKciYgP4YGa+PyJeD/w18Au2D4B+KjM/P+ux+xwHGFYgoJ1ItGFoUdixdnFoUt/jAMMLBAw3EkONwo6ePs2MQ52isJs9lGMQ4/oeiqEHYVRPn2ZT4+B7K3puJzzNzCI2Ry73IxSrFIShc+Ywp9LMAdr5hu0mZxHj2orFusSgp08zdyvqNCkOsHqBGLdsMNYlBCU9fZoZhzpNiwO0EwjoNhKaX0+fZn6GZJvaetK2FSGtL+Mgqcg4NKDN2YMzCDXFODSkzWMCBkJNMA4NajsQRkJ1Mg4Na/usgpFQXYxDC7o47WgktCzj0JKuXpdgJLQo49CiLl+4ZCQ0L+PQsncfP2YkNAi+K7Mj7z5+rNMn6fi6fTm2xjlz6FCfnpDOKDTOmUPHdgLRlyfm6Dj6FC+1z5mDpCJnDj3R9TGIEo9LrDfj0CN9DMSo0tgMxuoyDj3Tt2MQs0wap9EYPuMwp/Y+0WfYT67rux6AluYBSUlFxkFSkXGQVGQcJBUZB0lFxkFSkXGQVGQcJBUZB0lFxkFSkXGQVGQcJBUtFYeIeGdEHIuIX0RE8Wu8q+WujohHIuJERNy4zDoltWPZmcNDwO8C35y0QEScA3wWeAtwALguIg4suV5JDVvqLduZ+TBARExb7ArgRGY+Wi17J3AQOL7MuiU1q41jDhcDj49cP1nddpaIOBQRWxGxdfr06RaGJmmSmTOHiLgXeHnhrpsy82t1DiYzbwVuBdjY2GjtY1UknW1mHDLzzUuu4xRw6cj1S6rbJPVYG7sV9wOXR8SrIuI84F3AkRbWK2kJy57KfFtEnAR+C/j7iLinuv0VEXEUIDOfAz4E3AM8DHwlM4f9AYnSGlj2bMVXga8Wbv8v4JqR60eBo8usS1K7fIWkpCLjIKnIOEgqMg6SioyDpCLjIKnIOEgqMg6SioyDpCLjIKnIOEgqMg6SioyDpCLjIKnIOEgqMg6SiiKzn5/jGhGngccaeOg9wI8beNymDGm8QxorDGu8TY31lZm5t3RHb+PQlIjYysyJ387VN0Ma75DGCsMabxdjdbdCUpFxkFS0jnG4tesBzGlI4x3SWGFY4219rGt3zEHS7qzjzEHSLhgHSUUrH4eIeGdEHIuIX0TExFNBEXF1RDwSESci4sY2xzg2jgsi4h8j4vvVf8+fsNzPI+I71Z9Wv15w1raKiBdFxF3V/d+OiP1tjm9sLLPGekNEnB7Zlu/vYpzVWL4QET+KiIcm3B8R8enq7/LdiHhtowPKzJX+A/w68GrgG8DGhGXOAX4AXAacB/wbcKCj8X4CuLG6fCPw8QnL/aSj8c3cVsAfAp+rLr8LuKvHY70B+EwX4yuM9w3Aa4GHJtx/DfAPQABXAt9ucjwrP3PIzIcz85EZi10BnMjMRzPzZ8CdwMHmR1d0EDhcXT4MvLWjcUyym201+ne4G7gqIqLFMe7o0891psz8JvDUlEUOAl/Kbd8CXhoRFzU1npWPwy5dDDw+cv1kdVsXXpaZT1SX/xt42YTlXhwRWxHxrYh4aztDA3a3rZ5fJre/SPkZ4MJWRjdhHJVJP9e3V9P0uyPi0naGtpBWf0+X+iLdvoiIe4GXF+66KTO/1vZ4Zpk23tErmZkRMelc8ysz81REXAbcFxEPZuYP6h7rGvg6cEdmPhsRH2B7xvOmjsfUCysRh8x885IPcQoY/Rfjkuq2Rkwbb0T8MCIuyswnqinjjyY8xqnqv49GxDeA32B7/7ppu9lWO8ucjIhzgZcAT7YwtnEzx5qZo+O6je1jPn3V6u+puxXb7gcuj4hXRcR5bB9Ea/UMwIgjwHury+8Fzpr5RMT5EfGi6vIe4LeB4y2NbzfbavTv8A7gvqyOqLVs5ljH9tmvBR5ucXzzOgK8pzprcSXwzMguaP26PkLbwhHgt7G9b/Ys8EPgnur2VwBHx44Ef4/tf31v6nC8FwL/BHwfuBe4oLp9A7ituvx64EG2j74/CLyv5TGeta2AjwDXVpdfDPwNcAL4V+CyDrfnrLF+FDhWbct/Bn6tw7HeATwB/F/1O/s+4IPAB6v7A/hs9Xd5kAln3+r648unJRW5WyGpyDhIKjIOkoqMg6Qi4yCpyDhIKjIOkor+H8DQSANkBodFAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "ll_corner_pin_universe.plot(width=(2.5, 2.5), basis = 'xy', colors = {ll_corner_fuel_cell: 'orange', ll_corner_gap_cell: 'white', ll_corner_clad_cell: 'grey', ll_sleave_cell:'brown', ll_inner_water_cell: 'blue', ll_sleave_water_cell: 'blue', ll_sleave_ver_water_cell: 'blue', ll_opposite_water_cell: 'blue', ll_sleave_hor_water_cell: 'blue'})" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "lr_corner_fuel_or = openmc.ZCylinder(r=1.0414/2, name='lr Corner Cell: Fuel OR')\n", + "lr_corner_clad_ir = openmc.ZCylinder(r=1.06426/2, name='lr Corner Cell: Clad IR')\n", + "lr_corner_clad_or = openmc.ZCylinder(r=1.22682/2, name='lr Corner Cell: Clad OR')\n", + "\n", + "lr_corner_fuel_cell = openmc.Cell(name='lr fuel')\n", + "lr_corner_fuel_cell.fill = uo2\n", + "lr_corner_fuel_cell.region = -lr_corner_fuel_or \n", + "\n", + "lr_corner_gap_cell = openmc.Cell(name='lr air gap')\n", + "lr_corner_gap_cell.region = -lr_corner_clad_ir & +lr_corner_fuel_or\n", + "\n", + "lr_corner_clad_cell = openmc.Cell(name='lr clad')\n", + "lr_corner_clad_cell.fill = zircaloy\n", + "lr_corner_clad_cell.region = +lr_corner_clad_ir & -lr_corner_clad_or\n", + "\n", + "lr_sleave_ir = openmc.ZCylinder(x0=pitch/2-sleave_inner_radius-margin, y0=-pitch/2+sleave_inner_radius-margin, r=sleave_inner_radius)\n", + "lr_sleave_or = openmc.ZCylinder(x0=pitch/2-sleave_inner_radius-margin, y0=-pitch/2+sleave_inner_radius-margin, r=sleave_inner_radius+sleave_thickness)\n", + "\n", + "lr_sleave_hor_bound = openmc.XPlane(x0=pitch/2 - sleave_inner_radius - margin)\n", + "lr_sleave_ver_bound = openmc.YPlane(y0=-pitch/2 + sleave_inner_radius - margin)\n", + "\n", + "lr_sleave_cell = openmc.Cell(name='ur sleave cell')\n", + "lr_sleave_cell.region = -lr_sleave_or & +lr_sleave_ir & +lr_sleave_hor_bound & -lr_sleave_ver_bound & pin_cell_box\n", + "lr_sleave_cell.fill = zircaloy\n", + "\n", + "lr_sleave_water_cell = openmc.Cell(name='ur sleave water')\n", + "lr_sleave_water_cell.region = pin_cell_box & +lr_sleave_hor_bound & -lr_sleave_ver_bound & +lr_sleave_or\n", + "lr_sleave_water_cell.fill = water\n", + "\n", + "lr_sleave_ver_water_cell = openmc.Cell(name='ur vertically-equivalent sleave water')\n", + "lr_sleave_ver_water_cell.region = pin_cell_box & -lr_sleave_hor_bound & -lr_sleave_ver_bound & +lr_sleave_ir\n", + "lr_sleave_ver_water_cell.fill = water \n", + "\n", + "lr_opposite_water_cell = openmc.Cell(name='ur opposite water')\n", + "lr_opposite_water_cell.region = pin_cell_box & -lr_sleave_hor_bound & +lr_sleave_ver_bound & +lr_sleave_ir\n", + "lr_opposite_water_cell.fill = water \n", + "\n", + "lr_sleave_hor_water_cell = openmc.Cell(name='ur horizontally-equivalent sleave water')\n", + "lr_sleave_hor_water_cell.region = pin_cell_box & +lr_sleave_hor_bound & +lr_sleave_ver_bound & +lr_sleave_ir\n", + "lr_sleave_hor_water_cell.fill = water \n", + "\n", + "lr_inner_water_cell = openmc.Cell(name='ur inner water cell')\n", + "lr_inner_water_cell.region = pin_cell_box & -lr_sleave_ir & +lr_corner_clad_or\n", + "lr_inner_water_cell.fill = water\n", + "\n", + "lr_corner_pin_universe = openmc.Universe(cells=[lr_corner_fuel_cell, lr_corner_gap_cell, lr_corner_clad_cell, lr_sleave_cell, lr_inner_water_cell, lr_sleave_water_cell, lr_sleave_ver_water_cell, lr_opposite_water_cell, lr_sleave_hor_water_cell])" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "lr_corner_pin_universe.plot(width=(2.5, 2.5), basis = 'xy', colors = {lr_corner_fuel_cell: 'orange', lr_corner_gap_cell: 'white', lr_corner_clad_cell: 'grey', lr_sleave_cell:'brown', lr_inner_water_cell: 'blue', lr_sleave_water_cell: 'blue', lr_sleave_ver_water_cell: 'blue', lr_opposite_water_cell: 'blue', lr_sleave_hor_water_cell: 'blue'})" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/miriamrathbun/codes/openmc-mak/openmc/surface.py:1510: FutureWarning: \"ZCylinder(...) accepts an argument named 'r', not 'R'. Future versions of OpenMC will not accept the capitalized version.\n", + " warn(_WARNING_UPPER.format(type(self).__name__, 'r', 'R'),\n" + ] + } + ], + "source": [ + "quarter_pitch = pitch * 8\n", + "\n", + "assembly = openmc.RectLattice(name='Quarter Assembly')\n", + "assembly.pitch = (pitch, pitch)\n", + "assembly.lower_left = [-quarter_pitch/2, -quarter_pitch/2]\n", + "\n", + "assembly.universes = [\n", + " [ul_corner_pin_universe, fuel_pin_universe, fuel_pin_universe, fuel_pin_universe, fuel_pin_universe, fuel_pin_universe, fuel_pin_universe, ur_corner_pin_universe],\n", + " [fuel_pin_universe, fuel_pin_universe, fuel_pin_universe, fuel_pin_universe, fuel_pin_universe, fuel_pin_universe, fuel_pin_universe, fuel_pin_universe],\n", + " [fuel_pin_universe, fuel_pin_universe, fuel_pin_universe, fuel_pin_universe, fuel_pin_universe, fuel_pin_universe, fuel_pin_universe, fuel_pin_universe],\n", + " [fuel_pin_universe, fuel_pin_universe, fuel_pin_universe, water_pin_universe, fuel_pin_universe, fuel_pin_universe, fuel_pin_universe, fuel_pin_universe],\n", + " [fuel_pin_universe, fuel_pin_universe, fuel_pin_universe, fuel_pin_universe, water_pin_universe, fuel_pin_universe, fuel_pin_universe, fuel_pin_universe],\n", + " [fuel_pin_universe, fuel_pin_universe, fuel_pin_universe, fuel_pin_universe, fuel_pin_universe, fuel_pin_universe, fuel_pin_universe, fuel_pin_universe],\n", + " [fuel_pin_universe, fuel_pin_universe, fuel_pin_universe, fuel_pin_universe, fuel_pin_universe, fuel_pin_universe, fuel_pin_universe, fuel_pin_universe],\n", + " [ll_corner_pin_universe, fuel_pin_universe, fuel_pin_universe, fuel_pin_universe, fuel_pin_universe, fuel_pin_universe, fuel_pin_universe, lr_corner_pin_universe]\n", + "]\n", + "\n", + "assembly_region = openmc.rectangular_prism(width=quarter_pitch, height=quarter_pitch, origin=(0,0))\n", + "assembly_cell = openmc.Cell(name='quarter assembly cell', fill=assembly, region=assembly_region)\n", + "\n", + "assembly_sleave = openmc.Cell(name='quarter assembly sleave')\n", + "assembly_sleave.region = openmc.rectangular_prism(width=quarter_pitch+2*sleave_thickness, height=quarter_pitch+2*sleave_thickness, corner_radius=sleave_inner_radius+sleave_thickness) & ~assembly_cell.region\n", + "assembly_sleave.fill = zircaloy\n", + "\n", + "assembly_outer_water = openmc.Cell(name='assembly outer water')\n", + "assembly_outer_water.region = ~assembly_sleave.region & ~assembly_cell.region & openmc.rectangular_prism(width=quarter_pitch+2*sleave_thickness+1, height=quarter_pitch+2*sleave_thickness+1, boundary_type='reflective')\n", + "assembly_outer_water.fill = water\n", + "\n", + "quarter_assembly_universe = openmc.Universe(cells=[assembly_cell, assembly_sleave, assembly_outer_water])" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 25, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "quarter_assembly_universe.plot(width=(15,15), colors={assembly_outer_water: 'blue'})" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [], + "source": [ + "geom = openmc.Geometry(quarter_assembly_universe)\n", + "geom.export_to_xml()" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "JPOk4874OR3w", + "outputId": "b15d56c2-f9a1-42c4-b06f-3e779a1953ec" + }, + "outputs": [], + "source": [ + "# OpenMC simulation parameters\n", + "\n", + "point = openmc.stats.Point((0, 0, 0))\n", + "src = openmc.Source(space=point)\n", + "settings = openmc.Settings()\n", + "settings.source = src\n", + "settings.batches = 100\n", + "settings.inactive = 10\n", + "settings.particles = 1000\n", + "settings.export_to_xml()" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "lkX_1LrAzw71", + "outputId": "6331f2a0-42fc-4919-91d3-7bca6b5d735f" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " %%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%\n", + " ############### %%%%%%%%%%%%%%%%%%%%%%%%\n", + " ################## %%%%%%%%%%%%%%%%%%%%%%%\n", + " ################### %%%%%%%%%%%%%%%%%%%%%%%\n", + " #################### %%%%%%%%%%%%%%%%%%%%%%\n", + " ##################### %%%%%%%%%%%%%%%%%%%%%\n", + " ###################### %%%%%%%%%%%%%%%%%%%%\n", + " ####################### %%%%%%%%%%%%%%%%%%\n", + " ####################### %%%%%%%%%%%%%%%%%\n", + " ###################### %%%%%%%%%%%%%%%%%\n", + " #################### %%%%%%%%%%%%%%%%%\n", + " ################# %%%%%%%%%%%%%%%%%\n", + " ############### %%%%%%%%%%%%%%%%\n", + " ############ %%%%%%%%%%%%%%%\n", + " ######## %%%%%%%%%%%%%%\n", + " %%%%%%%%%%%\n", + "\n", + " | The OpenMC Monte Carlo Code\n", + " Copyright | 2011-2020 MIT and OpenMC contributors\n", + " License | https://docs.openmc.org/en/latest/license.html\n", + " Version | 0.12.1-dev\n", + " Git SHA1 | 0228ddba1d6399e654a295e51539590f076b2a3c\n", + " Date/Time | 2021-04-12 15:15:21\n", + " OpenMP Threads | 8\n", + "\n", + " Reading settings XML file...\n", + " Reading cross sections XML file...\n", + " Reading materials XML file...\n", + " Reading geometry XML file...\n", + " Reading U234 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/U234.h5\n", + " Reading U235 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/U235.h5\n", + " Reading U238 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/U238.h5\n", + " Reading U236 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/U236.h5\n", + " Reading O16 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/O16.h5\n", + " Reading O17 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/O17.h5\n", + " Reading Zr90 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/Zr90.h5\n", + " Reading C0 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/C0.h5\n", + " Reading Si28 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/Si28.h5\n", + " Reading Si29 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/Si29.h5\n", + " Reading Si30 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/Si30.h5\n", + " Reading Mn55 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/Mn55.h5\n", + " Reading P31 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/P31.h5\n", + " Reading S32 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/S32.h5\n", + " Reading S33 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/S33.h5\n", + " Reading S34 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/S34.h5\n", + " Reading S36 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/S36.h5\n", + " Reading Cr50 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/Cr50.h5\n", + " Reading Cr52 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/Cr52.h5\n", + " Reading Cr53 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/Cr53.h5\n", + " Reading Cr54 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/Cr54.h5\n", + " Reading Ni58 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/Ni58.h5\n", + " Reading Ni60 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/Ni60.h5\n", + " Reading Ni61 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/Ni61.h5\n", + " Reading Ni62 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/Ni62.h5\n", + " Reading Ni64 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/Ni64.h5\n", + " Reading Fe54 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/Fe54.h5\n", + " Reading Fe56 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/Fe56.h5\n", + " Reading Fe57 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/Fe57.h5\n", + " Reading Fe58 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/Fe58.h5\n", + " Reading H1 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/H1.h5\n", + " Reading H2 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/H2.h5\n", + " Reading c_H_in_H2O from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/c_H_in_H2O.h5\n", + " Minimum neutron data temperature: 294.0 K\n", + " Maximum neutron data temperature: 294.0 K\n", + " Preparing distributed cell instances...\n", + " Writing summary.h5 file...\n", + " Maximum neutron transport energy: 20000000.0 eV for U235\n", + " Initializing source particles...\n", + "\n", + " ====================> K EIGENVALUE SIMULATION <====================\n", + "\n", + " Bat./Gen. k Average k\n", + " ========= ======== ====================\n", + " 1/1 1.20596\n", + " 2/1 1.17725\n", + " 3/1 1.22903\n", + " 4/1 1.25595\n", + " 5/1 1.25464\n", + " 6/1 1.19484\n", + " 7/1 1.20845\n", + " 8/1 1.11385\n", + " 9/1 1.20241\n", + " 10/1 1.17714\n", + " 11/1 1.21900\n", + " 12/1 1.24344 1.23122 +/- 0.01222\n", + " 13/1 1.18577 1.21607 +/- 0.01671\n", + " 14/1 1.25341 1.22540 +/- 0.01506\n", + " 15/1 1.16432 1.21319 +/- 0.01689\n", + " 16/1 1.19189 1.20964 +/- 0.01424\n", + " 17/1 1.18475 1.20608 +/- 0.01255\n", + " 18/1 1.23268 1.20941 +/- 0.01137\n", + " 19/1 1.09926 1.19717 +/- 0.01582\n", + " 20/1 1.24832 1.20228 +/- 0.01505\n", + " 21/1 1.13900 1.19653 +/- 0.01478\n", + " 22/1 1.27620 1.20317 +/- 0.01503\n", + " 23/1 1.29588 1.21030 +/- 0.01556\n", + " 24/1 1.14165 1.20540 +/- 0.01522\n", + " 25/1 1.19325 1.20459 +/- 0.01419\n", + " 26/1 1.23371 1.20641 +/- 0.01340\n", + " 27/1 1.23268 1.20795 +/- 0.01268\n", + " 28/1 1.10873 1.20244 +/- 0.01316\n", + " 29/1 1.14639 1.19949 +/- 0.01280\n", + " 30/1 1.24465 1.20175 +/- 0.01235\n", + " 31/1 1.21818 1.20253 +/- 0.01177\n", + " 32/1 1.17997 1.20151 +/- 0.01127\n", + " 33/1 1.19293 1.20113 +/- 0.01078\n", + " 34/1 1.20978 1.20149 +/- 0.01032\n", + " 35/1 1.24639 1.20329 +/- 0.01006\n", + " 36/1 1.19880 1.20312 +/- 0.00967\n", + " 37/1 1.21696 1.20363 +/- 0.00932\n", + " 38/1 1.18314 1.20290 +/- 0.00901\n", + " 39/1 1.16487 1.20159 +/- 0.00879\n", + " 40/1 1.25905 1.20350 +/- 0.00871\n", + " 41/1 1.18639 1.20295 +/- 0.00844\n", + " 42/1 1.25987 1.20473 +/- 0.00836\n", + " 43/1 1.21967 1.20518 +/- 0.00812\n", + " 44/1 1.18532 1.20460 +/- 0.00790\n", + " 45/1 1.10094 1.20164 +/- 0.00822\n", + " 46/1 1.17034 1.20077 +/- 0.00804\n", + " 47/1 1.19107 1.20050 +/- 0.00782\n", + " 48/1 1.17497 1.19983 +/- 0.00764\n", + " 49/1 1.24290 1.20094 +/- 0.00752\n", + " 50/1 1.18399 1.20051 +/- 0.00735\n", + " 51/1 1.25434 1.20183 +/- 0.00728\n", + " 52/1 1.10167 1.19944 +/- 0.00750\n", + " 53/1 1.24434 1.20049 +/- 0.00740\n", + " 54/1 1.23006 1.20116 +/- 0.00726\n", + " 55/1 1.19075 1.20093 +/- 0.00710\n", + " 56/1 1.15255 1.19987 +/- 0.00702\n", + " 57/1 1.22948 1.20050 +/- 0.00690\n", + " 58/1 1.16780 1.19982 +/- 0.00679\n", + " 59/1 1.13035 1.19841 +/- 0.00680\n", + " 60/1 1.24983 1.19943 +/- 0.00674\n", + " 61/1 1.11795 1.19784 +/- 0.00680\n", + " 62/1 1.23461 1.19854 +/- 0.00670\n", + " 63/1 1.17725 1.19814 +/- 0.00659\n", + " 64/1 1.18257 1.19785 +/- 0.00647\n", + " 65/1 1.16513 1.19726 +/- 0.00638\n", + " 66/1 1.23539 1.19794 +/- 0.00630\n", + " 67/1 1.14146 1.19695 +/- 0.00627\n", + " 68/1 1.24386 1.19776 +/- 0.00621\n", + " 69/1 1.15268 1.19699 +/- 0.00615\n", + " 70/1 1.21613 1.19731 +/- 0.00606\n", + " 71/1 1.17274 1.19691 +/- 0.00597\n", + " 72/1 1.18517 1.19672 +/- 0.00588\n", + " 73/1 1.14883 1.19596 +/- 0.00583\n", + " 74/1 1.16359 1.19545 +/- 0.00576\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " 75/1 1.19540 1.19545 +/- 0.00567\n", + " 76/1 1.15401 1.19483 +/- 0.00562\n", + " 77/1 1.33939 1.19698 +/- 0.00594\n", + " 78/1 1.24558 1.19770 +/- 0.00590\n", + " 79/1 1.20401 1.19779 +/- 0.00581\n", + " 80/1 1.15683 1.19720 +/- 0.00576\n", + " 81/1 1.19522 1.19718 +/- 0.00568\n", + " 82/1 1.24057 1.19778 +/- 0.00563\n", + " 83/1 1.25570 1.19857 +/- 0.00561\n", + " 84/1 1.19560 1.19853 +/- 0.00553\n", + " 85/1 1.22024 1.19882 +/- 0.00547\n", + " 86/1 1.20019 1.19884 +/- 0.00539\n", + " 87/1 1.18864 1.19871 +/- 0.00533\n", + " 88/1 1.16494 1.19827 +/- 0.00527\n", + " 89/1 1.23639 1.19876 +/- 0.00523\n", + " 90/1 1.19507 1.19871 +/- 0.00516\n", + " 91/1 1.19785 1.19870 +/- 0.00510\n", + " 92/1 1.24397 1.19925 +/- 0.00507\n", + " 93/1 1.17376 1.19894 +/- 0.00502\n", + " 94/1 1.29989 1.20015 +/- 0.00510\n", + " 95/1 1.23815 1.20059 +/- 0.00506\n", + " 96/1 1.22451 1.20087 +/- 0.00501\n", + " 97/1 1.15918 1.20039 +/- 0.00497\n", + " 98/1 1.13020 1.19959 +/- 0.00498\n", + " 99/1 1.16169 1.19917 +/- 0.00494\n", + " 100/1 1.23024 1.19951 +/- 0.00490\n", + " Creating state point statepoint.100.h5...\n", + "\n", + " =======================> TIMING STATISTICS <=======================\n", + "\n", + " Total time for initialization = 8.1559e+00 seconds\n", + " Reading cross sections = 8.0639e+00 seconds\n", + " Total time in simulation = 3.0575e+00 seconds\n", + " Time in transport only = 3.0383e+00 seconds\n", + " Time in inactive batches = 2.5988e-01 seconds\n", + " Time in active batches = 2.7976e+00 seconds\n", + " Time synchronizing fission bank = 3.6140e-03 seconds\n", + " Sampling source sites = 2.9180e-03 seconds\n", + " SEND/RECV source sites = 5.9700e-04 seconds\n", + " Time accumulating tallies = 4.0000e-05 seconds\n", + " Time writing statepoints = 8.9120e-03 seconds\n", + " Total time for finalization = 7.0000e-06 seconds\n", + " Total time elapsed = 1.1256e+01 seconds\n", + " Calculation Rate (inactive) = 38479.0 particles/second\n", + " Calculation Rate (active) = 32170.1 particles/second\n", + "\n", + " ============================> RESULTS <============================\n", + "\n", + " k-effective (Collision) = 1.20249 +/- 0.00447\n", + " k-effective (Track-length) = 1.19951 +/- 0.00490\n", + " k-effective (Absorption) = 1.20115 +/- 0.00350\n", + " Combined k-effective = 1.20089 +/- 0.00309\n", + " Leakage Fraction = 0.00000 +/- 0.00000\n", + "\n" + ] + } + ], + "source": [ + "openmc.run()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "accelerator": "GPU", + "colab": { + "collapsed_sections": [], + "name": "thick_thin.IPYNB", + "provenance": [] + }, + "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.9.0" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/RBMK.ipynb b/RBMK.ipynb new file mode 100644 index 0000000..09185c4 --- /dev/null +++ b/RBMK.ipynb @@ -0,0 +1,559 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# A RBMK geometry \n", + "This notebook can be used as a template for modeling RBMK reactors.\n", + "\n", + "SOURCES\n", + "\"Fuel Assembly\": https://web.archive.org/web/20090908013425/http:/www.insc.anl.gov:80/rbmk/reactor/assembly.html\n", + "\"Fuel with burnable absorber for RBMK-1500\", pg250-252: https://www.osti.gov/etdeweb/servlets/purl/20269236\n", + "\"DESIGN AND FABRICATION OF NUCLEAR FUEL FOR WWER AND RBMK REACTORS\"\n", + "Slides 8-11: indico.ictp.it/event/a04215/session/26/contribution/16/material/0/1.pdf" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib inline\n", + "from math import pi, sin, cos, sqrt\n", + "import numpy as np\n", + "import openmc" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# Materials definitions\n", + "\n", + "fuel = openmc.Material(name='2.0% Fuel')\n", + "fuel.add_element('U', 0.995, enrichment=2.0)\n", + "fuel.add_element('Er', 0.005)\n", + "fuel.add_nuclide('O16', 2.0)\n", + "fuel.set_density('g/cm3', 10.400)\n", + "\n", + "zircaloy = openmc.Material(name='Zircaloy')\n", + "zircaloy.add_element('Zr', 0.99)\n", + "zircaloy.add_element('Nb', 0.01)\n", + "zircaloy.set_density('g/cm3', 8.59)\n", + "\n", + "wall = openmc.Material(name='Carrier Rod Material')\n", + "wall.add_element('Zr', 0.975)\n", + "wall.add_element('Nb', 0.025)\n", + "wall.set_density('g/cm3', 8.59)\n", + "\n", + "helium = openmc.Material(name='Helium')\n", + "helium.add_element('He', 1)\n", + "helium.set_density('g/cm3', 0.178)\n", + "\n", + "# Instantiate a Materials collection and export to xml\n", + "materials_file = openmc.Materials([fuel, zircaloy, helium, wall])\n", + "materials_file.export_to_xml()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "# Geometry definitions for the fuel rod\n", + "\n", + "#Making the boundary planes for the sleeves\n", + "sleeve_min_z = openmc.ZPlane(z0=-12)\n", + "sleeve_max_z = openmc.ZPlane(z0=+12)\n", + "\n", + "# Create cylinders for the fuel and clad\n", + "fuel_inner_radius = openmc.ZCylinder(r=0.55)\n", + "fuel_outer_radius = openmc.ZCylinder(r=0.566)\n", + "clad_inner_radius = openmc.ZCylinder(r=0.596)\n", + "clad_outer_radius = openmc.ZCylinder(r=0.68)\n", + "\n", + "# Create a universe to encapsulate a fuel rod\n", + "pin_cell_universe = openmc.Universe(name='2.0% Fuel Pin') \n", + "\n", + "# Create fuel cell\n", + "fuel_cell_top = openmc.Cell(name='2.0% Fuel')\n", + "fuel_cell_top.fill = fuel\n", + "fuel_cell_top.region = -fuel_inner_radius & +sleeve_max_z\n", + "pin_cell_universe.add_cell(fuel_cell_top)\n", + "\n", + "# Create void space\n", + "void_space_top = openmc.Cell(name='empty_space')\n", + "void_space_top.fill = helium\n", + "void_space_top.region = +fuel_inner_radius & -clad_inner_radius & +sleeve_max_z\n", + "pin_cell_universe.add_cell(void_space_top)\n", + "\n", + "# Create a clad cell\n", + "clad_cell_top = openmc.Cell(name='2.0% Clad')\n", + "clad_cell_top.fill = zircaloy\n", + "clad_cell_top.region = +clad_inner_radius & -clad_outer_radius & +sleeve_max_z\n", + "pin_cell_universe.add_cell(clad_cell_top)\n", + "\n", + "# Create fuel cell\n", + "fuel_cell_bot = openmc.Cell(name='2.0% Fuel')\n", + "fuel_cell_bot.fill = fuel\n", + "fuel_cell_bot.region = -fuel_inner_radius & -sleeve_min_z\n", + "pin_cell_universe.add_cell(fuel_cell_bot)\n", + "\n", + "# Create void space\n", + "void_space_bot = openmc.Cell(name='empty_space')\n", + "void_space_bot.fill = helium\n", + "void_space_bot.region = +fuel_inner_radius & -clad_inner_radius & -sleeve_min_z\n", + "pin_cell_universe.add_cell(void_space_bot)\n", + "\n", + "# Create a clad cell\n", + "clad_cell_bot = openmc.Cell(name='2.0% Clad')\n", + "clad_cell_bot.fill = zircaloy\n", + "clad_cell_bot.region = +clad_inner_radius & -clad_outer_radius & -sleeve_min_z\n", + "pin_cell_universe.add_cell(clad_cell_bot)\n", + "\n", + "# Create an outside of pin cell\n", + "moderator = openmc.Cell(name='Moderator')\n", + "moderator.fill = helium\n", + "moderator.region = +clad_outer_radius\n", + "pin_cell_universe.add_cell(moderator)\n", + "\n", + "# Create a 'sleeve' cell that slices through the middle of the elongated element\n", + "sleeve_cell = openmc.Cell(name='Sleeve')\n", + "sleeve_cell.fill = helium\n", + "sleeve_cell.region = -clad_outer_radius & +sleeve_min_z & -sleeve_max_z\n", + "pin_cell_universe.add_cell(sleeve_cell)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "# Geometry definitions for the fuel rod\n", + "\n", + "rod_inner_radius = openmc.ZCylinder(r=0.75) \n", + "rod_outer_radius = openmc.ZCylinder(r=0.7625)\n", + "\n", + "rod_cell_universe = openmc.Universe(name='Carrier Rod')\n", + "\n", + "inner_rod = openmc.Cell(name='Inner Rod')\n", + "inner_rod.fill = helium\n", + "inner_rod.region = -rod_inner_radius\n", + "rod_cell_universe.add_cell(inner_rod)\n", + "\n", + "outer_rod = openmc.Cell(name='Outer Rod')\n", + "outer_rod.fill = wall\n", + "outer_rod.region = +rod_inner_radius & -rod_outer_radius\n", + "rod_cell_universe.add_cell(outer_rod)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "# Create a circular Lattice for the bundle\n", + "\n", + "element_min_z = openmc.ZPlane(z0=-364, boundary_type='reflective')\n", + "element_max_z = openmc.ZPlane(z0=+364, boundary_type='reflective')\n", + "carrier_min_z = openmc.ZPlane(z0=-400, boundary_type='reflective')\n", + "carrier_max_z = openmc.ZPlane(z0=+600, boundary_type='reflective')\n", + "\n", + "circlat = openmc.Universe(name='Circular Lattice')\n", + "\n", + "channel = openmc.ZCylinder(r=4.5, boundary_type='reflective')\n", + "\n", + "channel_cell = openmc.Cell(name='Channel')\n", + "channel_cell.fill = helium\n", + "channel_cell.region = -channel & +rod_outer_radius & +element_min_z & -element_max_z\n", + "\n", + "#Calculations before finding pin placement\n", + "r_channel = 4.0\n", + "r_element = 0.68\n", + "r_outer = r_channel-r_element\n", + "\n", + "padding = pi*r_outer/6-2*r_element\n", + "r_inner = r_outer*cos(pi/12)-sqrt((r_element*2+padding)**2-(r_element+padding)**2)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "# Add the fuel pins into the channel\n", + "\n", + "num_in_rings = [6, 12]\n", + "radii = [r_inner, r_outer]\n", + "angles = [0, pi/12]\n", + "\n", + "for index in range(len(num_in_rings)):\n", + " elem_num = num_in_rings[index]\n", + " ring_radius = radii[index]\n", + " theta_0 = angles[index]\n", + " theta = 2*pi/elem_num\n", + " for element in range(elem_num):\n", + " x = ring_radius*cos(element*theta + theta_0)\n", + " y = ring_radius*sin(element*theta + theta_0)\n", + "\n", + " pin_boundary = openmc.ZCylinder(x0=x, y0=y, r=r_element)\n", + " pin = openmc.Cell(fill=pin_cell_universe, region=-pin_boundary & +element_min_z & -element_max_z)\n", + " pin.translation = (x,y,0)\n", + " pin.id = (index+1)*100 + element\n", + " channel_cell.region &= ~pin.region\n", + " circlat.add_cell(pin)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "# Add the 3 Components of the Carrier Rod\n", + "rod_bound = openmc.ZCylinder(r=0.7625, boundary_type='reflective')\n", + "rod_channel_min = openmc.ZPlane(z0=-364)\n", + "rod_channel_max = openmc.ZPlane(z0=+364)\n", + "\n", + "rod_above = openmc.Cell(fill=rod_cell_universe, region=-rod_bound & -carrier_max_z & +rod_channel_max)\n", + "rod_mid = openmc.Cell(fill=rod_cell_universe, region=-rod_outer_radius & +rod_channel_min & -rod_channel_max)\n", + "rod_below = openmc.Cell(fill=rod_cell_universe, region=-rod_bound & -rod_channel_min & +carrier_min_z)\n", + "\n", + "circlat.add_cell(rod_above)\n", + "circlat.add_cell(rod_mid)\n", + "circlat.add_cell(rod_below)\n", + "circlat.add_cell(channel_cell)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "geometry = openmc.Geometry(circlat)\n", + "geometry.export_to_xml()" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "circlat.plot(width=(12, 12), basis='xy')" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "# OpenMC simulation parameters\n", + "\n", + "batches = 100\n", + "inactive = 10\n", + "particles = 5000\n", + "\n", + "settings_file = openmc.Settings()\n", + "settings_file.batches = batches\n", + "settings_file.inactive = inactive\n", + "settings_file.particles = particles\n", + "\n", + "bounds = [-3, -3, -2.4, 3, 3, 2.4]\n", + "uniform_dist = openmc.stats.Box(bounds[:3], bounds[3:], only_fissionable=False) #only_fissionable != True due to lots of helium\n", + "settings_file.source = openmc.Source(space=uniform_dist)\n", + "\n", + "settings_file.export_to_xml()" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " %%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%\n", + " ############### %%%%%%%%%%%%%%%%%%%%%%%%\n", + " ################## %%%%%%%%%%%%%%%%%%%%%%%\n", + " ################### %%%%%%%%%%%%%%%%%%%%%%%\n", + " #################### %%%%%%%%%%%%%%%%%%%%%%\n", + " ##################### %%%%%%%%%%%%%%%%%%%%%\n", + " ###################### %%%%%%%%%%%%%%%%%%%%\n", + " ####################### %%%%%%%%%%%%%%%%%%\n", + " ####################### %%%%%%%%%%%%%%%%%\n", + " ###################### %%%%%%%%%%%%%%%%%\n", + " #################### %%%%%%%%%%%%%%%%%\n", + " ################# %%%%%%%%%%%%%%%%%\n", + " ############### %%%%%%%%%%%%%%%%\n", + " ############ %%%%%%%%%%%%%%%\n", + " ######## %%%%%%%%%%%%%%\n", + " %%%%%%%%%%%\n", + "\n", + " | The OpenMC Monte Carlo Code\n", + " Copyright | 2011-2020 MIT and OpenMC contributors\n", + " License | https://docs.openmc.org/en/latest/license.html\n", + " Version | 0.12.1-dev\n", + " Git SHA1 | 0228ddba1d6399e654a295e51539590f076b2a3c\n", + " Date/Time | 2021-04-12 12:40:32\n", + " OpenMP Threads | 8\n", + "\n", + " Reading settings XML file...\n", + " Reading cross sections XML file...\n", + " Reading materials XML file...\n", + " Reading geometry XML file...\n", + " Reading U234 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/U234.h5\n", + " Reading U235 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/U235.h5\n", + " Reading U238 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/U238.h5\n", + " Reading U236 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/U236.h5\n", + " Reading Er162 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/Er162.h5\n", + " Reading Er164 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/Er164.h5\n", + " Reading Er166 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/Er166.h5\n", + " Reading Er167 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/Er167.h5\n", + " Reading Er168 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/Er168.h5\n", + " Reading Er170 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/Er170.h5\n", + " Reading O16 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/O16.h5\n", + " Reading Zr90 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/Zr90.h5\n", + " Reading Zr91 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/Zr91.h5\n", + " Reading Zr92 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/Zr92.h5\n", + " Reading Zr94 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/Zr94.h5\n", + " Reading Zr96 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/Zr96.h5\n", + " Reading Nb93 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/Nb93.h5\n", + " Reading He3 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/He3.h5\n", + " Reading He4 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/He4.h5\n", + " Minimum neutron data temperature: 294.0 K\n", + " Maximum neutron data temperature: 294.0 K\n", + " Preparing distributed cell instances...\n", + " Writing summary.h5 file...\n", + " Maximum neutron transport energy: 20000000.0 eV for U235\n", + " Initializing source particles...\n", + "\n", + " ====================> K EIGENVALUE SIMULATION <====================\n", + "\n", + " Bat./Gen. k Average k\n", + " ========= ======== ====================\n", + " 1/1 0.36726\n", + " 2/1 0.41917\n", + " 3/1 0.41996\n", + " 4/1 0.42104\n", + " 5/1 0.42013\n", + " 6/1 0.41539\n", + " 7/1 0.41936\n", + " 8/1 0.41825\n", + " 9/1 0.43324\n", + " 10/1 0.43023\n", + " 11/1 0.43863\n", + " 12/1 0.41949 0.42906 +/- 0.00957\n", + " 13/1 0.41553 0.42455 +/- 0.00713\n", + " 14/1 0.43122 0.42622 +/- 0.00531\n", + " 15/1 0.43523 0.42802 +/- 0.00449\n", + " 16/1 0.42006 0.42670 +/- 0.00390\n", + " 17/1 0.42561 0.42654 +/- 0.00330\n", + " 18/1 0.41654 0.42529 +/- 0.00312\n", + " 19/1 0.43361 0.42621 +/- 0.00290\n", + " 20/1 0.41500 0.42509 +/- 0.00283\n", + " 21/1 0.42439 0.42503 +/- 0.00256\n", + " 22/1 0.41977 0.42459 +/- 0.00238\n", + " 23/1 0.41752 0.42405 +/- 0.00225\n", + " 24/1 0.43619 0.42491 +/- 0.00226\n", + " 25/1 0.41760 0.42443 +/- 0.00216\n", + " 26/1 0.42986 0.42477 +/- 0.00205\n", + " 27/1 0.41637 0.42427 +/- 0.00199\n", + " 28/1 0.41170 0.42357 +/- 0.00200\n", + " 29/1 0.41593 0.42317 +/- 0.00193\n", + " 30/1 0.41912 0.42297 +/- 0.00184\n", + " 31/1 0.41365 0.42253 +/- 0.00181\n", + " 32/1 0.41400 0.42214 +/- 0.00177\n", + " 33/1 0.41753 0.42194 +/- 0.00170\n", + " 34/1 0.41432 0.42162 +/- 0.00166\n", + " 35/1 0.41323 0.42128 +/- 0.00163\n", + " 36/1 0.43010 0.42162 +/- 0.00160\n", + " 37/1 0.41552 0.42140 +/- 0.00156\n", + " 38/1 0.41385 0.42113 +/- 0.00152\n", + " 39/1 0.42110 0.42113 +/- 0.00147\n", + " 40/1 0.41254 0.42084 +/- 0.00145\n", + " 41/1 0.41489 0.42065 +/- 0.00141\n", + " 42/1 0.42521 0.42079 +/- 0.00138\n", + " 43/1 0.42345 0.42087 +/- 0.00134\n", + " 44/1 0.42805 0.42108 +/- 0.00131\n", + " 45/1 0.42292 0.42114 +/- 0.00128\n", + " 46/1 0.42032 0.42111 +/- 0.00124\n", + " 47/1 0.42226 0.42114 +/- 0.00121\n", + " 48/1 0.42795 0.42132 +/- 0.00119\n", + " 49/1 0.41490 0.42116 +/- 0.00117\n", + " 50/1 0.42862 0.42134 +/- 0.00115\n", + " 51/1 0.42480 0.42143 +/- 0.00113\n", + " 52/1 0.41355 0.42124 +/- 0.00112\n", + " 53/1 0.42440 0.42131 +/- 0.00109\n", + " 54/1 0.41865 0.42125 +/- 0.00107\n", + " 55/1 0.42069 0.42124 +/- 0.00105\n", + " 56/1 0.41623 0.42113 +/- 0.00103\n", + " 57/1 0.41685 0.42104 +/- 0.00101\n", + " 58/1 0.41834 0.42099 +/- 0.00099\n", + " 59/1 0.43448 0.42126 +/- 0.00101\n", + " 60/1 0.40917 0.42102 +/- 0.00102\n", + " 61/1 0.42187 0.42104 +/- 0.00100\n", + " 62/1 0.42270 0.42107 +/- 0.00098\n", + " 63/1 0.42030 0.42105 +/- 0.00096\n", + " 64/1 0.43457 0.42130 +/- 0.00098\n", + " 65/1 0.41390 0.42117 +/- 0.00097\n", + " 66/1 0.42198 0.42118 +/- 0.00095\n", + " 67/1 0.42026 0.42117 +/- 0.00093\n", + " 68/1 0.41652 0.42109 +/- 0.00092\n", + " 69/1 0.41120 0.42092 +/- 0.00092\n", + " 70/1 0.42104 0.42092 +/- 0.00090\n", + " 71/1 0.40883 0.42072 +/- 0.00091\n", + " 72/1 0.42478 0.42079 +/- 0.00090\n", + " 73/1 0.42060 0.42079 +/- 0.00088\n", + " 74/1 0.41950 0.42077 +/- 0.00087\n", + " 75/1 0.41800 0.42072 +/- 0.00086\n", + " 76/1 0.42313 0.42076 +/- 0.00085\n", + " 77/1 0.42090 0.42076 +/- 0.00083\n", + " 78/1 0.41947 0.42074 +/- 0.00082\n", + " 79/1 0.42478 0.42080 +/- 0.00081\n", + " 80/1 0.43185 0.42096 +/- 0.00082\n", + " 81/1 0.41999 0.42094 +/- 0.00080\n", + " 82/1 0.41669 0.42089 +/- 0.00079\n", + " 83/1 0.42688 0.42097 +/- 0.00079\n", + " 84/1 0.42583 0.42103 +/- 0.00078\n", + " 85/1 0.41937 0.42101 +/- 0.00077\n", + " 86/1 0.42302 0.42104 +/- 0.00076\n", + " 87/1 0.41306 0.42093 +/- 0.00076\n", + " 88/1 0.42048 0.42093 +/- 0.00075\n", + " 89/1 0.41601 0.42087 +/- 0.00074\n", + " 90/1 0.42380 0.42090 +/- 0.00073\n", + " 91/1 0.42252 0.42092 +/- 0.00072\n", + " 92/1 0.42163 0.42093 +/- 0.00071\n", + " 93/1 0.42060 0.42093 +/- 0.00071\n", + " 94/1 0.41860 0.42090 +/- 0.00070\n", + " 95/1 0.41718 0.42086 +/- 0.00069\n", + " 96/1 0.42078 0.42085 +/- 0.00068\n", + " 97/1 0.41894 0.42083 +/- 0.00068\n", + " 98/1 0.40850 0.42069 +/- 0.00068\n", + " 99/1 0.41439 0.42062 +/- 0.00068\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " 100/1 0.41280 0.42054 +/- 0.00068\n", + " Creating state point statepoint.100.h5...\n", + "\n", + " =======================> TIMING STATISTICS <=======================\n", + "\n", + " Total time for initialization = 3.5405e+00 seconds\n", + " Reading cross sections = 3.4979e+00 seconds\n", + " Total time in simulation = 7.6338e+01 seconds\n", + " Time in transport only = 7.6297e+01 seconds\n", + " Time in inactive batches = 7.5955e+00 seconds\n", + " Time in active batches = 6.8742e+01 seconds\n", + " Time synchronizing fission bank = 1.7017e-02 seconds\n", + " Sampling source sites = 1.3410e-02 seconds\n", + " SEND/RECV source sites = 3.5210e-03 seconds\n", + " Time accumulating tallies = 3.9000e-05 seconds\n", + " Time writing statepoints = 5.7760e-03 seconds\n", + " Total time for finalization = 4.0000e-06 seconds\n", + " Total time elapsed = 7.9891e+01 seconds\n", + " Calculation Rate (inactive) = 6582.89 particles/second\n", + " Calculation Rate (active) = 6546.18 particles/second\n", + "\n", + " ============================> RESULTS <============================\n", + "\n", + " k-effective (Collision) = 0.42078 +/- 0.00067\n", + " k-effective (Track-length) = 0.42054 +/- 0.00068\n", + " k-effective (Absorption) = 0.42137 +/- 0.00110\n", + " Combined k-effective = 0.42081 +/- 0.00058\n", + " Leakage Fraction = 0.00000 +/- 0.00000\n", + "\n" + ] + } + ], + "source": [ + "openmc.run()" + ] + } + ], + "metadata": { + "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.9.0" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/SFR.ipynb b/SFR.ipynb new file mode 100644 index 0000000..ecfe1e3 --- /dev/null +++ b/SFR.ipynb @@ -0,0 +1,755 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "q9Vo6HOQUQbS", + "outputId": "020190f0-fec4-4a85-a716-2a98b03b3340" + }, + "source": [ + "# A Sodium Fast Reactor geometry \n", + "This notebook can be used as a template for modeling Sodium fast reactors.\n", + "\n", + "SOURCES:\n", + "A. Facchini, V. Giusti, R. Ciolini, K. Tucek, D. Thomas, E. D'Agata, \"Detailed Neutornics Study of the Power Evolution for the European Sodium Fast Reactor During a Positive Insertion of Reactivity,\" Nuc. Eng. Design 313 1-9 (2017)\n", + "A. Ponomarev, A. Bednarova, K. Mikityuk, \"New Sodium Fast Reactor Neutronics Benchmark,\" PHYSOR 2018" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "id": "EChOeJ7qVUB7" + }, + "outputs": [], + "source": [ + "%matplotlib inline\n", + "import openmc" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "id": "jlu98MGXV9MP" + }, + "outputs": [], + "source": [ + "# Materials definitions\n", + "\n", + "u235 = openmc.Material(name='U235')\n", + "u235.add_nuclide('U235', 1.0)\n", + "u235.set_density('g/cm3', 10.0)\n", + "\n", + "u238 = openmc.Material(name='U238')\n", + "u238.add_nuclide('U238', 1.0)\n", + "u238.set_density('g/cm3', 10.0)\n", + "\n", + "pu238 = openmc.Material(name='Pu238')\n", + "pu238.add_nuclide('Pu238', 1.0)\n", + "pu238.set_density('g/cm3', 10.0)\n", + "\n", + "pu239 = openmc.Material(name='U235')\n", + "pu239.add_nuclide('Pu239', 1.0)\n", + "pu239.set_density('g/cm3', 10.0)\n", + "\n", + "pu240 = openmc.Material(name='Pu240')\n", + "pu240.add_nuclide('Pu240', 1.0)\n", + "pu240.set_density('g/cm3', 10.0)\n", + "\n", + "pu241 = openmc.Material(name='Pu241')\n", + "pu241.add_nuclide('Pu241', 1.0)\n", + "pu241.set_density('g/cm3', 10.0)\n", + "\n", + "pu242 = openmc.Material(name='Pu242')\n", + "pu242.add_nuclide('Pu242', 1.0)\n", + "pu242.set_density('g/cm3', 10.0)\n", + "\n", + "am241 = openmc.Material(name='Am241')\n", + "am241.add_nuclide('Am241', 1.0)\n", + "am241.set_density('g/cm3', 10.0)\n", + "\n", + "o16 = openmc.Material(name='O16')\n", + "o16.add_nuclide('O16', 1.0)\n", + "o16.set_density('g/cm3', 10.0)\n", + "\n", + "sodium = openmc.Material(name='Na')\n", + "sodium.add_nuclide('Na23', 1.0)\n", + "sodium.set_density('g/cm3', 0.96)\n", + "\n", + "cu63 = openmc.Material(name='Cu63')\n", + "cu63.set_density('g/cm3', 10.0)\n", + "cu63.add_nuclide('Cu63', 1.0)\n", + "\n", + "Al2O3 = openmc.Material(name='Al2O3')\n", + "Al2O3.set_density('g/cm3', 10.0)\n", + "Al2O3.add_element('O', 3.0)\n", + "Al2O3.add_element('Al', 2.0)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "id": "_ltK5VzGZ8kk" + }, + "outputs": [], + "source": [ + "# Material mixtures\n", + "inner = openmc.Material.mix_materials(\n", + " [u235, u238, pu238, pu239, pu240, pu241, pu242, am241, o16],\n", + " [0.0019, 0.7509, 0.0046, 0.0612, 0.0383, 0.0106, 0.0134, 0.001, 0.1181],\n", + " 'wo')\n", + "outer = openmc.Material.mix_materials(\n", + " [u235, u238, pu238, pu239, pu240, pu241, pu242, am241, o16],\n", + " [0.0018, 0.73, 0.0053, 0.0711, 0.0445, 0.0124, 0.0156, 0.0017, 0.1176],\n", + " 'wo')\n", + "clad = openmc.Material.mix_materials(\n", + " [cu63,Al2O3], [0.997,0.003], 'wo')" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "id": "A2kNKaErZ7JR" + }, + "outputs": [], + "source": [ + "# Instantiate a Materials collection and export to xml\n", + "materials_file = openmc.Materials([inner, outer, sodium, clad])\n", + "materials_file.export_to_xml()" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "id": "OrML6oju4spK" + }, + "outputs": [], + "source": [ + "# Geometry definitions\n", + "\n", + "fuel_or = openmc.ZCylinder(surface_id=1, r=0.943/2) \n", + "clad_ir = openmc.ZCylinder(surface_id=2, r=0.973/2) \n", + "clad_or = openmc.ZCylinder(surface_id=3, r=1.073/2) \n", + "\n", + "top = openmc.ZPlane(surface_id=4, z0=+50, boundary_type='vacuum')\n", + "bottom = openmc.ZPlane(surface_id=5, z0=-50, boundary_type='vacuum') \n", + "\n", + "fuel_region = -fuel_or & -top & +bottom\n", + "gap_region = +fuel_or & -clad_ir & -top & +bottom\n", + "clad_region = +clad_ir & -clad_or & -top & +bottom\n", + "moderator_region = +clad_or & -top & +bottom\n", + " \n", + "gap_cell = openmc.Cell(cell_id=1, fill=inner, region=gap_region)\n", + "clad_cell = openmc.Cell(cell_id=2, fill=clad, region=clad_region)\n", + "sodium_cell = openmc.Cell(cell_id=3, fill=sodium, region=moderator_region)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "id": "8L0zqqhZfxKh" + }, + "outputs": [], + "source": [ + "inner_fuel_cell = openmc.Cell(cell_id=4, fill=inner, region=fuel_region)\n", + "inner_u = openmc.Universe(universe_id=1, cells=(inner_fuel_cell, gap_cell, clad_cell, sodium_cell))" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "id": "iAHLhKZYh6y5" + }, + "outputs": [], + "source": [ + "outer_fuel_cell = openmc.Cell(cell_id=5, fill=outer, region=fuel_region)\n", + "outer_u = openmc.Universe(universe_id=2, cells=(outer_fuel_cell, gap_cell, clad_cell, sodium_cell))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Creating filling for emtpy space in the core\n", + "\n", + "sodium_mod_cell = openmc.Cell(cell_id=6, fill=sodium)\n", + "sodium_mod_u = openmc.Universe(universe_id=3, cells=(sodium_mod_cell,))" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "id": "cWTxCkwKRwYj" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/miriamrathbun/codes/openmc-mak/openmc/mixin.py:68: IDWarning: Another Lattice instance already exists with id=1.\n", + " warn(msg, IDWarning)\n" + ] + } + ], + "source": [ + "# Define a lattice for inner assemblies\n", + "in_lat = openmc.HexLattice(lattice_id=1, name='inner assembly')\n", + "in_lat.center = (0., 0.)\n", + "in_lat.pitch = (21.08/17,)\n", + "in_lat.orientation = 'x'\n", + "in_lat.outer = sodium_mod_u\n", + "\n", + "# Create rings of fuel universes that will fill the lattice\n", + "inone = [inner_u]*48\n", + "intwo = [inner_u]*42\n", + "inthree = [inner_u]*36\n", + "infour = [inner_u]*30\n", + "infive = [inner_u]*24\n", + "insix = [inner_u]*18\n", + "inseven = [inner_u]*12\n", + "ineight = [inner_u]*6\n", + "innine = [inner_u]*1\n", + "in_lat.universes = [inone,intwo,inthree,infour,infive,insix,inseven,ineight,innine]\n", + "\n", + "# Create the prism that will contain the lattice\n", + "outer_in_surface = openmc.model.hexagonal_prism(edge_length=12.1705, orientation='x')\n", + "\n", + "# Fill a cell with the lattice. This cell is filled with the lattice and contained within the prism.\n", + "main_in_assembly = openmc.Cell(cell_id=7, fill=in_lat, region=outer_in_surface & -top & +bottom)\n", + "\n", + "# Fill a cell with a material that will surround the lattice\n", + "out_in_assembly = openmc.Cell(cell_id=8, fill=sodium, region=~outer_in_surface & -top & +bottom)\n", + "\n", + "# Create a universe that contains both \n", + "main_in_u = openmc.Universe(universe_id=4, cells=[main_in_assembly, out_in_assembly])" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "main_in_u.plot(origin = (0,0,0), pixels=(500, 500), width = (30.,30.), color_by = 'material')" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "id": "1SIgRmjLTuPJ" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/miriamrathbun/codes/openmc-mak/openmc/mixin.py:68: IDWarning: Another Lattice instance already exists with id=2.\n", + " warn(msg, IDWarning)\n" + ] + } + ], + "source": [ + "# Define a lattice for outer assemblies\n", + "out_lat = openmc.HexLattice(lattice_id=2, name='outer assembly')\n", + "out_lat.center = (0., 0.)\n", + "out_lat.pitch = (21.08/17,)\n", + "out_lat.orientation = 'x'\n", + "out_lat.outer = sodium_mod_u\n", + "\n", + "# Create rings of fuel universes that will fill the lattice\n", + "outone = [outer_u]*48\n", + "outtwo = [outer_u]*42\n", + "outthree = [outer_u]*36\n", + "outfour = [outer_u]*30\n", + "outfive = [outer_u]*24\n", + "outsix = [outer_u]*18\n", + "outseven = [outer_u]*12\n", + "outeight = [outer_u]*6\n", + "outnine = [outer_u]*1\n", + "out_lat.universes = [outone,outtwo,outthree,outfour,outfive,outsix,outseven,outeight,outnine]\n", + "\n", + "# Create the prism that will contain the lattice\n", + "outer_out_surface = openmc.model.hexagonal_prism(edge_length=12.1705)\n", + "\n", + "# Fill a cell with the lattice. This cell is filled with the lattice and contained within the prism.\n", + "main_out_assembly = openmc.Cell(cell_id=9, fill=out_lat, region=outer_out_surface & -top & +bottom)\n", + "\n", + "# Fill a cell with a material that will surround the lattice\n", + "out_out_assembly = openmc.Cell(cell_id=10, fill=sodium, region=~outer_out_surface & -top & +bottom)\n", + "\n", + "# Create a universe that contains both \n", + "main_out_u = openmc.Universe(universe_id=5, cells=[main_out_assembly, out_out_assembly])" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 283 + }, + "id": "pDf5K0t-eYRM", + "outputId": "97396467-3a79-41bb-e9bd-8d4ff43369cf" + }, + "outputs": [], + "source": [ + "# Create a hexagonal water cell\n", + "\n", + "reflector_assembly = openmc.model.hexagonal_prism(edge_length=12.1705, orientation='x')\n", + "ref_cell = openmc.Cell(cell_id=11, fill=sodium, region=reflector_assembly & -top & +bottom)\n", + "out_ref_cell = openmc.Cell(cell_id=12, fill=sodium, region=~reflector_assembly & -top & +bottom)\n", + "ref_u = openmc.Universe(universe_id=6, cells=[ref_cell, out_ref_cell])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We have 3 types of assemblies created. We can now make the entire reactor core by creating a lattice that is filled with the assemblies. " + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "id": "6lDqg4lLWD7v" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/miriamrathbun/codes/openmc-mak/openmc/mixin.py:68: IDWarning: Another Lattice instance already exists with id=3.\n", + " warn(msg, IDWarning)\n" + ] + } + ], + "source": [ + "# Define the core lattice\n", + "\n", + "core_lat = openmc.HexLattice(lattice_id=3, name='core')\n", + "core_lat.center = (0., 0.)\n", + "core_lat.pitch = (21.08,)\n", + "core_lat.outer = sodium_mod_u" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "id": "M1FcPGAbjH3J" + }, + "outputs": [], + "source": [ + "# Create rings of fuel universes that will fill the lattice\n", + "ref_one = [ref_u] * 96\n", + "ref_two = [ref_u] * 90\n", + "ref_three = [ref_u] * 84\n", + "ref_four = ([ref_u] * 5 + [main_out_u] * 4 + [ref_u] * 4) * 6\n", + "ref_five = ([ref_u] + [main_out_u] * 11) * 6\n", + "out_one = [main_out_u]*66\n", + "out_two = [main_out_u]*60\n", + "out_three = ([main_out_u]*2 + [main_in_u]*6 + [main_out_u] * 1)*6\n", + "in_one = [main_in_u]*48\n", + "in_two = [main_in_u]*42\n", + "in_three = [main_in_u]*36\n", + "in_four = [main_in_u]*30\n", + "in_five = [main_in_u]*24\n", + "in_six = [main_in_u]*18\n", + "in_seven = [main_in_u]*12\n", + "in_eight = [main_in_u]*6\n", + "in_nine = [main_in_u]*1\n", + "core_lat.universes = [ref_one,ref_two,ref_three,ref_four,ref_five,out_one,out_two,out_three,in_one,in_two,in_three,in_four,in_five,in_six,in_seven,in_eight,in_nine]" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 283 + }, + "id": "nzVEvJgpjyY2", + "outputId": "3f678f02-4a6c-4768-dc46-419ad37019a0", + "scrolled": true + }, + "outputs": [], + "source": [ + "# Create the prism that will contain the lattice\n", + "outer_core_surface = openmc.model.hexagonal_prism(edge_length=347.82, boundary_type='vacuum')\n", + "\n", + "# Fill a cell with the lattice. This cell is filled with the lattice and contained within the prism.\n", + "core = openmc.Cell(cell_id=13, fill=core_lat, region=outer_core_surface & -top & +bottom)\n", + "\n", + "# Fill a cell with a material that will surround the lattice\n", + "out_core = openmc.Cell(cell_id=14, fill=outer, region=~outer_core_surface & -top & +bottom)\n", + "\n", + "# Create a universe that contains both \n", + "main_u = openmc.Universe(universe_id=7, cells=[core, out_core]) " + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "main_u.plot(origin = (0,0,0), pixels=(1000, 1000), width = (660.,660.), color_by = 'material')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We now have an entire reactor core defined! We can export the geometry and run the code. " + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "geom = openmc.Geometry(main_u)\n", + "geom.export_to_xml()" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "5mPhUg7QWVw4", + "outputId": "f110f4ab-94b5-477b-8c55-cab8ed7c3116" + }, + "outputs": [], + "source": [ + "# OpenMC simulation parameters\n", + "\n", + "lower_left = [-300, -300, -50]\n", + "upper_right = [300, 300, 50]\n", + "uniform_dist = openmc.stats.Box(lower_left, upper_right, only_fissionable=True)\n", + "src = openmc.Source(space=uniform_dist)\n", + "\n", + "settings = openmc.Settings()\n", + "settings.source = src\n", + "settings.batches = 100\n", + "settings.inactive = 10\n", + "settings.particles = 1000\n", + "\n", + "settings.export_to_xml()" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "id": "A_f292ebWZFM", + "outputId": "d6710d6c-aea6-43c9-e63c-b2e62ea7ea08" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " %%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%\n", + " ############### %%%%%%%%%%%%%%%%%%%%%%%%\n", + " ################## %%%%%%%%%%%%%%%%%%%%%%%\n", + " ################### %%%%%%%%%%%%%%%%%%%%%%%\n", + " #################### %%%%%%%%%%%%%%%%%%%%%%\n", + " ##################### %%%%%%%%%%%%%%%%%%%%%\n", + " ###################### %%%%%%%%%%%%%%%%%%%%\n", + " ####################### %%%%%%%%%%%%%%%%%%\n", + " ####################### %%%%%%%%%%%%%%%%%\n", + " ###################### %%%%%%%%%%%%%%%%%\n", + " #################### %%%%%%%%%%%%%%%%%\n", + " ################# %%%%%%%%%%%%%%%%%\n", + " ############### %%%%%%%%%%%%%%%%\n", + " ############ %%%%%%%%%%%%%%%\n", + " ######## %%%%%%%%%%%%%%\n", + " %%%%%%%%%%%\n", + "\n", + " | The OpenMC Monte Carlo Code\n", + " Copyright | 2011-2020 MIT and OpenMC contributors\n", + " License | https://docs.openmc.org/en/latest/license.html\n", + " Version | 0.12.1-dev\n", + " Git SHA1 | 0228ddba1d6399e654a295e51539590f076b2a3c\n", + " Date/Time | 2021-02-22 22:22:08\n", + " OpenMP Threads | 8\n", + "\n", + " Reading settings XML file...\n", + " Reading cross sections XML file...\n", + " Reading materials XML file...\n", + " Reading geometry XML file...\n", + " Reading Na23 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/Na23.h5\n", + " Reading U235 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/U235.h5\n", + " Reading U238 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/U238.h5\n", + " Reading Pu239 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/Pu239.h5\n", + " Reading Pu240 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/Pu240.h5\n", + " Reading Pu241 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/Pu241.h5\n", + " Reading Pu242 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/Pu242.h5\n", + " Reading Am241 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/Am241.h5\n", + " Reading O16 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/O16.h5\n", + " Reading Cu63 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/Cu63.h5\n", + " Reading O17 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/O17.h5\n", + " Reading Al27 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/Al27.h5\n", + " Minimum neutron data temperature: 294.0 K\n", + " Maximum neutron data temperature: 294.0 K\n", + " Preparing distributed cell instances...\n", + " Writing summary.h5 file...\n", + " Maximum neutron transport energy: 20000000.0 eV for Na23\n", + " Initializing source particles...\n", + "\n", + " ====================> K EIGENVALUE SIMULATION <====================\n", + "\n", + " Bat./Gen. k Average k\n", + " ========= ======== ====================\n", + " 1/1 1.02481\n", + " 2/1 1.12641\n", + " 3/1 1.19114\n", + " 4/1 1.14944\n", + " 5/1 1.24417\n", + " 6/1 1.18112\n", + " 7/1 1.22681\n", + " 8/1 1.25324\n", + " 9/1 1.26160\n", + " 10/1 1.24391\n", + " 11/1 1.26299\n", + " 12/1 1.22630 1.24465 +/- 0.01834\n", + " 13/1 1.22617 1.23849 +/- 0.01225\n", + " 14/1 1.17487 1.22258 +/- 0.01811\n", + " 15/1 1.23711 1.22549 +/- 0.01433\n", + " 16/1 1.25744 1.23081 +/- 0.01285\n", + " 17/1 1.19600 1.22584 +/- 0.01195\n", + " 18/1 1.22848 1.22617 +/- 0.01035\n", + " 19/1 1.24147 1.22787 +/- 0.00929\n", + " 20/1 1.23635 1.22872 +/- 0.00835\n", + " 21/1 1.22312 1.22821 +/- 0.00757\n", + " 22/1 1.22163 1.22766 +/- 0.00693\n", + " 23/1 1.21767 1.22689 +/- 0.00642\n", + " 24/1 1.16644 1.22257 +/- 0.00735\n", + " 25/1 1.19885 1.22099 +/- 0.00702\n", + " 26/1 1.21883 1.22086 +/- 0.00657\n", + " 27/1 1.24819 1.22246 +/- 0.00638\n", + " 28/1 1.26476 1.22481 +/- 0.00645\n", + " 29/1 1.21935 1.22453 +/- 0.00611\n", + " 30/1 1.23808 1.22520 +/- 0.00584\n", + " 31/1 1.16740 1.22245 +/- 0.00620\n", + " 32/1 1.21038 1.22190 +/- 0.00593\n", + " 33/1 1.20477 1.22116 +/- 0.00572\n", + " 34/1 1.26182 1.22285 +/- 0.00573\n", + " 35/1 1.22385 1.22289 +/- 0.00550\n", + " 36/1 1.30378 1.22600 +/- 0.00613\n", + " 37/1 1.26827 1.22757 +/- 0.00610\n", + " 38/1 1.27147 1.22914 +/- 0.00609\n", + " 39/1 1.23282 1.22926 +/- 0.00587\n", + " 40/1 1.25327 1.23006 +/- 0.00573\n", + " 41/1 1.19087 1.22880 +/- 0.00569\n", + " 42/1 1.28910 1.23068 +/- 0.00582\n", + " 43/1 1.23440 1.23080 +/- 0.00564\n", + " 44/1 1.22528 1.23063 +/- 0.00547\n", + " 45/1 1.25779 1.23141 +/- 0.00537\n", + " 46/1 1.26413 1.23232 +/- 0.00530\n", + " 47/1 1.27685 1.23352 +/- 0.00529\n", + " 48/1 1.27599 1.23464 +/- 0.00527\n", + " 49/1 1.28307 1.23588 +/- 0.00528\n", + " 50/1 1.26215 1.23654 +/- 0.00519\n", + " 51/1 1.22880 1.23635 +/- 0.00507\n", + " 52/1 1.22389 1.23605 +/- 0.00495\n", + " 53/1 1.23361 1.23600 +/- 0.00484\n", + " 54/1 1.22966 1.23585 +/- 0.00473\n", + " 55/1 1.22266 1.23556 +/- 0.00463\n", + " 56/1 1.25986 1.23609 +/- 0.00456\n", + " 57/1 1.31764 1.23782 +/- 0.00479\n", + " 58/1 1.29656 1.23905 +/- 0.00484\n", + " 59/1 1.25418 1.23936 +/- 0.00475\n", + " 60/1 1.21933 1.23896 +/- 0.00467\n", + " 61/1 1.23886 1.23895 +/- 0.00458\n", + " 62/1 1.22153 1.23862 +/- 0.00451\n", + " 63/1 1.25440 1.23892 +/- 0.00443\n", + " 64/1 1.23758 1.23889 +/- 0.00435\n", + " 65/1 1.29599 1.23993 +/- 0.00439\n", + " 66/1 1.25912 1.24027 +/- 0.00433\n", + " 67/1 1.25699 1.24057 +/- 0.00426\n", + " 68/1 1.21444 1.24011 +/- 0.00421\n", + " 69/1 1.25080 1.24030 +/- 0.00414\n", + " 70/1 1.30284 1.24134 +/- 0.00420\n", + " 71/1 1.26208 1.24168 +/- 0.00415\n", + " 72/1 1.25869 1.24195 +/- 0.00409\n", + " 73/1 1.24739 1.24204 +/- 0.00403\n", + " 74/1 1.25263 1.24220 +/- 0.00397\n", + " 75/1 1.22410 1.24193 +/- 0.00391\n", + " 76/1 1.29268 1.24269 +/- 0.00393\n", + " 77/1 1.22569 1.24244 +/- 0.00388\n", + " 78/1 1.28431 1.24306 +/- 0.00387\n", + " 79/1 1.22645 1.24282 +/- 0.00382\n", + " 80/1 1.24248 1.24281 +/- 0.00377\n", + " 81/1 1.22740 1.24259 +/- 0.00372\n", + " 82/1 1.29676 1.24335 +/- 0.00374\n", + " 83/1 1.26406 1.24363 +/- 0.00370\n", + " 84/1 1.18714 1.24287 +/- 0.00373\n", + " 85/1 1.24634 1.24291 +/- 0.00368\n", + " 86/1 1.25176 1.24303 +/- 0.00364\n", + " 87/1 1.30837 1.24388 +/- 0.00369\n", + " 88/1 1.24285 1.24386 +/- 0.00364\n", + " 89/1 1.22941 1.24368 +/- 0.00360\n", + " 90/1 1.18066 1.24289 +/- 0.00364\n", + " 91/1 1.28586 1.24342 +/- 0.00363\n", + " 92/1 1.26556 1.24369 +/- 0.00360\n", + " 93/1 1.22569 1.24348 +/- 0.00356\n", + " 94/1 1.20319 1.24300 +/- 0.00355\n", + " 95/1 1.27998 1.24343 +/- 0.00354\n", + " 96/1 1.20130 1.24294 +/- 0.00353\n", + " 97/1 1.24200 1.24293 +/- 0.00349\n", + " 98/1 1.27352 1.24328 +/- 0.00347\n", + " 99/1 1.30545 1.24398 +/- 0.00350\n", + " 100/1 1.31981 1.24482 +/- 0.00356\n", + " Creating state point statepoint.100.h5...\n", + "\n", + " =======================> TIMING STATISTICS <=======================\n", + "\n", + " Total time for initialization = 2.3018e+00 seconds\n", + " Reading cross sections = 2.2651e+00 seconds\n", + " Total time in simulation = 1.0711e+00 seconds\n", + " Time in transport only = 1.0512e+00 seconds\n", + " Time in inactive batches = 9.2840e-02 seconds\n", + " Time in active batches = 9.7826e-01 seconds\n", + " Time synchronizing fission bank = 4.0280e-03 seconds\n", + " Sampling source sites = 3.3290e-03 seconds\n", + " SEND/RECV source sites = 5.3600e-04 seconds\n", + " Time accumulating tallies = 2.5000e-05 seconds\n", + " Time writing statepoints = 8.3760e-03 seconds\n", + " Total time for finalization = 7.0000e-06 seconds\n", + " Total time elapsed = 3.3798e+00 seconds\n", + " Calculation Rate (inactive) = 107712.0 particles/second\n", + " Calculation Rate (active) = 92000.4 particles/second\n", + "\n", + " ============================> RESULTS <============================\n", + "\n", + " k-effective (Collision) = 1.24514 +/- 0.00362\n", + " k-effective (Track-length) = 1.24482 +/- 0.00356\n", + " k-effective (Absorption) = 1.24692 +/- 0.00415\n", + " Combined k-effective = 1.24588 +/- 0.00254\n", + " Leakage Fraction = 0.11453 +/- 0.00147\n", + "\n" + ] + } + ], + "source": [ + "openmc.run()" + ] + } + ], + "metadata": { + "colab": { + "collapsed_sections": [], + "name": "FastReactor_3layers.ipynb", + "provenance": [] + }, + "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.9.0" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/TRIGA.ipynb b/TRIGA.ipynb new file mode 100644 index 0000000..20ad616 --- /dev/null +++ b/TRIGA.ipynb @@ -0,0 +1,1144 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "q9Vo6HOQUQbS", + "outputId": "a8c1843c-272d-461a-faf3-4b78fdbced3b" + }, + "source": [ + "# A TRIGA geometry \n", + "This notebook can be used as a template for modeling TRIGA reactors." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "id": "EChOeJ7qVUB7" + }, + "outputs": [], + "source": [ + "%matplotlib inline\n", + "import numpy as np\n", + "import openmc" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "id": "jlu98MGXV9MP" + }, + "outputs": [], + "source": [ + "# Materials definitions\n", + "\n", + "# Borated water\n", + "water = openmc.Material(name='Borated Water')\n", + "water.set_density('g/cm3', 0.740582)\n", + "water.add_nuclide('H1', 4.9457e-2)\n", + "water.add_nuclide('O16', 2.4732e-2)\n", + "water.add_nuclide('B10', 8.0042e-6)\n", + "\n", + "# 20% enriched uranium zirconium hydride fuel\n", + "uzrh = openmc.Material(name='UZrH')\n", + "uzrh.set_density('g/cm3', 6.128)\n", + "uzrh.add_nuclide('U235', .02376, 'wo')\n", + "uzrh.add_nuclide('U238', .09619, 'wo')\n", + "uzrh.add_element('H', .03, 'wo')\n", + "uzrh.add_element('Zr', .85, 'wo')\n", + "\n", + "molybdenum = openmc.Material(name='Molybdenum')\n", + "molybdenum.add_element('Mo', 1.0)\n", + "molybdenum.set_density('g/cm3', 10.22)\n", + "\n", + "graphite = openmc.Material(name='Graphite')\n", + "graphite.set_density('g/cm3', 1.70)\n", + "graphite.add_element('C', 1.0)\n", + "graphite.add_s_alpha_beta('c_Graphite')\n", + "\n", + "# Stainless steel\n", + "ss304 = openmc.Material(name='Stainless Steel 304')\n", + "ss304.set_density('g/cm3', 8.0)\n", + "ss304.add_element('C',.002,'wo')\n", + "ss304.add_element('Si',.004,'wo')\n", + "ss304.add_element('P',.0003,'wo')\n", + "ss304.add_element('S',.0002,'wo')\n", + "ss304.add_element('V',.003,'wo')\n", + "ss304.add_element('Cr',.115,'wo')\n", + "ss304.add_element('Mn',.006,'wo')\n", + "ss304.add_element('Fe',.8495,'wo')\n", + "ss304.add_element('Ni',.005,'wo')\n", + "ss304.add_element('Mo',.01,'wo')\n", + "ss304.add_element('W',.005,'wo')\n", + "\n", + "# Boron carbide\n", + "b4c = openmc.Material(name='Boron Carbide')\n", + "b4c.set_density('g/cm3', 2.52)\n", + "b4c.add_element('B', 4)\n", + "b4c.add_element('C', 1)\n", + "\n", + "zirconium = openmc.Material(name='Zirconium')\n", + "zirconium.add_element('Zr', 1.0)\n", + "zirconium.set_density('g/cm3', 6.506)\n", + "\n", + "void = openmc.Material(name='Void')\n", + "void.set_density('g/cm3', 0.001205)\n", + "void.add_element('Ni', 0.755268, 'wo')\n", + "void.add_element('C', 0.000124, 'wo')\n", + "void.add_element('O', 0.231781, 'wo')\n", + "void.add_element('Ar', 0.012827, 'wo')\n", + "\n", + "aluminum = openmc.Material(name='Aluminum')\n", + "aluminum.add_element('Al', 1.0)\n", + "aluminum.set_density('g/cm3', 2.6)\n", + "\n", + "# Instantiate a Materials collection and export to xml\n", + "materials_file = openmc.Materials([aluminum, zirconium, b4c, ss304, graphite, molybdenum, uzrh, water, void])\n", + "materials_file.export_to_xml()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "id": "6lDqg4lLWD7v" + }, + "outputs": [], + "source": [ + "# Geometry definitions for the fuel rod\n", + "\n", + "rod_outer_radius = openmc.ZCylinder(r=0.635)\n", + "uzrh_outer_radius = openmc.ZCylinder(r=3.6449)\n", + "molybdenum_outer_radius = openmc.ZCylinder(r=3.6449)\n", + "graphite_outer_radius = openmc.ZCylinder(r=3.6449)\n", + "ss304_outer_radius = openmc.ZCylinder(r=3.6449)\n", + "clad_outer_radius = openmc.ZCylinder(r=3.75412)\n", + "\n", + "empty_space_min = openmc.ZPlane(z0=-114.3)\n", + "empty_space_max = openmc.ZPlane(z0=-55.079265)\n", + "rod_min = openmc.ZPlane(z0=-55.079265)\n", + "rod_max = openmc.ZPlane(z0=-16.979265)\n", + "uzrh_min = openmc.ZPlane(z0=-55.079265)\n", + "uzrh_max = openmc.ZPlane(z0=-16.979265)\n", + "molybdenum_min = openmc.ZPlane(z0=-55.15864)\n", + "molybdenum_max = openmc.ZPlane(z0=-55.079265)\n", + "graphite_upper_min = openmc.ZPlane(z0=-16.979265)\n", + "graphite_upper_max = openmc.ZPlane(z0=-10.375265)\n", + "graphite_lower_min = openmc.ZPlane(z0=-64.621664)\n", + "graphite_lower_max = openmc.ZPlane(z0=-55.15864)\n", + "ss304_upper_min = openmc.ZPlane(z0=-10.375265)\n", + "ss304_upper_max = openmc.ZPlane(z0=+0)\n", + "ss304_lower_min = openmc.ZPlane(z0=-72.0598)\n", + "ss304_lower_max = openmc.ZPlane(z0=-64.621664)\n", + "clad_min = openmc.ZPlane(z0=-72.0598)\n", + "clad_max = openmc.ZPlane(z0=0)\n", + "\n", + "# Create a Universe to encapsulate the fuel rod\n", + "fuel_universe = openmc.Universe(name='UZrH Fuel Universe')\n", + "\n", + "# Create rod cell\n", + "rod_cell = openmc.Cell(name='Zr Rod')\n", + "rod_cell.fill = zirconium\n", + "rod_cell.region = -rod_outer_radius & +rod_min & -rod_max\n", + "fuel_universe.add_cell(rod_cell)\n", + "\n", + "# Create uzrh cell\n", + "uzrh_cell = openmc.Cell(name='UZrH')\n", + "uzrh_cell.fill = uzrh\n", + "uzrh_cell.region = +rod_outer_radius & -uzrh_outer_radius & +uzrh_min & -uzrh_max\n", + "fuel_universe.add_cell(uzrh_cell)\n", + "\n", + "# Create molybdenum disk\n", + "molybdenum_cell = openmc.Cell(name='Molybdenum')\n", + "molybdenum_cell.fill = molybdenum\n", + "molybdenum_cell.region = -molybdenum_outer_radius & +molybdenum_min & -molybdenum_max\n", + "fuel_universe.add_cell(molybdenum_cell)\n", + "\n", + "# Create upper graphite cell\n", + "graphite_upper_cell = openmc.Cell(name='Upper Graphite')\n", + "graphite_upper_cell.fill = graphite\n", + "graphite_upper_cell.region = -graphite_outer_radius & +graphite_upper_min & -graphite_upper_max\n", + "fuel_universe.add_cell(graphite_upper_cell)\n", + "\n", + "# Create lower graphite cell\n", + "graphite_lower_cell = openmc.Cell(name='Lower Graphite')\n", + "graphite_lower_cell.fill = graphite\n", + "graphite_lower_cell.region = -graphite_outer_radius & +graphite_lower_min & -graphite_lower_max\n", + "fuel_universe.add_cell(graphite_lower_cell)\n", + "\n", + "# Create upper ss304 cell\n", + "ss304_upper_cell = openmc.Cell(name='Upper Stainless Steel 304')\n", + "ss304_upper_cell.fill = ss304\n", + "ss304_upper_cell.region = -ss304_outer_radius & +ss304_upper_min & -ss304_upper_max \n", + "fuel_universe.add_cell(ss304_upper_cell)\n", + "\n", + "# Create lower ss304 cell\n", + "ss304_lower_cell = openmc.Cell(name='Lower Stainless Steel 304')\n", + "ss304_lower_cell.fill = ss304\n", + "ss304_lower_cell.region = -ss304_outer_radius & +ss304_lower_min & -ss304_lower_max\n", + "fuel_universe.add_cell(ss304_lower_cell)\n", + "\n", + "# Create clad cell\n", + "clad_cell = openmc.Cell(name='Stainless Steel 304 Cladding')\n", + "clad_cell.fill = ss304\n", + "clad_cell.region = -clad_outer_radius & +ss304_outer_radius & +clad_min & -clad_max\n", + "fuel_universe.add_cell(clad_cell)\n", + "\n", + "# Create empty space cell\n", + "empty_space_cell = openmc.Cell(name='Empty space before fuel rod')\n", + "empty_space_cell.fill = water\n", + "empty_space_cell.region = -clad_outer_radius & +empty_space_min & -empty_space_max\n", + "fuel_universe.add_cell(empty_space_cell)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "id": "osv05TS3yNUT" + }, + "outputs": [], + "source": [ + "# Geometry definitions for the transient rod\n", + "\n", + "void_outer_radius = openmc.ZCylinder(r=3.03276)\n", + "b4c_outer_radius = openmc.ZCylinder(r=3.03276)\n", + "clad_outer_radius = openmc.ZCylinder(r=3.38455)\n", + "aluminum_outer_radius = openmc.ZCylinder(r=3.03276)\n", + "\n", + "aluminum_1_min = openmc.ZPlane(z0=-114.3)\n", + "aluminum_1_max = openmc.ZPlane(z0=-113.03)\n", + "void_1_min = openmc.ZPlane(z0=-113.03)\n", + "void_1_max = openmc.ZPlane(z0=-57.785)\n", + "aluminum_2_min = openmc.ZPlane(z0=-57.785)\n", + "aluminum_2_max = openmc.ZPlane(z0=-56.515)\n", + "b4c_min = openmc.ZPlane(z0=-56.515)\n", + "b4c_max = openmc.ZPlane(z0=-18.415)\n", + "void_2_min = openmc.ZPlane(z0=-18.415)\n", + "void_2_max = openmc.ZPlane(z0=-18.0975)\n", + "aluminum_3_min = openmc.ZPlane(z0=-18.0975)\n", + "aluminum_3_max = openmc.ZPlane(z0=-16.8275)\n", + "void_3_min = openmc.ZPlane(z0=-16.8275)\n", + "void_3_max = openmc.ZPlane(z0=-7.3025)\n", + "aluminum_4_min = openmc.ZPlane(z0=-7.3025)\n", + "aluminum_4_max = openmc.ZPlane(z0=0)\n", + "clad_min = openmc.ZPlane(z0=-114.3)\n", + "clad_max = openmc.ZPlane(z0=0)\n", + "\n", + "# Create a Universe to encapsulate the transient rod\n", + "transient_universe = openmc.Universe(name='Transient Universe')\n", + "\n", + "# Create void 1 cell\n", + "void_1_cell = openmc.Cell(name= 'Void 1')\n", + "void_1_cell.fill = void\n", + "void_1_cell.region = -void_outer_radius & +void_1_min & -void_1_max\n", + "transient_universe.add_cell(void_1_cell)\n", + "\n", + "# Create void 2 cell\n", + "void_2_cell = openmc.Cell(name= 'Void 2')\n", + "void_2_cell.fill = void\n", + "void_2_cell.region = -void_outer_radius & +void_2_min & -void_2_max \n", + "transient_universe.add_cell(void_2_cell)\n", + "\n", + "# Create void 3 cell\n", + "void_3_cell = openmc.Cell(name= 'Void 3')\n", + "void_3_cell.fill = void\n", + "void_3_cell.region = -void_outer_radius & +void_3_min & -void_3_max \n", + "transient_universe.add_cell(void_3_cell)\n", + "\n", + "# Create b4c cell\n", + "b4c_cell = openmc.Cell(name='Boron Carbide')\n", + "b4c_cell.fill = b4c\n", + "b4c_cell.region = -b4c_outer_radius & -b4c_max & +b4c_min\n", + "transient_universe.add_cell(b4c_cell)\n", + "\n", + "# Create aluminum 1 cell\n", + "aluminum_1_cell = openmc.Cell(name='Aluminum')\n", + "aluminum_1_cell.fill = aluminum\n", + "aluminum_1_cell.region = -aluminum_outer_radius & +aluminum_1_min & -aluminum_1_max \n", + "transient_universe.add_cell(aluminum_1_cell)\n", + "\n", + "# Create aluminum 2 cell\n", + "aluminum_2_cell = openmc.Cell(name='Aluminum')\n", + "aluminum_2_cell.fill = aluminum\n", + "aluminum_2_cell.region = -aluminum_outer_radius & +aluminum_2_min & -aluminum_2_max\n", + "transient_universe.add_cell(aluminum_2_cell)\n", + "\n", + "# Create aluminum 3 cell\n", + "aluminum_3_cell = openmc.Cell(name='Aluminum')\n", + "aluminum_3_cell.fill = aluminum\n", + "aluminum_3_cell.region = -aluminum_outer_radius & +aluminum_3_min & -aluminum_3_max \n", + "transient_universe.add_cell(aluminum_3_cell)\n", + "\n", + "# Create aluminum 4 cell\n", + "aluminum_4_cell = openmc.Cell(name='Aluminum')\n", + "aluminum_4_cell.fill = aluminum\n", + "aluminum_4_cell.region = -aluminum_outer_radius & +aluminum_4_min & -aluminum_4_max\n", + "transient_universe.add_cell(aluminum_4_cell)\n", + "\n", + "# Create a clad cell\n", + "clad_cell = openmc.Cell(name='Aluminum Cladding')\n", + "clad_cell.fill = aluminum\n", + "clad_cell.region = -clad_outer_radius & +b4c_outer_radius & +clad_min & -clad_max \n", + "transient_universe.add_cell(clad_cell)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "id": "-0xO897aWbft" + }, + "outputs": [], + "source": [ + "# Geometry definitions for the control rod\n", + "\n", + "rod_outer_radius = openmc.ZCylinder(r=0.635)\n", + "uzrh_outer_radius = openmc.ZCylinder(r=3.33375)\n", + "void_outer_radius = openmc.ZCylinder(r=3.33375)\n", + "b4c_outer_radius = openmc.ZCylinder(r=3.33375)\n", + "ss304_outer_radius = openmc.ZCylinder(r=3.33375)\n", + "clad_outer_radius = openmc.ZCylinder(r=3.38455)\n", + "\n", + "ss304_5_min = openmc.ZPlane(z0=-114.3)\n", + "ss304_5_max = openmc.ZPlane(z0=-113.03)\n", + "void_4_min = openmc.ZPlane(z0=-113.03)\n", + "void_4_max = openmc.ZPlane(z0=-99.06)\n", + "ss304_4_min = openmc.ZPlane(z0=-99.06)\n", + "ss304_4_max = openmc.ZPlane(z0=-96.52)\n", + "rod_min = openmc.ZPlane(z0=-96.52)\n", + "rod_max = openmc.ZPlane(z0=-58.42)\n", + "uzrh_min = openmc.ZPlane(z0=-96.52)\n", + "uzrh_max = openmc.ZPlane(z0=-58.42)\n", + "void_1_min = openmc.ZPlane(z0=-58.42)\n", + "void_1_max = openmc.ZPlane(z0=-57.785)\n", + "ss304_1_min = openmc.ZPlane(z0=-57.785)\n", + "ss304_1_max = openmc.ZPlane(z0=-56.515)\n", + "b4c_1_min = openmc.ZPlane(z0=-56.515)\n", + "b4c_1_max = openmc.ZPlane(z0=-18.415)\n", + "void_2_min = openmc.ZPlane(z0=-18.415)\n", + "void_2_max = openmc.ZPlane(z0=-18.0975)\n", + "ss304_2_min = openmc.ZPlane(z0=-18.0975)\n", + "ss304_2_max = openmc.ZPlane(z0=-16.8275)\n", + "void_3_min = openmc.ZPlane(z0=-16.8275)\n", + "void_3_max = openmc.ZPlane(z0=-7.3025)\n", + "ss304_3_min = openmc.ZPlane(z0=-7.3025)\n", + "ss304_3_max = openmc.ZPlane(z0=0.0)\n", + "clad_min = openmc.ZPlane(z0=-114.3)\n", + "clad_max = openmc.ZPlane(z0=0.0)\n", + "\n", + "# Create a Universe to encapsulate the control rod\n", + "control_universe = openmc.Universe(name='Control Universe')\n", + "\n", + "# Create rod cell\n", + "rod_cell = openmc.Cell(name='Zr Rod')\n", + "rod_cell.fill = zirconium\n", + "rod_cell.region = -rod_outer_radius & +rod_min & -rod_max\n", + "control_universe.add_cell(rod_cell)\n", + "\n", + "# Create uzrh cell\n", + "uzrh_cell = openmc.Cell(name='UZrH')\n", + "uzrh_cell.fill = uzrh\n", + "uzrh_cell.region = +rod_outer_radius & -uzrh_outer_radius & +uzrh_min & -uzrh_max\n", + "control_universe.add_cell(uzrh_cell)\n", + "\n", + "# Create void 1 cell\n", + "void_1_cell = openmc.Cell(name= 'Void 1')\n", + "void_1_cell.fill = void\n", + "void_1_cell.region = -void_outer_radius & +void_1_min & -void_1_max\n", + "control_universe.add_cell(void_1_cell)\n", + "\n", + "# Create void 2 cell\n", + "void_2_cell = openmc.Cell(name= 'Void 2')\n", + "void_2_cell.fill = void\n", + "void_2_cell.region = -void_outer_radius & +void_2_min & -void_2_max \n", + "control_universe.add_cell(void_2_cell)\n", + "\n", + "# Create void 3 cell\n", + "void_3_cell = openmc.Cell(name= 'Void 3')\n", + "void_3_cell.fill = void\n", + "void_3_cell.region = -void_outer_radius & +void_3_min & -void_3_max \n", + "control_universe.add_cell(void_3_cell)\n", + "\n", + "# Create void 4 cell\n", + "void_4_cell = openmc.Cell(name= 'Void 3')\n", + "void_4_cell.fill = void\n", + "void_4_cell.region = -void_outer_radius & +void_4_min & -void_4_max \n", + "control_universe.add_cell(void_4_cell)\n", + "\n", + "# Create ss304 1 cell\n", + "ss304_1_cell = openmc.Cell(name='Stainless Steel 304 Cell 1')\n", + "ss304_1_cell.fill = ss304\n", + "ss304_1_cell.region = -ss304_outer_radius & +ss304_1_min & -ss304_1_max \n", + "control_universe.add_cell(ss304_1_cell)\n", + "\n", + "# Create ss304 2 cell\n", + "ss304_2_cell = openmc.Cell(name='Stainless Steel 304 Cell 2')\n", + "ss304_2_cell.fill = ss304\n", + "ss304_2_cell.region = -ss304_outer_radius & +ss304_2_min & -ss304_2_max \n", + "control_universe.add_cell(ss304_2_cell)\n", + "\n", + "# Create ss304 3 cell\n", + "ss304_3_cell = openmc.Cell(name='Stainless Steel 304 Cell 3')\n", + "ss304_3_cell.fill = ss304\n", + "ss304_3_cell.region = -ss304_outer_radius & +ss304_3_min & -ss304_3_max \n", + "control_universe.add_cell(ss304_3_cell)\n", + "\n", + "# Create ss304 4 cell\n", + "ss304_4_cell = openmc.Cell(name='Stainless Steel 304 Cell 4')\n", + "ss304_4_cell.fill = ss304\n", + "ss304_4_cell.region = -ss304_outer_radius & +ss304_4_min & -ss304_4_max \n", + "control_universe.add_cell(ss304_4_cell)\n", + "\n", + "# Create ss304 5 cell\n", + "ss304_5_cell = openmc.Cell(name='Stainless Steel 304 Cell 5')\n", + "ss304_5_cell.fill = ss304\n", + "ss304_5_cell.region = -ss304_outer_radius & +ss304_5_min & -ss304_5_max \n", + "control_universe.add_cell(ss304_5_cell)\n", + "\n", + "# Create b4c 1 cell\n", + "b4c_1_cell = openmc.Cell(name='B4C cell')\n", + "b4c_1_cell.fill = b4c\n", + "b4c_1_cell.region = -b4c_outer_radius & +b4c_1_min & -b4c_1_max\n", + "control_universe.add_cell(b4c_1_cell) \n", + "\n", + "# Create a clad Cell\n", + "clad_cell = openmc.Cell(name='Stainless Steel 304 Cladding')\n", + "clad_cell.fill = ss304\n", + "clad_cell.region = -clad_outer_radius & +ss304_outer_radius & +clad_min & -clad_max #Miriam: cladding is only the exterior coat.\n", + "control_universe.add_cell(clad_cell)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "id": "8h9JMENTw9P3" + }, + "outputs": [], + "source": [ + "# Create water universe to surround the lattice\n", + "\n", + "all_water_cell = openmc.Cell(fill=water)\n", + "outer_universe = openmc.Universe(cells=(all_water_cell,))" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "id": "q-VaKsxT8v3b" + }, + "outputs": [], + "source": [ + "# Create surfaces that will divide rings in the circular lattice\n", + "\n", + "ring_radii = np.array([0.0, 8.0, 16.0, 24.0, 32.0, 40.0])\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", + " water_cells.append(openmc.Cell(fill=water, region=water_region))" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 282 + }, + "id": "Ggrtg9BT8w9D", + "outputId": "9ba193b2-edc8-4540-d234-1f0cb00d5a5d" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the rings to visualize the circular lattice, without rods\n", + "\n", + "plot_args = {'width': (2*24.1, 2*24.1)}\n", + "bundle_universe = openmc.Universe(cells=water_cells)\n", + "bundle_universe.plot(**plot_args)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "DGqaeEPN8z2K", + "outputId": "e68c720d-cb6d-45c2-92b2-a96b9e1d6dd2" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Adding in a control rod...\n", + "Adding in a transient rod...\n", + "Adding in a water rod...\n", + "Adding in a transient rod...\n", + "Adding in a control rod...\n", + "Adding in a control rod...\n", + "Adding in a water rod...\n" + ] + } + ], + "source": [ + "# Arrange the pins in the circular lattice \n", + "\n", + "num_pins = [1, 6, 12, 18, 24, 30]\n", + "angles = [0, 0, 0, 0, 0, 0]\n", + "\n", + "controlRods = {'numPins' :[num_pins[1], num_pins[3], num_pins[5]],\n", + " 'howLeftFrom3oclock':[4 , 2 , 0]}\n", + "\n", + "transientRods = {'numPins' :[num_pins[3], num_pins[2]],\n", + " 'howLeftFrom3oclock':[1 , 0]}\n", + "\n", + "waterRods = {'numPins' :[num_pins[5], num_pins[2]],\n", + " 'howLeftFrom3oclock':[1 , 8]}\n", + "\n", + "def ControlRod(controlRods,n,j):\n", + " for irod in range(len(controlRods['numPins'])): \n", + " if n == controlRods['numPins'][irod] and \\\n", + " j-1 == controlRods['howLeftFrom3oclock'][irod]:\n", + " return True\n", + " return False\n", + "\n", + "def TransientRod(transientRods,n,j):\n", + " for irod in range(len(transientRods['numPins'])): \n", + " if n == transientRods['numPins'][irod] and \\\n", + " j-1 == transientRods['howLeftFrom3oclock'][irod]:\n", + " return True\n", + " return False\n", + "\n", + "def WaterRod(waterRods,n,j):\n", + " for irod in range(len(waterRods['numPins'])): \n", + " if n == waterRods['numPins'][irod] and \\\n", + " j-1 == waterRods['howLeftFrom3oclock'][irod]:\n", + " return True\n", + " return False\n", + "\n", + "\n", + "for i, (r, n, a) in enumerate(zip(ring_radii, num_pins, angles)):\n", + " \n", + " for j in range(n):\n", + " \n", + " # Determine location of center of pin\n", + " theta = (a + j/n*360.) * np.pi/180.\n", + " x = r*np.cos(theta)\n", + " y = r*np.sin(theta)\n", + " \n", + " pin_boundary = openmc.ZCylinder(x0=x, y0=y, r=clad_outer_radius.r)\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", + " if ControlRod(controlRods,n,j):\n", + " print('Adding in a control rod...')\n", + " pin = openmc.Cell(fill=control_universe, region=-pin_boundary)\n", + " elif TransientRod(transientRods,n,j):\n", + " print('Adding in a transient rod...')\n", + " pin = openmc.Cell(fill=transient_universe, region=-pin_boundary)\n", + " elif WaterRod(waterRods,n,j):\n", + " print('Adding in a water rod...')\n", + " pin = openmc.Cell(fill=outer_universe, region=-pin_boundary)\n", + " else:\n", + " pin = openmc.Cell(fill=fuel_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": 14, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 282 + }, + "id": "HyyFkCzS843z", + "outputId": "cbaa5f36-cfe2-4e1b-9178-00cb8272ea21" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the rings to visualize the filled circular lattice\n", + "\n", + "bundle_universe.plot(width=(100, 100), origin=[0,0,-40], \n", + " basis='xy', color_by='material',\n", + " colors={water:'blue',uzrh:'orange',\n", + " zirconium:'green',graphite:'gray',\n", + " b4c:'yellow'})" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "id": "XTzZHTnr0fO7" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Plotting fuel rod\n", + "\n", + "fuel_universe.plot(width=(20, 150), origin=[0,0,-40], basis='yz', color_by='material', colors={ss304:'fuchsia'})" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAFMAAAD4CAYAAACQadotAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Il7ecAAAACXBIWXMAAAsTAAALEwEAmpwYAAAJX0lEQVR4nO2df6zVZR3HX++uyT/9kkAykF1cVxf9MruSy5UzmoKz0DYcbhWZi+U0tbkcxGrrDzeTVsvSNpY03JxMpwabNAJWOt1Qrw5SZAjqLBVF1yo3Fya+++P7UCe4955z7v18z7nn7PPaGN/zPN/vfR5ePN/z5XDf9/PINkkM7+r2BPqJlBlIygwkZQaSMgM5rtsTaIUZM2Z4cHCwo2M+/vjjr9ue2c41PSFzcHCQkZGRjo4p6YV2r8nbPJCUGUjKDCRlBpIyA0mZgaTMQFJmICkzkJQZSMoMJGUGkjIDSZmBpMxAUmYgKTOQWmVKOlnSHyU9LWm3pGtK+3RJWyXtK7+fUOc8OkXdK/Nt4Drb84GzgCslzQdWAtttDwHby+uep1aZtg/YfqIcvwHsAWYDS4D15bT1wEV1zqNTdOw9U9Ig8GngEWCW7QOl6xVg1ijnr5A0Imnktdde69Q0J0VHZEp6D3APcK3tfzb2uUqOHZMes73W9rDt4Zkz2/qOa9eoXaakd1OJvMP2vaX5VUknlf6TgIN1z6MT1P00F3AbsMf2zxq6NgHLy/FyYGOd8+gUdYcQzga+DjwpaWdp+wFwI3CXpMuBF4BLap5HR6hVpu2HAI3RvbDOsbtBfgIKJGUGkjIDSZmBpMxAUmYgKTOQlBlIygwkZQaSMgNJmYGkzEBSZiApM5CUGUjKDCRlBpIyA0mZgXRNpqRFkvZK2i8ps0YTRdIAcAuwGJgPXFoCXT1Nt1bmAmC/7edsvwVsoApz9TTdqoQwG/hrw+sXgc82niBpBbACYO7cuS190btvfrHpOUuvntPqHNtmyj6AMrjVOi8BJze8nlPaeppuyXwMGJI0T9LxwDKqMFdP05X3TNtvS7oK2AIMAOts7+7GXCLpWike25uBzd0avw6m7AOoF0mZgaTMQFJmID1RC65VNp79/abnLOXO2sbPlRlIygwkZQaSMgNJmYGkzEBSZiApM5CUGUjKDCRlBpIyA0mZgfTV/xoteXhN85M+U9/4uTIDqW1lSloDfBl4C3gWuMz230vfKuBy4DBwte0tEWOeM/TbFs76YcRQo1LnytwKfNz2J4FngFUAJaC1DPgYsAi4tQS5ep7aZNr+g+23y8sdVKkNqAJaG2wfsv08sJ8qyNXzdOo981vA78vxaKGt2Udf0IsVtyb1nilpG/ChUbpW295YzllNVWDvjna+tu21wFqA4eHhntjPcVIybX9pvH5J3wQuBBb6fxtc9mVoC2q8zSUtAq4HvmL7zYauTcAySdMkzQOGgEfrmkcnqfMf7b8CpgFbqypm7LD9Hdu7Jd0FPE11+19p+3CN8+gYtcm0/ZFx+m4Abqhr7G6Rn4ACSZmBpMxAUmYgKTOQlBlIygwkZQaSMgNJmYGkzEBSZiApM5CUGUjKDCRlBpIyA0mZgaTMQFJmIJ3Yqeo6SZY0o7yWpJtLpa0/Szqj7jl0itr3nQTOA/7S0LyY6nvlQ1R1i35d5xw6Sd0r8+dUQYTGeMsS4HZX7AA+cGQ/tV6nzkTHEuAl27uO6srg1miMF9yi2ivtvIl+7QxuFSR9ApgH7CrRmDnAE5IWkMGt9rD9pO0TbQ/aHqS6lc+w/QpVcOsb5al+FvCPht1Re5pu/LTFZuACqsTwm8BlXZhDLXREZlmdR44NXNmJcTtNfgIKJGUGkjIDSZmBpMxAUmYgKTOQlBlIygwkZQaSMgNJmYGkzEBSZiApM5CUGUjKDCRlBtJXFbce2Nf820lLF9c3fq7MQGpdmZK+S/XNs8PA/bavL+21VNzq9g4CdZYvO5cqV/Qp24cknVjaGytufRjYJunUfqjTUedtfgVwo+1DALYPlvasuDUBTgU+L+kRSQ9IOrO0Z3BrNJoEt44DpgNnAWcCd0k6pdWvncGtBiRdAdxbEhyPSnoHmEEGtybE74BzASSdChwPvE5W3JoQ64B1kp6iKki6vKzSrLjVLmVD46+N0ZcVt5LxSZmBpMxAUmYgKTOQlBlIygwkZQaSMgNJmYGkzEBSZiApM5CUGUjKDCRlBpIyA0mZgaTMQFJmIHWW4jld0g5JO0syY0Fpz4pbE+Am4Me2Twd+VF5DVtyaEAbeV47fD7xcjvu24ladIYRrgS2Sfkr1l/a50j5WcOv/yvFIWkG1cpk7d26N04yjzuDWQuB7tu+RdAlwGzDuboCNZHCrAUm3A9eUl3cDvynHGdyaAC8D55TjLwL7ynFW3JoA3wZ+Iek44F+U9z+y4lb72H6IUbZmz4pbSUukzEBSZiApM5CUGUjKDCRlBpIyA0mZgaTMQFJmICkzkJQZSMoMJGUGkjIDSZmBpMxAUmYgKTOQScmUtFTSbknvSBo+qm9VCWftlXR+Q/ui0rZf0srJjD/VmOzKfAr4KvBgY+NRVbUWAbdKGpA0ANxCFd6aD1xazu0LJpvo2ANQ9klr5L9VtYDnJTVW1dpv+7ly3YZy7tOTmcdUoa73zLHCWS1V24I+rbg1XjjL9sb4KVX0ZXBrvHDWOIwXzurL0BbUd5uPVVXrMWBI0jxJx1M9pDbVNIeOM9l85sXAL4GZwP2Sdto+3/aYVbUkXQVsAQaAdbZ3T+pPMIWY7NP8PuC+MfpGraplezNVEq7vyE9AgaTMQFJmICkzkJQZSMoMJGUGkjIDSZmBpMxAUmYgKTOQlBlIX+1UteThNc1POuYHEOPIlRlIX63MpVfP6er4qn7Idmoj6Q1g7wQvn0G1QUm7nGb7ve1c0Csrc6/t4eanHYukkYlcK2mk3WvyPTOQlBlIr8hc24Vr276uJx5AvUKvrMyeIGUGMqVlTiRM29DfcqhW0jpJB8t+b0fapkvaKmlf+f2EphO2PWV/AR8FTgP+BAw3tM8HdgHTgHnAs8BAQ/9AaTuFalfBXcD8ccb5AnAG8FRD203AynK8EvhJs/lO6ZVpe4/t0T75NNuidgElVFs2xjsSqh1rnAeBv40yxvpyvB64qNl8p7TMcWgWmm05VDsOsxrKqr0CzGp2Qdc/TnYrTNsOti2p6b8huy6zhjBtK/2t8Kqkk2wfKMVSDza7oFdv82Zb1EaEajcBy8vxcqD5XdLtJ3aTp/nFVO93h4BXgS0Nfaupnth7gcWjXHsB8Ew5Z3WTce6kqiz77zLe5cAHge1UpSq3AdObzTc/TgbSq7f5lCRlBpIyA0mZgaTMQFJmICkzkP8AmzZOYDsl3BwAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Plotting transient rod\n", + "\n", + "transient_universe.plot(width=(20, 150), origin=[0,0,-40], basis='yz', color_by='material', colors={water:'fuchsia'})" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Plotting control rod\n", + "\n", + "control_universe.plot(width=(20, 150), origin=[0,0,-40], basis='yz', color_by='material', colors={ss304:'fuchsia'})" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Geometry definitions for the reactor\n", + "\n", + "reactor_wall = openmc.ZCylinder(r=50.0, boundary_type='vacuum')\n", + "reactor_top = openmc.ZPlane(z0=0.0, boundary_type='vacuum')\n", + "reactor_bottom = openmc.ZPlane(z0=-114.3, boundary_type='vacuum')\n", + "reactor = openmc.Cell()\n", + "reactor.region = -reactor_wall & -reactor_top & +reactor_bottom\n", + "reactor.fill = bundle_universe\n", + "reactor_universe = openmc.Universe(cells=[reactor])\n", + "\n", + "reactor_universe.plot(width=(100, 100), origin=[0,0,-40], \n", + " basis='yz', color_by='material',\n", + " colors={water:'blue',uzrh:'orange',\n", + " zirconium:'green',graphite:'gray',\n", + " b4c:'yellow'})\n", + "\n", + "geometry = openmc.Geometry(reactor_universe)\n", + "geometry.export_to_xml()" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": { + "cellView": "code", + "id": "5mPhUg7QWVw4" + }, + "outputs": [], + "source": [ + "# OpenMC simulation parameters\n", + "\n", + "batches = 100\n", + "inactive = 10\n", + "particles = 5000\n", + "\n", + "settings_file = openmc.Settings()\n", + "settings_file.batches = batches\n", + "settings_file.inactive = inactive\n", + "settings_file.particles = particles\n", + "\n", + "bounds = [-28.527375, -28.527375, -28.527375, 28.527375, 28.527375, 28.527375]\n", + "uniform_dist = openmc.stats.Box(bounds[:3], bounds[3:], only_fissionable=True)\n", + "settings_file.source = openmc.Source(space=uniform_dist)\n", + "\n", + "settings_file.export_to_xml()" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": { + "id": "A_f292ebWZFM" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " %%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%\n", + " ############### %%%%%%%%%%%%%%%%%%%%%%%%\n", + " ################## %%%%%%%%%%%%%%%%%%%%%%%\n", + " ################### %%%%%%%%%%%%%%%%%%%%%%%\n", + " #################### %%%%%%%%%%%%%%%%%%%%%%\n", + " ##################### %%%%%%%%%%%%%%%%%%%%%\n", + " ###################### %%%%%%%%%%%%%%%%%%%%\n", + " ####################### %%%%%%%%%%%%%%%%%%\n", + " ####################### %%%%%%%%%%%%%%%%%\n", + " ###################### %%%%%%%%%%%%%%%%%\n", + " #################### %%%%%%%%%%%%%%%%%\n", + " ################# %%%%%%%%%%%%%%%%%\n", + " ############### %%%%%%%%%%%%%%%%\n", + " ############ %%%%%%%%%%%%%%%\n", + " ######## %%%%%%%%%%%%%%\n", + " %%%%%%%%%%%\n", + "\n", + " | The OpenMC Monte Carlo Code\n", + " Copyright | 2011-2020 MIT and OpenMC contributors\n", + " License | https://docs.openmc.org/en/latest/license.html\n", + " Version | 0.12.1-dev\n", + " Git SHA1 | 0228ddba1d6399e654a295e51539590f076b2a3c\n", + " Date/Time | 2021-04-12 10:00:55\n", + " OpenMP Threads | 8\n", + "\n", + " Reading settings XML file...\n", + " Reading cross sections XML file...\n", + " Reading materials XML file...\n", + " Reading geometry XML file...\n", + " Reading H1 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/H1.h5\n", + " Reading O16 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/O16.h5\n", + " Reading B10 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/B10.h5\n", + " Reading U235 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/U235.h5\n", + " Reading U238 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/U238.h5\n", + " Reading H2 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/H2.h5\n", + " Reading Zr90 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/Zr90.h5\n", + " Reading Zr91 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/Zr91.h5\n", + " Reading Zr92 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/Zr92.h5\n", + " Reading Zr94 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/Zr94.h5\n", + " Reading Zr96 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/Zr96.h5\n", + " Reading Mo100 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/Mo100.h5\n", + " Reading Mo92 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/Mo92.h5\n", + " Reading Mo94 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/Mo94.h5\n", + " Reading Mo95 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/Mo95.h5\n", + " Reading Mo96 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/Mo96.h5\n", + " Reading Mo97 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/Mo97.h5\n", + " Reading Mo98 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/Mo98.h5\n", + " Reading C0 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/C0.h5\n", + " Reading Si28 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/Si28.h5\n", + " Reading Si29 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/Si29.h5\n", + " Reading Si30 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/Si30.h5\n", + " Reading P31 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/P31.h5\n", + " Reading S32 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/S32.h5\n", + " Reading S33 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/S33.h5\n", + " Reading S34 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/S34.h5\n", + " Reading S36 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/S36.h5\n", + " Reading V50 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/V50.h5\n", + " Reading V51 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/V51.h5\n", + " Reading Cr50 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/Cr50.h5\n", + " Reading Cr52 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/Cr52.h5\n", + " Reading Cr53 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/Cr53.h5\n", + " Reading Cr54 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/Cr54.h5\n", + " Reading Mn55 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/Mn55.h5\n", + " Reading Fe54 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/Fe54.h5\n", + " Reading Fe56 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/Fe56.h5\n", + " Reading Fe57 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/Fe57.h5\n", + " Reading Fe58 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/Fe58.h5\n", + " Reading Ni58 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/Ni58.h5\n", + " Reading Ni60 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/Ni60.h5\n", + " Reading Ni61 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/Ni61.h5\n", + " Reading Ni62 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/Ni62.h5\n", + " Reading Ni64 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/Ni64.h5\n", + " Reading W180 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/W180.h5\n", + " Reading W182 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/W182.h5\n", + " Reading W183 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/W183.h5\n", + " Reading W184 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/W184.h5\n", + " Reading W186 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/W186.h5\n", + " Reading B11 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/B11.h5\n", + " Reading O17 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/O17.h5\n", + " Reading Ar36 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/Ar36.h5\n", + " WARNING: Negative value(s) found on probability table for nuclide Ar36 at 294K\n", + " Reading Ar38 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/Ar38.h5\n", + " Reading Ar40 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/Ar40.h5\n", + " Reading Al27 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/Al27.h5\n", + " Reading c_Graphite from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/c_Graphite.h5\n", + " Minimum neutron data temperature: 294.0 K\n", + " Maximum neutron data temperature: 294.0 K\n", + " Preparing distributed cell instances...\n", + " Writing summary.h5 file...\n", + " Maximum neutron transport energy: 20000000.0 eV for H1\n", + " Initializing source particles...\n", + "\n", + " ====================> K EIGENVALUE SIMULATION <====================\n", + "\n", + " Bat./Gen. k Average k\n", + " ========= ======== ====================\n", + " 1/1 1.10145\n", + " 2/1 1.11882\n", + " 3/1 1.14717\n", + " 4/1 1.17966\n", + " 5/1 1.15913\n", + " 6/1 1.20627\n", + " 7/1 1.18170\n", + " 8/1 1.18638\n", + " 9/1 1.17219\n", + " 10/1 1.18670\n", + " 11/1 1.16349\n", + " 12/1 1.20555 1.18452 +/- 0.02103\n", + " 13/1 1.13633 1.16845 +/- 0.02013\n", + " 14/1 1.17646 1.17046 +/- 0.01438\n", + " 15/1 1.16547 1.16946 +/- 0.01118\n", + " 16/1 1.19266 1.17333 +/- 0.00991\n", + " 17/1 1.16401 1.17199 +/- 0.00848\n", + " 18/1 1.18430 1.17353 +/- 0.00751\n", + " 19/1 1.19096 1.17547 +/- 0.00690\n", + " 20/1 1.16996 1.17492 +/- 0.00619\n", + " 21/1 1.21025 1.17813 +/- 0.00646\n", + " 22/1 1.16321 1.17689 +/- 0.00603\n", + " 23/1 1.17115 1.17644 +/- 0.00556\n", + " 24/1 1.22113 1.17964 +/- 0.00606\n", + " 25/1 1.22173 1.18244 +/- 0.00630\n", + " 26/1 1.20065 1.18358 +/- 0.00600\n", + " 27/1 1.16530 1.18251 +/- 0.00574\n", + " 28/1 1.19524 1.18321 +/- 0.00546\n", + " 29/1 1.21012 1.18463 +/- 0.00535\n", + " 30/1 1.17722 1.18426 +/- 0.00509\n", + " 31/1 1.22580 1.18624 +/- 0.00523\n", + " 32/1 1.22713 1.18810 +/- 0.00532\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " 33/1 1.18152 1.18781 +/- 0.00509\n", + " 34/1 1.19174 1.18797 +/- 0.00488\n", + " 35/1 1.16542 1.18707 +/- 0.00477\n", + " 36/1 1.17726 1.18669 +/- 0.00459\n", + " 37/1 1.18762 1.18673 +/- 0.00442\n", + " 38/1 1.22714 1.18817 +/- 0.00450\n", + " 39/1 1.20317 1.18869 +/- 0.00437\n", + " 40/1 1.19103 1.18877 +/- 0.00422\n", + " 41/1 1.18732 1.18872 +/- 0.00409\n", + " 42/1 1.17655 1.18834 +/- 0.00397\n", + " 43/1 1.19444 1.18852 +/- 0.00386\n", + " 44/1 1.20193 1.18892 +/- 0.00376\n", + " 45/1 1.18119 1.18870 +/- 0.00366\n", + " 46/1 1.20957 1.18928 +/- 0.00360\n", + " 47/1 1.22192 1.19016 +/- 0.00361\n", + " 48/1 1.21260 1.19075 +/- 0.00357\n", + " 49/1 1.21932 1.19148 +/- 0.00355\n", + " 50/1 1.19490 1.19157 +/- 0.00346\n", + " 51/1 1.18269 1.19135 +/- 0.00338\n", + " 52/1 1.22270 1.19210 +/- 0.00338\n", + " 53/1 1.18729 1.19199 +/- 0.00331\n", + " 54/1 1.19737 1.19211 +/- 0.00323\n", + " 55/1 1.20254 1.19234 +/- 0.00317\n", + " 56/1 1.15489 1.19153 +/- 0.00320\n", + " 57/1 1.16295 1.19092 +/- 0.00319\n", + " 58/1 1.21431 1.19141 +/- 0.00316\n", + " 59/1 1.19051 1.19139 +/- 0.00310\n", + " 60/1 1.17480 1.19106 +/- 0.00305\n", + " 61/1 1.18701 1.19098 +/- 0.00300\n", + " 62/1 1.18980 1.19095 +/- 0.00294\n", + " 63/1 1.19358 1.19100 +/- 0.00288\n", + " 64/1 1.24258 1.19196 +/- 0.00298\n", + " 65/1 1.26457 1.19328 +/- 0.00321\n", + " 66/1 1.18476 1.19313 +/- 0.00316\n", + " 67/1 1.19036 1.19308 +/- 0.00310\n", + " 68/1 1.20020 1.19320 +/- 0.00305\n", + " 69/1 1.18108 1.19300 +/- 0.00301\n", + " 70/1 1.16760 1.19257 +/- 0.00299\n", + " 71/1 1.16753 1.19216 +/- 0.00297\n", + " 72/1 1.17831 1.19194 +/- 0.00293\n", + " 73/1 1.21037 1.19223 +/- 0.00289\n", + " 74/1 1.18342 1.19209 +/- 0.00285\n", + " 75/1 1.17585 1.19184 +/- 0.00282\n", + " 76/1 1.20600 1.19206 +/- 0.00278\n", + " 77/1 1.20947 1.19232 +/- 0.00275\n", + " 78/1 1.19107 1.19230 +/- 0.00271\n", + " 79/1 1.24353 1.19304 +/- 0.00278\n", + " 80/1 1.19198 1.19303 +/- 0.00274\n", + " 81/1 1.18376 1.19290 +/- 0.00270\n", + " 82/1 1.20239 1.19303 +/- 0.00267\n", + " 83/1 1.17231 1.19274 +/- 0.00264\n", + " 84/1 1.23129 1.19326 +/- 0.00266\n", + " 85/1 1.19862 1.19334 +/- 0.00262\n", + " 86/1 1.18867 1.19327 +/- 0.00259\n", + " 87/1 1.17876 1.19309 +/- 0.00256\n", + " 88/1 1.20506 1.19324 +/- 0.00254\n", + " 89/1 1.16997 1.19295 +/- 0.00252\n", + " 90/1 1.18842 1.19289 +/- 0.00249\n", + " 91/1 1.20587 1.19305 +/- 0.00246\n", + " 92/1 1.18877 1.19300 +/- 0.00243\n", + " 93/1 1.20260 1.19311 +/- 0.00241\n", + " 94/1 1.16801 1.19281 +/- 0.00240\n", + " 95/1 1.22211 1.19316 +/- 0.00239\n", + " 96/1 1.20895 1.19334 +/- 0.00237\n", + " 97/1 1.17232 1.19310 +/- 0.00236\n", + " 98/1 1.17738 1.19292 +/- 0.00234\n", + " 99/1 1.18179 1.19280 +/- 0.00231\n", + " 100/1 1.21148 1.19300 +/- 0.00230\n", + " Creating state point statepoint.100.h5...\n", + "\n", + " =======================> TIMING STATISTICS <=======================\n", + "\n", + " Total time for initialization = 9.2068e+00 seconds\n", + " Reading cross sections = 9.0835e+00 seconds\n", + " Total time in simulation = 6.2805e+00 seconds\n", + " Time in transport only = 6.2389e+00 seconds\n", + " Time in inactive batches = 6.3362e-01 seconds\n", + " Time in active batches = 5.6468e+00 seconds\n", + " Time synchronizing fission bank = 1.6112e-02 seconds\n", + " Sampling source sites = 1.2967e-02 seconds\n", + " SEND/RECV source sites = 3.0640e-03 seconds\n", + " Time accumulating tallies = 3.5000e-05 seconds\n", + " Time writing statepoints = 8.1710e-03 seconds\n", + " Total time for finalization = 4.0000e-06 seconds\n", + " Total time elapsed = 1.5534e+01 seconds\n", + " Calculation Rate (inactive) = 78911.5 particles/second\n", + " Calculation Rate (active) = 79690.4 particles/second\n", + "\n", + " ============================> RESULTS <============================\n", + "\n", + " k-effective (Collision) = 1.19261 +/- 0.00231\n", + " k-effective (Track-length) = 1.19300 +/- 0.00230\n", + " k-effective (Absorption) = 1.19197 +/- 0.00160\n", + " Combined k-effective = 1.19231 +/- 0.00151\n", + " Leakage Fraction = 0.04087 +/- 0.00031\n", + "\n" + ] + } + ], + "source": [ + "openmc.run()" + ] + } + ], + "metadata": { + "colab": { + "collapsed_sections": [], + "name": "2 TRIGA_IPYNB.ipynb", + "provenance": [] + }, + "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.9.0" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/VHTR.ipynb b/VHTR.ipynb new file mode 100644 index 0000000..4688bdc --- /dev/null +++ b/VHTR.ipynb @@ -0,0 +1,883 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "s8q2_PI6vJDd", + "outputId": "b4a99b1c-90b1-4484-bb73-ed358a0d9b2b" + }, + "source": [ + "# A VHTR geometry \n", + "This notebook can be used as a template for modeling VHTR reactors." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "id": "ztdDaVCavN_I" + }, + "outputs": [], + "source": [ + "%matplotlib inline\n", + "import openmc" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "Ran-jogzvQvC", + "outputId": "422e9494-2575-4625-c4c1-20a55a442142" + }, + "outputs": [], + "source": [ + "# Materials definitions\n", + "\n", + "fuel = openmc.Material(name='Fuel')\n", + "fuel.add_element('U', 1.0, enrichment=4.0)\n", + "fuel.add_nuclide('O16', 2.0)\n", + "fuel.set_density('g/cm3', 10.41)\n", + "\n", + "buffer = openmc.Material(name='Buffer')\n", + "buffer.add_element('C', 1.0)\n", + "buffer.set_density('g/cm3', 0.95)\n", + "buffer.add_s_alpha_beta('c_Graphite')\n", + "\n", + "IPyC = openmc.Material(name='Inner PyC')\n", + "IPyC.add_element('C', 1.0)\n", + "IPyC.set_density('g/cm3', 1.9)\n", + "IPyC.add_s_alpha_beta('c_Graphite')\n", + "\n", + "SiC = openmc.Material(name = \"SiC\")\n", + "SiC.add_element(\"Si\", 0.5)\n", + "SiC.add_element(\"C\", 0.5)\n", + "SiC.set_density(\"g/cm3\", 3.18)\n", + "\n", + "OPyC = openmc.Material(name='Outer PyC')\n", + "OPyC.add_element('C', 1.0)\n", + "OPyC.set_density('g/cm3', 1.9)\n", + "OPyC.add_s_alpha_beta('c_Graphite')\n", + "\n", + "graphite = openmc.Material(name='Graphite')\n", + "graphite.add_element('C', 1.0)\n", + "graphite.set_density('g/cm3', 1.7)\n", + "graphite.add_s_alpha_beta('c_Graphite')\n", + "\n", + "helium = openmc.Material(name='Helium')\n", + "helium.add_element('He', 1.0)\n", + "helium.set_density('g/cm3', 0.000166)\n", + "\n", + "b4c = openmc.Material(name='B4C Poison')\n", + "b4c.add_element('B', 4.0, enrichment=18.7, enrichment_target='B10', enrichment_type='wo')\n", + "b4c.add_element('C', 1.0)\n", + "b4c.set_density('g/cm3', 1.82)\n", + "\n", + "# Instantiate a Materials collection and export to xml\n", + "materials_list = [fuel, buffer, IPyC, SiC, OPyC, graphite, helium, b4c]\n", + "materials_file = openmc.Materials(materials_list)\n", + "materials_file.export_to_xml()" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 282 + }, + "id": "OU_alkFfwVGd", + "outputId": "7c06ff69-2077-456e-b860-9b385465151f" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Geometry definitions for TRISO particles\n", + "\n", + "kernelsph = openmc.Sphere(r=250e-4)\n", + "buffsph = openmc.Sphere(r=350e-4)\n", + "IPyCsph = openmc.Sphere(r=390e-4)\n", + "SiCsph = openmc.Sphere(r=425e-4)\n", + "OPyCsph = openmc.Sphere(r=470e-4)\n", + "\n", + "layers = [kernelsph, buffsph, IPyCsph, SiCsph, OPyCsph]\n", + "triso_mats = [fuel, buffer, IPyC, SiC, OPyC]\n", + "triso_cells = []\n", + "for i in range(5):\n", + " if (i == 0):\n", + " triso_cells.append(openmc.Cell(fill=triso_mats[0], region=-layers[0]))\n", + " else:\n", + " triso_cells.append(openmc.Cell(fill=triso_mats[i], region=+layers[i-1] & -layers[i]))\n", + "\n", + "triso_universe = openmc.Universe(cells=triso_cells)\n", + "triso_colors = {triso_cells[0]: (0.78, 0.2, 0.2), triso_cells[1]: (0.69, 0.89, 0.29), \n", + " triso_cells[2]: (0.29, 0.73, 0.47), triso_cells[3]: (0.12, 0.29, 0.42), \n", + " triso_cells[4]: (0.29, 0.73, 0.47)}\n", + "triso_universe.plot(width = (0.1, 0.1), colors = triso_colors)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "iRZUbB1uqld6", + "outputId": "371a1ccc-3603-447a-8721-2c0090b2448c" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[Cell\n", + "\tID =\t1\n", + "\tName =\t\n", + "\tFill =\tMaterial 1\n", + "\tRegion =\t-1\n", + "\tRotation =\tNone\n", + "\tTemperature =\tNone\n", + "\tTranslation =\tNone\n", + "\tVolume =\tNone\n", + ", Cell\n", + "\tID =\t2\n", + "\tName =\t\n", + "\tFill =\tMaterial 2\n", + "\tRegion =\t(1 -2)\n", + "\tRotation =\tNone\n", + "\tTemperature =\tNone\n", + "\tTranslation =\tNone\n", + "\tVolume =\tNone\n", + ", Cell\n", + "\tID =\t3\n", + "\tName =\t\n", + "\tFill =\tMaterial 3\n", + "\tRegion =\t(2 -3)\n", + "\tRotation =\tNone\n", + "\tTemperature =\tNone\n", + "\tTranslation =\tNone\n", + "\tVolume =\tNone\n", + ", Cell\n", + "\tID =\t4\n", + "\tName =\t\n", + "\tFill =\tMaterial 4\n", + "\tRegion =\t(3 -4)\n", + "\tRotation =\tNone\n", + "\tTemperature =\tNone\n", + "\tTranslation =\tNone\n", + "\tVolume =\tNone\n", + ", Cell\n", + "\tID =\t5\n", + "\tName =\t\n", + "\tFill =\tMaterial 5\n", + "\tRegion =\t(4 -5)\n", + "\tRotation =\tNone\n", + "\tTemperature =\tNone\n", + "\tTranslation =\tNone\n", + "\tVolume =\tNone\n", + "]\n" + ] + } + ], + "source": [ + "print(triso_cells)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "id": "9ZjOD3umK-RO" + }, + "outputs": [], + "source": [ + "# Generating TRISO particle lattice in cylindrical pin cell\n", + "\n", + "cylsurf = openmc.ZCylinder(r=0.6225)\n", + "maxz = openmc.ZPlane(z0=1.95, boundary_type='reflective')\n", + "minz = openmc.ZPlane(z0=-1.95, boundary_type='reflective')\n", + "\n", + "lattice_region = -cylsurf & -maxz & +minz\n", + "triso_outer_radius = 465e-4\n", + "spheres = openmc.model.pack_spheres(radius=triso_outer_radius, region=lattice_region, pf=0.3)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "id": "u7tWPGkaQaPP" + }, + "outputs": [], + "source": [ + "triso_particles = [openmc.model.TRISO(triso_outer_radius, fill=triso_universe, center=c) for c in spheres]" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "OIyhbji9Rvzr", + "outputId": "4f4e84a2-0b07-4318-c1b6-1b1f55a1a232" + }, + "outputs": [], + "source": [ + "vol_triso = 4/3 * 3.14 * triso_outer_radius**3 * len(triso_particles)\n", + "actual_pf = vol_triso/(3.14 * (0.6225) ** 2 * 3.9)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "id": "2Z8EXBSgR_yq" + }, + "outputs": [], + "source": [ + "lattice_cell = openmc.Cell(region=lattice_region)\n", + "lower_left, upp_right = lattice_cell.region.bounding_box\n", + "shape = (4, 4, 4)\n", + "pitch = (upp_right - lower_left)/shape\n", + "triso_latt = openmc.model.create_triso_lattice(triso_particles, lower_left, pitch, shape, graphite)\n", + "lattice_cell.fill = triso_latt\n", + "\n", + "lattice_universe = openmc.Universe(cells=[lattice_cell])" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 282 + }, + "id": "8S3JIn-x9doF", + "outputId": "da1312f4-92c6-4100-97a2-66af845295f7" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "lattice_universe.plot(width=(1.4,1.4))" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 282 + }, + "id": "yTqFsu7U9Pmf", + "outputId": "ebd66100-aa13-452b-912a-a1fed9e964f5" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "lattice_universe.plot(width=(1.4,1.4), color_by='material', colors = {graphite: (0.08, 0.09, 0.26)})" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "j3_6A6g-L_d4" + }, + "source": [ + "**Testing Pin Cell Embedded In Graphite Block**" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "id": "t80buCTqL-84" + }, + "outputs": [], + "source": [ + "hexaregion = openmc.model.hexagonal_prism(edge_length = 0.85, orientation = 'x', boundary_type='reflective')\n", + "\n", + "outer_region = hexaregion & +cylsurf & -maxz & +minz\n", + "outer_pin_cell = openmc.Cell(fill=graphite, region = outer_region)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "id": "ho_e-y7Cgi_q" + }, + "outputs": [], + "source": [ + "pin_cell_universe = openmc.Universe(cells=[lattice_cell, outer_pin_cell])" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 282 + }, + "id": "76wi7ezZgoHj", + "outputId": "55590ede-ff67-4a78-96d2-87d902b2c366" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "pin_cell_universe.plot(width=(1.8, 1.8), color_by='cell', colors = {outer_pin_cell: (0.08, 0.09, 0.26)})" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "jJasUqJAhn_e" + }, + "source": [ + "As expected, the outside hexagonal block and the non-triso area of the pin cell are both filled with graphite:" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 282 + }, + "id": "SnF1LEnihncs", + "outputId": "f9671980-db4b-4ce0-99a4-867aa59fe5d9" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "pin_cell_universe.plot(width=(1.9, 1.9), color_by='material', colors = {graphite: (0.08, 0.09, 0.26), fuel: (1, 0.86, 0.57)})" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "Mp8W0NWEhzhZ", + "outputId": "2204e776-fed4-4007-a05d-cba6acb11789" + }, + "outputs": [], + "source": [ + "geom = openmc.Geometry(pin_cell_universe)\n", + "geom.export_to_xml()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "OKwVl93-GboP" + }, + "source": [ + "**Creating Coolant Channels/Cells (Helium fill)**" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": { + "id": "lLnEBbE3aJqa" + }, + "outputs": [], + "source": [ + "small_coolant_surf = openmc.ZCylinder(r=0.6375)\n", + "big_coolant_surf = openmc.ZCylinder(r=0.79375)\n", + "\n", + "small_coolant_cell = openmc.Cell(region=-small_coolant_surf & -maxz & +minz, fill=helium)\n", + "big_coolant_cell = openmc.Cell(region=-big_coolant_surf & -maxz & +minz, fill=helium)\n", + "\n", + "outside_small_cell = openmc.Cell(region=+small_coolant_surf & -maxz & +minz, fill=graphite)\n", + "outside_big_cell = openmc.Cell(region=+big_coolant_surf & -maxz & +minz, fill=graphite)\n", + "\n", + "small_coolant_universe = openmc.Universe(cells=[small_coolant_cell, outside_small_cell])\n", + "big_coolant_universe = openmc.Universe(cells=[big_coolant_cell, outside_big_cell])" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "2wVWLYBZAJdL" + }, + "source": [ + "**Burnable Poison Rod Geometry**" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 286 + }, + "id": "aJnsdDgr7KeF", + "outputId": "f73b7161-dd64-49db-cd48-cde093cb4af9" + }, + "outputs": [], + "source": [ + "poison_surf = openmc.ZCylinder(r=0.6375)\n", + "poison_cell = openmc.Cell(region=-poison_surf & -maxz & +minz, fill=b4c)\n", + "outside_poison_cell = openmc.Cell(region=+poison_surf & -maxz & +minz, fill=graphite)\n", + "\n", + "poison_universe = openmc.Universe(cells=[poison_cell, outside_poison_cell])" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "FSEppy7-wB1-" + }, + "source": [ + "**Defining Material Outside Pin Cell For Use in Assemblies**" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": { + "id": "ijZDqnyY7Y2f" + }, + "outputs": [], + "source": [ + "outer_pin_region = +cylsurf & -maxz & +minz\n", + "outer_pin_cell = openmc.Cell(fill=graphite, region=outer_pin_region)\n", + "\n", + "total_pin_cell_universe = openmc.Universe(cells=[lattice_cell, outer_pin_cell])" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 282 + }, + "id": "s-DGB0Nf8guO", + "outputId": "355536e5-e765-4900-9c97-e2ed00503f8f" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "total_pin_cell_universe.plot(width=(1.9, 1.9), color_by='material', colors = {graphite: (0.08, 0.09, 0.26)})" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "LfIatUoiIeSa" + }, + "source": [ + "**Constructing Geometry of Hexagonal Fuel Assembly**" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": { + "id": "gxixGDvIIXnH" + }, + "outputs": [], + "source": [ + "outer_graphite_cell = openmc.Cell(fill=graphite)\n", + "outer_graphite_universe = openmc.Universe(cells=[outer_graphite_cell])" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": { + "id": "0lt1V5rQJFlY" + }, + "outputs": [], + "source": [ + "assemblylat = openmc.HexLattice(name=\"Assembly\")\n", + "assemblylat.outer = outer_graphite_universe\n", + "assemblylat.pitch = (1.9,)\n", + "assemblylat.center = (0.0, 0.0)\n", + "assemblylat.orientation = 'x'" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": { + "id": "6NyajaT_Dhdf" + }, + "outputs": [], + "source": [ + "def repeat_lat_element(n, pad_left, pad_right):\n", + " ring = []\n", + " for i in range(6):\n", + " ring += pad_left\n", + " for i in range(n):\n", + " ring.extend([total_pin_cell_universe]*2 + [big_coolant_universe])\n", + " ring += pad_right\n", + "\n", + " return ring" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": { + "id": "eMfy_09gPIjE" + }, + "outputs": [], + "source": [ + "def build_outer_ring(n, insert_poison_rod):\n", + " REPEAT_SECTION = 2\n", + " ring = []\n", + "\n", + " # burnable poison rods sides\n", + " poisonring = []\n", + " poisonring += [insert_poison_rod] + [total_pin_cell_universe] + [big_coolant_universe]\n", + " for i in range(REPEAT_SECTION):\n", + " poisonring.extend([total_pin_cell_universe]*2 + [big_coolant_universe])\n", + " poisonring += [total_pin_cell_universe]\n", + "\n", + " # normal sides\n", + " base = []\n", + " base += [outer_graphite_universe] + [total_pin_cell_universe] + [big_coolant_universe]\n", + " for i in range(REPEAT_SECTION):\n", + " base.extend([total_pin_cell_universe]*2 + [big_coolant_universe])\n", + " base += [total_pin_cell_universe]\n", + "\n", + " ring.extend(poisonring * n + base * (6 - n))\n", + "\n", + " return ring" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": { + "id": "vygU8F5vLG2x" + }, + "outputs": [], + "source": [ + "def build_all_rings(insert_poison_rod):\n", + " rings = []\n", + "\n", + " outer_ring = build_outer_ring(2, insert_poison_rod)\n", + " rings.append(outer_ring)\n", + "\n", + " for i in range(1, 8): # rings 1 through 7\n", + " ring_left = []\n", + " ring_right = []\n", + " if (i % 3 == 1):\n", + " ring_left = [big_coolant_universe]\n", + " ring_right = [total_pin_cell_universe]*2\n", + " elif (i % 3 == 2):\n", + " ring_left = [total_pin_cell_universe] + [big_coolant_universe]\n", + " else:\n", + " ring_right = [total_pin_cell_universe]\n", + "\n", + " n = 0\n", + " if (i <= 3):\n", + " n = 2\n", + " elif (i <= 6):\n", + " n = 1\n", + " else:\n", + " n = 0\n", + " \n", + " cur_ring = repeat_lat_element(n, ring_left, ring_right)\n", + " rings.append(cur_ring)\n", + "\n", + " inner_ring = []\n", + " for i in range(6):\n", + " inner_ring.extend([total_pin_cell_universe] + [small_coolant_universe])\n", + " rings.append(inner_ring)\n", + " rings.append([outer_graphite_universe]*6)\n", + " rings.append([outer_graphite_universe])\n", + "\n", + " return rings" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": { + "id": "KAqeuKY2j19E" + }, + "outputs": [], + "source": [ + "rings = build_all_rings(poison_universe)\n", + "assemblylat.universes = rings" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": { + "id": "LZWflaDwla6d" + }, + "outputs": [], + "source": [ + "assembly_surf = openmc.model.hexagonal_prism(edge_length=21, orientation='x', boundary_type='reflective')\n", + "assembly_cell = openmc.Cell(fill=assemblylat, region=assembly_surf & +minz & -maxz)\n", + "assembly_universe = openmc.Universe(cells=[assembly_cell])" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 282 + }, + "id": "iMr7NMMTs6kT", + "outputId": "a1ece088-efa8-4cc1-da2a-258fbe0ac6d6" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 31, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "assembly_universe.plot(width=(42, 42), color_by='material', colors={helium: (0.99, 0, 0.27), graphite: (0.08, 0.09, 0.26), b4c: (1, 0.85, 0.1)})" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "id": "pIFgdKfmyY7b", + "outputId": "b3e9bf24-0450-47ad-9430-023413ec58f6" + }, + "outputs": [], + "source": [ + "geom = openmc.Geometry(assembly_universe)\n", + "geom.export_to_xml()" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": { + "id": "RUFinDv9-4AH" + }, + "outputs": [], + "source": [ + "# OpenMC simulation parameters\n", + "\n", + "batches = 100\n", + "inactive = 10\n", + "particles = 5000\n", + "\n", + "settings_file = openmc.Settings()\n", + "settings_file.batches = batches\n", + "settings_file.inactive = inactive\n", + "settings_file.particles = particles\n", + "settings_file.output = {'tallies': True}\n", + "\n", + "bounds = [-5, -5, -0.63, 5, 5, 0.63]\n", + "uniform_dist = openmc.stats.Box(bounds[:3], bounds[3:], only_fissionable=True)\n", + "settings_file.source = openmc.Source(space=uniform_dist)\n", + "\n", + "settings_file.export_to_xml()" + ] + } + ], + "metadata": { + "colab": { + "collapsed_sections": [], + "name": "VHTR.ipynb", + "provenance": [] + }, + "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.9.0" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/VVER.ipynb b/VVER.ipynb new file mode 100644 index 0000000..c312733 --- /dev/null +++ b/VVER.ipynb @@ -0,0 +1,842 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "7SVc4tVhUN8l", + "outputId": "91d742b3-4226-4a1c-e1a6-51bbde0949e3" + }, + "source": [ + "# A VVER geometry \n", + "This notebook can be used as a template for modeling VVER reactors." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "id": "BpmPdBBHTz2E" + }, + "outputs": [], + "source": [ + "%matplotlib inline\n", + "import openmc" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "TBEO1_TrW7up", + "outputId": "f6c529e7-05aa-4e22-de7a-2d2ffc9c9421" + }, + "outputs": [], + "source": [ + "# Materials definitions\n", + "\n", + "au13=openmc.Material(name='au13')\n", + "au13.add_element('U', 1.0, enrichment=1.3)\n", + "au13.add_element('O', 2.0)\n", + "au13.set_density('g/cc', 10.4)\n", + "\n", + "au22=openmc.Material(name='au22')\n", + "au22.add_element('U', 1.0, enrichment=2.2)\n", + "au22.add_element('O', 2.0)\n", + "au22.set_density('g/cc', 10.4)\n", + "\n", + "av5=openmc.Material(name='av5')\n", + "av5.add_element('U', 1.0, enrichment=3.0)\n", + "av5.add_element('O', 2.0)\n", + "av5.set_density('g/cc', 10.4)\n", + "\n", + "awu=openmc.Material(name='awu')\n", + "awu.add_element('U', 1.0, enrichment=3.3)\n", + "awu.add_element('O', 2.0)\n", + "awu.set_density('g/cc', 10.4)\n", + "\n", + "go=openmc.Material(name='go')\n", + "go.add_element('U', 1.0, enrichment=4.0)\n", + "go.add_element('O', 2.0)\n", + "go.set_density('g/cc', 10.4)\n", + "\n", + "Gd2O3=openmc.Material(name='Gd2O3')\n", + "Gd2O3.add_element('Gd', 2.0)\n", + "Gd2O3.add_element('O', 3.0)\n", + "Gd2O3.set_density('g/cm3', 7.41)\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", + "water.add_s_alpha_beta('c_H_in_H2O')\n", + "\n", + "zirconium = openmc.Material(name=\"zirconium\")\n", + "zirconium.add_element('Zr', 1.0)\n", + "zirconium.set_density('g/cm3', 6.6)\n", + "\n", + "niobium=openmc.Material(name='niobium')\n", + "niobium.add_element('Nb',1.0)\n", + "niobium.set_density('g/cm3',8.57)\n", + "\n", + "helium=openmc.Material(name='Helium')\n", + "helium.add_element('He', 1.0)\n", + "helium.set_density('g/cm3', 0.178e-3)\n", + "\n", + "reflector_mat = openmc.Material(name='Reflector')\n", + "reflector_mat.add_nuclide('Be9', 1.0)\n", + "reflector_mat.add_nuclide('O16', 1.0)\n", + "reflector_mat.set_density('g/cm3', 2.9)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "id": "-VU_fMs2W751" + }, + "outputs": [], + "source": [ + "# Material mixtures\n", + "\n", + "alloy = openmc.Material.mix_materials([niobium, zirconium], [0.01, 0.99], 'wo')\n", + "fuel_awu = openmc.Material.mix_materials([Gd2O3, awu], [0.05, 0.95], 'wo')\n", + "fuel_go = openmc.Material.mix_materials([Gd2O3, go], [0.05, 0.95], 'wo')" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "id": "116XndltahRq" + }, + "outputs": [], + "source": [ + "# Instantiate a Materials collection and export to xml\n", + "materials_file = openmc.Materials([au13, au22, av5, fuel_awu, fuel_go, water, alloy, helium, reflector_mat])\n", + "materials_file.export_to_xml()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "htyVmeh8ahca", + "outputId": "20ecf082-9e37-4dc4-f987-cd42a1948e1c" + }, + "outputs": [], + "source": [ + "# Geometry definitions\n", + "\n", + "# Boudries and outer universe\n", + "all_water_out=openmc.Cell(cell_id=200, fill=water)\n", + "\n", + "# Top & bottom of the assembly \n", + "assembly_z0 = openmc.ZPlane(surface_id=300, z0=-75)\n", + "assembly_z1 = openmc.ZPlane(surface_id=301, z0=75)\n", + "assembly = openmc.model.hexagonal_prism(edge_length=18, orientation='y')\n", + "\n", + "# Top & bottom of the reflector\n", + "reflector_z0 = openmc.ZPlane(surface_id=303, z0=-95, boundary_type='vacuum')\n", + "reflector_z1 = openmc.ZPlane(surface_id=304, z0= 95, boundary_type='vacuum')\n", + "\n", + "# Reflector hexagon\n", + "reflector = openmc.model.hexagonal_prism(edge_length=19, orientation='y',\n", + " boundary_type='vacuum')\n", + "\n", + "assembly_cell = openmc.Cell()\n", + "reflect_cell = openmc.Cell()\n", + "top_reflect_cell = openmc.Cell()\n", + "bot_reflect_cell = openmc.Cell()" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "id": "ku5Yp2wzyXTg" + }, + "outputs": [], + "source": [ + "assembly_cell.region = assembly & -assembly_z1 & +assembly_z0\n", + "\n", + "reflect_cell.region = ~assembly & reflector \\\n", + "& -assembly_z1 & +assembly_z0\n", + "\n", + "top_reflect_cell.region = reflector & +assembly_z1 & -reflector_z1\n", + "\n", + "bot_reflect_cell.region = reflector & -assembly_z0 & +reflector_z0\n", + "\n", + "reflect_cell.fill = reflector_mat\n", + "top_reflect_cell.fill = reflector_mat\n", + "bot_reflect_cell.fill = reflector_mat\n", + "\n", + "# Create universes\n", + "all_water_out_u=openmc.Universe(cells=[all_water_out])\n", + "u_reflect = openmc.Universe(cells=(reflect_cell,top_reflect_cell,bot_reflect_cell))\n", + "u_root = openmc.Universe()" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 286 + }, + "id": "Sl9zZQjpahiO", + "outputId": "dbbad02d-0f40-4689-fdb7-af90e0b60b53" + }, + "outputs": [], + "source": [ + "fuel_or1 = openmc.ZCylinder(surface_id=400, r=0.3765)\n", + "clad_ir1 = openmc.ZCylinder(surface_id=401, r=0.4)\n", + "clad_or1 = openmc.ZCylinder(surface_id=402, r=0.465)\n", + "\n", + "fuel_region1 = -fuel_or1 & -assembly_z1 & +assembly_z0\n", + "clad_region1 = +fuel_or1 & -clad_or1 & -assembly_z1 & +assembly_z0\n", + "\n", + "moderator_region1 = +clad_or1 & -assembly_z1 & +assembly_z0 \n", + "\n", + "fuel_cell1 = openmc.Cell(cell_id=400, fill=water, region=fuel_region1)\n", + "clad_cell1 = openmc.Cell(cell_id=401, fill=alloy, region=clad_region1)\n", + "water_cell1 = openmc.Cell(cell_id=402, fill=water, region=moderator_region1)\n", + "\n", + "central_tube_u = openmc.Universe(cells=[fuel_cell1, clad_cell1, water_cell1])" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 286 + }, + "id": "s9WlvAAxahlm", + "outputId": "172bc8df-6006-44b8-e8e1-41142ef675ea" + }, + "outputs": [], + "source": [ + "# Geometry of au13 rod\n", + "\n", + "fuel_or2 = openmc.ZCylinder(surface_id=410, r=0.3765)\n", + "clad_ir2 = openmc.ZCylinder(surface_id=411, r=0.4)\n", + "clad_or2 = openmc.ZCylinder(surface_id=412, r=0.465)\n", + "\n", + "fuel_region2 = -fuel_or2 & -assembly_z1 & +assembly_z0\n", + "gap_region2 = +fuel_or2 & -clad_ir2 & -assembly_z1 & +assembly_z0\n", + "clad_region2 = +clad_ir2 & -clad_or2 & -assembly_z1 & +assembly_z0\n", + "\n", + "moderator_region2 = +clad_or2 & -assembly_z1 & +assembly_z0 \n", + "\n", + "fuel_cell2 = openmc.Cell(cell_id=410, fill=au13, region=fuel_region2)\n", + "gap_cell2 = openmc.Cell(cell_id=411, fill=helium, region=gap_region2)\n", + "clad_cell2 = openmc.Cell(cell_id=412, fill=alloy, region=clad_region2)\n", + "water_cell2 = openmc.Cell(cell_id=413, fill=water, region=moderator_region2)\n", + "\n", + "au13_u = openmc.Universe(cells=[fuel_cell2, gap_cell2, clad_cell2, water_cell2])" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "id": "zVCVJ9IHahot" + }, + "outputs": [], + "source": [ + "# Geometry of au22 rod\n", + "\n", + "fuel_or3 = openmc.ZCylinder(surface_id=420, r=0.3765)\n", + "clad_ir3 = openmc.ZCylinder(surface_id=421, r=0.4)\n", + "clad_or3 = openmc.ZCylinder(surface_id=422, r=0.465)\n", + "\n", + "fuel_region3 = -fuel_or3 & -assembly_z1 & +assembly_z0\n", + "gap_region3 = +fuel_or3 & -clad_ir3 & -assembly_z1 & +assembly_z0\n", + "clad_region3 = +clad_ir3 & -clad_or3 & -assembly_z1 & +assembly_z0\n", + "\n", + "moderator_region3 = +clad_or3 & -assembly_z1 & +assembly_z0 \n", + "\n", + "fuel_cell3 = openmc.Cell(cell_id=420, fill=au22, region=fuel_region3)\n", + "gap_cell3 = openmc.Cell(cell_id=421, fill=helium, region=gap_region3)\n", + "clad_cell3 = openmc.Cell(cell_id=422, fill=alloy, region=clad_region3)\n", + "water_cell3 = openmc.Cell(cell_id=423, fill=water, region=moderator_region3)\n", + "\n", + "au22_u = openmc.Universe(cells=[fuel_cell3, gap_cell3, clad_cell3, water_cell3])" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "id": "3MlM4EUuahu9" + }, + "outputs": [], + "source": [ + "# Geometry of av5 rod\n", + "\n", + "fuel_or4 = openmc.ZCylinder(surface_id=430, r=0.3765)\n", + "clad_ir4 = openmc.ZCylinder(surface_id=431, r=0.4)\n", + "clad_or4 = openmc.ZCylinder(surface_id=432, r=0.465)\n", + "\n", + "fuel_region4 = -fuel_or4 & -assembly_z1 & +assembly_z0\n", + "gap_region4 = +fuel_or4 & -clad_ir4 & -assembly_z1 & +assembly_z0\n", + "clad_region4 = +clad_ir4 & -clad_or4 & -assembly_z1 & +assembly_z0\n", + "\n", + "moderator_region4 = +clad_or4 & -assembly_z1 & +assembly_z0 \n", + "\n", + "fuel_cell4 = openmc.Cell(cell_id=430, fill=av5, region=fuel_region4)\n", + "gap_cell4 = openmc.Cell(cell_id=431, fill=helium, region=gap_region4)\n", + "clad_cell4 = openmc.Cell(cell_id=432, fill=alloy, region=clad_region4)\n", + "water_cell4 = openmc.Cell(cell_id=433, fill=water, region=moderator_region4)\n", + "\n", + "av5_u = openmc.Universe(cells=[fuel_cell4, gap_cell4, clad_cell4, water_cell4])" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "id": "Ks9nRXR4ah45" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/miriamrathbun/codes/openmc-mak/openmc/mixin.py:68: IDWarning: Another Surface instance already exists with id=440.\n", + " warn(msg, IDWarning)\n", + "/Users/miriamrathbun/codes/openmc-mak/openmc/mixin.py:68: IDWarning: Another Surface instance already exists with id=441.\n", + " warn(msg, IDWarning)\n", + "/Users/miriamrathbun/codes/openmc-mak/openmc/mixin.py:68: IDWarning: Another Surface instance already exists with id=442.\n", + " warn(msg, IDWarning)\n", + "/Users/miriamrathbun/codes/openmc-mak/openmc/mixin.py:68: IDWarning: Another Cell instance already exists with id=440.\n", + " warn(msg, IDWarning)\n", + "/Users/miriamrathbun/codes/openmc-mak/openmc/mixin.py:68: IDWarning: Another Cell instance already exists with id=441.\n", + " warn(msg, IDWarning)\n", + "/Users/miriamrathbun/codes/openmc-mak/openmc/mixin.py:68: IDWarning: Another Cell instance already exists with id=442.\n", + " warn(msg, IDWarning)\n", + "/Users/miriamrathbun/codes/openmc-mak/openmc/mixin.py:68: IDWarning: Another Cell instance already exists with id=443.\n", + " warn(msg, IDWarning)\n" + ] + } + ], + "source": [ + "# Geometry of awu rod\n", + "\n", + "fuel_or5 = openmc.ZCylinder(surface_id=440, r=0.3765)\n", + "clad_ir5 = openmc.ZCylinder(surface_id=441, r=0.4)\n", + "clad_or5 = openmc.ZCylinder(surface_id=442, r=0.465)\n", + "\n", + "fuel_region5 = -fuel_or5 & -assembly_z1 & +assembly_z0\n", + "gap_region5 = +fuel_or5 & -clad_ir5 & -assembly_z1 & +assembly_z0\n", + "clad_region5 = +clad_ir5 & -clad_or5 & -assembly_z1 & +assembly_z0\n", + "\n", + "moderator_region5 = +clad_or5 & -assembly_z1 & +assembly_z0 \n", + "\n", + "fuel_cell5 = openmc.Cell(cell_id=440, fill=fuel_awu, region=fuel_region5)\n", + "gap_cell5 = openmc.Cell(cell_id=441, fill=helium, region=gap_region5)\n", + "clad_cell5 = openmc.Cell(cell_id=442, fill=alloy, region=clad_region5)\n", + "water_cell5 = openmc.Cell(cell_id=443, fill=water, region=moderator_region5)\n", + "\n", + "awu_u = openmc.Universe(cells=[fuel_cell5, gap_cell5, clad_cell5, water_cell5])" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "id": "NV8O7-cZaiuX" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/miriamrathbun/codes/openmc-mak/openmc/mixin.py:68: IDWarning: Another Surface instance already exists with id=450.\n", + " warn(msg, IDWarning)\n", + "/Users/miriamrathbun/codes/openmc-mak/openmc/mixin.py:68: IDWarning: Another Surface instance already exists with id=451.\n", + " warn(msg, IDWarning)\n", + "/Users/miriamrathbun/codes/openmc-mak/openmc/mixin.py:68: IDWarning: Another Surface instance already exists with id=452.\n", + " warn(msg, IDWarning)\n", + "/Users/miriamrathbun/codes/openmc-mak/openmc/mixin.py:68: IDWarning: Another Cell instance already exists with id=450.\n", + " warn(msg, IDWarning)\n", + "/Users/miriamrathbun/codes/openmc-mak/openmc/mixin.py:68: IDWarning: Another Cell instance already exists with id=451.\n", + " warn(msg, IDWarning)\n", + "/Users/miriamrathbun/codes/openmc-mak/openmc/mixin.py:68: IDWarning: Another Cell instance already exists with id=452.\n", + " warn(msg, IDWarning)\n", + "/Users/miriamrathbun/codes/openmc-mak/openmc/mixin.py:68: IDWarning: Another Cell instance already exists with id=453.\n", + " warn(msg, IDWarning)\n" + ] + } + ], + "source": [ + "# Geometry of go rod\n", + "\n", + "fuel_or6 = openmc.ZCylinder(surface_id=450, r=0.3765)\n", + "clad_ir6 = openmc.ZCylinder(surface_id=451, r=0.4)\n", + "clad_or6 = openmc.ZCylinder(surface_id=452, r=0.465)\n", + "\n", + "fuel_region6 = -fuel_or6 & -assembly_z1 & +assembly_z0\n", + "gap_region6 = +fuel_or6 & -clad_ir6 & -assembly_z1 & +assembly_z0\n", + "clad_region6 = +clad_ir6 & -clad_or6 & -assembly_z1 & +assembly_z0\n", + "\n", + "moderator_region6 = +clad_or6 & -assembly_z1 & +assembly_z0 \n", + "\n", + "fuel_cell6 = openmc.Cell(cell_id=450, fill=fuel_go, region=fuel_region6)\n", + "gap_cell6 = openmc.Cell(cell_id=451, fill=helium, region=gap_region6)\n", + "clad_cell6 = openmc.Cell(cell_id=452, fill=alloy, region=clad_region6)\n", + "water_cell6 = openmc.Cell(cell_id=453, fill=water, region=moderator_region6)\n", + "\n", + "go_u = openmc.Universe(cells=[fuel_cell6, gap_cell6, clad_cell6, water_cell6])" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "Lnnkq16Oaisk", + "outputId": "676d78e5-ddf5-4fd9-b6b0-8e432a33a1da" + }, + "outputs": [], + "source": [ + "# Creating the hexagonal lattice\n", + "\n", + "lat=openmc.HexLattice(name='assembly')\n", + "lat.center = (0., 0.)\n", + "lat.pitch = (1.275,)\n", + "lat.outer=all_water_out_u" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": { + "id": "0wD6nzv-aihX" + }, + "outputs": [], + "source": [ + "ring7=[awu_u, awu_u, go_u,awu_u, go_u, awu_u, awu_u]*6\n", + "ring6= [au22_u, av5_u, au22_u,\n", + " av5_u, au22_u, av5_u,\n", + " au13_u,av5_u, au22_u,\n", + " av5_u,au22_u,av5_u,\n", + " au22_u,av5_u,au22_u,\n", + " av5_u,au22_u,av5_u,\n", + " au22_u,av5_u,au22_u,\n", + " av5_u,au22_u,av5_u,\n", + " au13_u,av5_u,au22_u,\n", + " av5_u,au22_u,av5_u,\n", + " au13_u,av5_u,au22_u,\n", + " av5_u,au22_u,av5_u]\n", + "ring5= [au13_u, au13_u, au22_u, au13_u, au13_u]*6\n", + "ring4=[au22_u, av5_u, au13_u, av5_u]*6\n", + "ring3=[au13_u, au22_u, au13_u]*6\n", + "ring2=[au22_u, av5_u]*6\n", + "ring1=[au13_u]*6\n", + "ring0=[central_tube_u]\n", + "lat.universes = [ring7, ring6, ring5, ring4, ring3, ring2, ring1, ring0]\n", + "lat.orientation='y'" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 282 + }, + "id": "3qjNGajDaifZ", + "outputId": "d5c8cad5-7430-4fb7-8bb1-7930f82841c0" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "assembly_cell.fill = lat\n", + "\n", + "u_root.add_cells([assembly_cell, reflect_cell, top_reflect_cell, bot_reflect_cell])\n", + "geom=openmc.Geometry(u_root)\n", + "geom.export_to_xml()\n", + "\n", + "u_root.plot(origin=(0,0,0),width=(25,25),color_by='material',colors={water:'blue'},pixels=[400,400])" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 282 + }, + "id": "j7GDiLQtBY1m", + "outputId": "0e5753e6-eeda-43d1-c137-12d17b1b8c67" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "u_root.plot(basis='yz',origin=(0,0,0),width=(50,50),color_by='material',colors={water:'blue'},pixels=[200,200])" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": { + "id": "EzaW9J5l8vRP" + }, + "outputs": [], + "source": [ + "# OpenMC simulation parameters\n", + "\n", + "batches = 100\n", + "inactive = 10\n", + "particles = 5000\n", + "\n", + "settings = openmc.Settings()\n", + "settings.batches = batches\n", + "settings.inactive = inactive\n", + "settings.particles = particles\n", + "\n", + "uniform_dist = openmc.stats.Box([-24,-24,-75],[24,24,75],only_fissionable=True)\n", + "settings.source = openmc.source.Source(space=uniform_dist)\n", + "\n", + "settings.export_to_xml()" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "id": "mzhyBvEOaiR8", + "outputId": "bb783e58-6ac3-4193-e64a-818bf9c0fa6d" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " %%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%\n", + " ############### %%%%%%%%%%%%%%%%%%%%%%%%\n", + " ################## %%%%%%%%%%%%%%%%%%%%%%%\n", + " ################### %%%%%%%%%%%%%%%%%%%%%%%\n", + " #################### %%%%%%%%%%%%%%%%%%%%%%\n", + " ##################### %%%%%%%%%%%%%%%%%%%%%\n", + " ###################### %%%%%%%%%%%%%%%%%%%%\n", + " ####################### %%%%%%%%%%%%%%%%%%\n", + " ####################### %%%%%%%%%%%%%%%%%\n", + " ###################### %%%%%%%%%%%%%%%%%\n", + " #################### %%%%%%%%%%%%%%%%%\n", + " ################# %%%%%%%%%%%%%%%%%\n", + " ############### %%%%%%%%%%%%%%%%\n", + " ############ %%%%%%%%%%%%%%%\n", + " ######## %%%%%%%%%%%%%%\n", + " %%%%%%%%%%%\n", + "\n", + " | The OpenMC Monte Carlo Code\n", + " Copyright | 2011-2020 MIT and OpenMC contributors\n", + " License | https://docs.openmc.org/en/latest/license.html\n", + " Version | 0.12.1-dev\n", + " Git SHA1 | 0228ddba1d6399e654a295e51539590f076b2a3c\n", + " Date/Time | 2021-04-12 10:35:09\n", + " OpenMP Threads | 8\n", + "\n", + " Reading settings XML file...\n", + " Reading cross sections XML file...\n", + " Reading materials XML file...\n", + " Reading geometry XML file...\n", + " Reading U234 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/U234.h5\n", + " Reading U235 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/U235.h5\n", + " Reading U238 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/U238.h5\n", + " Reading U236 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/U236.h5\n", + " Reading O16 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/O16.h5\n", + " Reading O17 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/O17.h5\n", + " Reading H1 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/H1.h5\n", + " Reading He3 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/He3.h5\n", + " Reading He4 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/He4.h5\n", + " Reading Be9 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/Be9.h5\n", + " Reading Nb93 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/Nb93.h5\n", + " Reading Zr90 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/Zr90.h5\n", + " Reading Zr91 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/Zr91.h5\n", + " Reading Zr92 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/Zr92.h5\n", + " Reading Zr94 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/Zr94.h5\n", + " Reading Zr96 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/Zr96.h5\n", + " Reading Gd152 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/Gd152.h5\n", + " Reading Gd154 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/Gd154.h5\n", + " Reading Gd155 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/Gd155.h5\n", + " Reading Gd156 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/Gd156.h5\n", + " Reading Gd157 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/Gd157.h5\n", + " Reading Gd158 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/Gd158.h5\n", + " Reading Gd160 from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/Gd160.h5\n", + " Reading c_H_in_H2O from\n", + " /Users/miriamrathbun/codes/openmc/nucleardata/endfb71_hdf5/c_H_in_H2O.h5\n", + " Minimum neutron data temperature: 294.0 K\n", + " Maximum neutron data temperature: 294.0 K\n", + " Preparing distributed cell instances...\n", + " Writing summary.h5 file...\n", + " Maximum neutron transport energy: 20000000.0 eV for U235\n", + " Initializing source particles...\n", + "\n", + " ====================> K EIGENVALUE SIMULATION <====================\n", + "\n", + " Bat./Gen. k Average k\n", + " ========= ======== ====================\n", + " 1/1 0.32731\n", + " 2/1 0.36782\n", + " 3/1 0.36363\n", + " 4/1 0.38721\n", + " 5/1 0.36266\n", + " 6/1 0.35733\n", + " 7/1 0.34599\n", + " 8/1 0.35970\n", + " 9/1 0.34754\n", + " 10/1 0.36502\n", + " 11/1 0.36282\n", + " 12/1 0.37708 0.36995 +/- 0.00713\n", + " 13/1 0.35447 0.36479 +/- 0.00660\n", + " 14/1 0.35739 0.36294 +/- 0.00502\n", + " 15/1 0.36162 0.36268 +/- 0.00390\n", + " 16/1 0.37096 0.36406 +/- 0.00347\n", + " 17/1 0.36046 0.36354 +/- 0.00298\n", + " 18/1 0.35110 0.36199 +/- 0.00301\n", + " 19/1 0.36965 0.36284 +/- 0.00279\n", + " 20/1 0.36503 0.36306 +/- 0.00250\n", + " 21/1 0.36692 0.36341 +/- 0.00229\n", + " 22/1 0.37157 0.36409 +/- 0.00220\n", + " 23/1 0.35954 0.36374 +/- 0.00205\n", + " 24/1 0.36843 0.36407 +/- 0.00193\n", + " 25/1 0.37429 0.36476 +/- 0.00192\n", + " 26/1 0.35738 0.36429 +/- 0.00186\n", + " 27/1 0.35847 0.36395 +/- 0.00178\n", + " 28/1 0.36363 0.36393 +/- 0.00168\n", + " 29/1 0.34334 0.36285 +/- 0.00192\n", + " 30/1 0.35107 0.36226 +/- 0.00191\n", + " 31/1 0.37232 0.36274 +/- 0.00188\n", + " 32/1 0.35593 0.36243 +/- 0.00182\n", + " 33/1 0.33948 0.36143 +/- 0.00201\n", + " 34/1 0.35854 0.36131 +/- 0.00192\n", + " 35/1 0.36516 0.36147 +/- 0.00185\n", + " 36/1 0.34700 0.36091 +/- 0.00186\n", + " 37/1 0.36810 0.36118 +/- 0.00181\n", + " 38/1 0.35695 0.36102 +/- 0.00175\n", + " 39/1 0.36776 0.36126 +/- 0.00171\n", + " 40/1 0.35303 0.36098 +/- 0.00167\n", + " 41/1 0.35764 0.36088 +/- 0.00162\n", + " 42/1 0.36321 0.36095 +/- 0.00157\n", + " 43/1 0.35907 0.36089 +/- 0.00153\n", + " 44/1 0.37837 0.36141 +/- 0.00157\n", + " 45/1 0.34815 0.36103 +/- 0.00157\n", + " 46/1 0.36897 0.36125 +/- 0.00154\n", + " 47/1 0.37862 0.36172 +/- 0.00157\n", + " 48/1 0.37571 0.36208 +/- 0.00157\n", + " 49/1 0.35559 0.36192 +/- 0.00154\n", + " 50/1 0.35851 0.36183 +/- 0.00150\n", + " 51/1 0.36326 0.36187 +/- 0.00147\n", + " 52/1 0.36563 0.36196 +/- 0.00143\n", + " 53/1 0.34442 0.36155 +/- 0.00146\n", + " 54/1 0.34858 0.36125 +/- 0.00145\n", + " 55/1 0.37772 0.36162 +/- 0.00147\n", + " 56/1 0.36296 0.36165 +/- 0.00144\n", + " 57/1 0.36482 0.36172 +/- 0.00141\n", + " 58/1 0.34370 0.36134 +/- 0.00143\n", + " 59/1 0.36959 0.36151 +/- 0.00141\n", + " 60/1 0.35648 0.36141 +/- 0.00138\n", + " 61/1 0.36666 0.36151 +/- 0.00136\n", + " 62/1 0.37184 0.36171 +/- 0.00135\n", + " 63/1 0.38048 0.36207 +/- 0.00137\n", + " 64/1 0.36500 0.36212 +/- 0.00134\n", + " 65/1 0.37043 0.36227 +/- 0.00133\n", + " 66/1 0.37493 0.36250 +/- 0.00132\n", + " 67/1 0.35683 0.36240 +/- 0.00130\n", + " 68/1 0.35266 0.36223 +/- 0.00129\n", + " 69/1 0.39498 0.36278 +/- 0.00139\n", + " 70/1 0.35308 0.36262 +/- 0.00137\n", + " 71/1 0.37292 0.36279 +/- 0.00136\n", + " 72/1 0.34912 0.36257 +/- 0.00136\n", + " 73/1 0.35564 0.36246 +/- 0.00134\n", + " 74/1 0.37878 0.36272 +/- 0.00134\n", + " 75/1 0.35663 0.36262 +/- 0.00133\n", + " 76/1 0.38357 0.36294 +/- 0.00134\n", + " 77/1 0.36621 0.36299 +/- 0.00132\n", + " 78/1 0.38089 0.36325 +/- 0.00133\n", + " 79/1 0.36460 0.36327 +/- 0.00131\n", + " 80/1 0.39157 0.36368 +/- 0.00135\n", + " 81/1 0.37191 0.36379 +/- 0.00134\n", + " 82/1 0.35763 0.36371 +/- 0.00132\n", + " 83/1 0.35565 0.36360 +/- 0.00131\n", + " 84/1 0.36902 0.36367 +/- 0.00129\n", + " 85/1 0.36607 0.36370 +/- 0.00128\n", + " 86/1 0.35523 0.36359 +/- 0.00127\n", + " 87/1 0.38251 0.36384 +/- 0.00127\n", + " 88/1 0.36575 0.36386 +/- 0.00126\n", + " 89/1 0.35643 0.36377 +/- 0.00124\n", + " 90/1 0.36464 0.36378 +/- 0.00123\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " 91/1 0.36379 0.36378 +/- 0.00121\n", + " 92/1 0.37030 0.36386 +/- 0.00120\n", + " 93/1 0.36556 0.36388 +/- 0.00119\n", + " 94/1 0.39963 0.36430 +/- 0.00125\n", + " 95/1 0.37369 0.36441 +/- 0.00124\n", + " 96/1 0.37141 0.36449 +/- 0.00123\n", + " 97/1 0.36872 0.36454 +/- 0.00121\n", + " 98/1 0.37599 0.36467 +/- 0.00121\n", + " 99/1 0.38600 0.36491 +/- 0.00122\n", + " 100/1 0.36745 0.36494 +/- 0.00120\n", + " Creating state point statepoint.100.h5...\n", + "\n", + " =======================> TIMING STATISTICS <=======================\n", + "\n", + " Total time for initialization = 4.6179e+00 seconds\n", + " Reading cross sections = 4.5650e+00 seconds\n", + " Total time in simulation = 1.2380e+01 seconds\n", + " Time in transport only = 1.2340e+01 seconds\n", + " Time in inactive batches = 1.1459e+00 seconds\n", + " Time in active batches = 1.1234e+01 seconds\n", + " Time synchronizing fission bank = 1.6836e-02 seconds\n", + " Sampling source sites = 1.3449e-02 seconds\n", + " SEND/RECV source sites = 3.2980e-03 seconds\n", + " Time accumulating tallies = 1.4600e-04 seconds\n", + " Time writing statepoints = 4.2660e-03 seconds\n", + " Total time for finalization = 5.0000e-06 seconds\n", + " Total time elapsed = 1.7078e+01 seconds\n", + " Calculation Rate (inactive) = 43632.5 particles/second\n", + " Calculation Rate (active) = 40055.6 particles/second\n", + "\n", + " ============================> RESULTS <============================\n", + "\n", + " k-effective (Collision) = 0.36479 +/- 0.00104\n", + " k-effective (Track-length) = 0.36494 +/- 0.00120\n", + " k-effective (Absorption) = 0.36468 +/- 0.00113\n", + " Combined k-effective = 0.36475 +/- 0.00094\n", + " Leakage Fraction = 0.27198 +/- 0.00064\n", + "\n" + ] + } + ], + "source": [ + "openmc.run()" + ] + } + ], + "metadata": { + "colab": { + "name": "VVER.ipynb", + "provenance": [] + }, + "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.9.0" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +}