From 288702ce593faa20c714d2ba33765def1d94a63f Mon Sep 17 00:00:00 2001 From: Jonathan Shimwell Date: Thu, 16 Jun 2022 18:04:14 +0100 Subject: [PATCH 1/7] added user env --- .devcontainer/Dockerfile | 20 +++++++++++++++ .devcontainer/devcontainer.json | 43 +++++++++++++++++++++++++++++++++ 2 files changed, 63 insertions(+) create mode 100644 .devcontainer/Dockerfile create mode 100644 .devcontainer/devcontainer.json diff --git a/.devcontainer/Dockerfile b/.devcontainer/Dockerfile new file mode 100644 index 0000000..1c3bdc6 --- /dev/null +++ b/.devcontainer/Dockerfile @@ -0,0 +1,20 @@ + +# A vscode remote container docker image with conda from +# https://hub.docker.com/_/microsoft-vscode-devcontainers +FROM mcr.microsoft.com/vscode/devcontainers/miniconda:0-3 + +RUN conda install -c conda-forge mamba + +# specifying dagmc version so all the examples work and no mpi to reduce complexity +RUN mamba install -c conda-forge -y "openmc=0.13.0=dagmc*nompi*" + +# Jupyter lab installed to run examples +RUN install -c conda-forge jupyterlab + +# downloads ENDF/B-VII.1 from https://openmc.org/official-data-libraries/ +RUN wget https://anl.box.com/shared/static/9igk353zpy8fn9ttvtrqgzvw1vtejoz6.xz + +# extracts the nuclear data +RUN tar -xf 9igk353zpy8fn9ttvtrqgzvw1vtejoz6.xz + +ENV OPENMC_CROSS_SECTIONS=/endfb71_hdf5/cross_sections.xml \ No newline at end of file diff --git a/.devcontainer/devcontainer.json b/.devcontainer/devcontainer.json new file mode 100644 index 0000000..6062e2e --- /dev/null +++ b/.devcontainer/devcontainer.json @@ -0,0 +1,43 @@ + +{ + "name": "Python 3", + "build": { + "dockerfile": "Dockerfile", + "context": "..", + "args": { + "VARIANT": "3.10-bullseye", + } + }, + + // Configure tool-specific properties. + "customizations": { + // Configure properties specific to VS Code. + "vscode": { + // Set *default* container specific settings.json values on container create. + "settings": { + "python.defaultInterpreterPath": "/usr/local/bin/python", + "python.linting.enabled": true, + "python.linting.pylintEnabled": true, + "python.formatting.autopep8Path": "/usr/local/py-utils/bin/autopep8", + "python.formatting.blackPath": "/usr/local/py-utils/bin/black", + "python.formatting.yapfPath": "/usr/local/py-utils/bin/yapf", + "python.linting.banditPath": "/usr/local/py-utils/bin/bandit", + "python.linting.flake8Path": "/usr/local/py-utils/bin/flake8", + "python.linting.mypyPath": "/usr/local/py-utils/bin/mypy", + "python.linting.pycodestylePath": "/usr/local/py-utils/bin/pycodestyle", + "python.linting.pydocstylePath": "/usr/local/py-utils/bin/pydocstyle", + "python.linting.pylintPath": "/usr/local/py-utils/bin/pylint" + }, + + // Add the IDs of extensions you want installed when the container is created. + "extensions": [ + "ms-python.python", + "ms-python.vscode-pylance" + ] + } + }, + + // Allows port 8888 used for Jupyter Notebook to be available locally. + "forwardPorts": [8888], + "remoteUser": "vscode" +} From 48443b8bb7f932f5634a3501a36582ff06001586 Mon Sep 17 00:00:00 2001 From: Jonathan Shimwell Date: Thu, 16 Jun 2022 18:08:46 +0100 Subject: [PATCH 2/7] added missing mamba :snake: --- .devcontainer/Dockerfile | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.devcontainer/Dockerfile b/.devcontainer/Dockerfile index 1c3bdc6..2ff7118 100644 --- a/.devcontainer/Dockerfile +++ b/.devcontainer/Dockerfile @@ -9,7 +9,7 @@ RUN conda install -c conda-forge mamba RUN mamba install -c conda-forge -y "openmc=0.13.0=dagmc*nompi*" # Jupyter lab installed to run examples -RUN install -c conda-forge jupyterlab +RUN mamba install -c conda-forge jupyterlab # downloads ENDF/B-VII.1 from https://openmc.org/official-data-libraries/ RUN wget https://anl.box.com/shared/static/9igk353zpy8fn9ttvtrqgzvw1vtejoz6.xz From 7850b389e67c432d7c6be5b081d8bb77d7ff10ed Mon Sep 17 00:00:00 2001 From: shimwell Date: Mon, 19 Jun 2023 22:17:54 +0100 Subject: [PATCH 3/7] added 30s ww vs non ww --- shielded_room_weight_window.ipynb | 875 ++++++++++++++++++++++++++++++ 1 file changed, 875 insertions(+) create mode 100644 shielded_room_weight_window.ipynb diff --git a/shielded_room_weight_window.ipynb b/shielded_room_weight_window.ipynb new file mode 100644 index 0000000..1f3f9f1 --- /dev/null +++ b/shielded_room_weight_window.ipynb @@ -0,0 +1,875 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "id": "72e0b25d-e541-4e8d-8805-b984374ee53d", + "metadata": {}, + "source": [ + "# Variance Reduction - Weight Windows\n", + "\n", + "## Creating and utilizing a wight window to accelerate the deep shielding simulations\n", + "\n", + "This example simulates a shield room / bunker with corridor entrance a neutron source in the center of the room with This example implements a single step of the Magic method of weight window generation. \n", + "\n", + "In this tutorial we shall focus on generating a weight window to accelerate the simulation of particles through a shield.\n", + "\n", + "Weight Windows are found using the MAGIC method and used to accelerate the simulation.\n", + "\n", + "The variance reduction method used for this simulation is well documented in the OpenMC documentation\n", + "https://docs.openmc.org/en/stable/methods/neutron_physics.html\n", + "\n", + "The MAGIC method is well described in the original publication\n", + "https://scientific-publications.ukaea.uk/wp-content/uploads/Published/INTERN1.pdf\n", + "\n", + "This example has been copied with permission from the neutronics-workshop\n", + "https://github.com/fusion-energy/neutronics-workshop\n" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "f00eddb1-1e3a-4973-ba0c-d8feeb2a6704", + "metadata": {}, + "source": [ + "First we import ```openmc``` including ```openmc.lib``` and other packages needed for the example" + ] + }, + { + "cell_type": "code", + "execution_count": 62, + "id": "3448d1db-4328-42e3-8960-50d53896f541", + "metadata": {}, + "outputs": [], + "source": [ + "import time # used to time the simulation\n", + "\n", + "import openmc\n", + "import openmc.lib # this example makes use of openmc lib to run the simulations\n", + "\n", + "from matplotlib import pyplot as plt\n", + "from matplotlib.colors import LogNorm # used for plotting log scale graphs" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "8179e89a-304b-4684-91a9-8a908b75e8cd", + "metadata": {}, + "source": [ + "We create a couple of materials for the simulation" + ] + }, + { + "cell_type": "code", + "execution_count": 63, + "id": "47cb21c7-0afa-446c-9a6b-76c8dfb2f93e", + "metadata": {}, + "outputs": [], + "source": [ + "mat_air = openmc.Material(name=\"Air\")\n", + "mat_air.add_element(\"N\", 0.784431)\n", + "mat_air.add_element(\"O\", 0.210748)\n", + "mat_air.add_element(\"Ar\", 0.0046)\n", + "mat_air.set_density(\"g/cc\", 0.001205)\n", + "\n", + "mat_concrete = openmc.Material()\n", + "mat_concrete.add_element(\"H\",0.168759)\n", + "mat_concrete.add_element(\"C\",0.001416)\n", + "mat_concrete.add_element(\"O\",0.562524)\n", + "mat_concrete.add_element(\"Na\",0.011838)\n", + "mat_concrete.add_element(\"Mg\",0.0014)\n", + "mat_concrete.add_element(\"Al\",0.021354)\n", + "mat_concrete.add_element(\"Si\",0.204115)\n", + "mat_concrete.add_element(\"K\",0.005656)\n", + "mat_concrete.add_element(\"Ca\",0.018674)\n", + "mat_concrete.add_element(\"Fe\",0.00426)\n", + "mat_concrete.set_density(\"g/cm3\", 2.3)\n", + "\n", + "materials = openmc.Materials([mat_air, mat_concrete])" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "424b234c-48a2-4d1b-b374-f69430e464db", + "metadata": {}, + "source": [ + "Now we define and plot the geometry. This geometry is define by parameters for every width and height. The parameters input into the geometry in a stacked manner so they can easily be adjusted to change the geometry without creating overlapping cells." + ] + }, + { + "cell_type": "code", + "execution_count": 64, + "id": "a72dc5e3-cb8e-41c2-9cfb-f8f7489c7f44", + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "width_a = 100\n", + "width_b = 200\n", + "width_c = 500\n", + "width_d = 250\n", + "width_e = 200\n", + "width_f = 200\n", + "width_g = 100\n", + "\n", + "depth_a = 100\n", + "depth_b = 200\n", + "depth_c = 700\n", + "depth_d = 600\n", + "depth_e = 200\n", + "depth_f = 100\n", + "\n", + "height_j = 100\n", + "height_k = 500\n", + "height_l = 100\n", + "\n", + "xplane_0 = openmc.XPlane(x0=0, boundary_type=\"vacuum\")\n", + "xplane_1 = openmc.XPlane(x0=xplane_0.x0 + width_a)\n", + "xplane_2 = openmc.XPlane(x0=xplane_1.x0 + width_b)\n", + "xplane_3 = openmc.XPlane(x0=xplane_2.x0 + width_c)\n", + "xplane_4 = openmc.XPlane(x0=xplane_3.x0 + width_d)\n", + "xplane_5 = openmc.XPlane(x0=xplane_4.x0 + width_e)\n", + "xplane_6 = openmc.XPlane(x0=xplane_5.x0 + width_f)\n", + "xplane_7 = openmc.XPlane(x0=xplane_6.x0 + width_g, boundary_type=\"vacuum\")\n", + "\n", + "yplane_0 = openmc.YPlane(y0=0, boundary_type=\"vacuum\")\n", + "yplane_1 = openmc.YPlane(y0=yplane_0.y0 + depth_a)\n", + "yplane_2 = openmc.YPlane(y0=yplane_1.y0 + depth_b)\n", + "yplane_3 = openmc.YPlane(y0=yplane_2.y0 + depth_c)\n", + "yplane_4 = openmc.YPlane(y0=yplane_3.y0 + depth_d)\n", + "yplane_5 = openmc.YPlane(y0=yplane_4.y0 + depth_e)\n", + "yplane_6 = openmc.YPlane(y0=yplane_5.y0 + depth_f, boundary_type=\"vacuum\")\n", + "\n", + "zplane_1 = openmc.ZPlane(z0=0, boundary_type=\"vacuum\")\n", + "zplane_2 = openmc.ZPlane(z0=zplane_1.z0 + height_j)\n", + "zplane_3 = openmc.ZPlane(z0=zplane_2.z0 + height_k)\n", + "zplane_4 = openmc.ZPlane(z0=zplane_3.z0 + height_l, boundary_type=\"vacuum\")\n", + "\n", + "outside_left_region = +xplane_0 & -xplane_1 & +yplane_1 & -yplane_5 & +zplane_1 & -zplane_4\n", + "wall_left_region = +xplane_1 & -xplane_2 & +yplane_2 & -yplane_4 & +zplane_2 & -zplane_3\n", + "wall_right_region = +xplane_5 & -xplane_6 & +yplane_2 & -yplane_5 & +zplane_2 & -zplane_3\n", + "wall_top_region = +xplane_1 & -xplane_4 & +yplane_4 & -yplane_5 & +zplane_2 & -zplane_3\n", + "outside_top_region = +xplane_0 & -xplane_7 & +yplane_5 & -yplane_6 & +zplane_1 & -zplane_4\n", + "wall_bottom_region = +xplane_1 & -xplane_6 & +yplane_1 & -yplane_2 & +zplane_2 & -zplane_3\n", + "outside_bottom_region = +xplane_0 & -xplane_7 & +yplane_0 & -yplane_1 & +zplane_1 & -zplane_4\n", + "wall_middle_region = +xplane_3 & -xplane_4 & +yplane_3 & -yplane_4 & +zplane_2 & -zplane_3\n", + "outside_right_region = +xplane_6 & -xplane_7 & +yplane_1 & -yplane_5 & +zplane_1 & -zplane_4\n", + "\n", + "room_region = +xplane_2 & -xplane_3 & +yplane_2 & -yplane_4 & +zplane_2 & -zplane_3\n", + "gap_region = +xplane_3 & -xplane_4 & +yplane_2 & -yplane_3 & +zplane_2 & -zplane_3\n", + "corridor_region = +xplane_4 & -xplane_5 & +yplane_2 & -yplane_5 & +zplane_2 & -zplane_3\n", + "\n", + "roof_region = +xplane_1 & -xplane_6 & +yplane_1 & -yplane_5 & +zplane_1 & -zplane_2\n", + "floor_region = +xplane_1 & -xplane_6 & +yplane_1 & -yplane_5 & +zplane_3 & -zplane_4\n", + "\n", + "outside_left_cell = openmc.Cell(region=outside_left_region, fill=mat_air)\n", + "outside_right_cell = openmc.Cell(region=outside_right_region, fill=mat_air)\n", + "outside_top_cell = openmc.Cell(region=outside_top_region, fill=mat_air)\n", + "outside_bottom_cell = openmc.Cell(region=outside_bottom_region, fill=mat_air)\n", + "wall_left_cell = openmc.Cell(region=wall_left_region, fill=mat_concrete)\n", + "wall_right_cell = openmc.Cell(region=wall_right_region, fill=mat_concrete)\n", + "wall_top_cell = openmc.Cell(region=wall_top_region, fill=mat_concrete)\n", + "wall_bottom_cell = openmc.Cell(region=wall_bottom_region, fill=mat_concrete)\n", + "wall_middle_cell = openmc.Cell(region=wall_middle_region, fill=mat_concrete)\n", + "room_cell = openmc.Cell(region=room_region, fill=mat_air)\n", + "gap_cell = openmc.Cell(region=gap_region, fill=mat_air)\n", + "corridor_cell = openmc.Cell(region=corridor_region, fill=mat_air)\n", + "\n", + "roof_cell = openmc.Cell(region=roof_region, fill=mat_concrete)\n", + "floor_cell = openmc.Cell(region=floor_region, fill=mat_concrete)\n", + "\n", + "geometry = openmc.Geometry(\n", + " [\n", + " outside_bottom_cell,\n", + " outside_top_cell,\n", + " outside_left_cell,\n", + " outside_right_cell,\n", + " wall_left_cell,\n", + " wall_right_cell,\n", + " wall_top_cell,\n", + " wall_bottom_cell,\n", + " wall_middle_cell,\n", + " room_cell,\n", + " gap_cell,\n", + " corridor_cell,\n", + " roof_cell,\n", + " floor_cell,\n", + " ]\n", + ")\n" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "51713fe1", + "metadata": {}, + "source": [ + "Now we plot the geometry and color by materials." + ] + }, + { + "cell_type": "code", + "execution_count": 65, + "id": "94c41f17", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "geometry.root_universe.plot(basis='xy', color_by='material') \n", + "plt.savefig('geometry_top_down_view.png', bbox_inches=\"tight\")" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "8d6bd790", + "metadata": {}, + "source": [ + "Next we create a point source, this also uses the same geometry parameters to place in the center of the room regardless of the values of the parameters." + ] + }, + { + "cell_type": "code", + "execution_count": 66, + "id": "fd4986b0", + "metadata": {}, + "outputs": [], + "source": [ + "# location of the point source\n", + "source_x = width_a + width_b + width_c * 0.5\n", + "source_y = depth_a + depth_b + depth_c * 0.75\n", + "source_z = height_j + height_k * 0.5\n", + "space = openmc.stats.Point((source_x, source_y, source_z))\n", + "\n", + "angle = openmc.stats.Isotropic()\n", + "\n", + "# all (100%) of source particles are 2.5MeV energy\n", + "energy = openmc.stats.Discrete([2.5e6], [1.0])\n", + "\n", + "source = openmc.Source(space=space, angle=angle, energy=energy)\n", + "source.particle = \"neutron\"\n" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "1456ac2f", + "metadata": {}, + "source": [ + "Next we create a mesh that encompasses the entire geometry and scores neutron flux" + ] + }, + { + "cell_type": "code", + "execution_count": 67, + "id": "9d7bbee6", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/j/openmc/openmc/mixin.py:70: IDWarning: Another Tally instance already exists with id=42.\n", + " warn(msg, IDWarning)\n" + ] + } + ], + "source": [ + "mesh = openmc.RegularMesh().from_domain(geometry)\n", + "mesh.dimension = (500, 500, 1)\n", + "\n", + "mesh_filter = openmc.MeshFilter(mesh)\n", + "particle_filter = openmc.ParticleFilter('neutron')\n", + "\n", + "flux_tally = openmc.Tally(name=\"flux tally\")\n", + "flux_tally.filters = [mesh_filter, particle_filter]\n", + "flux_tally.scores = [\"flux\"]\n", + "flux_tally.id = 42 # we set the ID because we need to access this later\n", + "\n", + "tallies = openmc.Tallies([flux_tally])" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "2bc34eac", + "metadata": {}, + "source": [ + "Creates the simulation settings" + ] + }, + { + "cell_type": "code", + "execution_count": 68, + "id": "ea32fb73", + "metadata": {}, + "outputs": [], + "source": [ + "settings = openmc.Settings()\n", + "\n", + "settings.run_mode = \"fixed source\"\n", + "settings.source = source\n", + "settings.particles = 40000\n", + "settings.batches = 5\n", + "# no need to write the tallies.out file which saves space and time when large meshes are used\n", + "settings.output = {'tallies': False}" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "9bc4e52b", + "metadata": {}, + "source": [ + "Creates and export the model" + ] + }, + { + "cell_type": "code", + "execution_count": 69, + "id": "6d8042a5", + "metadata": {}, + "outputs": [], + "source": [ + "model = openmc.Model(geometry, materials, settings, tallies)\n", + "model.export_to_xml() # this is necessary as openmc.lib loads up the model.xml file" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "488391db", + "metadata": {}, + "source": [ + "Now we make use of openmc.lib to control the simulation. Documentation on openmc.lib is here\n", + "https://docs.openmc.org/en/stable/pythonapi/capi.html\n", + "\n", + "We also time the simulation so that we can perform the same simulation again with weight windows and try to fine tune the particle so that both simulations take the same time and we are making a fair comparision." + ] + }, + { + "cell_type": "code", + "execution_count": 70, + "id": "9159a336", + "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-2023 MIT, UChicago Argonne LLC, and contributors\n", + " License | https://docs.openmc.org/en/latest/license.html\n", + " Version | 0.13.4-dev\n", + " Git SHA1 | 610a5d8c3485034626ce54ce87a88eaa8071cc23\n", + " Date/Time | 2023-06-19 22:04:12\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 N14 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/N14.h5\n", + " Reading N15 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/N15.h5\n", + " Reading O16 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/O16.h5\n", + " Reading O17 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/O17.h5\n", + " Reading O18 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/O18.h5\n", + " Reading Ar36 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/Ar36.h5\n", + " Reading Ar38 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/Ar38.h5\n", + " Reading Ar40 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/Ar40.h5\n", + " Reading H1 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/H1.h5\n", + " Reading H2 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/H2.h5\n", + " Reading C12 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/C12.h5\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " WARNING: Negative value(s) found on probability table for nuclide Ar36 at 294K\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Reading C13 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/C13.h5\n", + " Reading Na23 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/Na23.h5\n", + " Reading Mg24 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/Mg24.h5\n", + " Reading Mg25 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/Mg25.h5\n", + " Reading Mg26 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/Mg26.h5\n", + " Reading Al27 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/Al27.h5\n", + " Reading Si28 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/Si28.h5\n", + " Reading Si29 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/Si29.h5\n", + " Reading Si30 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/Si30.h5\n", + " Reading K39 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/K39.h5\n", + " Reading K40 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/K40.h5\n", + " Reading K41 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/K41.h5\n", + " Reading Ca40 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/Ca40.h5\n", + " Reading Ca42 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/Ca42.h5\n", + " Reading Ca43 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/Ca43.h5\n", + " Reading Ca44 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/Ca44.h5\n", + " Reading Ca46 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/Ca46.h5\n", + " Reading Ca48 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/Ca48.h5\n", + " Reading Fe54 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/Fe54.h5\n", + " Reading Fe56 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/Fe56.h5\n", + " Reading Fe57 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/Fe57.h5\n", + " Reading Fe58 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/Fe58.h5\n", + " Minimum neutron data temperature: 0 K\n", + " Maximum neutron data temperature: 1.7976931348623157e+308 K\n", + " Reading tallies XML file...\n", + " Preparing distributed cell instances...\n", + " Reading plot XML file...\n", + " Writing summary.h5 file...\n", + " Maximum neutron transport energy: 20000000 eV for N15\n", + "\n", + " ===============> FIXED SOURCE TRANSPORT SIMULATION <===============\n", + "\n", + " Simulating batch 1\n", + " Simulating batch 2\n", + " Simulating batch 3\n", + " Simulating batch 4\n", + " Simulating batch 5\n", + " Creating state point statepoint.5.h5...\n", + "\n", + " =======================> TIMING STATISTICS <=======================\n", + "\n", + " Total time for initialization = 3.0483e+00 seconds\n", + " Reading cross sections = 3.0176e+00 seconds\n", + " Total time in simulation = 1.4873e+01 seconds\n", + " Time in transport only = 1.4810e+01 seconds\n", + " Time in active batches = 1.4873e+01 seconds\n", + " Time accumulating tallies = 1.2549e-02 seconds\n", + " Time writing statepoints = 4.9269e-02 seconds\n", + " Total time for finalization = 2.1900e-06 seconds\n", + " Total time elapsed = 1.7932e+01 seconds\n", + " Calculation Rate (active) = 13447.1 particles/second\n", + "\n", + " ============================> RESULTS <============================\n", + "\n", + " Leakage Fraction = 0.00387 +/- 0.00013\n", + "\n", + "total time without weight windows 17.997257947921753s\n" + ] + } + ], + "source": [ + "# this helps time the simulation\n", + "t0 = time.time()\n", + "\n", + "# first we initialize openmc lib, this reads in the model.xml and material cross sections \n", + "openmc.lib.init()\n", + "\n", + "# This runs openmc with the settings provided earlier\n", + "openmc.lib.run()\n", + "\n", + "# End the connection to openmc lib and write out the statepoint file\n", + "openmc.lib.finalize()\n", + "\n", + "# End the connection to openmc lib and write out the statepoint file\n", + "openmc.lib.finalize()\n", + "\n", + "t1 = time.time()\n", + "\n", + "total = t1-t0\n", + "\n", + "print(f'total time without weight windows {total}s')" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "79ec2340", + "metadata": {}, + "source": [ + "Now we want to plot the results of the simulation. We want to do this twice to compare the results so I've written this up as a function that we can call." + ] + }, + { + "cell_type": "code", + "execution_count": 71, + "id": "e6f60d98", + "metadata": {}, + "outputs": [], + "source": [ + "def plot_mesh_tally(statepoint_filename, image_filename):\n", + "\n", + " with openmc.StatePoint(statepoint_filename) as sp:\n", + " flux_tally = sp.get_tally(name=\"flux tally\")\n", + "\n", + " mesh_extent = mesh.bounding_box.extent['xy']\n", + "\n", + " # get a slice of mean values on the xy basis mid z axis\n", + " flux_mean = flux_tally.get_reshaped_data(value='mean', expand_dims=True, squeeze=True)#[:, :, 1]\n", + " plt.subplot(1, 2, 1)\n", + " # create a plot of the mean flux values\n", + " plt.imshow(\n", + " flux_mean.T,\n", + " origin=\"lower\",\n", + " extent=mesh_extent,\n", + " norm=LogNorm(),\n", + " )\n", + " plt.title(\"Flux Mean\")\n", + "\n", + "\n", + " plt.subplot(1, 2, 2)\n", + " # get a slice of std dev values on the xy basis mid z axis\n", + " flux_std_dev = flux_tally.get_reshaped_data(value='std_dev', expand_dims=True, squeeze=True)# .squeeze()[:, :, 1]\n", + " # create a plot of the flux relative error\n", + " plt.imshow(\n", + " flux_std_dev.T,\n", + " origin=\"lower\",\n", + " extent=mesh_extent,\n", + " norm=LogNorm(),\n", + " )\n", + " plt.title(\"Flux Std. Dev.\")\n", + "\n", + " plt.savefig(image_filename)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "b15e186f", + "metadata": {}, + "source": [ + "This next section calls the plotting function and saves an image of the mesh tally as no_ww.png" + ] + }, + { + "cell_type": "code", + "execution_count": 72, + "id": "8fb8f31e", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_mesh_tally(f'statepoint.{settings.batches}.h5', 'no_ww.png')" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "2abd8995", + "metadata": {}, + "source": [ + "Now we want to run the simulation twice. Once to generate weight windows and once to make use of the weight windows. We are going to adjust the number of particles to try and spend the same total amount of computer time as the last simulation and make this a fair test. This might require some adaption of the particles as the simulation is set up for my laptop." + ] + }, + { + "cell_type": "code", + "execution_count": 73, + "id": "d519ac33", + "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-2023 MIT, UChicago Argonne LLC, and contributors\n", + " License | https://docs.openmc.org/en/latest/license.html\n", + " Version | 0.13.4-dev\n", + " Git SHA1 | 610a5d8c3485034626ce54ce87a88eaa8071cc23\n", + " Date/Time | 2023-06-19 22:04:31\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 N14 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/N14.h5\n", + " Reading N15 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/N15.h5\n", + " Reading O16 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/O16.h5\n", + " Reading O17 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/O17.h5\n", + " Reading O18 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/O18.h5\n", + " Reading Ar36 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/Ar36.h5\n", + " Reading Ar38 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/Ar38.h5\n", + " Reading Ar40 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/Ar40.h5\n", + " Reading H1 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/H1.h5\n", + " Reading H2 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/H2.h5\n", + " Reading C12 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/C12.h5\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " WARNING: Negative value(s) found on probability table for nuclide Ar36 at 294K\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Reading C13 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/C13.h5\n", + " Reading Na23 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/Na23.h5\n", + " Reading Mg24 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/Mg24.h5\n", + " Reading Mg25 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/Mg25.h5\n", + " Reading Mg26 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/Mg26.h5\n", + " Reading Al27 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/Al27.h5\n", + " Reading Si28 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/Si28.h5\n", + " Reading Si29 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/Si29.h5\n", + " Reading Si30 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/Si30.h5\n", + " Reading K39 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/K39.h5\n", + " Reading K40 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/K40.h5\n", + " Reading K41 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/K41.h5\n", + " Reading Ca40 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/Ca40.h5\n", + " Reading Ca42 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/Ca42.h5\n", + " Reading Ca43 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/Ca43.h5\n", + " Reading Ca44 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/Ca44.h5\n", + " Reading Ca46 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/Ca46.h5\n", + " Reading Ca48 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/Ca48.h5\n", + " Reading Fe54 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/Fe54.h5\n", + " Reading Fe56 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/Fe56.h5\n", + " Reading Fe57 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/Fe57.h5\n", + " Reading Fe58 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/Fe58.h5\n", + " Minimum neutron data temperature: 0 K\n", + " Maximum neutron data temperature: 1.7976931348623157e+308 K\n", + " Reading tallies XML file...\n", + " Preparing distributed cell instances...\n", + " Reading plot XML file...\n", + " Writing summary.h5 file...\n", + " Maximum neutron transport energy: 20000000 eV for N15\n", + "\n", + " ===============> FIXED SOURCE TRANSPORT SIMULATION <===============\n", + "\n", + " Simulating batch 1\n", + " Simulating batch 2\n", + " Simulating batch 3\n", + " Simulating batch 4\n", + " Simulating batch 5\n", + " Creating state point statepoint.5.h5...\n", + "\n", + " =======================> TIMING STATISTICS <=======================\n", + "\n", + " Total time for initialization = 2.9465e+00 seconds\n", + " Reading cross sections = 2.9232e+00 seconds\n", + " Total time in simulation = 2.5516e+00 seconds\n", + " Time in transport only = 2.4817e+00 seconds\n", + " Time in active batches = 2.5516e+00 seconds\n", + " Time accumulating tallies = 3.1487e-02 seconds\n", + " Time writing statepoints = 3.4734e-02 seconds\n", + " Total time for finalization = 1.9120e-06 seconds\n", + " Total time elapsed = 5.5113e+00 seconds\n", + " Calculation Rate (active) = 11757.3 particles/second\n", + "\n", + " ============================> RESULTS <============================\n", + "\n", + " Leakage Fraction = 0.00397 +/- 0.00034\n", + "\n", + " Maximum neutron transport energy: 20000000 eV for N15\n", + "\n", + " ===============> FIXED SOURCE TRANSPORT SIMULATION <===============\n", + "\n", + " Simulating batch 1\n", + " Simulating batch 2\n", + " Simulating batch 3\n", + " Simulating batch 4\n", + " Simulating batch 5\n", + " Creating state point statepoint.5.h5...\n", + "\n", + " =======================> TIMING STATISTICS <=======================\n", + "\n", + " Total time for initialization = 2.9465e+00 seconds\n", + " Reading cross sections = 2.9232e+00 seconds\n", + " Total time in simulation = 2.1431e+01 seconds\n", + " Time in transport only = 2.1295e+01 seconds\n", + " Time in active batches = 2.1431e+01 seconds\n", + " Time accumulating tallies = 6.8074e-02 seconds\n", + " Time writing statepoints = 6.3614e-02 seconds\n", + " Total time for finalization = 4.2290e-06 seconds\n", + " Total time elapsed = 2.4399e+01 seconds\n", + " Calculation Rate (active) = 69.9934 particles/second\n", + "\n", + " ============================> RESULTS <============================\n", + "\n", + " Leakage Fraction = 0.00400 +/- 0.00043\n", + "\n", + "total time without weight windows 24.757001638412476s\n" + ] + } + ], + "source": [ + "# this helps time the simulation\n", + "t0 = time.time()\n", + "\n", + "# first we initialize openmc lib, this reads in the model.xml and material cross sections \n", + "openmc.lib.init()\n", + "\n", + "# Now we find the mesh tally that will be used for creating the weight windows \n", + "# This ID of 42 matches the tally ID we set earlier\n", + "# At this point the tally is empty.\n", + "tally = openmc.lib.tallies[42]\n", + "\n", + "# We create a weight window object from the empty tally. \n", + "wws = openmc.lib.WeightWindows.from_tally(tally)\n", + "\n", + "# We are running a fraction of particles of the original simulation as we want\n", + "# to take less simulation time for the first run and leave some simulation time\n", + "# for the run with weight windows.\n", + "openmc.lib.settings.particles = 6000\n", + "\n", + "# This runs openmc with the settings provided earlier\n", + "openmc.lib.run()\n", + "\n", + "# The tally now contains meaningful information.\n", + "# So we can update the weight windows from the tally.\n", + "# This uses the MAGIC method\n", + "wws.update_magic(tally)\n", + "\n", + "# Now we enable weight window usage, previously this was set to False by default\n", + "openmc.lib.settings.weight_windows_on = True\n", + "\n", + "# As the particles are now splitting the number of particles run per second\n", + "# will be significantly lower. Therefore we will reduce the number of particles\n", + "# so that the simulation runs in reasonable amount of time\n", + "openmc.lib.settings.particles = 300\n", + "\n", + "# Now we run the simulation again, this time with the weight windows in use\n", + "openmc.lib.run()\n", + "\n", + "# End the connection to openmc lib and write out the statepoint file\n", + "openmc.lib.finalize()\n", + "\n", + "t1 = time.time()\n", + "\n", + "total = t1-t0\n", + "\n", + "print(f'total time without weight windows {total}s')" + ] + }, + { + "cell_type": "code", + "execution_count": 74, + "id": "fbf35ffc", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_mesh_tally(f'statepoint.{settings.batches}.h5', 'ww.png')" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "b086b6ec", + "metadata": {}, + "source": [ + "On my laptop both simulations took 20 seconds to complete but the resulting flux map from the simulation with weight windows shows neutrons got further through the geometry.\n", + "\n", + "The weight windows allow the computer to spend a larger proportion of time simulating valuable neutrons that have reached regions of low neutron flux." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c56069a4", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.10" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From 1772b6ed97c50dab3e8e9bb77a1c92cde1d7ac24 Mon Sep 17 00:00:00 2001 From: shimwell Date: Mon, 19 Jun 2023 22:22:36 +0100 Subject: [PATCH 4/7] removed old files --- .devcontainer/Dockerfile | 20 --------------- .devcontainer/devcontainer.json | 43 --------------------------------- 2 files changed, 63 deletions(-) delete mode 100644 .devcontainer/Dockerfile delete mode 100644 .devcontainer/devcontainer.json diff --git a/.devcontainer/Dockerfile b/.devcontainer/Dockerfile deleted file mode 100644 index 2ff7118..0000000 --- a/.devcontainer/Dockerfile +++ /dev/null @@ -1,20 +0,0 @@ - -# A vscode remote container docker image with conda from -# https://hub.docker.com/_/microsoft-vscode-devcontainers -FROM mcr.microsoft.com/vscode/devcontainers/miniconda:0-3 - -RUN conda install -c conda-forge mamba - -# specifying dagmc version so all the examples work and no mpi to reduce complexity -RUN mamba install -c conda-forge -y "openmc=0.13.0=dagmc*nompi*" - -# Jupyter lab installed to run examples -RUN mamba install -c conda-forge jupyterlab - -# downloads ENDF/B-VII.1 from https://openmc.org/official-data-libraries/ -RUN wget https://anl.box.com/shared/static/9igk353zpy8fn9ttvtrqgzvw1vtejoz6.xz - -# extracts the nuclear data -RUN tar -xf 9igk353zpy8fn9ttvtrqgzvw1vtejoz6.xz - -ENV OPENMC_CROSS_SECTIONS=/endfb71_hdf5/cross_sections.xml \ No newline at end of file diff --git a/.devcontainer/devcontainer.json b/.devcontainer/devcontainer.json deleted file mode 100644 index 6062e2e..0000000 --- a/.devcontainer/devcontainer.json +++ /dev/null @@ -1,43 +0,0 @@ - -{ - "name": "Python 3", - "build": { - "dockerfile": "Dockerfile", - "context": "..", - "args": { - "VARIANT": "3.10-bullseye", - } - }, - - // Configure tool-specific properties. - "customizations": { - // Configure properties specific to VS Code. - "vscode": { - // Set *default* container specific settings.json values on container create. - "settings": { - "python.defaultInterpreterPath": "/usr/local/bin/python", - "python.linting.enabled": true, - "python.linting.pylintEnabled": true, - "python.formatting.autopep8Path": "/usr/local/py-utils/bin/autopep8", - "python.formatting.blackPath": "/usr/local/py-utils/bin/black", - "python.formatting.yapfPath": "/usr/local/py-utils/bin/yapf", - "python.linting.banditPath": "/usr/local/py-utils/bin/bandit", - "python.linting.flake8Path": "/usr/local/py-utils/bin/flake8", - "python.linting.mypyPath": "/usr/local/py-utils/bin/mypy", - "python.linting.pycodestylePath": "/usr/local/py-utils/bin/pycodestyle", - "python.linting.pydocstylePath": "/usr/local/py-utils/bin/pydocstyle", - "python.linting.pylintPath": "/usr/local/py-utils/bin/pylint" - }, - - // Add the IDs of extensions you want installed when the container is created. - "extensions": [ - "ms-python.python", - "ms-python.vscode-pylance" - ] - } - }, - - // Allows port 8888 used for Jupyter Notebook to be available locally. - "forwardPorts": [8888], - "remoteUser": "vscode" -} From 857dd38ff2272c1fbed4eb40493d9aa5efb653f8 Mon Sep 17 00:00:00 2001 From: Jonathan Shimwell Date: Mon, 7 Aug 2023 10:13:09 +0100 Subject: [PATCH 5/7] squeeze usage correction --- shielded_room_weight_window.ipynb | 270 +++++++++++++++--------------- 1 file changed, 138 insertions(+), 132 deletions(-) diff --git a/shielded_room_weight_window.ipynb b/shielded_room_weight_window.ipynb index 1f3f9f1..a2d1e79 100644 --- a/shielded_room_weight_window.ipynb +++ b/shielded_room_weight_window.ipynb @@ -37,7 +37,7 @@ }, { "cell_type": "code", - "execution_count": 62, + "execution_count": 27, "id": "3448d1db-4328-42e3-8960-50d53896f541", "metadata": {}, "outputs": [], @@ -62,7 +62,7 @@ }, { "cell_type": "code", - "execution_count": 63, + "execution_count": 28, "id": "47cb21c7-0afa-446c-9a6b-76c8dfb2f93e", "metadata": {}, "outputs": [], @@ -100,7 +100,7 @@ }, { "cell_type": "code", - "execution_count": 64, + "execution_count": 29, "id": "a72dc5e3-cb8e-41c2-9cfb-f8f7489c7f44", "metadata": {}, "outputs": [], @@ -211,18 +211,20 @@ }, { "cell_type": "code", - "execution_count": 65, + "execution_count": 30, "id": "94c41f17", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": {}, + "metadata": { + "needs_background": "light" + }, "output_type": "display_data" } ], @@ -243,7 +245,7 @@ }, { "cell_type": "code", - "execution_count": 66, + "execution_count": 31, "id": "fd4986b0", "metadata": {}, "outputs": [], @@ -259,7 +261,7 @@ "# all (100%) of source particles are 2.5MeV energy\n", "energy = openmc.stats.Discrete([2.5e6], [1.0])\n", "\n", - "source = openmc.Source(space=space, angle=angle, energy=energy)\n", + "source = openmc.IndependentSource(space=space, angle=angle, energy=energy)\n", "source.particle = \"neutron\"\n" ] }, @@ -274,7 +276,7 @@ }, { "cell_type": "code", - "execution_count": 67, + "execution_count": 32, "id": "9d7bbee6", "metadata": {}, "outputs": [ @@ -282,7 +284,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "/home/j/openmc/openmc/mixin.py:70: IDWarning: Another Tally instance already exists with id=42.\n", + "/home/jshimwell/openmc/openmc/mixin.py:70: IDWarning: Another Tally instance already exists with id=42.\n", " warn(msg, IDWarning)\n" ] } @@ -313,7 +315,7 @@ }, { "cell_type": "code", - "execution_count": 68, + "execution_count": 33, "id": "ea32fb73", "metadata": {}, "outputs": [], @@ -339,7 +341,7 @@ }, { "cell_type": "code", - "execution_count": 69, + "execution_count": 34, "id": "6d8042a5", "metadata": {}, "outputs": [], @@ -362,7 +364,7 @@ }, { "cell_type": "code", - "execution_count": 70, + "execution_count": 35, "id": "9159a336", "metadata": {}, "outputs": [ @@ -398,25 +400,22 @@ " Copyright | 2011-2023 MIT, UChicago Argonne LLC, and contributors\n", " License | https://docs.openmc.org/en/latest/license.html\n", " Version | 0.13.4-dev\n", - " Git SHA1 | 610a5d8c3485034626ce54ce87a88eaa8071cc23\n", - " Date/Time | 2023-06-19 22:04:12\n", - " OpenMP Threads | 8\n", + " Git SHA1 | cd13d3471da30213bf68b91739994b73bb07cb90\n", + " Date/Time | 2023-08-07 10:11:14\n", + " OpenMP Threads | 28\n", "\n", " Reading settings XML file...\n", " Reading cross sections XML file...\n", " Reading materials XML file...\n", " Reading geometry XML file...\n", - " Reading N14 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/N14.h5\n", - " Reading N15 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/N15.h5\n", - " Reading O16 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/O16.h5\n", - " Reading O17 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/O17.h5\n", - " Reading O18 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/O18.h5\n", - " Reading Ar36 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/Ar36.h5\n", - " Reading Ar38 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/Ar38.h5\n", - " Reading Ar40 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/Ar40.h5\n", - " Reading H1 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/H1.h5\n", - " Reading H2 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/H2.h5\n", - " Reading C12 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/C12.h5\n" + " Reading N14 from /home/jshimwell/ENDF-B-VIII.0-NNDC/h5_files/neutron/N14.h5\n", + " Reading N15 from /home/jshimwell/ENDF-B-VIII.0-NNDC/h5_files/neutron/N15.h5\n", + " Reading O16 from /home/jshimwell/ENDF-B-VIII.0-NNDC/h5_files/neutron/O16.h5\n", + " Reading O17 from /home/jshimwell/ENDF-B-VIII.0-NNDC/h5_files/neutron/O17.h5\n", + " Reading O18 from /home/jshimwell/ENDF-B-VIII.0-NNDC/h5_files/neutron/O18.h5\n", + " Reading Ar36 from /home/jshimwell/ENDF-B-VIII.0-NNDC/h5_files/neutron/Ar36.h5\n", + " Reading Ar38 from /home/jshimwell/ENDF-B-VIII.0-NNDC/h5_files/neutron/Ar38.h5\n", + " Reading Ar40 from /home/jshimwell/ENDF-B-VIII.0-NNDC/h5_files/neutron/Ar40.h5\n" ] }, { @@ -430,28 +429,31 @@ "name": "stdout", "output_type": "stream", "text": [ - " Reading C13 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/C13.h5\n", - " Reading Na23 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/Na23.h5\n", - " Reading Mg24 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/Mg24.h5\n", - " Reading Mg25 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/Mg25.h5\n", - " Reading Mg26 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/Mg26.h5\n", - " Reading Al27 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/Al27.h5\n", - " Reading Si28 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/Si28.h5\n", - " Reading Si29 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/Si29.h5\n", - " Reading Si30 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/Si30.h5\n", - " Reading K39 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/K39.h5\n", - " Reading K40 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/K40.h5\n", - " Reading K41 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/K41.h5\n", - " Reading Ca40 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/Ca40.h5\n", - " Reading Ca42 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/Ca42.h5\n", - " Reading Ca43 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/Ca43.h5\n", - " Reading Ca44 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/Ca44.h5\n", - " Reading Ca46 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/Ca46.h5\n", - " Reading Ca48 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/Ca48.h5\n", - " Reading Fe54 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/Fe54.h5\n", - " Reading Fe56 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/Fe56.h5\n", - " Reading Fe57 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/Fe57.h5\n", - " Reading Fe58 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/Fe58.h5\n", + " Reading H1 from /home/jshimwell/ENDF-B-VIII.0-NNDC/h5_files/neutron/H1.h5\n", + " Reading H2 from /home/jshimwell/ENDF-B-VIII.0-NNDC/h5_files/neutron/H2.h5\n", + " Reading C12 from /home/jshimwell/ENDF-B-VIII.0-NNDC/h5_files/neutron/C12.h5\n", + " Reading C13 from /home/jshimwell/ENDF-B-VIII.0-NNDC/h5_files/neutron/C13.h5\n", + " Reading Na23 from /home/jshimwell/ENDF-B-VIII.0-NNDC/h5_files/neutron/Na23.h5\n", + " Reading Mg24 from /home/jshimwell/ENDF-B-VIII.0-NNDC/h5_files/neutron/Mg24.h5\n", + " Reading Mg25 from /home/jshimwell/ENDF-B-VIII.0-NNDC/h5_files/neutron/Mg25.h5\n", + " Reading Mg26 from /home/jshimwell/ENDF-B-VIII.0-NNDC/h5_files/neutron/Mg26.h5\n", + " Reading Al27 from /home/jshimwell/ENDF-B-VIII.0-NNDC/h5_files/neutron/Al27.h5\n", + " Reading Si28 from /home/jshimwell/ENDF-B-VIII.0-NNDC/h5_files/neutron/Si28.h5\n", + " Reading Si29 from /home/jshimwell/ENDF-B-VIII.0-NNDC/h5_files/neutron/Si29.h5\n", + " Reading Si30 from /home/jshimwell/ENDF-B-VIII.0-NNDC/h5_files/neutron/Si30.h5\n", + " Reading K39 from /home/jshimwell/ENDF-B-VIII.0-NNDC/h5_files/neutron/K39.h5\n", + " Reading K40 from /home/jshimwell/ENDF-B-VIII.0-NNDC/h5_files/neutron/K40.h5\n", + " Reading K41 from /home/jshimwell/ENDF-B-VIII.0-NNDC/h5_files/neutron/K41.h5\n", + " Reading Ca40 from /home/jshimwell/ENDF-B-VIII.0-NNDC/h5_files/neutron/Ca40.h5\n", + " Reading Ca42 from /home/jshimwell/ENDF-B-VIII.0-NNDC/h5_files/neutron/Ca42.h5\n", + " Reading Ca43 from /home/jshimwell/ENDF-B-VIII.0-NNDC/h5_files/neutron/Ca43.h5\n", + " Reading Ca44 from /home/jshimwell/ENDF-B-VIII.0-NNDC/h5_files/neutron/Ca44.h5\n", + " Reading Ca46 from /home/jshimwell/ENDF-B-VIII.0-NNDC/h5_files/neutron/Ca46.h5\n", + " Reading Ca48 from /home/jshimwell/ENDF-B-VIII.0-NNDC/h5_files/neutron/Ca48.h5\n", + " Reading Fe54 from /home/jshimwell/ENDF-B-VIII.0-NNDC/h5_files/neutron/Fe54.h5\n", + " Reading Fe56 from /home/jshimwell/ENDF-B-VIII.0-NNDC/h5_files/neutron/Fe56.h5\n", + " Reading Fe57 from /home/jshimwell/ENDF-B-VIII.0-NNDC/h5_files/neutron/Fe57.h5\n", + " Reading Fe58 from /home/jshimwell/ENDF-B-VIII.0-NNDC/h5_files/neutron/Fe58.h5\n", " Minimum neutron data temperature: 0 K\n", " Maximum neutron data temperature: 1.7976931348623157e+308 K\n", " Reading tallies XML file...\n", @@ -471,22 +473,22 @@ "\n", " =======================> TIMING STATISTICS <=======================\n", "\n", - " Total time for initialization = 3.0483e+00 seconds\n", - " Reading cross sections = 3.0176e+00 seconds\n", - " Total time in simulation = 1.4873e+01 seconds\n", - " Time in transport only = 1.4810e+01 seconds\n", - " Time in active batches = 1.4873e+01 seconds\n", - " Time accumulating tallies = 1.2549e-02 seconds\n", - " Time writing statepoints = 4.9269e-02 seconds\n", - " Total time for finalization = 2.1900e-06 seconds\n", - " Total time elapsed = 1.7932e+01 seconds\n", - " Calculation Rate (active) = 13447.1 particles/second\n", + " Total time for initialization = 1.6774e+00 seconds\n", + " Reading cross sections = 1.6547e+00 seconds\n", + " Total time in simulation = 3.6922e+00 seconds\n", + " Time in transport only = 3.6782e+00 seconds\n", + " Time in active batches = 3.6922e+00 seconds\n", + " Time accumulating tallies = 2.0352e-03 seconds\n", + " Time writing statepoints = 1.1032e-02 seconds\n", + " Total time for finalization = 9.9600e-07 seconds\n", + " Total time elapsed = 5.3843e+00 seconds\n", + " Calculation Rate (active) = 54167.8 particles/second\n", "\n", " ============================> RESULTS <============================\n", "\n", " Leakage Fraction = 0.00387 +/- 0.00013\n", "\n", - "total time without weight windows 17.997257947921753s\n" + "total time without weight windows 5.441159009933472s\n" ] } ], @@ -524,7 +526,7 @@ }, { "cell_type": "code", - "execution_count": 71, + "execution_count": 36, "id": "e6f60d98", "metadata": {}, "outputs": [], @@ -537,7 +539,7 @@ " mesh_extent = mesh.bounding_box.extent['xy']\n", "\n", " # get a slice of mean values on the xy basis mid z axis\n", - " flux_mean = flux_tally.get_reshaped_data(value='mean', expand_dims=True, squeeze=True)#[:, :, 1]\n", + " flux_mean = flux_tally.get_reshaped_data(value='mean', expand_dims=True).squeeze()\n", " plt.subplot(1, 2, 1)\n", " # create a plot of the mean flux values\n", " plt.imshow(\n", @@ -551,7 +553,7 @@ "\n", " plt.subplot(1, 2, 2)\n", " # get a slice of std dev values on the xy basis mid z axis\n", - " flux_std_dev = flux_tally.get_reshaped_data(value='std_dev', expand_dims=True, squeeze=True)# .squeeze()[:, :, 1]\n", + " flux_std_dev = flux_tally.get_reshaped_data(value='std_dev', expand_dims=True).squeeze()\n", " # create a plot of the flux relative error\n", " plt.imshow(\n", " flux_std_dev.T,\n", @@ -575,18 +577,20 @@ }, { "cell_type": "code", - "execution_count": 72, + "execution_count": 37, "id": "8fb8f31e", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": {}, + "metadata": { + "needs_background": "light" + }, "output_type": "display_data" } ], @@ -605,7 +609,7 @@ }, { "cell_type": "code", - "execution_count": 73, + "execution_count": 38, "id": "d519ac33", "metadata": {}, "outputs": [ @@ -641,25 +645,22 @@ " Copyright | 2011-2023 MIT, UChicago Argonne LLC, and contributors\n", " License | https://docs.openmc.org/en/latest/license.html\n", " Version | 0.13.4-dev\n", - " Git SHA1 | 610a5d8c3485034626ce54ce87a88eaa8071cc23\n", - " Date/Time | 2023-06-19 22:04:31\n", - " OpenMP Threads | 8\n", + " Git SHA1 | cd13d3471da30213bf68b91739994b73bb07cb90\n", + " Date/Time | 2023-08-07 10:11:20\n", + " OpenMP Threads | 28\n", "\n", " Reading settings XML file...\n", " Reading cross sections XML file...\n", " Reading materials XML file...\n", " Reading geometry XML file...\n", - " Reading N14 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/N14.h5\n", - " Reading N15 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/N15.h5\n", - " Reading O16 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/O16.h5\n", - " Reading O17 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/O17.h5\n", - " Reading O18 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/O18.h5\n", - " Reading Ar36 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/Ar36.h5\n", - " Reading Ar38 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/Ar38.h5\n", - " Reading Ar40 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/Ar40.h5\n", - " Reading H1 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/H1.h5\n", - " Reading H2 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/H2.h5\n", - " Reading C12 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/C12.h5\n" + " Reading N14 from /home/jshimwell/ENDF-B-VIII.0-NNDC/h5_files/neutron/N14.h5\n", + " Reading N15 from /home/jshimwell/ENDF-B-VIII.0-NNDC/h5_files/neutron/N15.h5\n", + " Reading O16 from /home/jshimwell/ENDF-B-VIII.0-NNDC/h5_files/neutron/O16.h5\n", + " Reading O17 from /home/jshimwell/ENDF-B-VIII.0-NNDC/h5_files/neutron/O17.h5\n", + " Reading O18 from /home/jshimwell/ENDF-B-VIII.0-NNDC/h5_files/neutron/O18.h5\n", + " Reading Ar36 from /home/jshimwell/ENDF-B-VIII.0-NNDC/h5_files/neutron/Ar36.h5\n", + " Reading Ar38 from /home/jshimwell/ENDF-B-VIII.0-NNDC/h5_files/neutron/Ar38.h5\n", + " Reading Ar40 from /home/jshimwell/ENDF-B-VIII.0-NNDC/h5_files/neutron/Ar40.h5\n" ] }, { @@ -673,28 +674,31 @@ "name": "stdout", "output_type": "stream", "text": [ - " Reading C13 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/C13.h5\n", - " Reading Na23 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/Na23.h5\n", - " Reading Mg24 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/Mg24.h5\n", - " Reading Mg25 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/Mg25.h5\n", - " Reading Mg26 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/Mg26.h5\n", - " Reading Al27 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/Al27.h5\n", - " Reading Si28 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/Si28.h5\n", - " Reading Si29 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/Si29.h5\n", - " Reading Si30 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/Si30.h5\n", - " Reading K39 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/K39.h5\n", - " Reading K40 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/K40.h5\n", - " Reading K41 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/K41.h5\n", - " Reading Ca40 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/Ca40.h5\n", - " Reading Ca42 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/Ca42.h5\n", - " Reading Ca43 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/Ca43.h5\n", - " Reading Ca44 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/Ca44.h5\n", - " Reading Ca46 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/Ca46.h5\n", - " Reading Ca48 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/Ca48.h5\n", - " Reading Fe54 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/Fe54.h5\n", - " Reading Fe56 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/Fe56.h5\n", - " Reading Fe57 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/Fe57.h5\n", - " Reading Fe58 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/Fe58.h5\n", + " Reading H1 from /home/jshimwell/ENDF-B-VIII.0-NNDC/h5_files/neutron/H1.h5\n", + " Reading H2 from /home/jshimwell/ENDF-B-VIII.0-NNDC/h5_files/neutron/H2.h5\n", + " Reading C12 from /home/jshimwell/ENDF-B-VIII.0-NNDC/h5_files/neutron/C12.h5\n", + " Reading C13 from /home/jshimwell/ENDF-B-VIII.0-NNDC/h5_files/neutron/C13.h5\n", + " Reading Na23 from /home/jshimwell/ENDF-B-VIII.0-NNDC/h5_files/neutron/Na23.h5\n", + " Reading Mg24 from /home/jshimwell/ENDF-B-VIII.0-NNDC/h5_files/neutron/Mg24.h5\n", + " Reading Mg25 from /home/jshimwell/ENDF-B-VIII.0-NNDC/h5_files/neutron/Mg25.h5\n", + " Reading Mg26 from /home/jshimwell/ENDF-B-VIII.0-NNDC/h5_files/neutron/Mg26.h5\n", + " Reading Al27 from /home/jshimwell/ENDF-B-VIII.0-NNDC/h5_files/neutron/Al27.h5\n", + " Reading Si28 from /home/jshimwell/ENDF-B-VIII.0-NNDC/h5_files/neutron/Si28.h5\n", + " Reading Si29 from /home/jshimwell/ENDF-B-VIII.0-NNDC/h5_files/neutron/Si29.h5\n", + " Reading Si30 from /home/jshimwell/ENDF-B-VIII.0-NNDC/h5_files/neutron/Si30.h5\n", + " Reading K39 from /home/jshimwell/ENDF-B-VIII.0-NNDC/h5_files/neutron/K39.h5\n", + " Reading K40 from /home/jshimwell/ENDF-B-VIII.0-NNDC/h5_files/neutron/K40.h5\n", + " Reading K41 from /home/jshimwell/ENDF-B-VIII.0-NNDC/h5_files/neutron/K41.h5\n", + " Reading Ca40 from /home/jshimwell/ENDF-B-VIII.0-NNDC/h5_files/neutron/Ca40.h5\n", + " Reading Ca42 from /home/jshimwell/ENDF-B-VIII.0-NNDC/h5_files/neutron/Ca42.h5\n", + " Reading Ca43 from /home/jshimwell/ENDF-B-VIII.0-NNDC/h5_files/neutron/Ca43.h5\n", + " Reading Ca44 from /home/jshimwell/ENDF-B-VIII.0-NNDC/h5_files/neutron/Ca44.h5\n", + " Reading Ca46 from /home/jshimwell/ENDF-B-VIII.0-NNDC/h5_files/neutron/Ca46.h5\n", + " Reading Ca48 from /home/jshimwell/ENDF-B-VIII.0-NNDC/h5_files/neutron/Ca48.h5\n", + " Reading Fe54 from /home/jshimwell/ENDF-B-VIII.0-NNDC/h5_files/neutron/Fe54.h5\n", + " Reading Fe56 from /home/jshimwell/ENDF-B-VIII.0-NNDC/h5_files/neutron/Fe56.h5\n", + " Reading Fe57 from /home/jshimwell/ENDF-B-VIII.0-NNDC/h5_files/neutron/Fe57.h5\n", + " Reading Fe58 from /home/jshimwell/ENDF-B-VIII.0-NNDC/h5_files/neutron/Fe58.h5\n", " Minimum neutron data temperature: 0 K\n", " Maximum neutron data temperature: 1.7976931348623157e+308 K\n", " Reading tallies XML file...\n", @@ -714,16 +718,16 @@ "\n", " =======================> TIMING STATISTICS <=======================\n", "\n", - " Total time for initialization = 2.9465e+00 seconds\n", - " Reading cross sections = 2.9232e+00 seconds\n", - " Total time in simulation = 2.5516e+00 seconds\n", - " Time in transport only = 2.4817e+00 seconds\n", - " Time in active batches = 2.5516e+00 seconds\n", - " Time accumulating tallies = 3.1487e-02 seconds\n", - " Time writing statepoints = 3.4734e-02 seconds\n", - " Total time for finalization = 1.9120e-06 seconds\n", - " Total time elapsed = 5.5113e+00 seconds\n", - " Calculation Rate (active) = 11757.3 particles/second\n", + " Total time for initialization = 1.7459e+00 seconds\n", + " Reading cross sections = 1.7213e+00 seconds\n", + " Total time in simulation = 6.6299e-01 seconds\n", + " Time in transport only = 6.4699e-01 seconds\n", + " Time in active batches = 6.6299e-01 seconds\n", + " Time accumulating tallies = 4.1188e-03 seconds\n", + " Time writing statepoints = 1.0360e-02 seconds\n", + " Total time for finalization = 1.1060e-06 seconds\n", + " Total time elapsed = 2.4252e+00 seconds\n", + " Calculation Rate (active) = 45249.9 particles/second\n", "\n", " ============================> RESULTS <============================\n", "\n", @@ -742,22 +746,22 @@ "\n", " =======================> TIMING STATISTICS <=======================\n", "\n", - " Total time for initialization = 2.9465e+00 seconds\n", - " Reading cross sections = 2.9232e+00 seconds\n", - " Total time in simulation = 2.1431e+01 seconds\n", - " Time in transport only = 2.1295e+01 seconds\n", - " Time in active batches = 2.1431e+01 seconds\n", - " Time accumulating tallies = 6.8074e-02 seconds\n", - " Time writing statepoints = 6.3614e-02 seconds\n", - " Total time for finalization = 4.2290e-06 seconds\n", - " Total time elapsed = 2.4399e+01 seconds\n", - " Calculation Rate (active) = 69.9934 particles/second\n", + " Total time for initialization = 1.7459e+00 seconds\n", + " Reading cross sections = 1.7213e+00 seconds\n", + " Total time in simulation = 4.6058e+00 seconds\n", + " Time in transport only = 4.5387e+00 seconds\n", + " Time in active batches = 4.6058e+00 seconds\n", + " Time accumulating tallies = 4.4872e-02 seconds\n", + " Time writing statepoints = 2.0340e-02 seconds\n", + " Total time for finalization = 1.9870e-06 seconds\n", + " Total time elapsed = 6.3840e+00 seconds\n", + " Calculation Rate (active) = 325.674 particles/second\n", "\n", " ============================> RESULTS <============================\n", "\n", - " Leakage Fraction = 0.00400 +/- 0.00043\n", + " Leakage Fraction = 0.00402 +/- 0.00056\n", "\n", - "total time without weight windows 24.757001638412476s\n" + "total time without weight windows 6.514809846878052s\n" ] } ], @@ -812,18 +816,20 @@ }, { "cell_type": "code", - "execution_count": 74, + "execution_count": 39, "id": "fbf35ffc", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": {}, + "metadata": { + "needs_background": "light" + }, "output_type": "display_data" } ], @@ -867,7 +873,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.10" + "version": "3.8.13" } }, "nbformat": 4, From 743065e34758911128e65b2500bbf67e6601af90 Mon Sep 17 00:00:00 2001 From: Patrick Shriwise Date: Wed, 10 Jul 2024 22:30:50 -0500 Subject: [PATCH 6/7] CI trigger commit From ef6a4cd1e24eb05fb48c6110e915b3fd6ebba868 Mon Sep 17 00:00:00 2001 From: Patrick Shriwise Date: Wed, 10 Jul 2024 22:32:19 -0500 Subject: [PATCH 7/7] Adding develop branch to CI --- .github/workflows/ci.yml | 2 ++ 1 file changed, 2 insertions(+) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 7cf5394..e043171 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -7,10 +7,12 @@ on: pull_request: branches: - main + - develop # Run every time a new commit is pushed push: branches: - main + - develop # Run every week on Sunday at midnight schedule: - cron: "0 0 * * 1"