From 8b993633b5925a8b1b4cbf186dcf53a759db4a43 Mon Sep 17 00:00:00 2001 From: Jonathan Shimwell Date: Mon, 17 Apr 2023 16:59:27 +0100 Subject: [PATCH 01/24] [skip ci] started cpp example --- .../spherical_mesh_weight_windows_cpp.py | 181 ++++++++++++++++++ 1 file changed, 181 insertions(+) create mode 100644 tasks/task_13_variance_reduction/spherical_mesh_weight_windows_cpp.py diff --git a/tasks/task_13_variance_reduction/spherical_mesh_weight_windows_cpp.py b/tasks/task_13_variance_reduction/spherical_mesh_weight_windows_cpp.py new file mode 100644 index 00000000..b478de28 --- /dev/null +++ b/tasks/task_13_variance_reduction/spherical_mesh_weight_windows_cpp.py @@ -0,0 +1,181 @@ +# This example has a sphere of concrete showing how to increase the depth of +# neutron transport through the concrete. +# First a simulation with no weight windows is shown +# Weight windows are found from the flux values obtained with the first simulation +# Secondly a simulation with weight windows is performed to find new flux values deeper into the concrete sphere +# Another set of weight windows is made from the second flux simulation +# The weight window value as a function of depth is plotted to show how these improve with each simulation iteration + +import openmc +import numpy as np +import matplotlib.pyplot as plt + + +# materials +mat_concrete = openmc.Material() +mat_concrete.add_element("H",0.168759) +mat_concrete.add_element("C",0.001416) +mat_concrete.add_element("O",0.562524) +mat_concrete.add_element("Na",0.011838) +mat_concrete.add_element("Mg",0.0014) +mat_concrete.add_element("Al",0.021354) +mat_concrete.add_element("Si",0.204115) +mat_concrete.add_element("K",0.005656) +mat_concrete.add_element("Ca",0.018674) +mat_concrete.add_element("Fe",0.00426) +mat_concrete.set_density("g/cm3", 2.3) + +my_materials = openmc.Materials([mat_concrete]) + +# surfaces +outer_surface = openmc.Sphere(r=500, boundary_type="vacuum") + +# regions +region_1 = -outer_surface + +# cells +cell_1 = openmc.Cell(region=region_1) +cell_1.fill = mat_concrete + +# settings +my_settings = openmc.Settings() + +my_geometry = openmc.Geometry([cell_1]) + +source = openmc.Source() +source.space = openmc.stats.Point((0.0, 0.0, 0.0)) +source.angle = openmc.stats.Isotropic() +source.energy = openmc.stats.Discrete([14e6], [1.0]) +source.particle = "neutron" + +my_settings = openmc.Settings() +my_settings.run_mode = "fixed source" +my_settings.source = source +my_settings.particles = 10000 +my_settings.batches = 10 + +# tally +mesh = openmc.SphericalMesh() +mesh.r_grid = np.linspace(0, outer_surface.r, 100) + +mesh_filter = openmc.MeshFilter(mesh) + +flux_tally = openmc.Tally(name="flux tally") +flux_tally.filters = [mesh_filter] +flux_tally.scores = ["flux"] + +# adds the mesh tally to the model +my_tallies = openmc.Tallies() +my_tallies.append(flux_tally) + +# model +model = openmc.model.Model(my_geometry, my_materials, my_settings, my_tallies) +output_file = model.run(cwd="no_ww") + + + + +import openmc.lib + +model.export_to_xml() + +with openmc.lib.run_in_memory(): + + openmc.lib.reset() # clears tallies + + tally = openmc.lib.tallies[1] + wws = openmc.lib.WeightWindows.from_tally(tally) + + openmc.lib.run() + + wws.update_magic(tally) # tally now has meaning information + openmc.lib.settings.weight_windows_on = True + + # second run + openmc.lib.run() + +# # plot flux against distance +# plt.plot( +# mesh.r_grid[1:], flux_tally.mean.flatten(), label="flux tally no ww", color="red" +# ) +# plt.legend() +# plt.yscale("log") +# plt.xlabel("Radius [cm]") +# plt.ylabel("Flux") +# plt.show() + + +# # plot weight window against distance +# plt.plot( +# mesh.r_grid[1:], +# weight_windows.lower_ww_bounds.flatten(), +# label="lower ww bounds", +# color="red", +# ) +# plt.plot( +# mesh.r_grid[1:], +# weight_windows.upper_ww_bounds.flatten(), +# label="lower up bounds", +# color="lightcoral", +# ) +# plt.legend() +# plt.xlabel("Radius [cm]") +# plt.ylabel("weight window bound value") +# plt.show() + +# model.settings.weight_windows = weight_windows +# # model update by assigning the weight windows found. + +# output_file = model.run(cwd="initial_ww") + +# with openmc.StatePoint(output_file) as sp: +# flux_tally_with_ww = sp.get_tally(id=flux_tally.id) +# # weight windows from flux +# weight_windows_2 = sp.generate_wws(tally=flux_tally_with_ww, rel_err_tol=0.7)[0] + + +# # plot flux with and with out weight windows against distance +# plt.plot( +# mesh.r_grid[1:], flux_tally.mean.flatten(), label="flux tally no ww", color="red" +# ) +# plt.plot( +# mesh.r_grid[1:], +# flux_tally_with_ww.mean.flatten(), +# label="flux tally with ww", +# color="blue", +# ) +# plt.legend() +# plt.yscale("log") +# plt.xlabel("Radius [cm]") +# plt.ylabel("Flux") +# plt.show() + +# # plot weight window against distance for the firstand second set of weight windows made +# plt.plot( +# mesh.r_grid[1:], +# weight_windows.lower_ww_bounds.flatten(), +# label="lower ww bounds", +# color="red", +# ) +# plt.plot( +# mesh.r_grid[1:], +# weight_windows.upper_ww_bounds.flatten(), +# label="lower up bounds", +# color="lightcoral", +# ) +# plt.plot( +# mesh.r_grid[1:], +# weight_windows_2.lower_ww_bounds.flatten(), +# label="lower ww bounds iteration 2", +# color="blue", +# ) +# plt.plot( +# mesh.r_grid[1:], +# weight_windows_2.upper_ww_bounds.flatten(), +# label="lower up bounds iteration 2", +# color="cornflowerblue", +# ) +# plt.legend() +# plt.xlabel("Radius [cm]") +# plt.ylabel("weight window bound value") +# plt.show() From 2cf9aa97599a97bd869431f76956353f3d994b8c Mon Sep 17 00:00:00 2001 From: Jonathan Shimwell Date: Mon, 5 Jun 2023 12:09:22 +0100 Subject: [PATCH 02/24] removed_unused_line --- .../1_example_transmutation_isotope_build_up.ipynb | 2 -- 1 file changed, 2 deletions(-) diff --git a/tasks/task_14_activation_transmutation_depletion/1_example_transmutation_isotope_build_up.ipynb b/tasks/task_14_activation_transmutation_depletion/1_example_transmutation_isotope_build_up.ipynb index a981e978..d5981775 100644 --- a/tasks/task_14_activation_transmutation_depletion/1_example_transmutation_isotope_build_up.ipynb +++ b/tasks/task_14_activation_transmutation_depletion/1_example_transmutation_isotope_build_up.ipynb @@ -60,8 +60,6 @@ "\n", "# MATERIALS\n", "\n", - "mats = openmc.Materials()\n", - "\n", "# makes a simple material from Silver\n", "my_material = openmc.Material() \n", "my_material.add_element('Ag', 1, percent_type='ao')\n", From afce024be6cefc715fcac62694a322b3cd2c5f80 Mon Sep 17 00:00:00 2001 From: shimwell Date: Sat, 10 Jun 2023 01:11:42 +0100 Subject: [PATCH 03/24] added batch by batch version --- .../analog_vs_weight_window_shielding.py | 171 ++++++++++++ .../generate_iterative_weight_windows.ipynb | 259 ------------------ .../generate_single_ww_and_apply.ipynb | 243 +++++++++++++--- .../spherical_mesh_weight_windows_cpp.py | 181 ------------ 4 files changed, 376 insertions(+), 478 deletions(-) create mode 100644 tasks/task_13_variance_reduction/analog_vs_weight_window_shielding.py delete mode 100644 tasks/task_13_variance_reduction/generate_iterative_weight_windows.ipynb delete mode 100644 tasks/task_13_variance_reduction/spherical_mesh_weight_windows_cpp.py diff --git a/tasks/task_13_variance_reduction/analog_vs_weight_window_shielding.py b/tasks/task_13_variance_reduction/analog_vs_weight_window_shielding.py new file mode 100644 index 00000000..db9ccfa7 --- /dev/null +++ b/tasks/task_13_variance_reduction/analog_vs_weight_window_shielding.py @@ -0,0 +1,171 @@ +# This example has a sphere of concrete with a second smaller shell of concrete +# surrounding the sphere. + +# The first simulation is analog with no variance reduction / weight windows. +# This simulation shows that not many neutrons get to the shell and the +# consequently the neutron spectra on the shell cell is unresolved. Additional +# batches improve the neutron spectra but it is clear that it would take many +# batches to get a reasonable neutron spectra. +# +# The second simulation makes use of a variance reduction method called weight +# windows. The value of the weight windows is assigned using the MAGIC method. +# https://scientific-publications.ukaea.uk/papers/application-of-novel-global-variance-reduction-methods-to-fusion-radiation-transport-problems/ +# The value of the weight windows are updated with each simulated batch and as +# the simulation runs for longer the weight windows improve gradually as does +# spectra tally. + +import openmc +# Note this example makes use of OpenMC lib which provides python bindings to +# the C/C++ methods in OpenMC and allows more direct control of the Monte Carlo +# simulation. In this example we iterate through the batches and access the +# tally result each time. +# Link to openmc.lib documentation https://docs.openmc.org/en/stable/pythonapi/capi.html +import openmc.lib +import numpy as np +import matplotlib.pyplot as plt + + +# This makes concrete which is a regular shielding material +mat_concrete = openmc.Material() +mat_concrete.add_element("H",0.168759) +mat_concrete.add_element("C",0.001416) +mat_concrete.add_element("O",0.562524) +mat_concrete.add_element("Na",0.011838) +mat_concrete.add_element("Mg",0.0014) +mat_concrete.add_element("Al",0.021354) +mat_concrete.add_element("Si",0.204115) +mat_concrete.add_element("K",0.005656) +mat_concrete.add_element("Ca",0.018674) +mat_concrete.add_element("Fe",0.00426) +mat_concrete.set_density("g/cm3", 2.3) + +my_materials = openmc.Materials([mat_concrete]) + +# surfaces +surf1 = openmc.Sphere(r=170) +outer_surface = openmc.Sphere(r=200, boundary_type="vacuum") + +# regions +region_1 = -surf1 +region_2 = -outer_surface & +surf1 + +# cells +cell_1 = openmc.Cell(region=region_1) +cell_1.fill = mat_concrete +cell_2 = openmc.Cell(region=region_2) +cell_2.fill = mat_concrete + +# settings +my_settings = openmc.Settings() + +my_geometry = openmc.Geometry([cell_1, cell_2]) + +# A point source 14MeV emitting neutron +source = openmc.Source() +source.space = openmc.stats.Point((0.0, 0.0, 0.0)) +source.angle = openmc.stats.Isotropic() +source.energy = openmc.stats.Discrete([14e6], [1.0]) +source.particle = "neutron" + +my_settings = openmc.Settings() +my_settings.run_mode = "fixed source" +my_settings.source = source +my_settings.particles = 50000 +my_settings.batches = 5 +# the mesh tallies produce large tallies.out files so this output setting avoids writing the tallies.out and saves time +my_settings.output = {'tallies': False} + +my_tallies = openmc.Tallies() + +# This spherical mesh tally is used for generating the weight windows. +mesh = openmc.SphericalMesh() +mesh.r_grid = np.linspace(0, outer_surface.r, 5000) +mesh_filter = openmc.MeshFilter(mesh) +flux_tally_for_ww = openmc.Tally(name="flux tally") +flux_tally_for_ww.filters = [mesh_filter] +flux_tally_for_ww.scores = ["flux"] +flux_tally_for_ww.id = 42 +my_tallies.append(flux_tally_for_ww) + +# This spectrum tally is on the outer shell and shows then energy distribution +# of neutrons present in the cell. +energy_filter = openmc.EnergyFilter.from_group_structure('CCFE-709') +surface_filter = openmc.CellFilter(cell_2) +outer_surface_spectra_tally = openmc.Tally(name='outer_surface_spectra_tally') +outer_surface_spectra_tally.scores = ['current'] +outer_surface_spectra_tally.filters = [surface_filter, energy_filter] +outer_surface_spectra_tally.id = 12 +my_tallies.append(outer_surface_spectra_tally) + +# creates and exports the model to an xml file. When using openmc.lib this +# export is needed as we don't use the normal model.run() method. +model = openmc.model.Model(my_geometry, my_materials, my_settings, my_tallies) +model.export_to_xml() + +fig, axs = plt.subplots(my_settings.batches, 2, sharex=True, sharey=True) + +# We run the model in analog mode batch by batch. Each time we plot the spectra +# tally result. The spectra tally will gradually to get better with each batch +# as the batches combine to continually improve the result. + +# this context manager helps close openmc lib when the code indent closes +with openmc.lib.run_in_memory(): + + # gets a live pointer to the tally, this updates as the tally is accumulated + spectra_tally = openmc.lib.tallies[outer_surface_spectra_tally.id] + + # simulation_init is needed prior to iter_batches + openmc.lib.simulation_init() + + # loops through each batch getting the latest tally result and plotting it + for counter, batch in enumerate(openmc.lib.iter_batches()): + + axs[counter][0].step(energy_filter.values[:-1], spectra_tally.mean.flatten()) + axs[counter][0].set_title(f'Batch {counter+1}') + axs[counter][0].set_yscale('log') + axs[counter][0].set_xscale('log') + + openmc.lib.simulation_finalize() + + +# originally we had 2000 particles per batch +# on my computer the analog simulation ran with 12470 particles/second +# and the weight windows simulation that comes next runs with 87 particles/second +# therefore we are going to decrease the settings.particles so that both simulations +# get the same amount of compute time +model.settings.particles = int(model.settings.particles*(87/12470)) +model.export_to_xml() +with openmc.lib.run_in_memory(): + + # gets a live pointer to the mesh tally that we use to generate the + ww_tally = openmc.lib.tallies[flux_tally_for_ww.id] + # generates a weight window from the tally (which is currently empty) + wws = openmc.lib.WeightWindows.from_tally(ww_tally) + + # gets a live pointer to the spectra tally that we will plot with each batch + spectra_tally = openmc.lib.tallies[outer_surface_spectra_tally.id] + + # turn the weight windows on + openmc.lib.settings.weight_windows_on = True + + openmc.lib.simulation_init() + for counter, batch in enumerate(openmc.lib.iter_batches()): + + # updates the weight window with the latest mesh tally flux results + wws.update_magic(ww_tally) + + # plots the spectra tally for the batch + axs[counter][1].step(energy_filter.values[:-1], spectra_tally.mean.flatten()) + axs[counter][1].set_title(f'Batch {counter+1}') + axs[counter][1].set_yscale('log') + axs[counter][1].set_xscale('log') + + openmc.lib.simulation_finalize() + +# sets titles, labels and saves the plot +axs[1][0].set_title('Analog simulation') +axs[2][0].set_title('Iterative weight windows simulation') +axs[0][4].set_xlabel(f'Energy [eV]') +axs[0][4].set_xlabel(f'Energy [eV]') +plt.savefig('ww.png', bbox_inches="tight") +plt.show() diff --git a/tasks/task_13_variance_reduction/generate_iterative_weight_windows.ipynb b/tasks/task_13_variance_reduction/generate_iterative_weight_windows.ipynb deleted file mode 100644 index 461255bb..00000000 --- a/tasks/task_13_variance_reduction/generate_iterative_weight_windows.ipynb +++ /dev/null @@ -1,259 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "d4d248c5-e7cd-428f-b099-061a1328853e", - "metadata": {}, - "source": [ - "# variance reduction techniques\n", - "\n", - "## Iteratively create and utilising a wight window to accelerate the deep shielding simulations" - ] - }, - { - "cell_type": "markdown", - "id": "7b02559d-a4f3-4e6f-83f4-1aa030bf59f5", - "metadata": {}, - "source": [ - "This example implements the Magic method of weight window generation. The theory of weight windows and the method are best described by the paper here https://scientific-publications.ukaea.uk/wp-content/uploads/Published/INTERN1.pdf\n", - "\n", - "In this tutorial we shall focus on generating a weight window to accelerate the simulation of particles through a shield. Then using that weight window to generate a new weight window and repeating the process to obtain a final weight window.\n", - "\n", - "First we must make a model. This is kept as simple as possible as the focus of this notebook is on generating and then using a weight window.\n", - "\n", - "The model is a single sphere of 200 cm radius filled with water and containing a 14MeV point source in the center" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "779490fe-0dfe-4523-982a-3881eff46e80", - "metadata": {}, - "outputs": [], - "source": [ - "import openmc\n", - "import openmc_weight_window_generator\n", - "# this is a minimal package that adds some functionality to openmc, namely it adds:\n", - "# - openmc.StatePoint.generate_wws which we use in a previous task\n", - "# - openmc.Model.generate_wws_magic_method which we use in this task\n", - "\n", - "\n", - "# creates a shielding material\n", - "water = openmc.Material(name='Water')\n", - "water.set_density('g/cc', 1.0)\n", - "water.add_element('H', 2)\n", - "water.add_element('O', 1)\n", - "materials = openmc.Materials([water])\n", - "\n", - "sphere1 = openmc.Sphere(r=200, boundary_type='vacuum')\n", - "\n", - "region1 = -sphere1\n", - "\n", - "cell1 = openmc.Cell(fill=water, region=region1)\n", - "\n", - "geometry = openmc.Geometry([cell1])\n", - "\n", - "source = openmc.Source()\n", - "source.space = openmc.stats.Point((0.0, 0.0, 0.0))\n", - "source.angle = openmc.stats.Isotropic()\n", - "source.energy = openmc.stats.Discrete([14e6], [1.0])\n", - "source.particle = 'neutron'\n", - "\n", - "my_settings = openmc.Settings()\n", - "my_settings.run_mode = 'fixed source'\n", - "my_settings.source = source\n", - "my_settings.particles = 10000\n", - "my_settings.batches = 10\n", - "# the mesh tallies produce large tallies.out files so this output setting avoids writing the tallies.out and saves time\n", - "my_settings.output = {'tallies': False}\n", - "\n", - "model = openmc.Model(geometry, materials, my_settings)" - ] - }, - { - "cell_type": "markdown", - "id": "980c9abe-cb26-4bf8-998d-08bc46b0cac7", - "metadata": {}, - "source": [ - "Now we can plot the simple geometry" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "da6728e8-a947-4dee-8e20-04a980019d33", - "metadata": {}, - "outputs": [], - "source": [ - "import matplotlib.pyplot as plt\n", - "plt.figure(figsize=(10,10))\n", - "model.geometry.root_universe.plot(width=(400, 400), pixels=(600, 600))\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "c3a3547e-f9d7-4b53-806b-0c84648e4df6", - "metadata": {}, - "source": [ - "Now we shall add a regular mesh tally over the the geometry.\n", - "\n", - "The mesh will be used to record the neutron flux in each mesh voxel" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "44dba5ef-ec9c-4280-8fc1-b9191b5c62ea", - "metadata": {}, - "outputs": [], - "source": [ - "mesh = openmc.RegularMesh()\n", - "mesh.lower_left = model.geometry.bounding_box[0]\n", - "mesh.upper_right = model.geometry.bounding_box[1]\n", - "mesh.dimension = (50, 50, 50)\n", - "\n", - "mesh_filter = openmc.MeshFilter(mesh)\n", - "\n", - "flux_tally = openmc.Tally(name='flux tally')\n", - "flux_tally.filters = [mesh_filter]\n", - "flux_tally.scores = ['flux']\n", - "\n", - "# adds the mesh tally to the model\n", - "model.tallies = [flux_tally]\n", - "\n", - "output_file = model.run()" - ] - }, - { - "cell_type": "markdown", - "id": "a2404758-0b31-442f-84c5-9e5cc2a455c3", - "metadata": {}, - "source": [ - "Now we can plot the flux and the standard deviation of the flux tally to see how far into the shield the neutrons got. " - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "a5997678-95a6-4178-99d2-b66df38cfc1c", - "metadata": {}, - "outputs": [], - "source": [ - "from matplotlib.colors import LogNorm\n", - "\n", - "with openmc.StatePoint(output_file) as sp:\n", - " flux_tally = sp.get_tally(id=flux_tally.id)\n", - "\n", - "llc, urc = model.geometry.bounding_box\n", - "\n", - "fig, (ax1, ax2) = plt.subplots(1,2)\n", - "fig.suptitle('Flux and std. dev. without weight window')\n", - "\n", - "slice_index = int(mesh.dimension[-1]/2)\n", - "\n", - "# create a plot of the mean values\n", - "flux_mean = flux_tally.mean.reshape(*mesh.dimension)\n", - "img1 = ax1.imshow(flux_mean[slice_index], origin='lower', extent=(llc[0], urc[0], llc[1], urc[1]), norm=LogNorm())\n", - "ax1.set_title('Flux Mean')\n", - "plt.colorbar(img1, ax=ax1, fraction=0.046)\n", - "img1.set_clim(vmin=1e-30, vmax=1.0)\n", - "\n", - "# create a plot of the flux relative error\n", - "flux_rel_err = flux_tally.get_values(value='rel_err').reshape(*mesh.dimension)\n", - "img2 = ax2.imshow(flux_rel_err[slice_index], origin='lower', extent=(llc[0], urc[0], llc[1], urc[1]))\n", - "ax2.set_title('Flux Rel. Err.')\n", - "plt.colorbar(img2, ax=ax2, fraction=0.046)\n", - "# ax2.set_colorbar(img2, ax=ax2)\n", - "img2.set_clim(vmin=0.0, vmax=1.0)\n", - "\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "e8bc03db-f38b-4c85-ae11-f222f4fe80c7", - "metadata": {}, - "source": [ - "Now we shall run the simulation several times, with each iteration we shall use the flux tally to produce a weight window. Then the weight window will be used in the subsequent simulation." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "5194f55d-ab70-44d5-a7c7-5dbb3f6efa8f", - "metadata": {}, - "outputs": [], - "source": [ - "# change this to 5 iterations and 50000 max splits to see a nice improvement in weight windows", - "model.generate_wws_magic_method(tally=flux_tally, iterations=3, max_split=300)" - ] - }, - { - "cell_type": "markdown", - "id": "76c22db3-6959-4ea7-b819-3ba49ac19eab", - "metadata": {}, - "source": [ - "Now we can plot the flux and the standard deviation of the flux tally to see how far into the shield the neutrons got. " - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "6b81b0c7-6313-43fc-895c-55494870508d", - "metadata": {}, - "outputs": [], - "source": [ - "from matplotlib.colors import LogNorm\n", - "\n", - "with openmc.StatePoint(output_file) as sp:\n", - " flux_tally = sp.get_tally(id=flux_tally.id)\n", - "\n", - "llc, urc = model.geometry.bounding_box\n", - "\n", - "fig, (ax1, ax2) = plt.subplots(1,2)\n", - "fig.suptitle('Flux and std. dev. without weight window')\n", - "\n", - "slice_index = int(mesh.dimension[-1]/2)\n", - "\n", - "# create a plot of the mean values\n", - "flux_mean = flux_tally.mean.reshape(*mesh.dimension)\n", - "img1 = ax1.imshow(flux_mean[slice_index], origin='lower', extent=(llc[0], urc[0], llc[1], urc[1]), norm=LogNorm())\n", - "ax1.set_title('Flux Mean')\n", - "plt.colorbar(img1, ax=ax1, fraction=0.046)\n", - "img1.set_clim(vmin=1e-30, vmax=1.0)\n", - "\n", - "# create a plot of the flux relative error\n", - "flux_rel_err = flux_tally.get_values(value='rel_err').reshape(*mesh.dimension)\n", - "img2 = ax2.imshow(flux_rel_err[slice_index], origin='lower', extent=(llc[0], urc[0], llc[1], urc[1]))\n", - "ax2.set_title('Flux Rel. Err.')\n", - "plt.colorbar(img2, ax=ax2, fraction=0.046)\n", - "# ax2.set_colorbar(img2, ax=ax2)\n", - "img2.set_clim(vmin=0.0, vmax=1.0)\n", - "\n", - "plt.show()" - ] - } - ], - "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.8.13" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/tasks/task_13_variance_reduction/generate_single_ww_and_apply.ipynb b/tasks/task_13_variance_reduction/generate_single_ww_and_apply.ipynb index f2b0c24a..798d433a 100644 --- a/tasks/task_13_variance_reduction/generate_single_ww_and_apply.ipynb +++ b/tasks/task_13_variance_reduction/generate_single_ww_and_apply.ipynb @@ -1,6 +1,7 @@ { "cells": [ { + "attachments": {}, "cell_type": "markdown", "id": "72e0b25d-e541-4e8d-8805-b984374ee53d", "metadata": {}, @@ -11,6 +12,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "id": "f00eddb1-1e3a-4973-ba0c-d8feeb2a6704", "metadata": {}, @@ -26,7 +28,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "id": "3448d1db-4328-42e3-8960-50d53896f541", "metadata": {}, "outputs": [], @@ -66,6 +68,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "id": "8179e89a-304b-4684-91a9-8a908b75e8cd", "metadata": {}, @@ -75,10 +78,30 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "id": "47cb21c7-0afa-446c-9a6b-76c8dfb2f93e", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "import matplotlib.pyplot as plt\n", "plt.figure(figsize=(10,10))\n", @@ -87,6 +110,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "id": "424b234c-48a2-4d1b-b374-f69430e464db", "metadata": {}, @@ -98,7 +122,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "id": "a72dc5e3-cb8e-41c2-9cfb-f8f7489c7f44", "metadata": {}, "outputs": [], @@ -110,15 +134,55 @@ "\n", "mesh_filter = openmc.MeshFilter(mesh)\n", "\n", - "flux_tally = openmc.Tally(name='flux tally')\n", - "flux_tally.filters = [mesh_filter]\n", - "flux_tally.scores = ['flux']\n", + "flux_tally_for_ww = openmc.Tally(name='flux tally')\n", + "flux_tally_for_ww.filters = [mesh_filter]\n", + "flux_tally_for_ww.scores = ['flux']\n", "\n", "# adds the mesh tally to the model\n", - "model.tallies = [flux_tally]" + "model.tallies = [flux_tally_for_ww]" ] }, { + "attachments": {}, + "cell_type": "markdown", + "id": "026db00f", + "metadata": {}, + "source": [ + "Now we shall run the simulation in analog mode" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "35f3c771", + "metadata": {}, + "outputs": [], + "source": [ + "output_file = model.run()\n" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "0918a61e", + "metadata": {}, + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7ff1e1b1", + "metadata": {}, + "outputs": [], + "source": [ + "with openmc.StatePoint(output_file) as sp:\n", + " flux_tally_result = sp.get_tally(id=flux_tally_for_ww.id)\n", + "plt.imshow(flux_tally.mean)\n", + "plt.show()" + ] + }, + { + "attachments": {}, "cell_type": "markdown", "id": "458867ab-5b7b-400a-bbf4-c290988a99da", "metadata": {}, @@ -128,15 +192,135 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "id": "1c5b84c7-0fe5-48d5-b2b7-58ce8cea57f1", "metadata": {}, - "outputs": [], + "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-10 00:56:18\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 /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 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", + " Minimum neutron data temperature: 294 K\n", + " Maximum neutron data temperature: 294 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 H1\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", + " Simulating batch 6\n", + " Simulating batch 7\n", + " Simulating batch 8\n", + " Simulating batch 9\n", + " Simulating batch 10\n", + " Creating state point statepoint.10.h5...\n", + "\n", + " =======================> TIMING STATISTICS <=======================\n", + "\n", + " Total time for initialization = 1.1600e-01 seconds\n", + " Reading cross sections = 1.0267e-01 seconds\n", + " Total time in simulation = 2.9703e+00 seconds\n", + " Time in transport only = 2.9462e+00 seconds\n", + " Time in active batches = 2.9703e+00 seconds\n", + " Time accumulating tallies = 8.5787e-03 seconds\n", + " Time writing statepoints = 1.3355e-02 seconds\n", + " Total time for finalization = 1.4820e-06 seconds\n", + " Total time elapsed = 3.0892e+00 seconds\n", + " Calculation Rate (active) = 33666.2 particles/second\n", + "\n", + " ============================> RESULTS <============================\n", + "\n", + " Leakage Fraction = 0.00000 +/- 0.00000\n", + "\n", + " Maximum neutron transport energy: 20000000 eV for H1\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" + ] + } + ], "source": [ - "output_file = model.run()" + "model.export_to_xml()\n", + "import openmc.lib\n", + "\n", + "openmc.lib.init()\n", + "\n", + "# gets a live pointer to the mesh tally that we use to generate the \n", + "ww_tally = openmc.lib.tallies[flux_tally_for_ww.id]\n", + "# generates a weight window from the tally (which is currently empty)\n", + "wws = openmc.lib.WeightWindows.from_tally(ww_tally)\n", + "\n", + "# runs the simulation\n", + "openmc.lib.run()\n", + "\n", + "# turn the weight windows on\n", + "openmc.lib.settings.weight_windows_on = True\n", + "\n", + "# updates the weight window with the latest mesh tally flux results \n", + "# As this flux map tells us where the neutrons go we can use it to create a wight window that promotes neutron transport in areas they normally don't reach.\n", + "wws.update_magic(ww_tally)\n", + "\n", + "# runs the simulation\n", + "openmc.lib.run()\n", + "\n", + "openmc.lib.simulation_finalize()" ] }, { + "attachments": {}, "cell_type": "markdown", "id": "e54d695d-1f35-477c-8506-fcbca57b179a", "metadata": {}, @@ -153,13 +337,9 @@ "source": [ "from matplotlib.colors import LogNorm\n", "\n", - "with openmc.StatePoint(output_file) as sp:\n", - " flux_tally = sp.get_tally(id=flux_tally.id)\n", - "\n", - "llc, urc = model.geometry.bounding_box\n", + "with openmc.StatePoint(f'statepoint.{my_settings.batches}.h5') as sp:\n", + " flux_tally_result = sp.get_tally(id=flux_tally_for_ww.id)\n", "\n", - "fig, (ax1, ax2) = plt.subplots(1,2)\n", - "fig.suptitle('Flux and std. dev. without weight window')\n", "\n", "slice_index = int(mesh.dimension[-1]/2)\n", "\n", @@ -182,31 +362,14 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "id": "f0b0c196-0829-4b36-abec-8fec944c8f2b", "metadata": {}, - "source": [ - "As this flux map tells us where the neutrons go we can use it to create a wieght window that promotes neutron transport in areas they normally don't reach." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "03cc2b9f-5421-41d3-9f0d-4d43cf82977f", - "metadata": {}, - "outputs": [], - "source": [ - "import openmc_weight_window_generator\n", - "# this is a minimal package that adds some functionality to openmc, namely it adds:\n", - "# - openmc.StatePoint.generate_wws which we use in this task\n", - "# - openmc.Model.generate_wws_magic_method which we use in the next task\n", - "\n", - "sp_file = openmc.StatePoint(output_file)\n", - "# this generates an openmc.WeightWindow object from the flux tally\n", - "weight_windows = sp_file.generate_wws(tally=flux_tally, rel_err_tol=0.7)" - ] + "source": [] }, { + "attachments": {}, "cell_type": "markdown", "id": "cfb6e00c-aada-4951-9cdf-022477defa6c", "metadata": {}, @@ -229,6 +392,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "id": "02af110d-9ea2-4782-a355-bbd6822cc394", "metadata": {}, @@ -254,6 +418,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "id": "4eee750a-8913-4dcc-a528-fcea1b74a854", "metadata": {}, @@ -294,6 +459,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "id": "2285d40b-2e8e-4f52-ac14-c742599cf08f", "metadata": {}, @@ -304,6 +470,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "id": "4e9a1ae6-7ab7-4bdb-be1a-39fa6a8ca4c2", "metadata": {}, @@ -339,7 +506,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.13" + "version": "3.10.10" } }, "nbformat": 4, diff --git a/tasks/task_13_variance_reduction/spherical_mesh_weight_windows_cpp.py b/tasks/task_13_variance_reduction/spherical_mesh_weight_windows_cpp.py deleted file mode 100644 index b478de28..00000000 --- a/tasks/task_13_variance_reduction/spherical_mesh_weight_windows_cpp.py +++ /dev/null @@ -1,181 +0,0 @@ -# This example has a sphere of concrete showing how to increase the depth of -# neutron transport through the concrete. -# First a simulation with no weight windows is shown -# Weight windows are found from the flux values obtained with the first simulation -# Secondly a simulation with weight windows is performed to find new flux values deeper into the concrete sphere -# Another set of weight windows is made from the second flux simulation -# The weight window value as a function of depth is plotted to show how these improve with each simulation iteration - -import openmc -import numpy as np -import matplotlib.pyplot as plt - - -# materials -mat_concrete = openmc.Material() -mat_concrete.add_element("H",0.168759) -mat_concrete.add_element("C",0.001416) -mat_concrete.add_element("O",0.562524) -mat_concrete.add_element("Na",0.011838) -mat_concrete.add_element("Mg",0.0014) -mat_concrete.add_element("Al",0.021354) -mat_concrete.add_element("Si",0.204115) -mat_concrete.add_element("K",0.005656) -mat_concrete.add_element("Ca",0.018674) -mat_concrete.add_element("Fe",0.00426) -mat_concrete.set_density("g/cm3", 2.3) - -my_materials = openmc.Materials([mat_concrete]) - -# surfaces -outer_surface = openmc.Sphere(r=500, boundary_type="vacuum") - -# regions -region_1 = -outer_surface - -# cells -cell_1 = openmc.Cell(region=region_1) -cell_1.fill = mat_concrete - -# settings -my_settings = openmc.Settings() - -my_geometry = openmc.Geometry([cell_1]) - -source = openmc.Source() -source.space = openmc.stats.Point((0.0, 0.0, 0.0)) -source.angle = openmc.stats.Isotropic() -source.energy = openmc.stats.Discrete([14e6], [1.0]) -source.particle = "neutron" - -my_settings = openmc.Settings() -my_settings.run_mode = "fixed source" -my_settings.source = source -my_settings.particles = 10000 -my_settings.batches = 10 - -# tally -mesh = openmc.SphericalMesh() -mesh.r_grid = np.linspace(0, outer_surface.r, 100) - -mesh_filter = openmc.MeshFilter(mesh) - -flux_tally = openmc.Tally(name="flux tally") -flux_tally.filters = [mesh_filter] -flux_tally.scores = ["flux"] - -# adds the mesh tally to the model -my_tallies = openmc.Tallies() -my_tallies.append(flux_tally) - -# model -model = openmc.model.Model(my_geometry, my_materials, my_settings, my_tallies) -output_file = model.run(cwd="no_ww") - - - - -import openmc.lib - -model.export_to_xml() - -with openmc.lib.run_in_memory(): - - openmc.lib.reset() # clears tallies - - tally = openmc.lib.tallies[1] - wws = openmc.lib.WeightWindows.from_tally(tally) - - openmc.lib.run() - - wws.update_magic(tally) # tally now has meaning information - openmc.lib.settings.weight_windows_on = True - - # second run - openmc.lib.run() - -# # plot flux against distance -# plt.plot( -# mesh.r_grid[1:], flux_tally.mean.flatten(), label="flux tally no ww", color="red" -# ) -# plt.legend() -# plt.yscale("log") -# plt.xlabel("Radius [cm]") -# plt.ylabel("Flux") -# plt.show() - - -# # plot weight window against distance -# plt.plot( -# mesh.r_grid[1:], -# weight_windows.lower_ww_bounds.flatten(), -# label="lower ww bounds", -# color="red", -# ) -# plt.plot( -# mesh.r_grid[1:], -# weight_windows.upper_ww_bounds.flatten(), -# label="lower up bounds", -# color="lightcoral", -# ) -# plt.legend() -# plt.xlabel("Radius [cm]") -# plt.ylabel("weight window bound value") -# plt.show() - -# model.settings.weight_windows = weight_windows -# # model update by assigning the weight windows found. - -# output_file = model.run(cwd="initial_ww") - -# with openmc.StatePoint(output_file) as sp: -# flux_tally_with_ww = sp.get_tally(id=flux_tally.id) -# # weight windows from flux -# weight_windows_2 = sp.generate_wws(tally=flux_tally_with_ww, rel_err_tol=0.7)[0] - - -# # plot flux with and with out weight windows against distance -# plt.plot( -# mesh.r_grid[1:], flux_tally.mean.flatten(), label="flux tally no ww", color="red" -# ) -# plt.plot( -# mesh.r_grid[1:], -# flux_tally_with_ww.mean.flatten(), -# label="flux tally with ww", -# color="blue", -# ) -# plt.legend() -# plt.yscale("log") -# plt.xlabel("Radius [cm]") -# plt.ylabel("Flux") -# plt.show() - -# # plot weight window against distance for the firstand second set of weight windows made -# plt.plot( -# mesh.r_grid[1:], -# weight_windows.lower_ww_bounds.flatten(), -# label="lower ww bounds", -# color="red", -# ) -# plt.plot( -# mesh.r_grid[1:], -# weight_windows.upper_ww_bounds.flatten(), -# label="lower up bounds", -# color="lightcoral", -# ) -# plt.plot( -# mesh.r_grid[1:], -# weight_windows_2.lower_ww_bounds.flatten(), -# label="lower ww bounds iteration 2", -# color="blue", -# ) -# plt.plot( -# mesh.r_grid[1:], -# weight_windows_2.upper_ww_bounds.flatten(), -# label="lower up bounds iteration 2", -# color="cornflowerblue", -# ) -# plt.legend() -# plt.xlabel("Radius [cm]") -# plt.ylabel("weight window bound value") -# plt.show() From fc8f743694ad92f20f9733a45d95758e87128e05 Mon Sep 17 00:00:00 2001 From: shimwell Date: Sat, 10 Jun 2023 22:53:23 +0100 Subject: [PATCH 04/24] 3 cpp examples starting to form --- ..._by_batch_till_tally_convergence_limit.py} | 0 .../generate_single_ww_and_apply.ipynb | 271 +++++++++++++----- ...iterative_spherical_mesh_weight_windows.py | 34 ++- .../spherical_mesh_weight_windows.py | 160 ----------- 4 files changed, 232 insertions(+), 233 deletions(-) rename tasks/task_13_variance_reduction/{analog_vs_weight_window_shielding.py => batch_by_batch_till_tally_convergence_limit.py} (100%) delete mode 100644 tasks/task_13_variance_reduction/spherical_mesh_weight_windows.py diff --git a/tasks/task_13_variance_reduction/analog_vs_weight_window_shielding.py b/tasks/task_13_variance_reduction/batch_by_batch_till_tally_convergence_limit.py similarity index 100% rename from tasks/task_13_variance_reduction/analog_vs_weight_window_shielding.py rename to tasks/task_13_variance_reduction/batch_by_batch_till_tally_convergence_limit.py diff --git a/tasks/task_13_variance_reduction/generate_single_ww_and_apply.ipynb b/tasks/task_13_variance_reduction/generate_single_ww_and_apply.ipynb index 798d433a..13c12ff9 100644 --- a/tasks/task_13_variance_reduction/generate_single_ww_and_apply.ipynb +++ b/tasks/task_13_variance_reduction/generate_single_ww_and_apply.ipynb @@ -28,7 +28,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "id": "3448d1db-4328-42e3-8960-50d53896f541", "metadata": {}, "outputs": [], @@ -78,24 +78,15 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "id": "47cb21c7-0afa-446c-9a6b-76c8dfb2f93e", "metadata": {}, "outputs": [ { "data": { + "image/png": "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", "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -104,8 +95,8 @@ ], "source": [ "import matplotlib.pyplot as plt\n", - "plt.figure(figsize=(10,10))\n", - "model.geometry.root_universe.plot(width=(400, 400), pixels=(600, 600))\n", + "\n", + "model.geometry.root_universe.plot()\n", "plt.show()" ] }, @@ -122,7 +113,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 5, "id": "a72dc5e3-cb8e-41c2-9cfb-f8f7489c7f44", "metadata": {}, "outputs": [], @@ -153,12 +144,97 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "id": "35f3c771", "metadata": {}, - "outputs": [], + "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-10 22:35:39\n", + " OpenMP Threads | 8\n", + "\n", + " Reading model XML file './model.xml' ...\n", + " WARNING: Other XML file input(s) are present. These files may be ignored in\n", + " favor of the ./model.xml file.\n", + " Reading cross sections XML file...\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 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", + " Minimum neutron data temperature: 294 K\n", + " Maximum neutron data temperature: 294 K\n", + " Preparing distributed cell instances...\n", + " Writing summary.h5 file...\n", + " Maximum neutron transport energy: 20000000 eV for H1\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", + " Simulating batch 6\n", + " Simulating batch 7\n", + " Simulating batch 8\n", + " Simulating batch 9\n", + " Simulating batch 10\n", + " Creating state point statepoint.10.h5...\n", + "\n", + " =======================> TIMING STATISTICS <=======================\n", + "\n", + " Total time for initialization = 1.0914e-01 seconds\n", + " Reading cross sections = 9.7824e-02 seconds\n", + " Total time in simulation = 2.8342e+00 seconds\n", + " Time in transport only = 2.7873e+00 seconds\n", + " Time in active batches = 2.8342e+00 seconds\n", + " Time accumulating tallies = 3.3279e-02 seconds\n", + " Time writing statepoints = 1.1546e-02 seconds\n", + " Total time for finalization = 3.3200e-07 seconds\n", + " Total time elapsed = 2.9460e+00 seconds\n", + " Calculation Rate (active) = 35283.5 particles/second\n", + "\n", + " ============================> RESULTS <============================\n", + "\n", + " Leakage Fraction = 0.00000 +/- 0.00000\n", + "\n" + ] + } + ], "source": [ - "output_file = model.run()\n" + "output_file = model.run()" ] }, { @@ -170,14 +246,35 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "id": "7ff1e1b1", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(50, 50, 50)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "with openmc.StatePoint(output_file) as sp:\n", " flux_tally_result = sp.get_tally(id=flux_tally_for_ww.id)\n", - "plt.imshow(flux_tally.mean)\n", + "flux_tally_result = flux_tally_result.get_reshaped_data(expand_dims=True).squeeze()\n", + "print(flux_tally_result.shape)\n", + "from matplotlib.colors import LogNorm\n", + "plt.imshow(flux_tally_result[:,25,:], norm=LogNorm())\n", "plt.show()" ] }, @@ -192,7 +289,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 8, "id": "1c5b84c7-0fe5-48d5-b2b7-58ce8cea57f1", "metadata": {}, "outputs": [ @@ -229,13 +326,11 @@ " License | https://docs.openmc.org/en/latest/license.html\n", " Version | 0.13.4-dev\n", " Git SHA1 | 610a5d8c3485034626ce54ce87a88eaa8071cc23\n", - " Date/Time | 2023-06-10 00:56:18\n", + " Date/Time | 2023-06-10 22:35:42\n", " OpenMP Threads | 8\n", "\n", - " Reading settings XML file...\n", + " Reading model XML file './model.xml' ...\n", " Reading cross sections XML file...\n", - " Reading materials XML file...\n", - " Reading geometry XML file...\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 O16 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/O16.h5\n", @@ -243,15 +338,27 @@ " Reading O18 from /home/j/nndc-b8.0-hdf5/endfb-viii.0-hdf5/neutron/O18.h5\n", " Minimum neutron data temperature: 294 K\n", " Maximum neutron data temperature: 294 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 H1\n", "\n", " ===============> FIXED SOURCE TRANSPORT SIMULATION <===============\n", "\n", - " Simulating batch 1\n", + " Simulating batch 1\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " WARNING: Other XML file input(s) are present. These files may be ignored in\n", + " favor of the ./model.xml file.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ " Simulating batch 2\n", " Simulating batch 3\n", " Simulating batch 4\n", @@ -265,30 +372,21 @@ "\n", " =======================> TIMING STATISTICS <=======================\n", "\n", - " Total time for initialization = 1.1600e-01 seconds\n", - " Reading cross sections = 1.0267e-01 seconds\n", - " Total time in simulation = 2.9703e+00 seconds\n", - " Time in transport only = 2.9462e+00 seconds\n", - " Time in active batches = 2.9703e+00 seconds\n", - " Time accumulating tallies = 8.5787e-03 seconds\n", - " Time writing statepoints = 1.3355e-02 seconds\n", - " Total time for finalization = 1.4820e-06 seconds\n", - " Total time elapsed = 3.0892e+00 seconds\n", - " Calculation Rate (active) = 33666.2 particles/second\n", + " Total time for initialization = 1.2083e-01 seconds\n", + " Reading cross sections = 1.0993e-01 seconds\n", + " Total time in simulation = 2.9952e+00 seconds\n", + " Time in transport only = 2.9737e+00 seconds\n", + " Time in active batches = 2.9952e+00 seconds\n", + " Time accumulating tallies = 4.5944e-03 seconds\n", + " Time writing statepoints = 1.3561e-02 seconds\n", + " Total time for finalization = 1.4840e-06 seconds\n", + " Total time elapsed = 3.1186e+00 seconds\n", + " Calculation Rate (active) = 33386.2 particles/second\n", "\n", " ============================> RESULTS <============================\n", "\n", " Leakage Fraction = 0.00000 +/- 0.00000\n", - "\n", - " Maximum neutron transport energy: 20000000 eV for H1\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" + "\n" ] } ], @@ -296,29 +394,67 @@ "model.export_to_xml()\n", "import openmc.lib\n", "\n", - "openmc.lib.init()\n", - "\n", - "# gets a live pointer to the mesh tally that we use to generate the \n", - "ww_tally = openmc.lib.tallies[flux_tally_for_ww.id]\n", - "# generates a weight window from the tally (which is currently empty)\n", - "wws = openmc.lib.WeightWindows.from_tally(ww_tally)\n", "\n", - "# runs the simulation\n", - "openmc.lib.run()\n", + "with openmc.lib.run_in_memory():\n", "\n", - "# turn the weight windows on\n", - "openmc.lib.settings.weight_windows_on = True\n", + " tally = openmc.lib.tallies[1] # points to empty tally reference\n", + " wws = openmc.lib.WeightWindows.from_tally(tally)\n", + " \n", + " #first run\n", + " openmc.lib.run()\n", "\n", - "# updates the weight window with the latest mesh tally flux results \n", - "# As this flux map tells us where the neutrons go we can use it to create a wight window that promotes neutron transport in areas they normally don't reach.\n", - "wws.update_magic(ww_tally)\n", + " wws.update_magic(tally) # tally now has meaning information\n", + " openmc.lib.settings.weight_windows_on = True\n", "\n", - "# runs the simulation\n", - "openmc.lib.run()\n", + " # export the weight windows to a h5 file for loading and plotting later\n", + " openmc.lib.export_weight_windows(filename='weight_windows.h5')\n", "\n", - "openmc.lib.simulation_finalize()" + " # second run\n", + " openmc.lib.run()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "7389fc33", + "metadata": {}, + "outputs": [ + { + "ename": "OutOfBoundsError", + "evalue": "Index in tallies array is out of bounds.", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mOutOfBoundsError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[11], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m ww_tally\u001b[39m.\u001b[39;49mmean\n\u001b[1;32m 2\u001b[0m \u001b[39m# slice_of_tally_values = ww_tally.mean.reshape(mesh.dimension)[:,25,:]\u001b[39;00m\n\u001b[1;32m 3\u001b[0m \u001b[39m# plt.imshow(slice_of_tally_values)\u001b[39;00m\n", + "File \u001b[0;32m~/openmc/openmc/lib/tally.py:309\u001b[0m, in \u001b[0;36mTally.mean\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 307\u001b[0m \u001b[39m@property\u001b[39m\n\u001b[1;32m 308\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mmean\u001b[39m(\u001b[39mself\u001b[39m):\n\u001b[0;32m--> 309\u001b[0m n \u001b[39m=\u001b[39m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mnum_realizations\n\u001b[1;32m 310\u001b[0m sum_ \u001b[39m=\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mresults[:, :, \u001b[39m1\u001b[39m]\n\u001b[1;32m 311\u001b[0m \u001b[39mif\u001b[39;00m n \u001b[39m>\u001b[39m \u001b[39m0\u001b[39m:\n", + "File \u001b[0;32m~/openmc/openmc/lib/tally.py:333\u001b[0m, in \u001b[0;36mTally.num_realizations\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 330\u001b[0m \u001b[39m@property\u001b[39m\n\u001b[1;32m 331\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mnum_realizations\u001b[39m(\u001b[39mself\u001b[39m):\n\u001b[1;32m 332\u001b[0m n \u001b[39m=\u001b[39m c_int32()\n\u001b[0;32m--> 333\u001b[0m _dll\u001b[39m.\u001b[39;49mopenmc_tally_get_n_realizations(\u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_index, n)\n\u001b[1;32m 334\u001b[0m \u001b[39mreturn\u001b[39;00m n\u001b[39m.\u001b[39mvalue\n", + "File \u001b[0;32m~/openmc/openmc/lib/error.py:23\u001b[0m, in \u001b[0;36m_error_handler\u001b[0;34m(err, func, args)\u001b[0m\n\u001b[1;32m 21\u001b[0m \u001b[39mraise\u001b[39;00m exc\u001b[39m.\u001b[39mAllocationError(msg)\n\u001b[1;32m 22\u001b[0m \u001b[39melif\u001b[39;00m err \u001b[39m==\u001b[39m errcode(\u001b[39m'\u001b[39m\u001b[39mOPENMC_E_OUT_OF_BOUNDS\u001b[39m\u001b[39m'\u001b[39m):\n\u001b[0;32m---> 23\u001b[0m \u001b[39mraise\u001b[39;00m exc\u001b[39m.\u001b[39mOutOfBoundsError(msg)\n\u001b[1;32m 24\u001b[0m \u001b[39melif\u001b[39;00m err \u001b[39m==\u001b[39m errcode(\u001b[39m'\u001b[39m\u001b[39mOPENMC_E_INVALID_ARGUMENT\u001b[39m\u001b[39m'\u001b[39m):\n\u001b[1;32m 25\u001b[0m \u001b[39mraise\u001b[39;00m exc\u001b[39m.\u001b[39mInvalidArgumentError(msg)\n", + "\u001b[0;31mOutOfBoundsError\u001b[0m: Index in tallies array is out of bounds." + ] + } + ], + "source": [ + "# ww_tally.mean\n", + "# slice_of_tally_values = ww_tally.mean.reshape(mesh.dimension)[:,25,:]\n", + "# plt.imshow(slice_of_tally_values)" ] }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "ae7160a8", + "metadata": {}, + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4b112488", + "metadata": {}, + "outputs": [], + "source": [] + }, { "attachments": {}, "cell_type": "markdown", @@ -341,6 +477,9 @@ " flux_tally_result = sp.get_tally(id=flux_tally_for_ww.id)\n", "\n", "\n", + "fig, (ax1, ax2) = plt.subplots(1,2)\n", + "fig.suptitle('Flux and std. dev. without weight window')\n", + "\n", "slice_index = int(mesh.dimension[-1]/2)\n", "\n", "# create a plot of the mean values\n", diff --git a/tasks/task_13_variance_reduction/iterative_spherical_mesh_weight_windows.py b/tasks/task_13_variance_reduction/iterative_spherical_mesh_weight_windows.py index a633a90b..3d2abc56 100644 --- a/tasks/task_13_variance_reduction/iterative_spherical_mesh_weight_windows.py +++ b/tasks/task_13_variance_reduction/iterative_spherical_mesh_weight_windows.py @@ -59,17 +59,37 @@ my_tallies = openmc.Tallies() my_tallies.append(flux_tally) -import openmc_weight_window_generator -# import adds generate_wws_magic_method method to the model class model = openmc.Model(my_geometry, my_materials, my_settings, my_tallies) +model.export_to_xml() + + + +import openmc.lib + +iterations = 5 + +with openmc.lib.run_in_memory(): + + tally = openmc.lib.tallies[1] + + wws = openmc.lib.WeightWindows.from_tally(tally) + + for i in range(iterations): + + openmc.lib.run() + + wws.update_magic(tally) + + openmc.lib.settings.weight_windows_on = True + + openmc.lib.reset() + + +plot_flux_tally(f'statepoint.{model.settings.batches}.h5') + -all_wws = model.generate_wws_magic_method( - tally=flux_tally, iterations=50, - max_split=500_000, - output_dir="magic_ww", rel_err_tol=0.99 -) # plots the flux as a function of radius for each iteration output_files = [Path("magic_ww") / str(c) / f"statepoint.{my_settings.batches}.h5" for c in range(1, len(all_wws))] diff --git a/tasks/task_13_variance_reduction/spherical_mesh_weight_windows.py b/tasks/task_13_variance_reduction/spherical_mesh_weight_windows.py deleted file mode 100644 index d262ff34..00000000 --- a/tasks/task_13_variance_reduction/spherical_mesh_weight_windows.py +++ /dev/null @@ -1,160 +0,0 @@ -# This example has a sphere of water showing how to increase the depth of -# neutron transport through the water. -# First a simulation with no weight windows is shown -# Weight windows are found from the flux values obtained with the first simulation -# Secondly a simulation with weight windows is performed to find new flux values deeper into the water sphere -# Another set of weight windows is made from the second flux simulation -# The weight window value as a function of depth is plotted to show how these improve with each simulation iteration - -import openmc -import numpy as np -import matplotlib.pyplot as plt - - -# materials -mat_water = openmc.Material() -mat_water.add_element("H", 1) -mat_water.add_element("O", 2) -mat_water.set_density("g/cm3", 1.0) - -my_materials = openmc.Materials([mat_water]) - -# surfaces -outer_surface = openmc.Sphere(r=500, boundary_type="vacuum") - -# regions -region_1 = -outer_surface - -# cells -cell_1 = openmc.Cell(region=region_1) -cell_1.fill = mat_water - -# settings -my_settings = openmc.Settings() - -my_geometry = openmc.Geometry([cell_1]) - -source = openmc.Source() -source.space = openmc.stats.Point((0.0, 0.0, 0.0)) -source.angle = openmc.stats.Isotropic() -source.energy = openmc.stats.Discrete([14e6], [1.0]) -source.particle = "neutron" - -my_settings = openmc.Settings() -my_settings.run_mode = "fixed source" -my_settings.source = source -my_settings.particles = 10000 -my_settings.batches = 10 - -# tally -mesh = openmc.SphericalMesh() -mesh.r_grid = np.linspace(0, outer_surface.r, 100) - -mesh_filter = openmc.MeshFilter(mesh) - -flux_tally = openmc.Tally(name="flux tally") -flux_tally.filters = [mesh_filter] -flux_tally.scores = ["flux"] - -# adds the mesh tally to the model -my_tallies = openmc.Tallies() -my_tallies.append(flux_tally) - -# model -model = openmc.model.Model(my_geometry, my_materials, my_settings, my_tallies) -output_file = model.run(cwd="no_ww") - -import openmc_weight_window_generator - -# post process the flux values to create the first batch of weight windows -with openmc.StatePoint(output_file) as sp: - flux_tally = sp.get_tally(id=flux_tally.id) - # weight windows from flux - weight_windows = sp.generate_wws(tally=flux_tally, rel_err_tol=0.7)[0] - - -# plot flux against distance -plt.plot( - mesh.r_grid[1:], flux_tally.mean.flatten(), label="flux tally no ww", color="red" -) -plt.legend() -plt.yscale("log") -plt.xlabel("Radius [cm]") -plt.ylabel("Flux") -plt.show() - - -# plot weight window against distance -plt.plot( - mesh.r_grid[1:], - weight_windows.lower_ww_bounds.flatten(), - label="lower ww bounds", - color="red", -) -plt.plot( - mesh.r_grid[1:], - weight_windows.upper_ww_bounds.flatten(), - label="lower up bounds", - color="lightcoral", -) -plt.legend() -plt.xlabel("Radius [cm]") -plt.ylabel("weight window bound value") -plt.show() - -model.settings.weight_windows = weight_windows -# model update by assigning the weight windows found. - -output_file = model.run(cwd="initial_ww") - -with openmc.StatePoint(output_file) as sp: - flux_tally_with_ww = sp.get_tally(id=flux_tally.id) - # weight windows from flux - weight_windows_2 = sp.generate_wws(tally=flux_tally_with_ww, rel_err_tol=0.7)[0] - - -# plot flux with and with out weight windows against distance -plt.plot( - mesh.r_grid[1:], flux_tally.mean.flatten(), label="flux tally no ww", color="red" -) -plt.plot( - mesh.r_grid[1:], - flux_tally_with_ww.mean.flatten(), - label="flux tally with ww", - color="blue", -) -plt.legend() -plt.yscale("log") -plt.xlabel("Radius [cm]") -plt.ylabel("Flux") -plt.show() - -# plot weight window against distance for the firstand second set of weight windows made -plt.plot( - mesh.r_grid[1:], - weight_windows.lower_ww_bounds.flatten(), - label="lower ww bounds", - color="red", -) -plt.plot( - mesh.r_grid[1:], - weight_windows.upper_ww_bounds.flatten(), - label="lower up bounds", - color="lightcoral", -) -plt.plot( - mesh.r_grid[1:], - weight_windows_2.lower_ww_bounds.flatten(), - label="lower ww bounds iteration 2", - color="blue", -) -plt.plot( - mesh.r_grid[1:], - weight_windows_2.upper_ww_bounds.flatten(), - label="lower up bounds iteration 2", - color="cornflowerblue", -) -plt.legend() -plt.xlabel("Radius [cm]") -plt.ylabel("weight window bound value") -plt.show() From 28ff1fde04614610bcabe731099d04dd2313d10a Mon Sep 17 00:00:00 2001 From: Jonathan Shimwell Date: Tue, 13 Jun 2023 18:43:09 +0100 Subject: [PATCH 05/24] [skip ci] added readme for task 13 --- tasks/task_13_variance_reduction/README.md | 13 +++++++++++++ 1 file changed, 13 insertions(+) create mode 100644 tasks/task_13_variance_reduction/README.md diff --git a/tasks/task_13_variance_reduction/README.md b/tasks/task_13_variance_reduction/README.md new file mode 100644 index 00000000..e369ef1a --- /dev/null +++ b/tasks/task_13_variance_reduction/README.md @@ -0,0 +1,13 @@ +Varience reduction examples + +Currently OpenMC supports two types of variance reduction. +A detailed description of each method can be found in the [documentation](https://docs.openmc.org/en/stable/methods/neutron_physics.html?highlight=survival#variance-reduction-techniques). + +The workshop contains the following variance reduction examples: + +| Filename | variance reduction technique | geometry | mesh type | +|---|---|---|---| +| shielded_room_survival_biasing.py | survival_biasing | shielded bunker | RegularMesh | +| generate_single_ww_and_apply.ipynb | weight windows | sphere | SphericalMesh | +| iterative_spherical_mesh_weight_windows.py | weight windows | sphere | SphericalMesh | +| batch_by_batch_till_tally_convergence_limit.py | weight windows | sphere | SphericalMesh | \ No newline at end of file From befe31fb87811ae8066bb2defb9ed96a68f14544 Mon Sep 17 00:00:00 2001 From: Jonathan Shimwell Date: Tue, 13 Jun 2023 18:54:25 +0100 Subject: [PATCH 06/24] [skip ci] simpler plotting --- .../shielded_room_survival_biasing.py | 70 +++---------------- 1 file changed, 8 insertions(+), 62 deletions(-) diff --git a/tasks/task_13_variance_reduction/shielded_room_survival_biasing.py b/tasks/task_13_variance_reduction/shielded_room_survival_biasing.py index 477310f3..588b017f 100644 --- a/tasks/task_13_variance_reduction/shielded_room_survival_biasing.py +++ b/tasks/task_13_variance_reduction/shielded_room_survival_biasing.py @@ -76,16 +76,16 @@ roof_region = +xplane_1 & -xplane_6 & +yplane_1 & -yplane_5 & +zplane_1 & -zplane_2 floor_region = +xplane_1 & -xplane_6 & +yplane_1 & -yplane_5 & +zplane_3 & -zplane_4 -outside_left_cell = openmc.Cell(region=outside_left_region, fill=air, name="outside_left_cell") -outside_right_cell = openmc.Cell(region=outside_right_region, fill=air, name="outside_right_cell") -outside_top_cell = openmc.Cell(region=outside_top_region, fill=air, name="outside_top_cell") -outside_bottom_cell = openmc.Cell(region=outside_bottom_region, fill=air, name="outside_bottom_cell") +outside_left_cell = openmc.Cell(region=outside_left_region, fill=air) +outside_right_cell = openmc.Cell(region=outside_right_region, fill=air) +outside_top_cell = openmc.Cell(region=outside_top_region, fill=air) +outside_bottom_cell = openmc.Cell(region=outside_bottom_region, fill=air) wall_left_cell = openmc.Cell(region=wall_left_region, fill=concrete) wall_right_cell = openmc.Cell(region=wall_right_region, fill=concrete) wall_top_cell = openmc.Cell(region=wall_top_region, fill=concrete) wall_bottom_cell = openmc.Cell(region=wall_bottom_region, fill=concrete) wall_middle_cell = openmc.Cell(region=wall_middle_region, fill=concrete) -room_cell = openmc.Cell(region=room_region, fill=air, name="room_cell") +room_cell = openmc.Cell(region=room_region, fill=air) gap_cell = openmc.Cell(region=gap_region, fill=air) corridor_cell = openmc.Cell(region=corridor_region, fill=air) @@ -120,62 +120,8 @@ source_y = depth_a + depth_b + depth_c * 0.75 source_z = height_j + height_k * 0.5 -xlabel, ylabel = geometry.get_axis_labels(view_direction="z") -plt.xlabel(xlabel) -plt.ylabel(ylabel) - -plot_extent = geometry.get_mpl_plot_extent(view_direction="z") - -data_slice = geometry.get_slice_of_material_ids(view_direction="z") -# plots the materials with randomly assigned colors -plt.imshow( - np.fliplr(data_slice), - extent=plot_extent, -) - -# plots the outline of the cells -plt.contour( - np.fliplr(data_slice), - origin="upper", - colors="k", - linestyles="solid", - linewidths=1, - extent=plot_extent, -) - -# plots the source location -plt.scatter(source_x, source_y, c="red") -plt.savefig('geometry_view.png') - -plt.clf() -plt.cla() - -xlabel, ylabel = geometry.get_axis_labels(view_direction="y") -plt.xlabel(xlabel) -plt.ylabel(ylabel) - -plot_extent = geometry.get_mpl_plot_extent(view_direction="y") - -data_slice = geometry.get_slice_of_material_ids(view_direction="y") -# plots the materials with randomly assigned colors -plt.imshow( - np.fliplr(data_slice), - extent=plot_extent, -) - -# plots the outline of the cells -plt.contour( - np.fliplr(data_slice), - origin="upper", - colors="k", - linestyles="solid", - linewidths=1, - extent=plot_extent, -) - -# plots the source location -plt.scatter(source_x, source_z, c="red") -plt.savefig('geometry_view_2.png') +geometry.root_universe.plot(basis='xy', color_by='material') +plt.savefig('geometry_view_2.png', bbox_inches="tight") mesh = openmc.RegularMesh().from_domain(geometry) mesh.dimension = (100, 100, 1) @@ -267,4 +213,4 @@ def run_and_plot(model, filename, output=True): "weight": 0.3, # value needs to be between 0 and 1 "weight_avg": 0.9, # value needs to be between 0 and 1 } -run_and_plot(model, "yes_survival_biasing.png") +# run_and_plot(model, "yes_survival_biasing.png") From 9992457e2ecd593db004e7c2b6df3d390160057b Mon Sep 17 00:00:00 2001 From: Jonathan Shimwell Date: Thu, 15 Jun 2023 16:11:25 +0100 Subject: [PATCH 07/24] returned to old version due to file breakage --- .../generate_single_ww_and_apply.ipynb | 371 ++---------------- 1 file changed, 36 insertions(+), 335 deletions(-) diff --git a/tasks/task_13_variance_reduction/generate_single_ww_and_apply.ipynb b/tasks/task_13_variance_reduction/generate_single_ww_and_apply.ipynb index 6da03ed1..e1ec105c 100644 --- a/tasks/task_13_variance_reduction/generate_single_ww_and_apply.ipynb +++ b/tasks/task_13_variance_reduction/generate_single_ww_and_apply.ipynb @@ -28,7 +28,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "id": "3448d1db-4328-42e3-8960-50d53896f541", "metadata": {}, "outputs": [], @@ -78,30 +78,14 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "id": "47cb21c7-0afa-446c-9a6b-76c8dfb2f93e", "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "import matplotlib.pyplot as plt\n", -<<<<<<< HEAD - "\n", - "model.geometry.root_universe.plot()\n", -======= "plt.figure(figsize=(10,10))\n", - "model.geometry.root_universe.plot(pixels=(600, 600))\n", ->>>>>>> develop + "model.geometry.root_universe.plot(width=(400, 400), pixels=(600, 600))\n", "plt.show()" ] }, @@ -118,7 +102,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "id": "a72dc5e3-cb8e-41c2-9cfb-f8f7489c7f44", "metadata": {}, "outputs": [], @@ -130,157 +114,12 @@ "\n", "mesh_filter = openmc.MeshFilter(mesh)\n", "\n", - "flux_tally_for_ww = openmc.Tally(name='flux tally')\n", - "flux_tally_for_ww.filters = [mesh_filter]\n", - "flux_tally_for_ww.scores = ['flux']\n", + "flux_tally = openmc.Tally(name='flux tally')\n", + "flux_tally.filters = [mesh_filter]\n", + "flux_tally.scores = ['flux']\n", "\n", "# adds the mesh tally to the model\n", - "model.tallies = [flux_tally_for_ww]" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "id": "026db00f", - "metadata": {}, - "source": [ - "Now we shall run the simulation in analog mode" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "35f3c771", - "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-10 22:35:39\n", - " OpenMP Threads | 8\n", - "\n", - " Reading model XML file './model.xml' ...\n", - " WARNING: Other XML file input(s) are present. These files may be ignored in\n", - " favor of the ./model.xml file.\n", - " Reading cross sections XML file...\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 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", - " Minimum neutron data temperature: 294 K\n", - " Maximum neutron data temperature: 294 K\n", - " Preparing distributed cell instances...\n", - " Writing summary.h5 file...\n", - " Maximum neutron transport energy: 20000000 eV for H1\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", - " Simulating batch 6\n", - " Simulating batch 7\n", - " Simulating batch 8\n", - " Simulating batch 9\n", - " Simulating batch 10\n", - " Creating state point statepoint.10.h5...\n", - "\n", - " =======================> TIMING STATISTICS <=======================\n", - "\n", - " Total time for initialization = 1.0914e-01 seconds\n", - " Reading cross sections = 9.7824e-02 seconds\n", - " Total time in simulation = 2.8342e+00 seconds\n", - " Time in transport only = 2.7873e+00 seconds\n", - " Time in active batches = 2.8342e+00 seconds\n", - " Time accumulating tallies = 3.3279e-02 seconds\n", - " Time writing statepoints = 1.1546e-02 seconds\n", - " Total time for finalization = 3.3200e-07 seconds\n", - " Total time elapsed = 2.9460e+00 seconds\n", - " Calculation Rate (active) = 35283.5 particles/second\n", - "\n", - " ============================> RESULTS <============================\n", - "\n", - " Leakage Fraction = 0.00000 +/- 0.00000\n", - "\n" - ] - } - ], - "source": [ - "output_file = model.run()" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "id": "0918a61e", - "metadata": {}, - "source": [] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "7ff1e1b1", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "(50, 50, 50)\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "with openmc.StatePoint(output_file) as sp:\n", - " flux_tally_result = sp.get_tally(id=flux_tally_for_ww.id)\n", - "flux_tally_result = flux_tally_result.get_reshaped_data(expand_dims=True).squeeze()\n", - "print(flux_tally_result.shape)\n", - "from matplotlib.colors import LogNorm\n", - "plt.imshow(flux_tally_result[:,25,:], norm=LogNorm())\n", - "plt.show()" + "model.tallies = [flux_tally]" ] }, { @@ -294,172 +133,14 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "id": "1c5b84c7-0fe5-48d5-b2b7-58ce8cea57f1", "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-10 22:35:42\n", - " OpenMP Threads | 8\n", - "\n", - " Reading model XML file './model.xml' ...\n", - " Reading cross sections XML file...\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 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", - " Minimum neutron data temperature: 294 K\n", - " Maximum neutron data temperature: 294 K\n", - " Preparing distributed cell instances...\n", - " Writing summary.h5 file...\n", - " Maximum neutron transport energy: 20000000 eV for H1\n", - "\n", - " ===============> FIXED SOURCE TRANSPORT SIMULATION <===============\n", - "\n", - " Simulating batch 1\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " WARNING: Other XML file input(s) are present. These files may be ignored in\n", - " favor of the ./model.xml file.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " Simulating batch 2\n", - " Simulating batch 3\n", - " Simulating batch 4\n", - " Simulating batch 5\n", - " Simulating batch 6\n", - " Simulating batch 7\n", - " Simulating batch 8\n", - " Simulating batch 9\n", - " Simulating batch 10\n", - " Creating state point statepoint.10.h5...\n", - "\n", - " =======================> TIMING STATISTICS <=======================\n", - "\n", - " Total time for initialization = 1.2083e-01 seconds\n", - " Reading cross sections = 1.0993e-01 seconds\n", - " Total time in simulation = 2.9952e+00 seconds\n", - " Time in transport only = 2.9737e+00 seconds\n", - " Time in active batches = 2.9952e+00 seconds\n", - " Time accumulating tallies = 4.5944e-03 seconds\n", - " Time writing statepoints = 1.3561e-02 seconds\n", - " Total time for finalization = 1.4840e-06 seconds\n", - " Total time elapsed = 3.1186e+00 seconds\n", - " Calculation Rate (active) = 33386.2 particles/second\n", - "\n", - " ============================> RESULTS <============================\n", - "\n", - " Leakage Fraction = 0.00000 +/- 0.00000\n", - "\n" - ] - } - ], - "source": [ - "model.export_to_xml()\n", - "import openmc.lib\n", - "\n", - "\n", - "with openmc.lib.run_in_memory():\n", - "\n", - " tally = openmc.lib.tallies[1] # points to empty tally reference\n", - " wws = openmc.lib.WeightWindows.from_tally(tally)\n", - " \n", - " #first run\n", - " openmc.lib.run()\n", - "\n", - " wws.update_magic(tally) # tally now has meaning information\n", - " openmc.lib.settings.weight_windows_on = True\n", - "\n", - " # export the weight windows to a h5 file for loading and plotting later\n", - " openmc.lib.export_weight_windows(filename='weight_windows.h5')\n", - "\n", - " # second run\n", - " openmc.lib.run()\n" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "7389fc33", - "metadata": {}, - "outputs": [ - { - "ename": "OutOfBoundsError", - "evalue": "Index in tallies array is out of bounds.", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mOutOfBoundsError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[11], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m ww_tally\u001b[39m.\u001b[39;49mmean\n\u001b[1;32m 2\u001b[0m \u001b[39m# slice_of_tally_values = ww_tally.mean.reshape(mesh.dimension)[:,25,:]\u001b[39;00m\n\u001b[1;32m 3\u001b[0m \u001b[39m# plt.imshow(slice_of_tally_values)\u001b[39;00m\n", - "File \u001b[0;32m~/openmc/openmc/lib/tally.py:309\u001b[0m, in \u001b[0;36mTally.mean\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 307\u001b[0m \u001b[39m@property\u001b[39m\n\u001b[1;32m 308\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mmean\u001b[39m(\u001b[39mself\u001b[39m):\n\u001b[0;32m--> 309\u001b[0m n \u001b[39m=\u001b[39m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mnum_realizations\n\u001b[1;32m 310\u001b[0m sum_ \u001b[39m=\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mresults[:, :, \u001b[39m1\u001b[39m]\n\u001b[1;32m 311\u001b[0m \u001b[39mif\u001b[39;00m n \u001b[39m>\u001b[39m \u001b[39m0\u001b[39m:\n", - "File \u001b[0;32m~/openmc/openmc/lib/tally.py:333\u001b[0m, in \u001b[0;36mTally.num_realizations\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 330\u001b[0m \u001b[39m@property\u001b[39m\n\u001b[1;32m 331\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mnum_realizations\u001b[39m(\u001b[39mself\u001b[39m):\n\u001b[1;32m 332\u001b[0m n \u001b[39m=\u001b[39m c_int32()\n\u001b[0;32m--> 333\u001b[0m _dll\u001b[39m.\u001b[39;49mopenmc_tally_get_n_realizations(\u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_index, n)\n\u001b[1;32m 334\u001b[0m \u001b[39mreturn\u001b[39;00m n\u001b[39m.\u001b[39mvalue\n", - "File \u001b[0;32m~/openmc/openmc/lib/error.py:23\u001b[0m, in \u001b[0;36m_error_handler\u001b[0;34m(err, func, args)\u001b[0m\n\u001b[1;32m 21\u001b[0m \u001b[39mraise\u001b[39;00m exc\u001b[39m.\u001b[39mAllocationError(msg)\n\u001b[1;32m 22\u001b[0m \u001b[39melif\u001b[39;00m err \u001b[39m==\u001b[39m errcode(\u001b[39m'\u001b[39m\u001b[39mOPENMC_E_OUT_OF_BOUNDS\u001b[39m\u001b[39m'\u001b[39m):\n\u001b[0;32m---> 23\u001b[0m \u001b[39mraise\u001b[39;00m exc\u001b[39m.\u001b[39mOutOfBoundsError(msg)\n\u001b[1;32m 24\u001b[0m \u001b[39melif\u001b[39;00m err \u001b[39m==\u001b[39m errcode(\u001b[39m'\u001b[39m\u001b[39mOPENMC_E_INVALID_ARGUMENT\u001b[39m\u001b[39m'\u001b[39m):\n\u001b[1;32m 25\u001b[0m \u001b[39mraise\u001b[39;00m exc\u001b[39m.\u001b[39mInvalidArgumentError(msg)\n", - "\u001b[0;31mOutOfBoundsError\u001b[0m: Index in tallies array is out of bounds." - ] - } - ], + "outputs": [], "source": [ - "# ww_tally.mean\n", - "# slice_of_tally_values = ww_tally.mean.reshape(mesh.dimension)[:,25,:]\n", - "# plt.imshow(slice_of_tally_values)" + "output_file = model.run()" ] }, - { - "attachments": {}, - "cell_type": "markdown", - "id": "ae7160a8", - "metadata": {}, - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "4b112488", - "metadata": {}, - "outputs": [], - "source": [] - }, { "attachments": {}, "cell_type": "markdown", @@ -478,9 +159,10 @@ "source": [ "from matplotlib.colors import LogNorm\n", "\n", - "with openmc.StatePoint(f'statepoint.{my_settings.batches}.h5') as sp:\n", - " flux_tally_result = sp.get_tally(id=flux_tally_for_ww.id)\n", + "with openmc.StatePoint(output_file) as sp:\n", + " flux_tally = sp.get_tally(id=flux_tally.id)\n", "\n", + "llc, urc = model.geometry.bounding_box\n", "\n", "fig, (ax1, ax2) = plt.subplots(1,2)\n", "fig.suptitle('Flux and std. dev. without weight window')\n", @@ -510,7 +192,26 @@ "cell_type": "markdown", "id": "f0b0c196-0829-4b36-abec-8fec944c8f2b", "metadata": {}, - "source": [] + "source": [ + "As this flux map tells us where the neutrons go we can use it to create a wieght window that promotes neutron transport in areas they normally don't reach." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "03cc2b9f-5421-41d3-9f0d-4d43cf82977f", + "metadata": {}, + "outputs": [], + "source": [ + "import openmc_weight_window_generator\n", + "# this is a minimal package that adds some functionality to openmc, namely it adds:\n", + "# - openmc.StatePoint.generate_wws which we use in this task\n", + "# - openmc.Model.generate_wws_magic_method which we use in the next task\n", + "\n", + "sp_file = openmc.StatePoint(output_file)\n", + "# this generates an openmc.WeightWindow object from the flux tally\n", + "weight_windows = sp_file.generate_wws(tally=flux_tally, rel_err_tol=0.7)" + ] }, { "attachments": {}, @@ -650,7 +351,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.10" + "version": "3.8.13" } }, "nbformat": 4, From e221ab6224c0acc4d9b0549d7ab47a04afcd4121 Mon Sep 17 00:00:00 2001 From: Jonathan Shimwell Date: Fri, 16 Jun 2023 19:03:28 +0100 Subject: [PATCH 08/24] renamed files; --- .../1_shielded_room_survival_biasing.ipynb | 318 ++++++++++++++++++ ...py => 1_shielded_room_survival_biasing.py} | 0 ....ipynb => 2_shielded_room_single_ww.ipynb} | 0 ...ws.py => 3_sphere_iterative_per_run_ww.py} | 0 ....py => 4_sphere_iterative_per_batch_ww.py} | 0 5 files changed, 318 insertions(+) create mode 100644 tasks/task_13_variance_reduction/1_shielded_room_survival_biasing.ipynb rename tasks/task_13_variance_reduction/{shielded_room_survival_biasing.py => 1_shielded_room_survival_biasing.py} (100%) rename tasks/task_13_variance_reduction/{generate_single_ww_and_apply.ipynb => 2_shielded_room_single_ww.ipynb} (100%) rename tasks/task_13_variance_reduction/{iterative_spherical_mesh_weight_windows.py => 3_sphere_iterative_per_run_ww.py} (100%) rename tasks/task_13_variance_reduction/{batch_by_batch_till_tally_convergence_limit.py => 4_sphere_iterative_per_batch_ww.py} (100%) diff --git a/tasks/task_13_variance_reduction/1_shielded_room_survival_biasing.ipynb b/tasks/task_13_variance_reduction/1_shielded_room_survival_biasing.ipynb new file mode 100644 index 00000000..15d7bab2 --- /dev/null +++ b/tasks/task_13_variance_reduction/1_shielded_room_survival_biasing.ipynb @@ -0,0 +1,318 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This example simulates a shield room / bunker with corridor entrance a neutron source in the center of the room.\n", + "\n", + "Variance reduction is used to accelerate the simulation.\n", + "\n", + "The variance reduction method used for this simulation is not as effective as other variance reduction methods available in OpenMC but is the first task in the variance reduction section as it is the simplest to implement.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "vscode": { + "languageId": "plaintext" + } + }, + "outputs": [], + "source": [ + "import openmc\n", + "import numpy as np\n", + "from matplotlib import pyplot as plt\n", + "from matplotlib.colors import LogNorm\n", + "\n", + "\n", + "air = openmc.Material(name=\"Air\")\n", + "air.set_density(\"g/cc\", 0.001205)\n", + "air.add_element(\"N\", 0.784431)\n", + "air.add_element(\"O\", 0.210748)\n", + "air.add_element(\"Ar\", 0.0046)\n", + "\n", + "concrete = openmc.Material(name=\"concrete\")\n", + "concrete.set_density(\"g/cm3\", 7.874)\n", + "concrete.add_element(\"Fe\", 1)\n", + "\n", + "materials = openmc.Materials([air, concrete])\n", + "\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", + "\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=air)\n", + "outside_right_cell = openmc.Cell(region=outside_right_region, fill=air)\n", + "outside_top_cell = openmc.Cell(region=outside_top_region, fill=air)\n", + "outside_bottom_cell = openmc.Cell(region=outside_bottom_region, fill=air)\n", + "wall_left_cell = openmc.Cell(region=wall_left_region, fill=concrete)\n", + "wall_right_cell = openmc.Cell(region=wall_right_region, fill=concrete)\n", + "wall_top_cell = openmc.Cell(region=wall_top_region, fill=concrete)\n", + "wall_bottom_cell = openmc.Cell(region=wall_bottom_region, fill=concrete)\n", + "wall_middle_cell = openmc.Cell(region=wall_middle_region, fill=concrete)\n", + "room_cell = openmc.Cell(region=room_region, fill=air)\n", + "gap_cell = openmc.Cell(region=gap_region, fill=air)\n", + "corridor_cell = openmc.Cell(region=corridor_region, fill=air)\n", + "\n", + "roof_cell = openmc.Cell(region=roof_region, fill=concrete)\n", + "floor_cell = openmc.Cell(region=floor_region, fill=concrete)\n", + "\n", + "materials = openmc.Materials([air, concrete])\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", + "\n", + "model = openmc.Model()\n", + "model.geometry = geometry\n", + "\n", + "# 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", + "\n", + "geometry.root_universe.plot(basis='xy', color_by='material') \n", + "plt.savefig('geometry_view_2.png', bbox_inches=\"tight\")\n", + "\n", + "mesh = openmc.RegularMesh().from_domain(geometry)\n", + "mesh.dimension = (100, 100, 1)\n", + "\n", + "mesh_filter = openmc.MeshFilter(mesh)\n", + "\n", + "flux_tally = openmc.Tally(name=\"flux tally\")\n", + "flux_tally.filters = [mesh_filter]\n", + "flux_tally.scores = [\"flux\"]\n", + "\n", + "model.tallies = [flux_tally]\n", + "\n", + "space = openmc.stats.Point((source_x, source_y, source_z))\n", + "angle = openmc.stats.Isotropic()\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", + "model.settings.run_mode = \"fixed source\"\n", + "model.settings.source = source\n", + "model.settings.particles = 2000\n", + "model.settings.batches = 5\n", + "\n", + "\n", + "def run_and_plot(model, filename, output=True):\n", + "\n", + " sp_filename = model.run(output=output)\n", + "\n", + " with openmc.StatePoint(sp_filename) as sp:\n", + " flux_tally = sp.get_tally(name=\"flux tally\")\n", + "\n", + " mesh_extent = mesh.bounding_box.extent['xy']\n", + "\n", + " # create a plot of the mean flux values\n", + " flux_mean = flux_tally.mean.reshape(100, 100)\n", + " plt.subplot(1, 2, 1)\n", + " plt.imshow(\n", + " flux_mean,\n", + " origin=\"lower\",\n", + " extent=mesh_extent,\n", + " norm=LogNorm(),\n", + " )\n", + " plt.title(\"Flux Mean\")\n", + "\n", + " data_slice = geometry.get_slice_of_material_ids(view_direction=\"z\")\n", + " xlabel, ylabel = geometry.get_axis_labels(view_direction=\"z\")\n", + " plt.xlabel(xlabel)\n", + " plt.ylabel(ylabel)\n", + "\n", + " plt.contour(\n", + " np.fliplr(data_slice),\n", + " origin=\"upper\",\n", + " colors=\"k\",\n", + " linestyles=\"solid\",\n", + " linewidths=1,\n", + " extent=mesh_extent,\n", + " )\n", + "\n", + " plt.subplot(1, 2, 2)\n", + " # create a plot of the flux relative error\n", + " flux_std_dev = flux_tally.get_values(value=\"std_dev\").reshape(*mesh.dimension)\n", + " plt.imshow(\n", + " flux_std_dev,\n", + " origin=\"lower\",\n", + " extent=mesh_extent,\n", + " norm=LogNorm(),\n", + " )\n", + " plt.title(\"Flux Std. Dev.\")\n", + "\n", + " plt.xlabel(xlabel)\n", + " plt.ylabel(ylabel)\n", + " plt.contour(\n", + " np.fliplr(data_slice),\n", + " origin=\"upper\",\n", + " colors=\"k\",\n", + " linestyles=\"solid\",\n", + " linewidths=1,\n", + " extent=mesh_extent,\n", + " )\n", + " plt.savefig(filename)\n", + " return sp\n", + "\n", + "\n", + "run_and_plot(model, \"no_survival_biasing.png\")\n", + "\n", + "model.settings.survival_biasing = True\n", + "model.settings.cutoff = {\n", + " \"weight\": 0.3, # value needs to be between 0 and 1\n", + " \"weight_avg\": 0.9, # value needs to be between 0 and 1\n", + "}\n", + "# run_and_plot(model, \"yes_survival_biasing.png\")\n" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "vscode": { + "languageId": "plaintext" + } + }, + "outputs": [], + "source": [] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "vscode": { + "languageId": "plaintext" + } + }, + "outputs": [], + "source": [] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "vscode": { + "languageId": "plaintext" + } + }, + "outputs": [], + "source": [] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "vscode": { + "languageId": "plaintext" + } + }, + "outputs": [], + "source": [] + } + ], + "metadata": { + "language_info": { + "name": "python" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/tasks/task_13_variance_reduction/shielded_room_survival_biasing.py b/tasks/task_13_variance_reduction/1_shielded_room_survival_biasing.py similarity index 100% rename from tasks/task_13_variance_reduction/shielded_room_survival_biasing.py rename to tasks/task_13_variance_reduction/1_shielded_room_survival_biasing.py diff --git a/tasks/task_13_variance_reduction/generate_single_ww_and_apply.ipynb b/tasks/task_13_variance_reduction/2_shielded_room_single_ww.ipynb similarity index 100% rename from tasks/task_13_variance_reduction/generate_single_ww_and_apply.ipynb rename to tasks/task_13_variance_reduction/2_shielded_room_single_ww.ipynb diff --git a/tasks/task_13_variance_reduction/iterative_spherical_mesh_weight_windows.py b/tasks/task_13_variance_reduction/3_sphere_iterative_per_run_ww.py similarity index 100% rename from tasks/task_13_variance_reduction/iterative_spherical_mesh_weight_windows.py rename to tasks/task_13_variance_reduction/3_sphere_iterative_per_run_ww.py diff --git a/tasks/task_13_variance_reduction/batch_by_batch_till_tally_convergence_limit.py b/tasks/task_13_variance_reduction/4_sphere_iterative_per_batch_ww.py similarity index 100% rename from tasks/task_13_variance_reduction/batch_by_batch_till_tally_convergence_limit.py rename to tasks/task_13_variance_reduction/4_sphere_iterative_per_batch_ww.py From c96244b41484cf952f508df50e0676f2f574fb6a Mon Sep 17 00:00:00 2001 From: Jonathan Shimwell Date: Mon, 19 Jun 2023 09:24:07 +0100 Subject: [PATCH 09/24] refactored example --- .../1_shielded_room_survival_biasing.ipynb | 660 ++++++++++++++---- 1 file changed, 517 insertions(+), 143 deletions(-) diff --git a/tasks/task_13_variance_reduction/1_shielded_room_survival_biasing.ipynb b/tasks/task_13_variance_reduction/1_shielded_room_survival_biasing.ipynb index 15d7bab2..3933ea78 100644 --- a/tasks/task_13_variance_reduction/1_shielded_room_survival_biasing.ipynb +++ b/tasks/task_13_variance_reduction/1_shielded_room_survival_biasing.ipynb @@ -9,36 +9,82 @@ "\n", "Variance reduction is used to accelerate the simulation.\n", "\n", - "The variance reduction method used for this simulation is not as effective as other variance reduction methods available in OpenMC but is the first task in the variance reduction section as it is the simplest to implement.\n" + "The variance reduction method used for this simulation (survival_biasing) is not as effective as other variance reduction methods available in OpenMC but is the first task in the variance reduction section as it is the simplest to implement.\n", + "\n", + "Openmc documentation on survival-biasing\n", + "https://docs.openmc.org/en/stable/methods/neutron_physics.html#survival-biasing\n" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "First we import openmc and other packages needed for the example" ] }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "vscode": { - "languageId": "plaintext" - } - }, + "execution_count": 1, + "metadata": {}, "outputs": [], "source": [ "import openmc\n", "import numpy as np\n", "from matplotlib import pyplot as plt\n", - "from matplotlib.colors import LogNorm\n", - "\n", - "\n", - "air = openmc.Material(name=\"Air\")\n", - "air.set_density(\"g/cc\", 0.001205)\n", - "air.add_element(\"N\", 0.784431)\n", - "air.add_element(\"O\", 0.210748)\n", - "air.add_element(\"Ar\", 0.0046)\n", - "\n", - "concrete = openmc.Material(name=\"concrete\")\n", - "concrete.set_density(\"g/cm3\", 7.874)\n", - "concrete.add_element(\"Fe\", 1)\n", - "\n", - "materials = openmc.Materials([air, concrete])\n", + "from matplotlib.colors import LogNorm # used for plotting log scale graphs" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We create a couple of materials for the simulation" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "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", + "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": 5, + "metadata": {}, + "outputs": [], + "source": [ "\n", "width_a = 100\n", "width_b = 200\n", @@ -59,7 +105,6 @@ "height_k = 500\n", "height_l = 100\n", "\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", @@ -99,23 +144,22 @@ "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=air)\n", - "outside_right_cell = openmc.Cell(region=outside_right_region, fill=air)\n", - "outside_top_cell = openmc.Cell(region=outside_top_region, fill=air)\n", - "outside_bottom_cell = openmc.Cell(region=outside_bottom_region, fill=air)\n", - "wall_left_cell = openmc.Cell(region=wall_left_region, fill=concrete)\n", - "wall_right_cell = openmc.Cell(region=wall_right_region, fill=concrete)\n", - "wall_top_cell = openmc.Cell(region=wall_top_region, fill=concrete)\n", - "wall_bottom_cell = openmc.Cell(region=wall_bottom_region, fill=concrete)\n", - "wall_middle_cell = openmc.Cell(region=wall_middle_region, fill=concrete)\n", - "room_cell = openmc.Cell(region=room_region, fill=air)\n", - "gap_cell = openmc.Cell(region=gap_region, fill=air)\n", - "corridor_cell = openmc.Cell(region=corridor_region, fill=air)\n", - "\n", - "roof_cell = openmc.Cell(region=roof_region, fill=concrete)\n", - "floor_cell = openmc.Cell(region=floor_region, fill=concrete)\n", - "\n", - "materials = openmc.Materials([air, concrete])\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", @@ -133,45 +177,153 @@ " roof_cell,\n", " floor_cell,\n", " ]\n", - ")\n", - "\n", - "model = openmc.Model()\n", - "model.geometry = geometry\n", + ")\n" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we plot the geometry and color by materials." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "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", + "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": 7, + "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", - "geometry.root_universe.plot(basis='xy', color_by='material') \n", - "plt.savefig('geometry_view_2.png', bbox_inches=\"tight\")\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", + "metadata": {}, + "source": [ + "Create a mesh that encompasses the entire geoemtry and scores neutron flux" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ "mesh = openmc.RegularMesh().from_domain(geometry)\n", "mesh.dimension = (100, 100, 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]\n", + "flux_tally.filters = [mesh_filter, particle_filter]\n", "flux_tally.scores = [\"flux\"]\n", "\n", - "model.tallies = [flux_tally]\n", - "\n", - "space = openmc.stats.Point((source_x, source_y, source_z))\n", - "angle = openmc.stats.Isotropic()\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", - "model.settings.run_mode = \"fixed source\"\n", - "model.settings.source = source\n", - "model.settings.particles = 2000\n", - "model.settings.batches = 5\n", - "\n", + "tallies = openmc.Tallies([flux_tally])" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Creates the simulation settings" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "settings = openmc.Settings()\n", "\n", - "def run_and_plot(model, filename, output=True):\n", + "settings.run_mode = \"fixed source\"\n", + "settings.source = source\n", + "settings.particles = 2000\n", + "settings.batches = 5" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Creates the model" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "model = openmc.Model(geometry, materials, settings, tallies)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We are going to run this model twice. Once with survival_biasing and once without. This next code bock makes a function so that we can easily run the simulation twice with these two different settings." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "def run_and_plot(model, image_filename):\n", "\n", - " sp_filename = model.run(output=output)\n", + " sp_filename = model.run()\n", "\n", " with openmc.StatePoint(sp_filename) as sp:\n", " flux_tally = sp.get_tally(name=\"flux tally\")\n", @@ -179,7 +331,7 @@ " mesh_extent = mesh.bounding_box.extent['xy']\n", "\n", " # create a plot of the mean flux values\n", - " flux_mean = flux_tally.mean.reshape(100, 100)\n", + " flux_mean = flux_tally.get_reshaped_data(value='mean', expand_dims=True).squeeze()\n", " plt.subplot(1, 2, 1)\n", " plt.imshow(\n", " flux_mean,\n", @@ -189,23 +341,10 @@ " )\n", " plt.title(\"Flux Mean\")\n", "\n", - " data_slice = geometry.get_slice_of_material_ids(view_direction=\"z\")\n", - " xlabel, ylabel = geometry.get_axis_labels(view_direction=\"z\")\n", - " plt.xlabel(xlabel)\n", - " plt.ylabel(ylabel)\n", - "\n", - " plt.contour(\n", - " np.fliplr(data_slice),\n", - " origin=\"upper\",\n", - " colors=\"k\",\n", - " linestyles=\"solid\",\n", - " linewidths=1,\n", - " extent=mesh_extent,\n", - " )\n", "\n", " plt.subplot(1, 2, 2)\n", " # create a plot of the flux relative error\n", - " flux_std_dev = flux_tally.get_values(value=\"std_dev\").reshape(*mesh.dimension)\n", + " flux_std_dev = flux_tally.get_reshaped_data(value='std_dev', expand_dims=True).squeeze()\n", " plt.imshow(\n", " flux_std_dev,\n", " origin=\"lower\",\n", @@ -214,102 +353,337 @@ " )\n", " plt.title(\"Flux Std. Dev.\")\n", "\n", - " plt.xlabel(xlabel)\n", - " plt.ylabel(ylabel)\n", - " plt.contour(\n", - " np.fliplr(data_slice),\n", - " origin=\"upper\",\n", - " colors=\"k\",\n", - " linestyles=\"solid\",\n", - " linewidths=1,\n", - " extent=mesh_extent,\n", - " )\n", - " plt.savefig(filename)\n", - " return sp\n", - "\n", - "\n", - "run_and_plot(model, \"no_survival_biasing.png\")\n", - "\n", - "model.settings.survival_biasing = True\n", - "model.settings.cutoff = {\n", - " \"weight\": 0.3, # value needs to be between 0 and 1\n", - " \"weight_avg\": 0.9, # value needs to be between 0 and 1\n", - "}\n", - "# run_and_plot(model, \"yes_survival_biasing.png\")\n" + " plt.savefig(image_filename)\n", + " return sp" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, - "source": [] + "source": [ + "Now we run the model without survival_biasing and save the meesh tally image" + ] }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "vscode": { - "languageId": "plaintext" - } - }, - "outputs": [], - "source": [] - }, - { - "attachments": {}, - "cell_type": "markdown", + "execution_count": 17, "metadata": {}, - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "vscode": { - "languageId": "plaintext" + "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 | 96d150a64e7636138bdc60042d97f3d33f5cce38\n", + " Date/Time | 2023-06-19 09:22:41\n", + " OpenMP Threads | 28\n", + "\n", + " Reading model XML file './model.xml' ...\n", + " Reading cross sections XML file...\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", + " WARNING: Negative value(s) found on probability table for nuclide Ar36 at 294K\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", + " 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: 294 K\n", + " Maximum neutron data temperature: 294 K\n", + " Preparing distributed cell instances...\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 = 1.6954e+00 seconds\n", + " Reading cross sections = 1.6605e+00 seconds\n", + " Total time in simulation = 2.5190e-01 seconds\n", + " Time in transport only = 2.4342e-01 seconds\n", + " Time in active batches = 2.5190e-01 seconds\n", + " Time accumulating tallies = 1.7898e-03 seconds\n", + " Time writing statepoints = 6.1760e-03 seconds\n", + " Total time for finalization = 1.1361e-02 seconds\n", + " Total time elapsed = 1.9681e+00 seconds\n", + " Calculation Rate (active) = 39697.8 particles/second\n", + "\n", + " ============================> RESULTS <============================\n", + "\n", + " Leakage Fraction = 0.00486 +/- 0.00066\n", + "\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" } - }, - "outputs": [], - "source": [] + ], + "source": [ + "\n", + "run_and_plot(model, \"no_survival_biasing.png\")\n" + ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, - "source": [] + "source": [ + "Now we run the model again with survival_biasing enabled. This needs to me set on the model settings. The values chosen can be fine tunned to the model but for this example we have chosen some values after a little exploration." + ] }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "vscode": { - "languageId": "plaintext" + "execution_count": 15, + "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 | 96d150a64e7636138bdc60042d97f3d33f5cce38\n", + " Date/Time | 2023-06-19 09:21:47\n", + " OpenMP Threads | 28\n", + "\n", + " Reading model XML file './model.xml' ...\n", + " Reading cross sections XML file...\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", + " WARNING: Negative value(s) found on probability table for nuclide Ar36 at 294K\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", + " 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: 294 K\n", + " Maximum neutron data temperature: 294 K\n", + " Preparing distributed cell instances...\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 = 1.6743e+00 seconds\n", + " Reading cross sections = 1.6428e+00 seconds\n", + " Total time in simulation = 2.6225e-01 seconds\n", + " Time in transport only = 2.4040e-01 seconds\n", + " Time in active batches = 2.6225e-01 seconds\n", + " Time accumulating tallies = 1.5301e-02 seconds\n", + " Time writing statepoints = 6.1750e-03 seconds\n", + " Total time for finalization = 1.3299e-02 seconds\n", + " Total time elapsed = 1.9594e+00 seconds\n", + " Calculation Rate (active) = 38130.9 particles/second\n", + "\n", + " ============================> RESULTS <============================\n", + "\n", + " Leakage Fraction = 0.00486 +/- 0.00066\n", + "\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" } - }, - "outputs": [], - "source": [] + ], + "source": [ + "\n", + "model.settings.survival_biasing = True\n", + "model.settings.cutoff = {\n", + " \"weight\": 0.3, # value needs to be between 0 and 1\n", + " \"weight_avg\": 0.9, # value needs to be between 0 and 1\n", + "}\n", + "run_and_plot(model, \"yes_survival_biasing.png\")\n" + ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "vscode": { - "languageId": "plaintext" - } - }, - "outputs": [], - "source": [] + "source": [ + "Comparing the two simulations we notice that the survival_biasing simulation resulted in slightly improved flux tally and a slightly improved standard deviation.\n", + "\n", + "This model is used again in the next example that makes use of weight windows and yields more impressive acceleration. " + ] } ], "metadata": { + "kernelspec": { + "display_name": "openmc_dev", + "language": "python", + "name": "python3" + }, "language_info": { - "name": "python" + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.13" }, "orig_nbformat": 4 }, From 5010a58fe5886dd686d34b2cfdd15f80bad4e909 Mon Sep 17 00:00:00 2001 From: Jonathan Shimwell Date: Mon, 19 Jun 2023 14:03:50 +0100 Subject: [PATCH 10/24] [skip ci] updated script names --- tasks/task_13_variance_reduction/README.md | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/tasks/task_13_variance_reduction/README.md b/tasks/task_13_variance_reduction/README.md index e369ef1a..33c8e7b0 100644 --- a/tasks/task_13_variance_reduction/README.md +++ b/tasks/task_13_variance_reduction/README.md @@ -7,7 +7,7 @@ The workshop contains the following variance reduction examples: | Filename | variance reduction technique | geometry | mesh type | |---|---|---|---| -| shielded_room_survival_biasing.py | survival_biasing | shielded bunker | RegularMesh | -| generate_single_ww_and_apply.ipynb | weight windows | sphere | SphericalMesh | -| iterative_spherical_mesh_weight_windows.py | weight windows | sphere | SphericalMesh | -| batch_by_batch_till_tally_convergence_limit.py | weight windows | sphere | SphericalMesh | \ No newline at end of file +| 1_shielded_room_survival_biasing.py | survival_biasing | shielded bunker | RegularMesh | +| 2_shielded_room_single_ww.ipynb | weight windows | sphere | SphericalMesh | +| 3_sphere_iterative_per_run_ww.py | weight windows | sphere | SphericalMesh | +| 4_sphere_iterative_per_batch_ww.py | weight windows | sphere | SphericalMesh | \ No newline at end of file From 0ecbbb55143264905dd1132dacb524b57168dcf0 Mon Sep 17 00:00:00 2001 From: shimwell Date: Mon, 19 Jun 2023 20:50:42 +0100 Subject: [PATCH 11/24] transposing mesh plot --- .../1_shielded_room_survival_biasing.ipynb | 305 +----------------- .../1_shielded_room_survival_biasing.py | 215 ------------ 2 files changed, 17 insertions(+), 503 deletions(-) delete mode 100644 tasks/task_13_variance_reduction/1_shielded_room_survival_biasing.py diff --git a/tasks/task_13_variance_reduction/1_shielded_room_survival_biasing.ipynb b/tasks/task_13_variance_reduction/1_shielded_room_survival_biasing.ipynb index 3933ea78..77e9fda7 100644 --- a/tasks/task_13_variance_reduction/1_shielded_room_survival_biasing.ipynb +++ b/tasks/task_13_variance_reduction/1_shielded_room_survival_biasing.ipynb @@ -25,7 +25,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -45,7 +45,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -81,7 +81,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -190,22 +190,9 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAMcAAADMCAYAAADHwrcFAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAAsTAAALEwEAmpwYAAANzElEQVR4nO3dfYxc1X3G8e+DUWziYNeOWWPZVnCIRWIQdcBFVKgpMRI4NK1JoyDzRw0t1VYRiPzRF5mmbWhVV00kFDVtseQ0FoYWHMsKwlTQBDlNqBQi2wmGtUmMDTiwsbMrQkwpKhu//PrHPWumy5zd8e7cuXNnn480mjtn77n+zXifvee+zL2KCMzs3c6pugCzbuVwmGU4HGYZDodZhsNhluFwmGWcW3UBZZk7d2b0XTi76jKsQsM/e4s33hjRZPv3bDj6LpzNP2y+ruoyrEKf6981pf4eVpllOBxmGQ6HWYbDYZbhcJhlOBxmGT27K3cibw/N4/jAsqrLqK0LfmOAGTNPTLr/yM/n8ItnPjSlGn7l8peY1Xd8SssYz7QNx5svLOGFL99cdRk1Fcz76KEpheOtnyyc8ue/4s8fLDUcHlaZZTgcZhkOh1mGw2GW4XCYZTgcZhkOh1mGw2GW4XCYZTgcZhkOh1mGw2GW4XCYZTgcZhkOh1nGtP0+Rzssv2sHcz78StVlTGj/X9/GyND8qsuoHYdjCmb1HWf2B4arLmNC55x7quoSasnDKrMMh8Msw+EwyygtHJK2SBqWtL+h7R5JP5W0Lz1ubPjZ3ZIOSzoo6YaG9islDaSffUXSpK+abXY2ylxz3A+sadL+5YhYmR6PA0haAawDLk197pM0I82/CegHlqdHs2WatV1p4YiIp4DXW5x9LbAtIkYi4mXgMHCVpEXAnIh4Oop7Qj8A3FRKwWZjVLHNcaek59Kwa15qWwy82jDPYGpbnKbHtjclqV/SXkl733hjpN112zTT6XBsAi4GVgLHgHtTe7PtiBinvamI2BwRqyJi1dy5M6dYqk13HQ1HRAxFxKmIOA18Fbgq/WgQWNow6xLgaGpf0qTdrHQdDUfahhj1KWB0T9ZOYJ2kmZKWUWx4746IY8Cbkq5Oe6nWA492smabvko7fUTSw8C1wAJJg8AXgGslraQYGh0B/gggIg5I2g48D5wE7oiI0XMePkux5+s84In0MCtdaeGIiFuaNH9tnPk3AhubtO8FLmtjaWYt8RFyswyHwyzD4TDLcDjMMhwOswyHwyzD4TDLcDjMMhwOswyHwyzD4TDLcDjMMhwOswyHwyzD4TDLcDjMMhwOswyHwyzD4TDLcDjMMhwOswyH48wFFLMXUhynT6+YzGfQKdXV5nAg8lcenahPr5jMZ9Ap1dXmcAATffDNY9CNv0itmcz76dSfgm76rB2OFtQ3Bs1N5v106jPops/a4TDLyF4OVNIVLfQ/EREDbazHrGuMd63c7wJ7GH9Ntwy4qJ0FmXWL8cKxJyJWj9dZ0rfbXI9Z18huc0wUjFbnMaurlm5BIOlyiuHTmfkj4hsl1WTWFSYMh6QtwOXAAeB0ag7A4bCe1sqa4+qIWHG2C06h+iQwHBGXpbb5wNcp1kJHgJsj4hfpZ3cDtwOngLsi4pup/UreubPT48Dn0m2XzUrVynGOpyWddTgofqHXjGnbAOyKiOXArvSatPx1wKWpz32SZqQ+m4B+ivsELm+yTLNStBKOrRQBOZjuHz4g6bmJOkXEU8DrY5rXpuWNLvemhvZtETESES8Dh4Gr0g0250TE02lt8UBDH7NStTKs2gL8HjDAO9sck7Uw3SGWiDgmqS+1Lwa+3zDfYGo7kabHtpuVrpVwvBIRO0uuo9mBxtypmNntDUn9FEMwLlj43vZU1gMuvGE3J/57dluXOeO8X7Z1ed2olXD8WNJDwGPAyGjjJHflDklalNYai4Dh1D4ILG2YbwlwNLUvadLeVERsBjYDLL9kvjfak6Wf/q+qS6ilVrY5zqMIxfXAb6fHJyf57+0Ebk3TtwKPNrSvkzRT0jKKDe/daQj2pqSrJQlY39DHrFQTrjki4vcns2BJDwPXAgskDQJfAP4e2C7pduAV4DPp3zggaTvwPHASuCMiTqVFfZZ3duU+kR5mpWvlIOBWimMLx9PrecC9EfEH4/WLiFsyP7ouM/9GYGOT9r3AZRPVadZurQyrLh8NBkA6aPfR0ioy6xKthOOctLYAzhzlbumcLLM6a+WX/F7ge5J2UOxGvZkmwx+zXtPKBvkDkvYCqymOO/xuRDxfemVmFWtpeJTC4EDYtJLd5pD0w4k6tzJPb/DxxM7pns96vDXHRyY4wVDA3DbX06W66YIxva57PuvxwvHhFvqfmngWs3rKhiMiftLJQsy6jS/qNkb3jHh732Q+607+/zgcY3TPiLf3dfNlSaGFcEi6s/EIudl00cqa40Jgj6TtktakU8fNet6E4YiIv6D4fsXXgNuAQ5L+TtLFJddmVqmWtjnSxQ1+lh4ngXnADklfKrE2s0q18n2Ouyi+tfca8C/An0bECUnnAIeAPyu3RLNqtHJu1QKKkw3/33GPiDgtabJflzXreq2clftX4/zsR+0tx6x7+DiHWYbDYZbhcJhlOBxmGQ6HWYbDYZbhcJhlOBxmGQ6HWYbDYZbhcJhlOBxmGQ6HWYbDYZbhcJhlVBIOSUfS/cz3pSu4I2m+pCclHUrPjfcEuVvS4XQv9BuqqNmmnyrXHB+PiJURsSq93gDsiojlwK70GkkrgHXApcAa4D5JM6oo2KaXbhpWrQW2pumtwE0N7dsiYiQiXgYOA1d1vjybbqoKRwDfkvQDSf2pbWG6tTLpuS+1LwZebeg7mNrMSlXVvf2uiYijkvqAJyX9eJx5m11EruklU1PQ+gEuWPjeqVdp01ola46IOJqeh4FHKIZJQ5IWAaTn4TT7ILC0ofsS4GhmuZsjYlVErJo7d2ZZ5ds00fFwSJot6fzRaeB6YD+wk+L6WKTnR9P0TmCdpJmSllFcfXF3Z6u26aiKYdVC4JF0yd1zgYci4j8k7QG2S7odeAX4DEBEHJC0neKehCeBOyLCN82x0nU8HBHxEvCrTdp/DlyX6bMR397ZOqybduWadRWHwyzD4TDLcDjMMhwOswyHwyzD4TDLcDjMMhwOswyHwyzD4TDLqOr7HD3h7aF5vHVkYdVl1NLI0LyJZ6qYwzEFh/7x01WXYCXysMosw+Ewy3A4zDIcDrMMh+PMhUyaXtDEfWrZpz0cjjNX/ml2BSD3qWef9nA4zDIcDrMMh8Msw+Ewy3A4zDIcDrMMh8Msw+Ewy3A4zDKm7fc5zr/kVS75469XXYZNwfuWD5a6/Gkbjll9x5m1+pmqy7Au5mGVWYbDYZbhcJhl1CYcktZIOijpsKQNVddjva8W4ZA0A/hn4BPACuAWSSuqrcp6XS3CQXEr5sMR8VJE/BLYBqytuCbrcXUJx2Lg1YbXg6nNrDR1Oc7R7DuS7/pSsaR+oD+9HPmta3fsL7Wq9lgAvFZ1EROoQ43w7jo/MJWF1SUcg8DShtdLgKNjZ4qIzcBmAEl7I2JVZ8qbvDrUWYcaof111mVYtQdYLmmZpPcA64CdFddkPa4Wa46IOCnpTuCbwAxgS0QcqLgs63G1CAdARDwOPH4WXTaXVUub1aHOOtQIba5TEZ2/WJZZHdRlm8Os43ouHN12momkI5IGJO2TtDe1zZf0pKRD6Xlew/x3p9oPSrqhxLq2SBqWtL+h7azrknRlen+HJX1FUtsuTZip8R5JP02f5z5JN5ZWY0T0zINiY/1F4IPAe4BngRUV13QEWDCm7UvAhjS9Afhiml6Rap4JLEvvZUZJdX0MuALYP5W6gN3Ar1Mci3oC+ETJNd4D/EmTedteY6+tOepymslaYGua3grc1NC+LSJGIuJl4DDFe2q7iHgKeH0qdUlaBMyJiKej+C18oKFPWTXmtL3GXgtHN55mEsC3JP0gHcEHWBgRxwDSc19qr7r+s61rcZoe2162OyU9l4Zdo0O/ttfYa+Fo6TSTDrsmIq6gOKP4DkkfG2febqwf8nVVUe8m4GJgJXAMuDe1t73GXgtHS6eZdFJEHE3Pw8AjFMOkobS6Jz0Pp9mrrv9s6xpM02PbSxMRQxFxKiJOA1/lnWFn22vstXB01WkmkmZLOn90Grge2J9qujXNdivwaJreCayTNFPSMmA5xcZkp5xVXWno9aakq9MeoPUNfUoxGt7kUxSfZzk1Vrknp6S9MDcCL1Dsrfh8xbV8kGIPyrPAgdF6gPcDu4BD6Xl+Q5/Pp9oP0sY9P01qe5hiWHKC4q/r7ZOpC1iVfkFfBP6JdGC5xBofBAaA51IgFpVVo4+Qm2X02rDKrG0cDrMMh8Msw+Ewy3A4zDIcDrMMh6PGJF0k6X8l7WvT8v5T0v9I6vqLKXSCw1F/L0bEynYsKCI+Duxtx7J6gcPRpST9WjrzdFY6DeWApMta6Lc+9XtW0oOp7X5Jm9Ka4SVJv5nOaP2RpPtLfzM1VZsLLEw3EbFH0k7gb4HzgH+NiHEvUifpUopTKK6JiNckzW/48TxgNfA7wGPANcAfAnskrYyIfSW8jVpzOLrb31CcTPk2cFcL868GdkTEawAR0fhFocciIiQNAEMRMQAg6QBwEbCvjXX3BA+rutt84H3A+cCsFuYX+e8qjKTn0w3To6/9R7IJh6O7bQb+Evg34IstzL8LuFnS+6G4YEKJtfU8/8XoUpLWAycj4iEV9yf5nqTVEfHtXJ+IOCBpI/BdSaeAZ4DbOlNx7/Ep6zUm6SLg3yNiwr1YZ7HM71Bc3WPa79L1sKreTgFz23kQkOILWifasby685rDLMNrDrMMh8Msw+Ewy3A4zDIcDrOM/wMBMY2FOTRWiAAAAABJRU5ErkJggg==", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "\n", "geometry.root_universe.plot(basis='xy', color_by='material') \n", @@ -222,7 +209,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -251,7 +238,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -278,7 +265,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -300,7 +287,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -317,7 +304,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -334,7 +321,7 @@ " flux_mean = flux_tally.get_reshaped_data(value='mean', expand_dims=True).squeeze()\n", " plt.subplot(1, 2, 1)\n", " plt.imshow(\n", - " flux_mean,\n", + " flux_mean.T,\n", " origin=\"lower\",\n", " extent=mesh_extent,\n", " norm=LogNorm(),\n", @@ -346,7 +333,7 @@ " # create a plot of the flux relative error\n", " flux_std_dev = flux_tally.get_reshaped_data(value='std_dev', expand_dims=True).squeeze()\n", " plt.imshow(\n", - " flux_std_dev,\n", + " flux_std_dev.T,\n", " origin=\"lower\",\n", " extent=mesh_extent,\n", " norm=LogNorm(),\n", @@ -367,138 +354,9 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": null, "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 | 96d150a64e7636138bdc60042d97f3d33f5cce38\n", - " Date/Time | 2023-06-19 09:22:41\n", - " OpenMP Threads | 28\n", - "\n", - " Reading model XML file './model.xml' ...\n", - " Reading cross sections XML file...\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", - " WARNING: Negative value(s) found on probability table for nuclide Ar36 at 294K\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", - " 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: 294 K\n", - " Maximum neutron data temperature: 294 K\n", - " Preparing distributed cell instances...\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 = 1.6954e+00 seconds\n", - " Reading cross sections = 1.6605e+00 seconds\n", - " Total time in simulation = 2.5190e-01 seconds\n", - " Time in transport only = 2.4342e-01 seconds\n", - " Time in active batches = 2.5190e-01 seconds\n", - " Time accumulating tallies = 1.7898e-03 seconds\n", - " Time writing statepoints = 6.1760e-03 seconds\n", - " Total time for finalization = 1.1361e-02 seconds\n", - " Total time elapsed = 1.9681e+00 seconds\n", - " Calculation Rate (active) = 39697.8 particles/second\n", - "\n", - " ============================> RESULTS <============================\n", - "\n", - " Leakage Fraction = 0.00486 +/- 0.00066\n", - "\n" - ] - }, - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 17, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "\n", "run_and_plot(model, \"no_survival_biasing.png\")\n" @@ -514,138 +372,9 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": null, "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 | 96d150a64e7636138bdc60042d97f3d33f5cce38\n", - " Date/Time | 2023-06-19 09:21:47\n", - " OpenMP Threads | 28\n", - "\n", - " Reading model XML file './model.xml' ...\n", - " Reading cross sections XML file...\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", - " WARNING: Negative value(s) found on probability table for nuclide Ar36 at 294K\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", - " 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: 294 K\n", - " Maximum neutron data temperature: 294 K\n", - " Preparing distributed cell instances...\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 = 1.6743e+00 seconds\n", - " Reading cross sections = 1.6428e+00 seconds\n", - " Total time in simulation = 2.6225e-01 seconds\n", - " Time in transport only = 2.4040e-01 seconds\n", - " Time in active batches = 2.6225e-01 seconds\n", - " Time accumulating tallies = 1.5301e-02 seconds\n", - " Time writing statepoints = 6.1750e-03 seconds\n", - " Total time for finalization = 1.3299e-02 seconds\n", - " Total time elapsed = 1.9594e+00 seconds\n", - " Calculation Rate (active) = 38130.9 particles/second\n", - "\n", - " ============================> RESULTS <============================\n", - "\n", - " Leakage Fraction = 0.00486 +/- 0.00066\n", - "\n" - ] - }, - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 15, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "\n", "model.settings.survival_biasing = True\n", @@ -683,7 +412,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.13" + "version": "3.10.10" }, "orig_nbformat": 4 }, diff --git a/tasks/task_13_variance_reduction/1_shielded_room_survival_biasing.py b/tasks/task_13_variance_reduction/1_shielded_room_survival_biasing.py deleted file mode 100644 index ac0bde39..00000000 --- a/tasks/task_13_variance_reduction/1_shielded_room_survival_biasing.py +++ /dev/null @@ -1,215 +0,0 @@ -import openmc -import openmc_geometry_plot # adds extra plotting functions to openmc.Geometry object -import numpy as np -from matplotlib import pyplot as plt -from matplotlib.colors import LogNorm - - -air = openmc.Material(name="Air") -air.set_density("g/cc", 0.001205) -air.add_element("N", 0.784431) -air.add_element("O", 0.210748) -air.add_element("Ar", 0.0046) - -concrete = openmc.Material(name="concrete") -concrete.set_density("g/cm3", 7.874) -concrete.add_element("Fe", 1) - -materials = openmc.Materials([air, concrete]) - -width_a = 100 -width_b = 200 -width_c = 500 -width_d = 250 -width_e = 200 -width_f = 200 -width_g = 100 - -depth_a = 100 -depth_b = 200 -depth_c = 700 -depth_d = 600 -depth_e = 200 -depth_f = 100 - -height_j = 100 -height_k = 500 -height_l = 100 - - -xplane_0 = openmc.XPlane(x0=0, boundary_type="vacuum") -xplane_1 = openmc.XPlane(x0=xplane_0.x0 + width_a) -xplane_2 = openmc.XPlane(x0=xplane_1.x0 + width_b) -xplane_3 = openmc.XPlane(x0=xplane_2.x0 + width_c) -xplane_4 = openmc.XPlane(x0=xplane_3.x0 + width_d) -xplane_5 = openmc.XPlane(x0=xplane_4.x0 + width_e) -xplane_6 = openmc.XPlane(x0=xplane_5.x0 + width_f) -xplane_7 = openmc.XPlane(x0=xplane_6.x0 + width_g, boundary_type="vacuum") - -yplane_0 = openmc.YPlane(y0=0, boundary_type="vacuum") -yplane_1 = openmc.YPlane(y0=yplane_0.y0 + depth_a) -yplane_2 = openmc.YPlane(y0=yplane_1.y0 + depth_b) -yplane_3 = openmc.YPlane(y0=yplane_2.y0 + depth_c) -yplane_4 = openmc.YPlane(y0=yplane_3.y0 + depth_d) -yplane_5 = openmc.YPlane(y0=yplane_4.y0 + depth_e) -yplane_6 = openmc.YPlane(y0=yplane_5.y0 + depth_f, boundary_type="vacuum") - -zplane_1 = openmc.ZPlane(z0=0, boundary_type="vacuum") -zplane_2 = openmc.ZPlane(z0=zplane_1.z0 + height_j) -zplane_3 = openmc.ZPlane(z0=zplane_2.z0 + height_k) -zplane_4 = openmc.ZPlane(z0=zplane_3.z0 + height_l, boundary_type="vacuum") - -outside_left_region = +xplane_0 & -xplane_1 & +yplane_1 & -yplane_5 & +zplane_1 & -zplane_4 -wall_left_region = +xplane_1 & -xplane_2 & +yplane_2 & -yplane_4 & +zplane_2 & -zplane_3 -wall_right_region = +xplane_5 & -xplane_6 & +yplane_2 & -yplane_5 & +zplane_2 & -zplane_3 -wall_top_region = +xplane_1 & -xplane_4 & +yplane_4 & -yplane_5 & +zplane_2 & -zplane_3 -outside_top_region = +xplane_0 & -xplane_7 & +yplane_5 & -yplane_6 & +zplane_1 & -zplane_4 -wall_bottom_region = +xplane_1 & -xplane_6 & +yplane_1 & -yplane_2 & +zplane_2 & -zplane_3 -outside_bottom_region = +xplane_0 & -xplane_7 & +yplane_0 & -yplane_1 & +zplane_1 & -zplane_4 -wall_middle_region = +xplane_3 & -xplane_4 & +yplane_3 & -yplane_4 & +zplane_2 & -zplane_3 -outside_right_region = +xplane_6 & -xplane_7 & +yplane_1 & -yplane_5 & +zplane_1 & -zplane_4 - -room_region = +xplane_2 & -xplane_3 & +yplane_2 & -yplane_4 & +zplane_2 & -zplane_3 -gap_region = +xplane_3 & -xplane_4 & +yplane_2 & -yplane_3 & +zplane_2 & -zplane_3 -corridor_region = +xplane_4 & -xplane_5 & +yplane_2 & -yplane_5 & +zplane_2 & -zplane_3 - -roof_region = +xplane_1 & -xplane_6 & +yplane_1 & -yplane_5 & +zplane_1 & -zplane_2 -floor_region = +xplane_1 & -xplane_6 & +yplane_1 & -yplane_5 & +zplane_3 & -zplane_4 - -outside_left_cell = openmc.Cell(region=outside_left_region, fill=air) -outside_right_cell = openmc.Cell(region=outside_right_region, fill=air) -outside_top_cell = openmc.Cell(region=outside_top_region, fill=air) -outside_bottom_cell = openmc.Cell(region=outside_bottom_region, fill=air) -wall_left_cell = openmc.Cell(region=wall_left_region, fill=concrete) -wall_right_cell = openmc.Cell(region=wall_right_region, fill=concrete) -wall_top_cell = openmc.Cell(region=wall_top_region, fill=concrete) -wall_bottom_cell = openmc.Cell(region=wall_bottom_region, fill=concrete) -wall_middle_cell = openmc.Cell(region=wall_middle_region, fill=concrete) -room_cell = openmc.Cell(region=room_region, fill=air) -gap_cell = openmc.Cell(region=gap_region, fill=air) -corridor_cell = openmc.Cell(region=corridor_region, fill=air) - -roof_cell = openmc.Cell(region=roof_region, fill=concrete) -floor_cell = openmc.Cell(region=floor_region, fill=concrete) - -materials = openmc.Materials([air, concrete]) -geometry = openmc.Geometry( - [ - outside_bottom_cell, - outside_top_cell, - outside_left_cell, - outside_right_cell, - wall_left_cell, - wall_right_cell, - wall_top_cell, - wall_bottom_cell, - wall_middle_cell, - room_cell, - gap_cell, - corridor_cell, - roof_cell, - floor_cell, - ] -) - -model = openmc.Model() -model.geometry = geometry - -# location of the point source -source_x = width_a + width_b + width_c * 0.5 -source_y = depth_a + depth_b + depth_c * 0.75 -source_z = height_j + height_k * 0.5 - -geometry.root_universe.plot(basis='xy', color_by='material') -plt.savefig('geometry_view_2.png', bbox_inches="tight") - -mesh = openmc.RegularMesh().from_domain(geometry) -mesh.dimension = (100, 100, 1) - -mesh_filter = openmc.MeshFilter(mesh) - -flux_tally = openmc.Tally(name="flux tally") -flux_tally.filters = [mesh_filter] -flux_tally.scores = ["flux"] - -model.tallies = [flux_tally] - -space = openmc.stats.Point((source_x, source_y, source_z)) -angle = openmc.stats.Isotropic() -energy = openmc.stats.Discrete([2.5e6], [1.0]) - -source = openmc.Source(space=space, angle=angle, energy=energy) -source.particle = "neutron" -model.settings.run_mode = "fixed source" -model.settings.source = source -model.settings.particles = 2000 -model.settings.batches = 5 - - -def run_and_plot(model, filename, output=True): - - sp_filename = model.run(output=output) - - with openmc.StatePoint(sp_filename) as sp: - flux_tally = sp.get_tally(name="flux tally") - - mesh_extent = mesh.bounding_box.extent['xy'] - - # create a plot of the mean flux values - flux_mean = flux_tally.mean.reshape(100, 100) - plt.subplot(1, 2, 1) - plt.imshow( - flux_mean, - origin="lower", - extent=mesh_extent, - norm=LogNorm(), - ) - plt.title("Flux Mean") - - data_slice = geometry.get_slice_of_material_ids(view_direction="z") - xlabel, ylabel = geometry.get_axis_labels(view_direction="z") - plt.xlabel(xlabel) - plt.ylabel(ylabel) - - plt.contour( - np.fliplr(data_slice), - origin="upper", - colors="k", - linestyles="solid", - linewidths=1, - extent=mesh_extent, - ) - - plt.subplot(1, 2, 2) - # create a plot of the flux relative error - flux_std_dev = flux_tally.get_values(value="std_dev").reshape(*mesh.dimension) - plt.imshow( - flux_std_dev, - origin="lower", - extent=mesh_extent, - norm=LogNorm(), - ) - plt.title("Flux Std. Dev.") - - plt.xlabel(xlabel) - plt.ylabel(ylabel) - plt.contour( - np.fliplr(data_slice), - origin="upper", - colors="k", - linestyles="solid", - linewidths=1, - extent=mesh_extent, - ) - plt.savefig(filename) - return sp - - -run_and_plot(model, "no_survival_biasing.png") - -model.settings.survival_biasing = True -model.settings.cutoff = { - "weight": 0.3, # value needs to be between 0 and 1 - "weight_avg": 0.9, # value needs to be between 0 and 1 -} -# run_and_plot(model, "yes_survival_biasing.png") From e7cf7613d3293f137015f710e898406c0e5868e7 Mon Sep 17 00:00:00 2001 From: shimwell Date: Mon, 19 Jun 2023 22:18:37 +0100 Subject: [PATCH 12/24] added timed example for ww --- .../2_shielded_room_single_ww.ipynb | 502 ++++++++++++------ 1 file changed, 350 insertions(+), 152 deletions(-) diff --git a/tasks/task_13_variance_reduction/2_shielded_room_single_ww.ipynb b/tasks/task_13_variance_reduction/2_shielded_room_single_ww.ipynb index e1ec105c..f4f09f67 100644 --- a/tasks/task_13_variance_reduction/2_shielded_room_single_ww.ipynb +++ b/tasks/task_13_variance_reduction/2_shielded_room_single_ww.ipynb @@ -6,9 +6,24 @@ "id": "72e0b25d-e541-4e8d-8805-b984374ee53d", "metadata": {}, "source": [ - "# variance reduction techniques\n", + "# Variance Reduction - Weight Windows\n", "\n", - "## Creating and utilising a wight window to accelerate the deep shielding simulations" + "## 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" ] }, { @@ -17,13 +32,7 @@ "id": "f00eddb1-1e3a-4973-ba0c-d8feeb2a6704", "metadata": {}, "source": [ - "This example implements a single step of the Magic method of weight window generation. The theory of weight windows and the method are best described by the paper here https://scientific-publications.ukaea.uk/wp-content/uploads/Published/INTERN1.pdf\n", - "\n", - "In this tutorial we shall focus on generating a weight window to accelerate the simulation of particles through a shield.\n", - "\n", - "First we must make a model. This is kept as simple as possible as the focus of this notebook is on generating and then using a weight window.\n", - "\n", - "The model is a single sphere of 200 cm radius filled with water and containing a 14MeV point source in the center" + "First we import ```openmc``` including ```openmc.lib``` and other packages needed for the example" ] }, { @@ -33,38 +42,13 @@ "metadata": {}, "outputs": [], "source": [ - "import openmc\n", + "import time # used to time the simulation\n", "\n", - "# creates a shielding material\n", - "water = openmc.Material(name='Water')\n", - "water.set_density('g/cc', 1.0)\n", - "water.add_element('H', 2)\n", - "water.add_element('O', 1)\n", - "materials = openmc.Materials([water])\n", - "\n", - "sphere1 = openmc.Sphere(r=200, boundary_type='vacuum')\n", - "\n", - "region1 = -sphere1\n", - "\n", - "cell1 = openmc.Cell(fill=water, region=region1)\n", - "\n", - "geometry = openmc.Geometry([cell1])\n", - "\n", - "source = openmc.Source()\n", - "source.space = openmc.stats.Point((0.0, 0.0, 0.0))\n", - "source.angle = openmc.stats.Isotropic()\n", - "source.energy = openmc.stats.Discrete([14e6], [1.0])\n", - "source.particle = 'neutron'\n", - "\n", - "my_settings = openmc.Settings()\n", - "my_settings.run_mode = 'fixed source'\n", - "my_settings.source = source\n", - "my_settings.particles = 10000\n", - "my_settings.batches = 10\n", - "# the mesh tallies produce large tallies.out files so this output setting avoids writing the tallies.out and saves time\n", - "my_settings.output = {'tallies': False}\n", + "import openmc\n", + "import openmc.lib # this example makes use of openmc lib to run the simulations\n", "\n", - "model = openmc.model.Model(geometry, materials, my_settings)" + "from matplotlib import pyplot as plt\n", + "from matplotlib.colors import LogNorm # used for plotting log scale graphs" ] }, { @@ -73,7 +57,7 @@ "id": "8179e89a-304b-4684-91a9-8a908b75e8cd", "metadata": {}, "source": [ - "Now we can plot the simple geometry" + "We create a couple of materials for the simulation" ] }, { @@ -83,10 +67,26 @@ "metadata": {}, "outputs": [], "source": [ - "import matplotlib.pyplot as plt\n", - "plt.figure(figsize=(10,10))\n", - "model.geometry.root_universe.plot(width=(400, 400), pixels=(600, 600))\n", - "plt.show()" + "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])" ] }, { @@ -95,9 +95,7 @@ "id": "424b234c-48a2-4d1b-b374-f69430e464db", "metadata": {}, "source": [ - "Now we shall add a regular mesh tally over the the geometry.\n", - "\n", - "The mesh will be used to record the neutron flux in each mesh voxel" + "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." ] }, { @@ -107,229 +105,429 @@ "metadata": {}, "outputs": [], "source": [ - "mesh = openmc.RegularMesh()\n", - "mesh.lower_left = model.geometry.bounding_box[0]\n", - "mesh.upper_right = model.geometry.bounding_box[1]\n", - "mesh.dimension = (50, 50, 50)\n", - "\n", - "mesh_filter = openmc.MeshFilter(mesh)\n", - "\n", - "flux_tally = openmc.Tally(name='flux tally')\n", - "flux_tally.filters = [mesh_filter]\n", - "flux_tally.scores = ['flux']\n", "\n", - "# adds the mesh tally to the model\n", - "model.tallies = [flux_tally]" + "width_a = 100\n", + "width_b = 100\n", + "width_c = 500\n", + "width_d = 100\n", + "width_e = 100\n", + "width_f = 100\n", + "width_g = 100\n", + "\n", + "depth_a = 100\n", + "depth_b = 100\n", + "depth_c = 700\n", + "depth_d = 600\n", + "depth_e = 100\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": "458867ab-5b7b-400a-bbf4-c290988a99da", + "id": "51713fe1", "metadata": {}, "source": [ - "Now we shall run the simulation and record flux in each mesh voxel" + "Now we plot the geometry and color by materials." ] }, { "cell_type": "code", "execution_count": null, - "id": "1c5b84c7-0fe5-48d5-b2b7-58ce8cea57f1", + "id": "94c41f17", "metadata": {}, "outputs": [], "source": [ - "output_file = model.run()" + "\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": "e54d695d-1f35-477c-8506-fcbca57b179a", + "id": "8d6bd790", "metadata": {}, "source": [ - "Now we can plot the flux and the standard deviation of the flux tally to see how far into the shield the neutrons got. " + "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": null, - "id": "0494f6db-ec78-43f2-a6be-c4c55c7e7d0a", + "id": "fd4986b0", "metadata": {}, "outputs": [], "source": [ - "from matplotlib.colors import LogNorm\n", - "\n", - "with openmc.StatePoint(output_file) as sp:\n", - " flux_tally = sp.get_tally(id=flux_tally.id)\n", + "# 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", - "llc, urc = model.geometry.bounding_box\n", + "angle = openmc.stats.Isotropic()\n", "\n", - "fig, (ax1, ax2) = plt.subplots(1,2)\n", - "fig.suptitle('Flux and std. dev. without weight window')\n", + "# all (100%) of source particles are 2.5MeV energy\n", + "energy = openmc.stats.Discrete([2.5e6], [1.0])\n", "\n", - "slice_index = int(mesh.dimension[-1]/2)\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": null, + "id": "9d7bbee6", + "metadata": {}, + "outputs": [], + "source": [ + "mesh = openmc.RegularMesh().from_domain(geometry)\n", + "mesh.dimension = (500, 500, 1)\n", "\n", - "# create a plot of the mean values\n", - "flux_mean = flux_tally.mean.reshape(*mesh.dimension)\n", - "img1 = ax1.imshow(flux_mean[slice_index], origin='lower', extent=(llc[0], urc[0], llc[1], urc[1]), norm=LogNorm())\n", - "ax1.set_title('Flux Mean')\n", - "plt.colorbar(img1, ax=ax1, fraction=0.046)\n", - "img1.set_clim(vmin=1e-30, vmax=1.0)\n", + "mesh_filter = openmc.MeshFilter(mesh)\n", + "particle_filter = openmc.ParticleFilter('neutron')\n", "\n", - "# create a plot of the flux relative error\n", - "flux_rel_err = flux_tally.get_values(value='rel_err').reshape(*mesh.dimension)\n", - "img2 = ax2.imshow(flux_rel_err[slice_index], origin='lower', extent=(llc[0], urc[0], llc[1], urc[1]))\n", - "ax2.set_title('Flux Rel. Err.')\n", - "plt.colorbar(img2, ax=ax2, fraction=0.046)\n", - "# ax2.set_colorbar(img2, ax=ax2)\n", - "img2.set_clim(vmin=0.0, vmax=1.0)\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", - "plt.show()" + "tallies = openmc.Tallies([flux_tally])" ] }, { "attachments": {}, "cell_type": "markdown", - "id": "f0b0c196-0829-4b36-abec-8fec944c8f2b", + "id": "2bc34eac", "metadata": {}, "source": [ - "As this flux map tells us where the neutrons go we can use it to create a wieght window that promotes neutron transport in areas they normally don't reach." + "Creates the simulation settings" ] }, { "cell_type": "code", "execution_count": null, - "id": "03cc2b9f-5421-41d3-9f0d-4d43cf82977f", + "id": "ea32fb73", "metadata": {}, "outputs": [], "source": [ - "import openmc_weight_window_generator\n", - "# this is a minimal package that adds some functionality to openmc, namely it adds:\n", - "# - openmc.StatePoint.generate_wws which we use in this task\n", - "# - openmc.Model.generate_wws_magic_method which we use in the next task\n", - "\n", - "sp_file = openmc.StatePoint(output_file)\n", - "# this generates an openmc.WeightWindow object from the flux tally\n", - "weight_windows = sp_file.generate_wws(tally=flux_tally, rel_err_tol=0.7)" + "settings = openmc.Settings()\n", + "\n", + "settings.run_mode = \"fixed source\"\n", + "settings.source = source\n", + "settings.particles = 80000\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": "cfb6e00c-aada-4951-9cdf-022477defa6c", + "id": "9bc4e52b", "metadata": {}, "source": [ - "The weight window generated uses the same mesh as the flux tally, uses the flux to generate lower_ww_bounds, sets the upper_bound_ratio to 5 (rule of thumb used here) and sets the max_split to 1_000_000. These can all be changed to customise the weight window but are reasonable defaults.\n", - "\n", - "We can plot the lower_ww_bounds of the generated weight window to see how it changes over the geometry" + "Creates and export the model" ] }, { "cell_type": "code", "execution_count": null, - "id": "c2cc0474-ab96-4db9-a261-ff0b1fe9256b", + "id": "6d8042a5", "metadata": {}, "outputs": [], "source": [ - "plt.imshow(weight_windows[0].lower_ww_bounds[slice_index], origin='lower', extent=(llc[0], urc[0], llc[1], urc[1]), norm=LogNorm())\n", - "plt.title('lower_ww_bounds')\n", - "plt.colorbar()" + "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": "02af110d-9ea2-4782-a355-bbd6822cc394", + "id": "488391db", "metadata": {}, "source": [ - "Now we can rerun the simulation but this time using the weight window to push the particles further into the geometry" + "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": null, - "id": "4c5f7fda-870f-4c84-8820-e87966de2ae0", + "id": "9159a336", "metadata": {}, "outputs": [], "source": [ - "#deletes the old output files\n", - "!rm summary.h5\n", - "!rm statepoint.*.h5\n", + "# 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", - "model.settings.weight_windows = weight_windows\n", - "model.settings.max_split = 1_000 # might want to increase this to 1_000_000 and get a better result \n", - "model.run()" + "t1 = time.time()\n", + "\n", + "total = t1-t0\n", + "\n", + "print(f'total time without weight windows {total}s')" ] }, { "attachments": {}, "cell_type": "markdown", - "id": "4eee750a-8913-4dcc-a528-fcea1b74a854", + "id": "79ec2340", "metadata": {}, "source": [ - "We can now plot the flux and standard devation of the flux for the simulation that used weight windows and see that the particles penetrated further into the shield and that the standard deviation has been reduced." + "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": null, - "id": "fb2b523c-f925-4670-927b-22ce695de56e", + "id": "e6f60d98", "metadata": {}, "outputs": [], "source": [ - "with openmc.StatePoint(output_file) as sp:\n", - " flux_tally = sp.get_tally(id=flux_tally.id)\n", - "\n", - "fig, (ax1, ax2) = plt.subplots(1,2)\n", - "fig.tight_layout() \n", - "fig.suptitle('Flux and std. dev. with weight window')\n", - "\n", - "# create a plot of the mean values\n", - "flux_mean = flux_tally.mean.reshape(*mesh.dimension)\n", - "img1 = ax1.imshow(flux_mean[slice_index], origin='lower', extent=(llc[0], urc[0], llc[1], urc[1]), norm=LogNorm())\n", - "ax1.set_title('Flux Mean')\n", - "plt.colorbar(img1, ax=ax1, fraction=0.046)\n", - "img1.set_clim(vmin=1e-30, vmax=1.0)\n", - "\n", - "# create a plot of the flux relative error\n", - "flux_rel_err = flux_tally.get_values(value='rel_err').reshape(*mesh.dimension)\n", - "img2 = ax2.imshow(flux_rel_err[slice_index], origin='lower', extent=(llc[0], urc[0], llc[1], urc[1]))\n", - "ax2.set_title('Flux Rel. Err.')\n", - "plt.colorbar(img2, ax=ax2, fraction=0.046)\n", - "# ax2.set_colorbar(img2, ax=ax2)\n", - "img2.set_clim(vmin=0.0, vmax=1.0)\n", - "\n", - "plt.show()" + "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()#[:, :, 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()#[:, :, 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": "2285d40b-2e8e-4f52-ac14-c742599cf08f", + "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": null, + "id": "8fb8f31e", + "metadata": {}, + "outputs": [], + "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": null, + "id": "d519ac33", "metadata": {}, + "outputs": [], "source": [ - "Notice that the particles now get further into the shielding and the error has been reduce across the simulation.\n", + "# 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 = 12000\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 = 380\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", - "This is not exactly a fair comparison as the second simulation takes a little longer to run. To make it fairer we could use a trigger to stop each simulation after the same amount of time. However that would complicate the example." + "t1 = time.time()\n", + "\n", + "total = t1-t0\n", + "\n", + "print(f'total time without weight windows {total}s')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "fbf35ffc", + "metadata": {}, + "outputs": [], + "source": [ + "plot_mesh_tally(f'statepoint.{settings.batches}.h5', 'ww.png')" ] }, { "attachments": {}, "cell_type": "markdown", - "id": "4e9a1ae6-7ab7-4bdb-be1a-39fa6a8ca4c2", + "id": "b086b6ec", "metadata": {}, "source": [ - "Learning Outcomes:\n", - "* Weight windows can be useful for accelerating deep shielding simulations where particles\n", - "* Weight windows can be generated from a neutron flux field\n", - "* The MAGIC method is a popular method of generating weight windows" + "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": "91d6b1bb-8b69-46fb-9a09-91727db67c29", + "id": "c56069a4", "metadata": {}, "outputs": [], "source": [] @@ -351,7 +549,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.13" + "version": "3.10.10" } }, "nbformat": 4, From 081a096b6f52111ea1e7b8b646f33000d48d5dd2 Mon Sep 17 00:00:00 2001 From: Jonathan Shimwell Date: Tue, 20 Jun 2023 16:40:21 +0100 Subject: [PATCH 13/24] added ww plot --- .../2_shielded_room_single_ww.ipynb | 13 +++++-------- 1 file changed, 5 insertions(+), 8 deletions(-) diff --git a/tasks/task_13_variance_reduction/2_shielded_room_single_ww.ipynb b/tasks/task_13_variance_reduction/2_shielded_room_single_ww.ipynb index f4f09f67..95e86f6f 100644 --- a/tasks/task_13_variance_reduction/2_shielded_room_single_ww.ipynb +++ b/tasks/task_13_variance_reduction/2_shielded_room_single_ww.ipynb @@ -8,9 +8,9 @@ "source": [ "# Variance Reduction - Weight Windows\n", "\n", - "## Creating and utilizing a wight window to accelerate the deep shielding simulations\n", + "## Creating and utilizing a wight window to accelerate 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", + "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", @@ -20,10 +20,7 @@ "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" + "https://scientific-publications.ukaea.uk/wp-content/uploads/Published/INTERN1.pdf\n" ] }, { @@ -393,7 +390,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()#[:, :, 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", @@ -407,7 +404,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()#[:, :, 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", From e9c6537e53fdd3dd60ce668d2c282f2c02c54439 Mon Sep 17 00:00:00 2001 From: Jonathan Shimwell Date: Wed, 21 Jun 2023 14:00:41 +0100 Subject: [PATCH 14/24] removing dilute_initial arg which is not longer supported --- .../shut_down_dose_rate_example.py | 1 - ...ample_transmutation_isotope_build_up.ipynb | 11 ++--- .../2_example_tally_change_with_burnup.ipynb | 43 +++++++++++++++---- 3 files changed, 38 insertions(+), 17 deletions(-) diff --git a/tasks/task_09_CSG_dose_tallies/shut_down_dose_rate_example.py b/tasks/task_09_CSG_dose_tallies/shut_down_dose_rate_example.py index 28c59b51..0c9bcf4b 100644 --- a/tasks/task_09_CSG_dose_tallies/shut_down_dose_rate_example.py +++ b/tasks/task_09_CSG_dose_tallies/shut_down_dose_rate_example.py @@ -109,7 +109,6 @@ # final_step=False, operator_kwargs={ "normalization_mode": "source-rate", # needed as this is a fixed source simulation - "dilute_initial": 0, # need to avoid adding small amounts of fissle material "chain_file": chain_file }, ) diff --git a/tasks/task_14_activation_transmutation_depletion/1_example_transmutation_isotope_build_up.ipynb b/tasks/task_14_activation_transmutation_depletion/1_example_transmutation_isotope_build_up.ipynb index d5981775..40781722 100644 --- a/tasks/task_14_activation_transmutation_depletion/1_example_transmutation_isotope_build_up.ipynb +++ b/tasks/task_14_activation_transmutation_depletion/1_example_transmutation_isotope_build_up.ipynb @@ -146,18 +146,16 @@ "# this file tells openmc the decay paths between isotopes including probabilities of different routes and half lives\n", "# To download this xml file you can run these commands\n", "# pip install openmc_data\n", - "# download_nndc_chain -d nuclear_data -r b8.0\n", + "# download_endf_chain -d nuclear_data -r b8.0\n", "\n", "openmc.config['chain_file'] = '/nuclear_data/chain-nndc-b8.0.xml'\n", "\n", "operator = openmc.deplete.CoupledOperator(\n", " model=model,\n", " normalization_mode=\"source-rate\", # set for fixed source simulation, otherwise defaults to fission simulation\n", - " dilute_initial=0, # set to zero to avoid adding small amounts of isotopes, defaults to adding small amounts of fissionable isotopes\n", " reduce_chain=True, # reduced to only the isotopes present in depletable materials and their possible progeny\n", " reduce_chain_level=5,\n", - ")\n", - "\n" + ")" ] }, { @@ -239,7 +237,6 @@ "metadata": {}, "outputs": [], "source": [ - "\n", "integrator.integrate()\n", "\n", "# bash command to show the output files produce\n", @@ -322,7 +319,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3.10.6 ('openmc_plot_dev')", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -336,7 +333,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.10" + "version": "3.8.13" }, "vscode": { "interpreter": { diff --git a/tasks/task_14_activation_transmutation_depletion/2_example_tally_change_with_burnup.ipynb b/tasks/task_14_activation_transmutation_depletion/2_example_tally_change_with_burnup.ipynb index b3c05f18..164d6f61 100644 --- a/tasks/task_14_activation_transmutation_depletion/2_example_tally_change_with_burnup.ipynb +++ b/tasks/task_14_activation_transmutation_depletion/2_example_tally_change_with_burnup.ipynb @@ -16,14 +16,13 @@ "outputs": [], "source": [ "# remove any old files\n", - "!rm settings.xm model.xml materials.xml geometry.xml settings.xml\n", + "!rm settings.xm model.xml materials.xml geometry.xml settings.xml model.xml\n", "\n", "import openmc\n", "import openmc.deplete\n", "import math\n", "\n", "\n", - "\n", "# MATERIALS\n", "\n", "mats = openmc.Materials()\n", @@ -128,13 +127,12 @@ "# this file tells openmc the decay paths between isotopes including probabilities of different routes and half lives\n", "# To download this xml file you can run these commands\n", "# pip install openmc_data\n", - "# download_nndc_chain -d nuclear_data -r b8.0\n", - "openmc.config['chain_file'] = '/nuclear_data/chain-nndc-b8.0.xml'\n", + "# download_endf_chain -d nuclear_data -r b8.0\n", + "# openmc.config['chain_file'] = '/nuclear_data/chain-nndc-b8.0.xml'\n", "\n", "operator = openmc.deplete.CoupledOperator(\n", " model=model,\n", " normalization_mode=\"source-rate\", # set for fixed source simulation, otherwise defaults to fission simulation\n", - " dilute_initial=0, # set to zero to avoid adding small amounts of isotopes, defaults to adding small amounts of fissionable isotopes\n", " reduce_chain=True # reduced to only the isotopes present in depletable materials and their possible progeny\n", ")\n", "\n", @@ -186,14 +184,41 @@ "source": [ "results = openmc.deplete.ResultsList.from_hdf5(\"depletion_results.h5\")\n", "\n", - "times, number_of_n_gamma_reactions = results.get_reaction_rate(breeding_material, 'Li6', '(n,gamma)')\n", - "number_of_n_gamma_reactions" + "times, number_of_n_gamma_reactions = results.get_reaction_rate(breeding_material, 'Li6', '(n,gamma)')" ] + }, + { + "cell_type": "markdown", + "id": "f4e5eaee-f68c-48cc-b8c2-fb79ba4abee5", + "metadata": {}, + "source": [ + "Then we can plot the changing reaction rate as a function of time steps" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "bba28c5c-21fc-4563-a473-d9638541d56a", + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "plt.plot(times, number_of_n_gamma_reactions)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a268d5ff-d90a-4e2c-be05-5f8c6d7f61ea", + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { "kernelspec": { - "display_name": "Python 3.10.6 ('openmc_plot_dev')", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -207,7 +232,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.10" + "version": "3.8.13" }, "vscode": { "interpreter": { From 758529dc7b8f4f781fb97f793b56eb7d87591baf Mon Sep 17 00:00:00 2001 From: Jonathan Shimwell Date: Wed, 21 Jun 2023 15:06:37 +0100 Subject: [PATCH 15/24] 3rd task working --- .../3_sphere_iterative_per_run_ww.ipynb | 433 ++++++++++++++++++ tasks/task_13_variance_reduction/README.md | 8 +- 2 files changed, 437 insertions(+), 4 deletions(-) create mode 100644 tasks/task_13_variance_reduction/3_sphere_iterative_per_run_ww.ipynb diff --git a/tasks/task_13_variance_reduction/3_sphere_iterative_per_run_ww.ipynb b/tasks/task_13_variance_reduction/3_sphere_iterative_per_run_ww.ipynb new file mode 100644 index 00000000..c8384c44 --- /dev/null +++ b/tasks/task_13_variance_reduction/3_sphere_iterative_per_run_ww.ipynb @@ -0,0 +1,433 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "72e0b25d-e541-4e8d-8805-b984374ee53d", + "metadata": {}, + "source": [ + "# Variance Reduction - Weight Windows\n", + "\n", + "## Iteratively creating and utilizing a wight window to accelerate deep shielding simulations\n", + "\n", + "This example simulates a sphere of material with a neutron source in the center.This example implements the MAGIC method of weight window generation on each simulation run.\n", + "\n", + "In this tutorial we shall focus on generating a weight window to accelerate the simulation of particles through a shield and improving the weight window with each iteration.\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" + ] + }, + { + "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": null, + "id": "3448d1db-4328-42e3-8960-50d53896f541", + "metadata": {}, + "outputs": [], + "source": [ + "import openmc\n", + "import openmc.lib # this example makes use of openmc lib to run the simulations\n", + "\n", + "import numpy as np\n", + "\n", + "from matplotlib import pyplot as plt\n", + "from matplotlib.colors import LogNorm # used for plotting log scale graphs" + ] + }, + { + "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": null, + "id": "47cb21c7-0afa-446c-9a6b-76c8dfb2f93e", + "metadata": {}, + "outputs": [], + "source": [ + "mat_water = openmc.Material()\n", + "mat_water.add_element(\"H\", 1)\n", + "mat_water.add_element(\"O\", 2)\n", + "mat_water.set_density(\"g/cm3\", 1.0)\n", + "\n", + "my_materials = openmc.Materials([mat_water])" + ] + }, + { + "cell_type": "markdown", + "id": "424b234c-48a2-4d1b-b374-f69430e464db", + "metadata": {}, + "source": [ + "Now we define and plot the spherical geometry." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a72dc5e3-cb8e-41c2-9cfb-f8f7489c7f44", + "metadata": {}, + "outputs": [], + "source": [ + "# outer surface at 500 cm\n", + "outer_surface = openmc.model.RectangularParallelepiped(-300, 300, -300, 300, -300, 300, boundary_type=\"vacuum\")\n", + "\n", + "# A single region below the surface\n", + "region_1 = -outer_surface\n", + "\n", + "# A single cell full of water\n", + "cell_1 = openmc.Cell(region=region_1)\n", + "cell_1.fill = mat_water\n", + "\n", + "my_geometry = openmc.Geometry([cell_1])" + ] + }, + { + "cell_type": "markdown", + "id": "51713fe1", + "metadata": {}, + "source": [ + "Now we plot the geometry and color by materials." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "94c41f17", + "metadata": {}, + "outputs": [], + "source": [ + "my_geometry.root_universe.plot(basis='xy', color_by='material') \n", + "plt.savefig('geometry_top_down_view.png', bbox_inches=\"tight\")" + ] + }, + { + "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": null, + "id": "fd4986b0", + "metadata": {}, + "outputs": [], + "source": [ + "# location of the point source\n", + "space = openmc.stats.Point((0, 0, 0))\n", + "angle = openmc.stats.Isotropic()\n", + "\n", + "# all (100%) of source particles are 14MeV energy\n", + "energy = openmc.stats.Discrete([14e6], [1.0])\n", + "\n", + "source = openmc.Source(space=space, angle=angle, energy=energy)\n", + "source.particle = \"neutron\"" + ] + }, + { + "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": null, + "id": "9d7bbee6", + "metadata": {}, + "outputs": [], + "source": [ + "mesh = openmc.RegularMesh().from_domain(domain=my_geometry)\n", + "print(mesh)\n", + "# mesh.r_grid = np.linspace(0, outer_surface.r, 100)\n", + "\n", + "mesh_filter = openmc.MeshFilter(mesh)\n", + "\n", + "flux_tally = openmc.Tally(name=\"flux tally\")\n", + "flux_tally.filters = [mesh_filter]\n", + "flux_tally.scores = [\"flux\"]\n", + "flux_tally.id = 55 # we set the ID number here as we need to access it during the openmc lib run\n", + "\n", + "# adds the mesh tally to the model\n", + "my_tallies = openmc.Tallies()\n", + "my_tallies.append(flux_tally)\n", + "\n", + "tallies = openmc.Tallies([flux_tally])" + ] + }, + { + "cell_type": "markdown", + "id": "2bc34eac", + "metadata": {}, + "source": [ + "Creates the simulation settings" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ea32fb73", + "metadata": {}, + "outputs": [], + "source": [ + "my_settings = openmc.Settings()\n", + "my_settings.run_mode = \"fixed source\"\n", + "my_settings.source = source\n", + "my_settings.particles = 120\n", + "my_settings.batches = 10\n", + "\n", + "# no need to write the tallies.out file which saves space and time when large meshes are used\n", + "my_settings.output = {'tallies': False}" + ] + }, + { + "cell_type": "markdown", + "id": "9bc4e52b", + "metadata": {}, + "source": [ + "Creates and export the model" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6d8042a5", + "metadata": {}, + "outputs": [], + "source": [ + "model = openmc.Model(my_geometry, my_materials, my_settings, my_tallies)\n", + "\n", + "# deletes old input and output files\n", + "!rm *.xml\n", + "!rm *.h5\n", + "\n", + "model.export_to_xml() # this is necessary as openmc.lib loads up the model.xml file" + ] + }, + { + "cell_type": "markdown", + "id": "bf5eeb8b", + "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": null, + "id": "bc9ec8cb", + "metadata": {}, + "outputs": [], + "source": [ + "def plot_mesh_tally_and_weight_window(statepoint_filename, weight_window_filename, image_filename):\n", + " \n", + " with openmc.StatePoint(statepoint_filename) as sp:\n", + " flux_tally = sp.get_tally(name=\"flux tally\")\n", + "\n", + " tally_mesh = flux_tally.find_filter(openmc.MeshFilter).mesh\n", + " tally_mesh_extent = tally_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()[:,:,int(mesh.dimension[1]/2)]\n", + " plt.subplot(1, 3, 1)\n", + " # create a plot of the mean flux values\n", + " plt.imshow(\n", + " flux_mean.T,\n", + " origin=\"lower\",\n", + " extent=tally_mesh_extent,\n", + " norm=LogNorm(),\n", + " )\n", + " plt.title(\"Flux Mean\")\n", + "\n", + "\n", + " plt.subplot(1, 3, 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()[:,:,int(mesh.dimension[1]/2)]\n", + " # create a plot of the flux relative error\n", + " plt.imshow(\n", + " flux_std_dev.T,\n", + " origin=\"lower\",\n", + " extent=tally_mesh_extent,\n", + " norm=LogNorm(),\n", + " )\n", + " plt.title(\"Flux Std. Dev.\")\n", + "\n", + " wws=openmc.hdf5_to_wws(weight_window_filename)\n", + " ww = wws[0] # get the one and only mesh tally\n", + " ww_mesh = ww.mesh # get the mesh that the weight window is mapped on\n", + " ww_mesh_extent = ww_mesh.bounding_box.extent['xy']\n", + " reshaped_ww_vals = ww.lower_ww_bounds.reshape(mesh.dimension)\n", + " print('reshaped_ww_vals.shape', reshaped_ww_vals.shape)\n", + " # slice on XZ basis, midplane Y axis\n", + " slice_of_ww = reshaped_ww_vals[:,:,int(mesh.dimension[1]/2)]\n", + " plt.subplot(1, 3, 3)\n", + " plt.imshow(\n", + " slice_of_ww.T,\n", + " origin=\"lower\",\n", + " extent=ww_mesh_extent,\n", + " norm=LogNorm(),\n", + " )\n", + " plt.title(\"Weight Window lower bound\")\n", + "\n", + " plt.savefig(image_filename)" + ] + }, + { + "cell_type": "markdown", + "id": "647a81d8", + "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 run 5 iterations with each iteration improving the weight window." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9159a336", + "metadata": {}, + "outputs": [], + "source": [ + "with openmc.lib.run_in_memory():\n", + "\n", + " tally = openmc.lib.tallies[55]\n", + "\n", + " wws = openmc.lib.WeightWindows.from_tally(tally)\n", + "\n", + " for i in range(5): # 5 iterations of weight window improvements\n", + "\n", + " openmc.lib.run()\n", + "\n", + " wws.update_magic(tally)\n", + "\n", + " # we write out the weight window map for plotting later\n", + " openmc.lib.export_weight_windows(filename=f'weight_windows{i}.h5')\n", + " # we write out the statepoint so that the tally can be plotted later\n", + " openmc.lib.statepoint_write(filename=f'statepoint_simulation_{i}.h5')\n", + "\n", + " openmc.lib.settings.weight_windows_on = True\n", + "\n", + " plot_mesh_tally_and_weight_window(\n", + " f'statepoint_simulation_{i}.h5',\n", + " f'weight_windows{i}.h5',\n", + " f'plot_{i}.png'\n", + " )\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "id": "e293ce43", + "metadata": {}, + "source": [] + }, + { + "cell_type": "markdown", + "id": "79ec2340", + "metadata": {}, + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e6f60d98", + "metadata": {}, + "outputs": [], + "source": [ + "from IPython.display import Image\n", + "Image(\"plot_0.png\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b45de49c-2de4-4ae1-a4a7-a26c41f676e8", + "metadata": {}, + "outputs": [], + "source": [ + "Image(\"plot_1.png\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f259af33-6570-47d3-bb9c-edd8f1b19267", + "metadata": {}, + "outputs": [], + "source": [ + "Image(\"plot_2.png\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ad0dec70-db34-424a-96ce-9b518103b71b", + "metadata": {}, + "outputs": [], + "source": [ + "Image(\"plot_3.png\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1d3817e6-d1c5-40a9-9803-b10b7aabf4ee", + "metadata": {}, + "outputs": [], + "source": [ + "Image(\"plot_4.png\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "49bd6ac9-3116-4dfe-a279-31d2a17f29fe", + "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.8.13" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/tasks/task_13_variance_reduction/README.md b/tasks/task_13_variance_reduction/README.md index 33c8e7b0..7ea0e797 100644 --- a/tasks/task_13_variance_reduction/README.md +++ b/tasks/task_13_variance_reduction/README.md @@ -7,7 +7,7 @@ The workshop contains the following variance reduction examples: | Filename | variance reduction technique | geometry | mesh type | |---|---|---|---| -| 1_shielded_room_survival_biasing.py | survival_biasing | shielded bunker | RegularMesh | -| 2_shielded_room_single_ww.ipynb | weight windows | sphere | SphericalMesh | -| 3_sphere_iterative_per_run_ww.py | weight windows | sphere | SphericalMesh | -| 4_sphere_iterative_per_batch_ww.py | weight windows | sphere | SphericalMesh | \ No newline at end of file +| 1_shielded_room_survival_biasing.py | survival_biasing | shielded bunker | +| 2_shielded_room_single_ww.ipynb | weight windows | shielded bunker | +| 3_cube_iterative_per_run_ww.py | weight windows | cube | +| 4_cube_iterative_per_batch_ww.py | weight windows | cube | \ No newline at end of file From db613a10d74132b33fdc3d88f47cfae50a3e2810 Mon Sep 17 00:00:00 2001 From: Jonathan Shimwell Date: Wed, 21 Jun 2023 16:43:47 +0100 Subject: [PATCH 16/24] added comments --- .../3_sphere_iterative_per_run_ww.ipynb | 78 +++++----- .../3_sphere_iterative_per_run_ww.py | 135 ------------------ 2 files changed, 40 insertions(+), 173 deletions(-) delete mode 100644 tasks/task_13_variance_reduction/3_sphere_iterative_per_run_ww.py diff --git a/tasks/task_13_variance_reduction/3_sphere_iterative_per_run_ww.ipynb b/tasks/task_13_variance_reduction/3_sphere_iterative_per_run_ww.ipynb index c8384c44..d4d7e273 100644 --- a/tasks/task_13_variance_reduction/3_sphere_iterative_per_run_ww.ipynb +++ b/tasks/task_13_variance_reduction/3_sphere_iterative_per_run_ww.ipynb @@ -289,7 +289,7 @@ " )\n", " plt.title(\"Weight Window lower bound\")\n", "\n", - " plt.savefig(image_filename)" + " plt.savefig(image_filename, bbox_inches=\"tight\")" ] }, { @@ -312,14 +312,19 @@ "source": [ "with openmc.lib.run_in_memory():\n", "\n", + " # loads up a live pointer to the tally with id=55, at this stage the tally is empty\n", " tally = openmc.lib.tallies[55]\n", "\n", + " # makes weight windows from the tally, at this stage the values are empty\n", " wws = openmc.lib.WeightWindows.from_tally(tally)\n", "\n", - " for i in range(5): # 5 iterations of weight window improvements\n", + " # 5 iterations of weight window improvements\n", + " for i in range(5):\n", "\n", + " # run the simulation\n", " openmc.lib.run()\n", "\n", + " # improves the weight window with the latest tally results\n", " wws.update_magic(tally)\n", "\n", " # we write out the weight window map for plotting later\n", @@ -327,14 +332,15 @@ " # we write out the statepoint so that the tally can be plotted later\n", " openmc.lib.statepoint_write(filename=f'statepoint_simulation_{i}.h5')\n", "\n", + " # turns on the weight windows to ensure they are used\n", " openmc.lib.settings.weight_windows_on = True\n", "\n", + " # creates a plot of the flux, std_dev and weight window\n", " plot_mesh_tally_and_weight_window(\n", " f'statepoint_simulation_{i}.h5',\n", " f'weight_windows{i}.h5',\n", " f'plot_{i}.png'\n", - " )\n", - "\n" + " )" ] }, { @@ -350,60 +356,56 @@ "source": [] }, { - "cell_type": "code", - "execution_count": null, - "id": "e6f60d98", - "metadata": {}, - "outputs": [], - "source": [ - "from IPython.display import Image\n", - "Image(\"plot_0.png\")" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "b45de49c-2de4-4ae1-a4a7-a26c41f676e8", - "metadata": {}, - "outputs": [], - "source": [ - "Image(\"plot_1.png\")" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "f259af33-6570-47d3-bb9c-edd8f1b19267", + "cell_type": "markdown", + "id": "0c6548fc-a538-432f-9694-3092db42b1b4", "metadata": {}, - "outputs": [], "source": [ - "Image(\"plot_2.png\")" + "The iterative improvment of the flux / standard deviation / weight windows with each simulation run can be seen when we plot all the simulation results one after each other." ] }, { "cell_type": "code", "execution_count": null, - "id": "ad0dec70-db34-424a-96ce-9b518103b71b", + "id": "0b89dd15-1596-4fb8-9988-9b37d38b9b7c", "metadata": {}, "outputs": [], "source": [ - "Image(\"plot_3.png\")" + "from PIL import Image\n", + "images = [Image.open(x) for x in [f'plot_{c}.png' for c in range(5)]]\n", + "widths, heights = zip(*(i.size for i in images))\n", + "\n", + "total_height = sum(heights)\n", + "max_width = max(widths)\n", + "\n", + "new_im = Image.new('RGB', (max_width, total_height))\n", + "y_offset = 0\n", + "for im in images:\n", + " new_im.paste(im, (0,y_offset))\n", + " y_offset += im.size[1]\n", + "new_im.save('flux_std-dev_ww_for_all_simulations_reset.png')\n", + "new_im" ] }, { - "cell_type": "code", - "execution_count": null, - "id": "1d3817e6-d1c5-40a9-9803-b10b7aabf4ee", + "cell_type": "markdown", + "id": "d6daa0ba-5a5b-4701-aeaa-d57db34fb485", "metadata": {}, - "outputs": [], "source": [ - "Image(\"plot_4.png\")" + "Learning outcome\n", + "\n", + "Weight windows can be incrementally improved by running subsequent simulations.\n", + "\n", + "Running lots of small simulations where the weight window can incrementally improve the wieght window and can yields better results that a big single simulation to generate weight windows and a single big simulation to make use of the weight windows.\n", + "\n", + "Doing this iteration with openmc.lib means we don't need to reload the nuclear data between simulations which saves time.\n", + "\n", + "Additionally we have access to openmc.lib methods which are nessecary for updating the weight window with the MAGIC method and exporting the weight window to a h5 file.\n" ] }, { "cell_type": "code", "execution_count": null, - "id": "49bd6ac9-3116-4dfe-a279-31d2a17f29fe", + "id": "74b59746-2e58-45b4-baeb-37b69244d145", "metadata": {}, "outputs": [], "source": [] diff --git a/tasks/task_13_variance_reduction/3_sphere_iterative_per_run_ww.py b/tasks/task_13_variance_reduction/3_sphere_iterative_per_run_ww.py deleted file mode 100644 index 3d2abc56..00000000 --- a/tasks/task_13_variance_reduction/3_sphere_iterative_per_run_ww.py +++ /dev/null @@ -1,135 +0,0 @@ -# This example has a sphere of water showing how to increase the depth of -# neutron transport through the water. -# A series of simulations are performed that iteratively improve the weight window values -# The resulting neutron flux can be observed to propagate further through the geometry - -import openmc -import numpy as np -import matplotlib.pyplot as plt -import plotly.graph_objects as go -from pathlib import Path - - -# materials -mat_water = openmc.Material() -mat_water.add_element("H", 1) -mat_water.add_element("O", 2) -mat_water.set_density("g/cm3", 1.0) - -my_materials = openmc.Materials([mat_water]) - -# surfaces -outer_surface = openmc.Sphere(r=50*100, boundary_type="vacuum") - -# regions -region_1 = -outer_surface - -# cells -cell_1 = openmc.Cell(region=region_1) -cell_1.fill = mat_water - -# settings -my_settings = openmc.Settings() - -my_geometry = openmc.Geometry([cell_1]) - -source = openmc.Source() -source.space = openmc.stats.Point((0.0, 0.0, 0.0)) -source.angle = openmc.stats.Isotropic() -source.energy = openmc.stats.Discrete([14e6], [1.0]) -source.particle = "neutron" - -my_settings = openmc.Settings() -my_settings.run_mode = "fixed source" -my_settings.source = source -my_settings.particles = 10000 -my_settings.batches = 10 - -# tally -mesh = openmc.SphericalMesh() -mesh.r_grid = np.linspace(0, outer_surface.r, 100) - -mesh_filter = openmc.MeshFilter(mesh) - -flux_tally = openmc.Tally(name="flux tally") -flux_tally.filters = [mesh_filter] -flux_tally.scores = ["flux"] - -# adds the mesh tally to the model -my_tallies = openmc.Tallies() -my_tallies.append(flux_tally) - - -model = openmc.Model(my_geometry, my_materials, my_settings, my_tallies) - -model.export_to_xml() - - - -import openmc.lib - -iterations = 5 - -with openmc.lib.run_in_memory(): - - tally = openmc.lib.tallies[1] - - wws = openmc.lib.WeightWindows.from_tally(tally) - - for i in range(iterations): - - openmc.lib.run() - - wws.update_magic(tally) - - openmc.lib.settings.weight_windows_on = True - - openmc.lib.reset() - - -plot_flux_tally(f'statepoint.{model.settings.batches}.h5') - - - -# plots the flux as a function of radius for each iteration -output_files = [Path("magic_ww") / str(c) / f"statepoint.{my_settings.batches}.h5" for c in range(1, len(all_wws))] -fig = go.Figure() -for i, output_file in enumerate(output_files): - with openmc.StatePoint(output_file) as sp: - flux_tally = sp.get_tally(name="flux tally") - fig.add_trace( - go.Scatter( - x=mesh.r_grid[1:], y=flux_tally.mean.flatten(), name=f"flux tally, iteration {i+1}" - ) - ) -fig.update_yaxes(type="log") -fig.update_layout(xaxis_title="Radius [cm]", yaxis_title="Flux") -fig.show() - -# plots the lower bound of the the weight window values as a function of radius for each iteration -fig = go.Figure() -for i, weight_windows in enumerate(all_wws): - fig.add_trace( - go.Scatter( - x=mesh.r_grid[1:], - y=weight_windows[0].lower_ww_bounds.flatten(), - name=f"lower ww bounds, iteration {i+1}", - ) - ) -fig.update_yaxes(type="log") -fig.update_layout(xaxis_title="Radius [cm]", yaxis_title="weight window lower bound value") -fig.show() - -# plots the upper bound of the the weight window values as a function of radius for each iteration -fig = go.Figure() -for i, weight_windows in enumerate(all_wws): - fig.add_trace( - go.Scatter( - x=mesh.r_grid[1:], - y=weight_windows[0].upper_ww_bounds.flatten(), - name=f"upper ww bounds, iteration {i+1}", - ) - ) -fig.update_yaxes(type="log") -fig.update_layout(xaxis_title="Radius [cm]", yaxis_title="weight window upper bound value") -fig.show() From d13e14b9783a1dd5909f304aebf9beed37027b48 Mon Sep 17 00:00:00 2001 From: Jonathan Shimwell Date: Wed, 21 Jun 2023 17:19:04 +0100 Subject: [PATCH 17/24] converted task 4 to notebook --- .../4_sphere_iterative_per_batch_ww.ipynb | 387 ++++++++++++++++++ tasks/task_13_variance_reduction/README.md | 8 +- .../activation_from_spectra.py | 99 +++++ 3 files changed, 490 insertions(+), 4 deletions(-) create mode 100644 tasks/task_13_variance_reduction/4_sphere_iterative_per_batch_ww.ipynb create mode 100644 tasks/task_14_activation_transmutation_depletion/activation_from_spectra.py diff --git a/tasks/task_13_variance_reduction/4_sphere_iterative_per_batch_ww.ipynb b/tasks/task_13_variance_reduction/4_sphere_iterative_per_batch_ww.ipynb new file mode 100644 index 00000000..16a519dc --- /dev/null +++ b/tasks/task_13_variance_reduction/4_sphere_iterative_per_batch_ww.ipynb @@ -0,0 +1,387 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "db6c76be-284f-4355-88aa-b4c89b9bbcea", + "metadata": {}, + "source": [ + "This example has a sphere of concrete with a second smaller shell of concrete\n", + "surrounding the sphere.\n", + "\n", + "The first simulation is analog with no variance reduction / weight windows.\n", + "This simulation shows that not many neutrons get to the shell and the \n", + "consequently the neutron spectra on the shell cell is unresolved. Additional\n", + "batches improve the neutron spectra but it is clear that it would take many\n", + "batches to get a reasonable neutron spectra.\n", + "\n", + "The second simulation makes use of a variance reduction method called weight\n", + "windows. The value of the weight windows is assigned using the MAGIC method.\n", + "https://scientific-publications.ukaea.uk/papers/application-of-novel-global-variance-reduction-methods-to-fusion-radiation-transport-problems/\n", + "The value of the weight windows are updated with each simulated batch and as\n", + "the simulation runs for longer the weight windows improve gradually as does\n", + "spectra tally." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ecaafb63-bd33-4597-baf3-8e8cccd32f9c", + "metadata": {}, + "outputs": [], + "source": [ + "import openmc\n", + "# Note this example makes use of OpenMC lib which provides python bindings to\n", + "# the C/C++ methods in OpenMC and allows more direct control of the Monte Carlo\n", + "# simulation. In this example we iterate through the batches and access the\n", + "# tally result each time.\n", + "# Link to openmc.lib documentation https://docs.openmc.org/en/stable/pythonapi/capi.html\n", + "import openmc.lib\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "markdown", + "id": "1e8755e5-f1f8-4c4f-b142-eb8b1e6e6f84", + "metadata": {}, + "source": [ + "This makes concrete which is the shielding material for this simulation" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b26aff6f-e542-4c62-af29-9a4f7a793733", + "metadata": {}, + "outputs": [], + "source": [ + "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", + "my_materials = openmc.Materials([mat_concrete])" + ] + }, + { + "cell_type": "markdown", + "id": "78616dec-bac6-405e-bcfc-b0724670d209", + "metadata": {}, + "source": [ + "This makes the spherical geometry" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0cb35d51-3d94-48a3-98fa-804a3195383a", + "metadata": {}, + "outputs": [], + "source": [ + "# surfaces\n", + "surf1 = openmc.Sphere(r=170)\n", + "outer_surface = openmc.Sphere(r=200, boundary_type=\"vacuum\")\n", + "\n", + "# regions\n", + "region_1 = -surf1\n", + "region_2 = -outer_surface & +surf1\n", + "\n", + "# cells\n", + "cell_1 = openmc.Cell(region=region_1)\n", + "cell_1.fill = mat_concrete\n", + "cell_2 = openmc.Cell(region=region_2)\n", + "cell_2.fill = mat_concrete\n", + "\n", + "# settings\n", + "my_settings = openmc.Settings()\n", + "\n", + "my_geometry = openmc.Geometry([cell_1, cell_2])\n", + "\n", + "my_geometry.root_universe.plot(basis='xy', color_by='cell') \n", + "plt.savefig('geometry_top_down_view.png', bbox_inches=\"tight\")" + ] + }, + { + "cell_type": "markdown", + "id": "b8be07cf-a90c-4fe9-ab86-44e26b0e6bfa", + "metadata": {}, + "source": [ + "This code makes a 14MeV neutron point source" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d4868792-6ee6-440e-982c-4698a215c65b", + "metadata": {}, + "outputs": [], + "source": [ + "source = openmc.IndependentSource()\n", + "source.space = openmc.stats.Point((0.0, 0.0, 0.0))\n", + "source.angle = openmc.stats.Isotropic()\n", + "source.energy = openmc.stats.Discrete([14e6], [1.0])\n", + "source.particle = \"neutron\"" + ] + }, + { + "cell_type": "markdown", + "id": "d70dd451-02ff-44d6-9628-84ed2753b578", + "metadata": {}, + "source": [ + "This section makes the simulation settings" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f11ceb32-f439-4ecd-a99f-fbf0471d9405", + "metadata": {}, + "outputs": [], + "source": [ + "my_settings = openmc.Settings()\n", + "my_settings.run_mode = \"fixed source\"\n", + "my_settings.source = source\n", + "my_settings.particles = 50000\n", + "my_settings.batches = 5\n", + "# the mesh tallies produce large tallies.out files so this output setting avoids writing the tallies.out and saves time\n", + "my_settings.output = {'tallies': False}" + ] + }, + { + "cell_type": "markdown", + "id": "e4a965a3-0c7e-4634-9f91-16b0a4325b8d", + "metadata": {}, + "source": [ + "This section makes the tallies.\n", + "\n", + "We have a spherical mesh tally for the getting the flux. This is used to generate the weight windows.\n", + "\n", + "We also have a neutron spectra tally to show how the neutrons energy distribution in the outer shell cell is resolved." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a51cd616-b0ff-4322-82db-4608f3082611", + "metadata": {}, + "outputs": [], + "source": [ + "my_tallies = openmc.Tallies()\n", + "\n", + "# This spherical mesh tally is used for generating the weight windows.\n", + "mesh = openmc.SphericalMesh()\n", + "mesh.r_grid = np.linspace(0, outer_surface.r, 5000)\n", + "mesh_filter = openmc.MeshFilter(mesh)\n", + "flux_tally_for_ww = openmc.Tally(name=\"flux tally\")\n", + "flux_tally_for_ww.filters = [mesh_filter]\n", + "flux_tally_for_ww.scores = [\"flux\"]\n", + "flux_tally_for_ww.id = 42\n", + "my_tallies.append(flux_tally_for_ww)\n", + "\n", + "# This spectrum tally is on the outer shell and shows then energy distribution\n", + "# of neutrons present in the cell.\n", + "energy_filter = openmc.EnergyFilter.from_group_structure('CCFE-709')\n", + "surface_filter = openmc.CellFilter(cell_2)\n", + "outer_surface_spectra_tally = openmc.Tally(name='outer_surface_spectra_tally')\n", + "outer_surface_spectra_tally.scores = ['current']\n", + "outer_surface_spectra_tally.filters = [surface_filter, energy_filter]\n", + "outer_surface_spectra_tally.id = 12\n", + "my_tallies.append(outer_surface_spectra_tally)" + ] + }, + { + "cell_type": "markdown", + "id": "f62aacde-8f5e-4fdb-82bd-58f43037b6ac", + "metadata": {}, + "source": [ + "creates and exports the model to an xml file. When using openmc.lib this\n", + "export is needed as we don't use the normal model.run() method." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "540dde33-25a4-45d9-859f-11ab2e222cfe", + "metadata": {}, + "outputs": [], + "source": [ + "model = openmc.model.Model(my_geometry, my_materials, my_settings, my_tallies)\n", + "model.export_to_xml()" + ] + }, + { + "cell_type": "markdown", + "id": "580415f1-d56e-4a4a-b1b4-1ef30aeb92e4", + "metadata": {}, + "source": [ + "Creates a plotting figure that we will build up with the simulations results. Initially this will be empty but we shall simulate and populate these rows and columns with neutron spectra in the outer shell cell." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ec4a2ecf-ec9e-43a3-b2f1-249ef97aae0e", + "metadata": {}, + "outputs": [], + "source": [ + "fig, axs = plt.subplots(my_settings.batches, 2, sharex=True, sharey=True)" + ] + }, + { + "cell_type": "markdown", + "id": "862c2695-7aec-43e9-9461-0689ceed2482", + "metadata": {}, + "source": [ + "We run the model in analog mode batch by batch. Each time we plot the spectra\n", + "tally result. The spectra tally will gradually to get better with each batch\n", + "as the batches combine to continually improve the result." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ddb7274d-0782-4462-acf1-edf8f99895e6", + "metadata": {}, + "outputs": [], + "source": [ + "# this context manager helps close openmc lib when the code indent closes\n", + "with openmc.lib.run_in_memory():\n", + "\n", + " # gets a live pointer to the tally, this updates as the tally is accumulated\n", + " spectra_tally = openmc.lib.tallies[outer_surface_spectra_tally.id]\n", + " \n", + " # simulation_init is needed prior to iter_batches\n", + " openmc.lib.simulation_init()\n", + "\n", + " # loops through each batch getting the latest tally result and plotting it\n", + " for counter, batch in enumerate(openmc.lib.iter_batches()):\n", + "\n", + " axs[counter][0].step(energy_filter.values[:-1], spectra_tally.mean.flatten())\n", + " axs[counter][0].set_title(f'Batch {counter+1}')\n", + " axs[counter][0].set_yscale('log')\n", + " axs[counter][0].set_xscale('log')\n", + "\n", + " openmc.lib.simulation_finalize()" + ] + }, + { + "cell_type": "markdown", + "id": "e000825a-033c-4663-8e9f-70390ed54b8e", + "metadata": {}, + "source": [ + "Now we simulate the same model but with weight windows that are improved on each batch" + ] + }, + { + "cell_type": "markdown", + "id": "05c69e62-54f8-45b3-919f-f20bb1d3cc80", + "metadata": {}, + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a7701329-7fba-480c-98de-661969d743b4", + "metadata": {}, + "outputs": [], + "source": [ + "# originally we had 2000 particles per batch\n", + "# on my computer the analog simulation ran with 12470 particles/second\n", + "# and the weight windows simulation that comes next runs with 87 particles/second\n", + "# therefore we are going to decrease the settings.particles so that both simulations\n", + "# get the same amount of compute time. These numbers might differ for your computer.\n", + "model.settings.particles = int(model.settings.particles*(87/12470))\n", + "\n", + "# export the model again so the particles is updated\n", + "model.export_to_xml()\n", + "with openmc.lib.run_in_memory():\n", + "\n", + " # gets a live pointer to the mesh tally that we use to generate the \n", + " ww_tally = openmc.lib.tallies[flux_tally_for_ww.id]\n", + " # generates a weight window from the tally (which is currently empty)\n", + " wws = openmc.lib.WeightWindows.from_tally(ww_tally)\n", + " \n", + " # gets a live pointer to the spectra tally that we will plot with each batch\n", + " spectra_tally = openmc.lib.tallies[outer_surface_spectra_tally.id]\n", + "\n", + " # turn the weight windows on\n", + " openmc.lib.settings.weight_windows_on = True\n", + "\n", + " openmc.lib.simulation_init()\n", + " for counter, batch in enumerate(openmc.lib.iter_batches()):\n", + "\n", + " # updates the weight window with the latest mesh tally flux results \n", + " wws.update_magic(ww_tally)\n", + "\n", + " # plots the spectra tally for the batch\n", + " axs[counter][1].step(energy_filter.values[:-1], spectra_tally.mean.flatten())\n", + " axs[counter][1].set_title(f'Batch {counter+1}')\n", + " axs[counter][1].set_yscale('log')\n", + " axs[counter][1].set_xscale('log')\n", + "\n", + " openmc.lib.simulation_finalize()\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "73db1d34-39f5-4065-9113-fe27cf654c1a", + "metadata": {}, + "outputs": [], + "source": [ + "# sets titles, labels and saves the plot\n", + "axs[0][0].set_title('Analog simulation')\n", + "axs[0][1].set_title('Iterative weight windows simulation')\n", + "axs[4][1].set_xlabel(f'Energy [eV]')\n", + "axs[4][0].set_xlabel(f'Energy [eV]')\n", + "fig.savefig('improving_spectra_with_ww_iteration.jpg', bbox_inches=\"tight\")\n", + "# plt.show()\n", + "from IPython.display import Image\n", + "Image('improving_spectra_with_ww_iteration.jpg')" + ] + }, + { + "cell_type": "markdown", + "id": "b2c74788-8de5-4be7-9263-7f988fc43890", + "metadata": {}, + "source": [ + "In the left hand side colum we see that just running a non varience reduction simulation and only occational neutrons get to the outer shell cell to contribute to the tally. This would take a long time to converge the spectra.\n", + "\n", + "However with weight windows we see the tally results are developing relatively quickly and we can start to see some spectra structure after just a few batches.\n", + "\n", + "We have previously seen flux maps benefit from weight windows but this example showed that spectra simulations can also be improved.\n", + "\n", + "The other difference is that we are improving the weight window each batch instead of each simulation. This is quite fine grain evolution of the weight windows. The finaly tally result ends up getting contributions from several batches where each batch has different weight windows." + ] + } + ], + "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.8.13" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/tasks/task_13_variance_reduction/README.md b/tasks/task_13_variance_reduction/README.md index 7ea0e797..48614670 100644 --- a/tasks/task_13_variance_reduction/README.md +++ b/tasks/task_13_variance_reduction/README.md @@ -7,7 +7,7 @@ The workshop contains the following variance reduction examples: | Filename | variance reduction technique | geometry | mesh type | |---|---|---|---| -| 1_shielded_room_survival_biasing.py | survival_biasing | shielded bunker | -| 2_shielded_room_single_ww.ipynb | weight windows | shielded bunker | -| 3_cube_iterative_per_run_ww.py | weight windows | cube | -| 4_cube_iterative_per_batch_ww.py | weight windows | cube | \ No newline at end of file +| 1_shielded_room_survival_biasing.py | survival_biasing | shielded bunker | RegularMesh | Flux map | air space and concrete | +| 2_shielded_room_single_ww.ipynb | weight windows | sphere | RegularMesh | air space and concrete | +| 3_sphere_iterative_per_run_ww.py | weight windows | cube | RegularMesh | Water | +| 4_sphere_iterative_per_batch_ww.py | weight windows | sphere | SphericalMesh | concrete | \ No newline at end of file diff --git a/tasks/task_14_activation_transmutation_depletion/activation_from_spectra.py b/tasks/task_14_activation_transmutation_depletion/activation_from_spectra.py new file mode 100644 index 00000000..5704cf2e --- /dev/null +++ b/tasks/task_14_activation_transmutation_depletion/activation_from_spectra.py @@ -0,0 +1,99 @@ + +# spectra_tally.mean +# normalised_spectra = spectra_tally.mean / sum(spectra_tally.mean) + +# normalised_spectra is probability of each enegry , sum of normalised_spectra = 1 + + + +import openmc + +# MATERIALS + +# Due to the hydrogen content water is a very good neutron moderator +my_material = openmc.Material() +my_material.add_element('H', 1, percent_type='ao') +my_material.add_element('O', 2, percent_type='ao') +my_material.set_density('g/cm3', 1) + +my_materials = openmc.Materials([my_material]) + + +# GEOMETRY + +# surfaces +outer_surface = openmc.Sphere(r=500, boundary_type='vacuum') + +# cells +cell_1 = openmc.Cell(region=-outer_surface) +cell_1.fill = my_material + +my_geometry = openmc.Geometry([cell_1]) + + +# SIMULATION SETTINGS + +# Instantiate a Settings object +my_settings = openmc.Settings() +my_settings.batches = 10 +my_settings.particles = 10000 +my_settings.run_mode = 'fixed source' + +# Create a DT point source +my_source = openmc.Source() +my_source.space = openmc.stats.Point((0, 0, 0)) +my_source.angle = openmc.stats.Isotropic() +my_source.energy = openmc.stats.Discrete([14e6], [1]) +my_settings.source = my_source + +#creates an empty tally object +my_tallies = openmc.Tallies() + +# sets up filters for the tallies +neutron_particle_filter = openmc.ParticleFilter(['neutron']) + +# creates an array of 300 linear spaced energy bins from 0MeV to 15MeV +# our source is 14MeV so this should capture all the neutron energies in the simulation +# there is a disadvantage of using a linear group structure which is covered in part 2 of this task +import numpy as np +energy_filter = openmc.EnergyFilter(np.linspace(0, 15e6, 300)) + +# setup the filters for the cell tally +cell_filter = openmc.CellFilter(cell_1) + +# create the tally +cell_spectra_tally = openmc.Tally(name='cell_spectra_tally') +cell_spectra_tally.scores = ['flux'] +cell_spectra_tally.filters = [cell_filter, neutron_particle_filter, energy_filter] +my_tallies.append(cell_spectra_tally) + +# combine all the required parts to make a model +model = openmc.model.Model(my_geometry, my_materials, my_settings, my_tallies) + +# remove old files and runs OpenMC + +results_filename = model.run() + +# open the results file +results = openmc.StatePoint(results_filename) + +#extracts the tally values from the simulation results +cell_tally = results.get_tally(name='cell_spectra_tally') + +# flattens the ndarray into a 1d array +flux = cell_tally.mean.flatten() + +spectrum_probability = flux / sum(flux) + +proberbility_per_ev = spectrum_probability / np.diff(energy_filter.bins).flatten() + +tab = openmc.stats.Tabular( + x = energy_filter.bins, + p=proberbility_per_ev, + interpolation='histogram' +) + +energy_filter.tabular(cell_tally.mean.flatten()) + +source = openmc.Source() +source.energy = tab From b776efaa63af8a89c5da9e8c957ce5153ab8dee6 Mon Sep 17 00:00:00 2001 From: Jonathan Shimwell Date: Wed, 21 Jun 2023 17:27:28 +0100 Subject: [PATCH 18/24] [skip ci] removed old py file --- .../4_sphere_iterative_per_batch_ww.py | 171 ------------------ 1 file changed, 171 deletions(-) delete mode 100644 tasks/task_13_variance_reduction/4_sphere_iterative_per_batch_ww.py diff --git a/tasks/task_13_variance_reduction/4_sphere_iterative_per_batch_ww.py b/tasks/task_13_variance_reduction/4_sphere_iterative_per_batch_ww.py deleted file mode 100644 index db9ccfa7..00000000 --- a/tasks/task_13_variance_reduction/4_sphere_iterative_per_batch_ww.py +++ /dev/null @@ -1,171 +0,0 @@ -# This example has a sphere of concrete with a second smaller shell of concrete -# surrounding the sphere. - -# The first simulation is analog with no variance reduction / weight windows. -# This simulation shows that not many neutrons get to the shell and the -# consequently the neutron spectra on the shell cell is unresolved. Additional -# batches improve the neutron spectra but it is clear that it would take many -# batches to get a reasonable neutron spectra. -# -# The second simulation makes use of a variance reduction method called weight -# windows. The value of the weight windows is assigned using the MAGIC method. -# https://scientific-publications.ukaea.uk/papers/application-of-novel-global-variance-reduction-methods-to-fusion-radiation-transport-problems/ -# The value of the weight windows are updated with each simulated batch and as -# the simulation runs for longer the weight windows improve gradually as does -# spectra tally. - -import openmc -# Note this example makes use of OpenMC lib which provides python bindings to -# the C/C++ methods in OpenMC and allows more direct control of the Monte Carlo -# simulation. In this example we iterate through the batches and access the -# tally result each time. -# Link to openmc.lib documentation https://docs.openmc.org/en/stable/pythonapi/capi.html -import openmc.lib -import numpy as np -import matplotlib.pyplot as plt - - -# This makes concrete which is a regular shielding material -mat_concrete = openmc.Material() -mat_concrete.add_element("H",0.168759) -mat_concrete.add_element("C",0.001416) -mat_concrete.add_element("O",0.562524) -mat_concrete.add_element("Na",0.011838) -mat_concrete.add_element("Mg",0.0014) -mat_concrete.add_element("Al",0.021354) -mat_concrete.add_element("Si",0.204115) -mat_concrete.add_element("K",0.005656) -mat_concrete.add_element("Ca",0.018674) -mat_concrete.add_element("Fe",0.00426) -mat_concrete.set_density("g/cm3", 2.3) - -my_materials = openmc.Materials([mat_concrete]) - -# surfaces -surf1 = openmc.Sphere(r=170) -outer_surface = openmc.Sphere(r=200, boundary_type="vacuum") - -# regions -region_1 = -surf1 -region_2 = -outer_surface & +surf1 - -# cells -cell_1 = openmc.Cell(region=region_1) -cell_1.fill = mat_concrete -cell_2 = openmc.Cell(region=region_2) -cell_2.fill = mat_concrete - -# settings -my_settings = openmc.Settings() - -my_geometry = openmc.Geometry([cell_1, cell_2]) - -# A point source 14MeV emitting neutron -source = openmc.Source() -source.space = openmc.stats.Point((0.0, 0.0, 0.0)) -source.angle = openmc.stats.Isotropic() -source.energy = openmc.stats.Discrete([14e6], [1.0]) -source.particle = "neutron" - -my_settings = openmc.Settings() -my_settings.run_mode = "fixed source" -my_settings.source = source -my_settings.particles = 50000 -my_settings.batches = 5 -# the mesh tallies produce large tallies.out files so this output setting avoids writing the tallies.out and saves time -my_settings.output = {'tallies': False} - -my_tallies = openmc.Tallies() - -# This spherical mesh tally is used for generating the weight windows. -mesh = openmc.SphericalMesh() -mesh.r_grid = np.linspace(0, outer_surface.r, 5000) -mesh_filter = openmc.MeshFilter(mesh) -flux_tally_for_ww = openmc.Tally(name="flux tally") -flux_tally_for_ww.filters = [mesh_filter] -flux_tally_for_ww.scores = ["flux"] -flux_tally_for_ww.id = 42 -my_tallies.append(flux_tally_for_ww) - -# This spectrum tally is on the outer shell and shows then energy distribution -# of neutrons present in the cell. -energy_filter = openmc.EnergyFilter.from_group_structure('CCFE-709') -surface_filter = openmc.CellFilter(cell_2) -outer_surface_spectra_tally = openmc.Tally(name='outer_surface_spectra_tally') -outer_surface_spectra_tally.scores = ['current'] -outer_surface_spectra_tally.filters = [surface_filter, energy_filter] -outer_surface_spectra_tally.id = 12 -my_tallies.append(outer_surface_spectra_tally) - -# creates and exports the model to an xml file. When using openmc.lib this -# export is needed as we don't use the normal model.run() method. -model = openmc.model.Model(my_geometry, my_materials, my_settings, my_tallies) -model.export_to_xml() - -fig, axs = plt.subplots(my_settings.batches, 2, sharex=True, sharey=True) - -# We run the model in analog mode batch by batch. Each time we plot the spectra -# tally result. The spectra tally will gradually to get better with each batch -# as the batches combine to continually improve the result. - -# this context manager helps close openmc lib when the code indent closes -with openmc.lib.run_in_memory(): - - # gets a live pointer to the tally, this updates as the tally is accumulated - spectra_tally = openmc.lib.tallies[outer_surface_spectra_tally.id] - - # simulation_init is needed prior to iter_batches - openmc.lib.simulation_init() - - # loops through each batch getting the latest tally result and plotting it - for counter, batch in enumerate(openmc.lib.iter_batches()): - - axs[counter][0].step(energy_filter.values[:-1], spectra_tally.mean.flatten()) - axs[counter][0].set_title(f'Batch {counter+1}') - axs[counter][0].set_yscale('log') - axs[counter][0].set_xscale('log') - - openmc.lib.simulation_finalize() - - -# originally we had 2000 particles per batch -# on my computer the analog simulation ran with 12470 particles/second -# and the weight windows simulation that comes next runs with 87 particles/second -# therefore we are going to decrease the settings.particles so that both simulations -# get the same amount of compute time -model.settings.particles = int(model.settings.particles*(87/12470)) -model.export_to_xml() -with openmc.lib.run_in_memory(): - - # gets a live pointer to the mesh tally that we use to generate the - ww_tally = openmc.lib.tallies[flux_tally_for_ww.id] - # generates a weight window from the tally (which is currently empty) - wws = openmc.lib.WeightWindows.from_tally(ww_tally) - - # gets a live pointer to the spectra tally that we will plot with each batch - spectra_tally = openmc.lib.tallies[outer_surface_spectra_tally.id] - - # turn the weight windows on - openmc.lib.settings.weight_windows_on = True - - openmc.lib.simulation_init() - for counter, batch in enumerate(openmc.lib.iter_batches()): - - # updates the weight window with the latest mesh tally flux results - wws.update_magic(ww_tally) - - # plots the spectra tally for the batch - axs[counter][1].step(energy_filter.values[:-1], spectra_tally.mean.flatten()) - axs[counter][1].set_title(f'Batch {counter+1}') - axs[counter][1].set_yscale('log') - axs[counter][1].set_xscale('log') - - openmc.lib.simulation_finalize() - -# sets titles, labels and saves the plot -axs[1][0].set_title('Analog simulation') -axs[2][0].set_title('Iterative weight windows simulation') -axs[0][4].set_xlabel(f'Energy [eV]') -axs[0][4].set_xlabel(f'Energy [eV]') -plt.savefig('ww.png', bbox_inches="tight") -plt.show() From 33dd2692c11140fa3771993f759ed41722da714a Mon Sep 17 00:00:00 2001 From: shimwell Date: Wed, 21 Jun 2023 21:16:18 +0100 Subject: [PATCH 19/24] [skip ci] updated nndc to endf --- .devcontainer/base.Dockerfile | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.devcontainer/base.Dockerfile b/.devcontainer/base.Dockerfile index 4a6b6326..e83e5e33 100644 --- a/.devcontainer/base.Dockerfile +++ b/.devcontainer/base.Dockerfile @@ -247,7 +247,7 @@ RUN openmc_data_downloader -d nuclear_data -l ENDFB-8.0-NNDC TENDL-2019 -p neutr RUN pip install openmc_data && \ mkdir -p /nuclear_data && \ - download_nndc_chain -d nuclear_data -r b8.0 + download_endf_chain -d nuclear_data -r b8.0 # install WMP nuclear data RUN wget https://github.com/mit-crpg/WMP_Library/releases/download/v1.1/WMP_Library_v1.1.tar.gz && \ @@ -255,4 +255,4 @@ RUN wget https://github.com/mit-crpg/WMP_Library/releases/download/v1.1/WMP_Libr rm WMP_Library_v1.1.tar.gz ENV OPENMC_CROSS_SECTIONS=/nuclear_data/cross_sections.xml -ENV OPENMC_CHAIN_FILE=/nuclear_data/chain-nndc-b8.0.xml +ENV OPENMC_CHAIN_FILE=/nuclear_data/chain-endf-b8.0.xml From c6c0c9a58658e5f1d8be8ac0809e5ef85c7dc73a Mon Sep 17 00:00:00 2001 From: Jonathan Shimwell Date: Thu, 22 Jun 2023 13:16:35 +0100 Subject: [PATCH 20/24] corrected mesh index --- .../3_sphere_iterative_per_run_ww.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tasks/task_13_variance_reduction/3_sphere_iterative_per_run_ww.ipynb b/tasks/task_13_variance_reduction/3_sphere_iterative_per_run_ww.ipynb index d4d7e273..b51873da 100644 --- a/tasks/task_13_variance_reduction/3_sphere_iterative_per_run_ww.ipynb +++ b/tasks/task_13_variance_reduction/3_sphere_iterative_per_run_ww.ipynb @@ -248,7 +248,7 @@ " tally_mesh_extent = tally_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()[:,:,int(mesh.dimension[1]/2)]\n", + " flux_mean = flux_tally.get_reshaped_data(value='mean', expand_dims=True).squeeze()[:,:,int(mesh.dimension[2]/2)]\n", " plt.subplot(1, 3, 1)\n", " # create a plot of the mean flux values\n", " plt.imshow(\n", From 5476c955f2c951ed2c169470ec1e769214af822a Mon Sep 17 00:00:00 2001 From: Jonathan Shimwell Date: Fri, 23 Jun 2023 10:37:38 +0100 Subject: [PATCH 21/24] testing vr task --- .github/workflows/ci_tests.yml | 25 ++++++++--------- tests/test_task_15.py | 50 ++++++++++++++++++++++++++++++++++ tests/test_task_16.py | 50 ++++++++++++++++++++++++++++++++++ tests/test_task_17.py | 50 ++++++++++++++++++++++++++++++++++ tests/test_task_18.py | 50 ++++++++++++++++++++++++++++++++++ 5 files changed, 211 insertions(+), 14 deletions(-) create mode 100644 tests/test_task_15.py create mode 100644 tests/test_task_16.py create mode 100644 tests/test_task_17.py create mode 100644 tests/test_task_18.py diff --git a/.github/workflows/ci_tests.yml b/.github/workflows/ci_tests.yml index 69f66d4d..d32ca73c 100644 --- a/.github/workflows/ci_tests.yml +++ b/.github/workflows/ci_tests.yml @@ -71,21 +71,18 @@ jobs: run: | pytest tests/test_task_12.py -v -# VR times out, reimplement onces cpp VR is ready -# - name: test task 13 -# run: | -# pytest tests/test_task_13.py -v + - name: test task 13 + run: | + pytest tests/test_task_13.py -v - name: test task 14 run: | pytest tests/test_task_14.py -v - - # TODO include when these have been speed up - # - name: test task 15 - # run: | - # pytest tests/test_task_15.py -v - - # - name: test task 15 - # run: | - # pytest tests/test_task_15.py -v - +# TODO add task 15 and 16 + - name: test task 17 + run: | + pytest tests/test_task_14.py -v + + - name: test task 18 + run: | + pytest tests/test_task_14.py -v diff --git a/tests/test_task_15.py b/tests/test_task_15.py new file mode 100644 index 00000000..eb284bfc --- /dev/null +++ b/tests/test_task_15.py @@ -0,0 +1,50 @@ + +""" +tests the create_isotope_plot from plotting_utils in the same way the examples +use the function. +""" + +import os +import sys +import unittest +from pathlib import Path + +import nbformat +from nbconvert.preprocessors import ExecutePreprocessor +from nbconvert.preprocessors.execute import CellExecutionError + + +def _notebook_run(path): + """ + Execute a notebook via nbconvert and collect output. + :returns (parsed nb object, execution errors) + """ + kernel_name = 'python%d' % sys.version_info[0] + this_file_directory = os.path.dirname(__file__) + errors = [] + + with open(path) as f: + nb = nbformat.read(f, as_version=4) + nb.metadata.get('kernelspec', {})['name'] = kernel_name + ep = ExecutePreprocessor(kernel_name=kernel_name, timeout=1900) #, allow_errors=True + + try: + ep.preprocess(nb, {'metadata': {'path': this_file_directory}}) + + except CellExecutionError as e: + if "SKIP" in e.traceback: + print(str(e.traceback).split("\n")[-2]) + else: + raise e + + return nb, errors + + +class test_tasks(unittest.TestCase): + +# No module named 'openmc_model' + def test_task_14(self): + for notebook in Path().rglob("tasks/task_15_*/*.ipynb"): + print(notebook) + nb, errors = _notebook_run(notebook) + assert errors == [] diff --git a/tests/test_task_16.py b/tests/test_task_16.py new file mode 100644 index 00000000..7a479631 --- /dev/null +++ b/tests/test_task_16.py @@ -0,0 +1,50 @@ + +""" +tests the create_isotope_plot from plotting_utils in the same way the examples +use the function. +""" + +import os +import sys +import unittest +from pathlib import Path + +import nbformat +from nbconvert.preprocessors import ExecutePreprocessor +from nbconvert.preprocessors.execute import CellExecutionError + + +def _notebook_run(path): + """ + Execute a notebook via nbconvert and collect output. + :returns (parsed nb object, execution errors) + """ + kernel_name = 'python%d' % sys.version_info[0] + this_file_directory = os.path.dirname(__file__) + errors = [] + + with open(path) as f: + nb = nbformat.read(f, as_version=4) + nb.metadata.get('kernelspec', {})['name'] = kernel_name + ep = ExecutePreprocessor(kernel_name=kernel_name, timeout=1900) #, allow_errors=True + + try: + ep.preprocess(nb, {'metadata': {'path': this_file_directory}}) + + except CellExecutionError as e: + if "SKIP" in e.traceback: + print(str(e.traceback).split("\n")[-2]) + else: + raise e + + return nb, errors + + +class test_tasks(unittest.TestCase): + +# No module named 'openmc_model' + def test_task_14(self): + for notebook in Path().rglob("tasks/task_16_*/*.ipynb"): + print(notebook) + nb, errors = _notebook_run(notebook) + assert errors == [] diff --git a/tests/test_task_17.py b/tests/test_task_17.py new file mode 100644 index 00000000..126824eb --- /dev/null +++ b/tests/test_task_17.py @@ -0,0 +1,50 @@ + +""" +tests the create_isotope_plot from plotting_utils in the same way the examples +use the function. +""" + +import os +import sys +import unittest +from pathlib import Path + +import nbformat +from nbconvert.preprocessors import ExecutePreprocessor +from nbconvert.preprocessors.execute import CellExecutionError + + +def _notebook_run(path): + """ + Execute a notebook via nbconvert and collect output. + :returns (parsed nb object, execution errors) + """ + kernel_name = 'python%d' % sys.version_info[0] + this_file_directory = os.path.dirname(__file__) + errors = [] + + with open(path) as f: + nb = nbformat.read(f, as_version=4) + nb.metadata.get('kernelspec', {})['name'] = kernel_name + ep = ExecutePreprocessor(kernel_name=kernel_name, timeout=1900) #, allow_errors=True + + try: + ep.preprocess(nb, {'metadata': {'path': this_file_directory}}) + + except CellExecutionError as e: + if "SKIP" in e.traceback: + print(str(e.traceback).split("\n")[-2]) + else: + raise e + + return nb, errors + + +class test_tasks(unittest.TestCase): + +# No module named 'openmc_model' + def test_task_14(self): + for notebook in Path().rglob("tasks/task_17_*/*.ipynb"): + print(notebook) + nb, errors = _notebook_run(notebook) + assert errors == [] diff --git a/tests/test_task_18.py b/tests/test_task_18.py new file mode 100644 index 00000000..0c608989 --- /dev/null +++ b/tests/test_task_18.py @@ -0,0 +1,50 @@ + +""" +tests the create_isotope_plot from plotting_utils in the same way the examples +use the function. +""" + +import os +import sys +import unittest +from pathlib import Path + +import nbformat +from nbconvert.preprocessors import ExecutePreprocessor +from nbconvert.preprocessors.execute import CellExecutionError + + +def _notebook_run(path): + """ + Execute a notebook via nbconvert and collect output. + :returns (parsed nb object, execution errors) + """ + kernel_name = 'python%d' % sys.version_info[0] + this_file_directory = os.path.dirname(__file__) + errors = [] + + with open(path) as f: + nb = nbformat.read(f, as_version=4) + nb.metadata.get('kernelspec', {})['name'] = kernel_name + ep = ExecutePreprocessor(kernel_name=kernel_name, timeout=1900) #, allow_errors=True + + try: + ep.preprocess(nb, {'metadata': {'path': this_file_directory}}) + + except CellExecutionError as e: + if "SKIP" in e.traceback: + print(str(e.traceback).split("\n")[-2]) + else: + raise e + + return nb, errors + + +class test_tasks(unittest.TestCase): + +# No module named 'openmc_model' + def test_task_14(self): + for notebook in Path().rglob("tasks/task_18_*/*.ipynb"): + print(notebook) + nb, errors = _notebook_run(notebook) + assert errors == [] From 75c4d729d67b8c8cec45e6ad9fb0cbb28cf8d63c Mon Sep 17 00:00:00 2001 From: Jonathan Shimwell Date: Fri, 23 Jun 2023 15:42:27 +0100 Subject: [PATCH 22/24] [skip ci] added particle to from tally --- .../2_shielded_room_single_ww.ipynb | 2 +- .../3_sphere_iterative_per_run_ww.ipynb | 17 ++++++++++++++++- .../4_sphere_iterative_per_batch_ww.ipynb | 14 +++++++++++++- 3 files changed, 30 insertions(+), 3 deletions(-) diff --git a/tasks/task_13_variance_reduction/2_shielded_room_single_ww.ipynb b/tasks/task_13_variance_reduction/2_shielded_room_single_ww.ipynb index 95e86f6f..8efb85dd 100644 --- a/tasks/task_13_variance_reduction/2_shielded_room_single_ww.ipynb +++ b/tasks/task_13_variance_reduction/2_shielded_room_single_ww.ipynb @@ -464,7 +464,7 @@ "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", + "wws = openmc.lib.WeightWindows.from_tally(tally, particle='neutron')\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", diff --git a/tasks/task_13_variance_reduction/3_sphere_iterative_per_run_ww.ipynb b/tasks/task_13_variance_reduction/3_sphere_iterative_per_run_ww.ipynb index b51873da..1706741f 100644 --- a/tasks/task_13_variance_reduction/3_sphere_iterative_per_run_ww.ipynb +++ b/tasks/task_13_variance_reduction/3_sphere_iterative_per_run_ww.ipynb @@ -1,6 +1,7 @@ { "cells": [ { + "attachments": {}, "cell_type": "markdown", "id": "72e0b25d-e541-4e8d-8805-b984374ee53d", "metadata": {}, @@ -23,6 +24,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "id": "f00eddb1-1e3a-4973-ba0c-d8feeb2a6704", "metadata": {}, @@ -47,6 +49,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "id": "8179e89a-304b-4684-91a9-8a908b75e8cd", "metadata": {}, @@ -70,6 +73,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "id": "424b234c-48a2-4d1b-b374-f69430e464db", "metadata": {}, @@ -98,6 +102,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "id": "51713fe1", "metadata": {}, @@ -117,6 +122,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "id": "8d6bd790", "metadata": {}, @@ -143,6 +149,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "id": "1456ac2f", "metadata": {}, @@ -176,6 +183,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "id": "2bc34eac", "metadata": {}, @@ -201,6 +209,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "id": "9bc4e52b", "metadata": {}, @@ -225,6 +234,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "id": "bf5eeb8b", "metadata": {}, @@ -293,6 +303,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "id": "647a81d8", "metadata": {}, @@ -316,7 +327,7 @@ " tally = openmc.lib.tallies[55]\n", "\n", " # makes weight windows from the tally, at this stage the values are empty\n", - " wws = openmc.lib.WeightWindows.from_tally(tally)\n", + " wws = openmc.lib.WeightWindows.from_tally(tally, particle='neutron')\n", "\n", " # 5 iterations of weight window improvements\n", " for i in range(5):\n", @@ -344,18 +355,21 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "id": "e293ce43", "metadata": {}, "source": [] }, { + "attachments": {}, "cell_type": "markdown", "id": "79ec2340", "metadata": {}, "source": [] }, { + "attachments": {}, "cell_type": "markdown", "id": "0c6548fc-a538-432f-9694-3092db42b1b4", "metadata": {}, @@ -387,6 +401,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "id": "d6daa0ba-5a5b-4701-aeaa-d57db34fb485", "metadata": {}, diff --git a/tasks/task_13_variance_reduction/4_sphere_iterative_per_batch_ww.ipynb b/tasks/task_13_variance_reduction/4_sphere_iterative_per_batch_ww.ipynb index 16a519dc..334bdf93 100644 --- a/tasks/task_13_variance_reduction/4_sphere_iterative_per_batch_ww.ipynb +++ b/tasks/task_13_variance_reduction/4_sphere_iterative_per_batch_ww.ipynb @@ -1,6 +1,7 @@ { "cells": [ { + "attachments": {}, "cell_type": "markdown", "id": "db6c76be-284f-4355-88aa-b4c89b9bbcea", "metadata": {}, @@ -41,6 +42,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "id": "1e8755e5-f1f8-4c4f-b142-eb8b1e6e6f84", "metadata": {}, @@ -72,6 +74,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "id": "78616dec-bac6-405e-bcfc-b0724670d209", "metadata": {}, @@ -110,6 +113,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "id": "b8be07cf-a90c-4fe9-ab86-44e26b0e6bfa", "metadata": {}, @@ -132,6 +136,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "id": "d70dd451-02ff-44d6-9628-84ed2753b578", "metadata": {}, @@ -156,6 +161,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "id": "e4a965a3-0c7e-4634-9f91-16b0a4325b8d", "metadata": {}, @@ -198,6 +204,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "id": "f62aacde-8f5e-4fdb-82bd-58f43037b6ac", "metadata": {}, @@ -218,6 +225,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "id": "580415f1-d56e-4a4a-b1b4-1ef30aeb92e4", "metadata": {}, @@ -236,6 +244,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "id": "862c2695-7aec-43e9-9461-0689ceed2482", "metadata": {}, @@ -273,6 +282,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "id": "e000825a-033c-4663-8e9f-70390ed54b8e", "metadata": {}, @@ -281,6 +291,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "id": "05c69e62-54f8-45b3-919f-f20bb1d3cc80", "metadata": {}, @@ -307,7 +318,7 @@ " # gets a live pointer to the mesh tally that we use to generate the \n", " ww_tally = openmc.lib.tallies[flux_tally_for_ww.id]\n", " # generates a weight window from the tally (which is currently empty)\n", - " wws = openmc.lib.WeightWindows.from_tally(ww_tally)\n", + " wws = openmc.lib.WeightWindows.from_tally(ww_tally, particle='neutron')\n", " \n", " # gets a live pointer to the spectra tally that we will plot with each batch\n", " spectra_tally = openmc.lib.tallies[outer_surface_spectra_tally.id]\n", @@ -349,6 +360,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "id": "b2c74788-8de5-4be7-9263-7f988fc43890", "metadata": {}, From 650bb8ebdb109395a0a0a71eece5ec82f93e657d Mon Sep 17 00:00:00 2001 From: shimwell Date: Sun, 25 Jun 2023 08:27:28 +0100 Subject: [PATCH 23/24] removed duplicate final --- .../task_13_variance_reduction/2_shielded_room_single_ww.ipynb | 3 --- 1 file changed, 3 deletions(-) diff --git a/tasks/task_13_variance_reduction/2_shielded_room_single_ww.ipynb b/tasks/task_13_variance_reduction/2_shielded_room_single_ww.ipynb index 8efb85dd..839ea997 100644 --- a/tasks/task_13_variance_reduction/2_shielded_room_single_ww.ipynb +++ b/tasks/task_13_variance_reduction/2_shielded_room_single_ww.ipynb @@ -356,9 +356,6 @@ "# 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", From 11f6717440c345eb154711f807f1d9d2422235d7 Mon Sep 17 00:00:00 2001 From: Jonathan Shimwell Date: Tue, 27 Jun 2023 15:17:07 +0100 Subject: [PATCH 24/24] added pip stl_to_h5m --- .devcontainer/base.Dockerfile | 1 + 1 file changed, 1 insertion(+) diff --git a/.devcontainer/base.Dockerfile b/.devcontainer/base.Dockerfile index e83e5e33..50761245 100644 --- a/.devcontainer/base.Dockerfile +++ b/.devcontainer/base.Dockerfile @@ -94,6 +94,7 @@ RUN apt-get install libxinerama-dev -y # python packages from the neutronics workflow RUN pip install neutronics_material_maker[density] \ + stl_to_h5m \ remove_dagmc_tags \ openmc-plasma-source \ openmc-dagmc-wrapper \