crp/OpenMC
1
0
Fork 0
mirror of https://github.com/openmc-dev/openmc.git synced 2026-07-28 06:05:58 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions 5

Merge pull request #725 from smharper/pyapi_filters

Browse source 
Separate Filter classes in Python API
This commit is contained in:
Paul Romano 2016-10-03 06:43:51 -05:00 • committed by GitHub
commit 22e3906193
29 changed files with 2069 additions and 1345 deletions
Download patch file Download diff file Expand all files Collapse all files

119
docs/source/pythonapi/examples/mdgxs-part-i.ipynb
View file

File diff suppressed because one or more lines are too long

360
docs/source/pythonapi/examples/mdgxs-part-ii.ipynb
View file

File diff suppressed because one or more lines are too long

313
docs/source/pythonapi/examples/mgxs-part-iii.ipynb
View file

File diff suppressed because one or more lines are too long

85
docs/source/pythonapi/examples/mgxs-part-iv.ipynb
View file

File diff suppressed because one or more lines are too long

109
docs/source/pythonapi/examples/pandas-dataframes.ipynb
View file

File diff suppressed because one or more lines are too long

84
docs/source/pythonapi/examples/post-processing.ipynb
View file

File diff suppressed because one or more lines are too long

89
docs/source/pythonapi/examples/tally-arithmetic.ipynb
View file

@ -338,7 +338,7 @@
"outputs": [
{
"data": {
"image/png": "iVBORw0KGgoAAAANSUhEUgAAAPoAAAD6AgMAAAD1grKuAAAABGdBTUEAALGPC/xhBQAAACBjSFJN\nAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAAADFBMVEX///9yEhLpgJFNv8Tq\nQYT7AAAAAWJLR0QAiAUdSAAAAAd0SU1FB+AJAwQmKDRX/78AAALKSURBVGje7dpLcqQwDAbgHHE2\nYeEj+D4cwQucBUfo+3CEXoSp8OhuhF70T4qpKXmdr21LogK2Pj7A8QmNP+HDhw8fPnz48Kf6VH9G\n+66vy+je8k19jnf8C5dXIPv86ms56lPdjvaYbyodx3ze+XLE76cXFiD4zPji99z0/AJ4n1lfvJ6f\nnl0A6x+578efMSg1wPr172/jPO5yFXM+Ef78gdblM+WPHyguP//t1/g6pA0wfln+ho/fwgYYn19C\n/xwDvwHGc9OvC+hs37DTrwuwfWanXxdQTC9Mvyygs3wjTL8uwPJpn/tNDbSGz7T0SBEWw4vLXzbQ\n6b6RoveIoO6TvPxlA63qs7z8ZQPF9F+SH22vbX8OQKf5Rtv+EgDNJ3X58wZaxWd1+fMGiuFvir8b\nvjp8J/tGy/6jAmRvhW8fwL3vVT+o3grfPoB7r/IpALI3tz8FoJN84/NV873hB8UnM3xzANtf8nb4\ndwmg3grfFEDJO8JPE0i9Ff4pAYL3pI8mkHor/HMCeO9JH00g9SafEsh7T/ppARBvp48UwJnelT5S\nACd7O31TAlnvKx9SQCd7B58KgPO+8iMFuPWe9E8F8BveWX7bAjzX9y4//Jve+fhsH6Ctv7n8PTzj\nvY/v9gEOHz58+PBX+6v/f/wPvnd54f3j6venE/yl769Xv7+j3x/o98/V32/o9+fl389Xnx+g5x/o\n+Qt6/oOeP6HnX+j5G3z+h54/ouefV5/foufP6Pk3ev4On/+j9w/o/Qd6/4Le/6D3T/D9V67Y/ZsV\nQBq+s+8f0ftP+P41axXguP9NWgDuu/Cdfv+N3r/D9/9TAID+A7T/Ae2/gPs/0P4TtP8F7r9J3AIO\n9P+g/Udw/9Oygbf7r9D+L7j/DO1/Q/vv4P4/tP8Q7n9E+y/h/k+0/xTuf4X7b+H+X7T/+BPuf3aM\n8OHDhw8fPnz4w/4vzcvgeY10sY0AAAAldEVYdGRhdGU6Y3JlYXRlADIwMTYtMDktMDNUMDQ6Mzg6\nNDAtMDQ6MDBo/hqzAAAAJXRFWHRkYXRlOm1vZGlmeQAyMDE2LTA5LTAzVDA0OjM4OjQwLTA0OjAw\nGaOiDwAAAABJRU5ErkJggg==\n",
"image/png": "iVBORw0KGgoAAAANSUhEUgAAAPoAAAD6AgMAAAD1grKuAAAABGdBTUEAALGPC/xhBQAAACBjSFJN\nAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAAADFBMVEX///9yEhLpgJFNv8Tq\nQYT7AAAAAWJLR0QAiAUdSAAAAAd0SU1FB+AJHgM6No8TBkYAAALKSURBVGje7dpLcqQwDAbgHHE2\nYeEj+D4cwQucBUfo+3CEXoSp8OhuhF70T4qpKXmdr21LogK2Pj7A8QmNP+HDhw8fPnz48Kf6VH9G\n+66vy+je8k19jnf8C5dXIPv86ms56lPdjvaYbyodx3ze+XLE76cXFiD4zPji99z0/AJ4n1lfvJ6f\nnl0A6x+578efMSg1wPr172/jPO5yFXM+Ef78gdblM+WPHyguP//t1/g6pA0wfln+ho/fwgYYn19C\n/xwDvwHGc9OvC+hs37DTrwuwfWanXxdQTC9Mvyygs3wjTL8uwPJpn/tNDbSGz7T0SBEWw4vLXzbQ\n6b6RoveIoO6TvPxlA63qs7z8ZQPF9F+SH22vbX8OQKf5Rtv+EgDNJ3X58wZaxWd1+fMGiuFvir8b\nvjp8J/tGy/6jAmRvhW8fwL3vVT+o3grfPoB7r/IpALI3tz8FoJN84/NV873hB8UnM3xzANtf8nb4\ndwmg3grfFEDJO8JPE0i9Ff4pAYL3pI8mkHor/HMCeO9JH00g9SafEsh7T/ppARBvp48UwJnelT5S\nACd7O31TAlnvKx9SQCd7B58KgPO+8iMFuPWe9E8F8BveWX7bAjzX9y4//Jve+fhsH6Ctv7n8PTzj\nvY/v9gEOHz58+PBX+6v/f/wPvnd54f3j6venE/yl769Xv7+j3x/o98/V32/o9+fl389Xnx+g5x/o\n+Qt6/oOeP6HnX+j5G3z+h54/ouefV5/foufP6Pk3ev4On/+j9w/o/Qd6/4Le/6D3T/D9V67Y/ZsV\nQBq+s+8f0ftP+P41axXguP9NWgDuu/Cdfv+N3r/D9/9TAID+A7T/Ae2/gPs/0P4TtP8F7r9J3AIO\n9P+g/Udw/9Oygbf7r9D+L7j/DO1/Q/vv4P4/tP8Q7n9E+y/h/k+0/xTuf4X7b+H+X7T/+BPuf3aM\n8OHDhw8fPnz4w/4vzcvgeY10sY0AAAAldEVYdGRhdGU6Y3JlYXRlADIwMTYtMDktMjlUMjM6NTg6\nNTItMDQ6MDBn7ClZAAAAJXRFWHRkYXRlOm1vZGlmeQAyMDE2LTA5LTI5VDIzOjU4OjUyLTA0OjAw\nFrGR5QAAAABJRU5ErkJggg==\n",
"text/plain": [
"<IPython.core.display.Image object>"
]
@ -386,18 +386,18 @@
"# Create Tallies to compute microscopic multi-group cross-sections\n",
"\n",
"# Instantiate energy filter for multi-group cross-section Tallies\n",
"energy_filter = openmc.Filter(type='energy', bins=[0., 0.625e-6, 20.])\n",
"energy_filter = openmc.EnergyFilter([0., 0.625e-6, 20.])\n",
"\n",
"# Instantiate flux Tally in moderator and fuel\n",
"tally = openmc.Tally(name='flux')\n",
"tally.filters = [openmc.Filter(type='cell', bins=[fuel_cell.id, moderator_cell.id])]\n",
"tally.filters = [openmc.CellFilter([fuel_cell.id, moderator_cell.id])]\n",
"tally.filters.append(energy_filter)\n",
"tally.scores = ['flux']\n",
"tallies_file.append(tally)\n",
"\n",
"# Instantiate reaction rate Tally in fuel\n",
"tally = openmc.Tally(name='fuel rxn rates')\n",
"tally.filters = [openmc.Filter(type='cell', bins=[fuel_cell.id])]\n",
"tally.filters = [openmc.CellFilter([fuel_cell.id])]\n",
"tally.filters.append(energy_filter)\n",
"tally.scores = ['nu-fission', 'scatter']\n",
"tally.nuclides = [u238, u235]\n",
@ -405,7 +405,7 @@
"\n",
"# Instantiate reaction rate Tally in moderator\n",
"tally = openmc.Tally(name='moderator rxn rates')\n",
"tally.filters = [openmc.Filter(type='cell', bins=[moderator_cell.id])]\n",
"tally.filters = [openmc.CellFilter([moderator_cell.id])]\n",
"tally.filters.append(energy_filter)\n",
"tally.scores = ['absorption', 'total']\n",
"tally.nuclides = [o16, h1]\n",
@ -417,8 +417,7 @@
"mesh.dimension = [1, 1, 1]\n",
"mesh.lower_left = [-0.63, -0.63, -100.]\n",
"mesh.width = [1.26, 1.26, 200.]\n",
"mesh_filter = openmc.Filter(type='mesh', bins=[mesh.id])\n",
"mesh_filter.mesh = mesh\n",
"mesh_filter = openmc.MeshFilter(mesh)\n",
"\n",
"# Instantiate thermal, fast, and total leakage tallies\n",
"leak = openmc.Tally(name='leakage')\n",
@ -427,12 +426,12 @@
"tallies_file.append(leak)\n",
"\n",
"thermal_leak = openmc.Tally(name='thermal leakage')\n",
"thermal_leak.filters = [mesh_filter, openmc.Filter(type='energy', bins=[0., 0.625e-6])]\n",
"thermal_leak.filters = [mesh_filter, openmc.EnergyFilter([0., 0.625e-6])]\n",
"thermal_leak.scores = ['current']\n",
"tallies_file.append(thermal_leak)\n",
"\n",
"fast_leak = openmc.Tally(name='fast leakage')\n",
"fast_leak.filters = [mesh_filter, openmc.Filter(type='energy', bins=[0.625e-6, 20.])]\n",
"fast_leak.filters = [mesh_filter, openmc.EnergyFilter([0.625e-6, 20.])]\n",
"fast_leak.scores = ['current']\n",
"tallies_file.append(fast_leak)"
]
@ -464,7 +463,7 @@
"# Resonance Escape Probability tallies\n",
"therm_abs_rate = openmc.Tally(name='therm. abs. rate')\n",
"therm_abs_rate.scores = ['absorption']\n",
"therm_abs_rate.filters = [openmc.Filter(type='energy', bins=[0., 0.625e-6])]\n",
"therm_abs_rate.filters = [openmc.EnergyFilter([0., 0.625e-6])]\n",
"tallies_file.append(therm_abs_rate)"
]
},
@ -479,8 +478,8 @@
"# Thermal Flux Utilization tallies\n",
"fuel_therm_abs_rate = openmc.Tally(name='fuel therm. abs. rate')\n",
"fuel_therm_abs_rate.scores = ['absorption']\n",
"fuel_therm_abs_rate.filters = [openmc.Filter(type='energy', bins=[0., 0.625e-6]),\n",
" openmc.Filter(type='cell', bins=[fuel_cell.id])]\n",
"fuel_therm_abs_rate.filters = [openmc.EnergyFilter([0., 0.625e-6]),\n",
" openmc.CellFilter([fuel_cell.id])]\n",
"tallies_file.append(fuel_therm_abs_rate)"
]
},
@ -495,7 +494,7 @@
"# Fast Fission Factor tallies\n",
"therm_fiss_rate = openmc.Tally(name='therm. fiss. rate')\n",
"therm_fiss_rate.scores = ['nu-fission']\n",
"therm_fiss_rate.filters = [openmc.Filter(type='energy', bins=[0., 0.625e-6])]\n",
"therm_fiss_rate.filters = [openmc.EnergyFilter([0., 0.625e-6])]\n",
"tallies_file.append(therm_fiss_rate)"
]
},
@ -508,11 +507,11 @@
"outputs": [],
"source": [
"# Instantiate energy filter to illustrate Tally slicing\n",
"fine_energy_filter = openmc.Filter(type='energy', bins=np.logspace(np.log10(1e-8), np.log10(20), 10))\n",
"fine_energy_filter = openmc.EnergyFilter(np.logspace(np.log10(1e-8), np.log10(20), 10))\n",
"\n",
"# Instantiate flux Tally in moderator and fuel\n",
"tally = openmc.Tally(name='need-to-slice')\n",
"tally.filters = [openmc.Filter(type='cell', bins=[fuel_cell.id, moderator_cell.id])]\n",
"tally.filters = [openmc.CellFilter(bins=[fuel_cell.id, moderator_cell.id])]\n",
"tally.filters.append(fine_energy_filter)\n",
"tally.scores = ['nu-fission', 'scatter']\n",
"tally.nuclides = [h1, u238]\n",
@ -550,7 +549,6 @@
"name": "stdout",
"output_type": "stream",
"text": [
"rm: cannot remove 'statepoint.*': No such file or directory\n",
"\n",
" %%%%%%%%%%%%%%%\n",
" %%%%%%%%%%%%%%%%%%%%%%%%\n",
@ -580,9 +578,9 @@
" Copyright | 2011-2016 Massachusetts Institute of Technology\n",
" License | http://openmc.readthedocs.io/en/latest/license.html\n",
" Version | 0.8.0\n",
" Git SHA1 | 623b705a399f16c8e5063732bc6e6a357611542d\n",
" Date/Time | 2016-09-03 04:38:41\n",
" OpenMP Threads | 4\n",
" Git SHA1 | b02fa21928a37a2254bec13c9802ff8173b6aefd\n",
" Date/Time | 2016-09-29 23:59:21\n",
" MPI Processes | 1\n",
"\n",
" ===========================================================================\n",
" ========================> INITIALIZATION <=========================\n",
@ -592,12 +590,12 @@
" Reading geometry XML file...\n",
" Reading cross sections XML file...\n",
" Reading materials XML file...\n",
" Reading U235 from /opt/xsdata/nndc_new/U235.h5\n",
" Reading U238 from /opt/xsdata/nndc_new/U238.h5\n",
" Reading O16 from /opt/xsdata/nndc_new/O16.h5\n",
" Reading H1 from /opt/xsdata/nndc_new/H1.h5\n",
" Reading B10 from /opt/xsdata/nndc_new/B10.h5\n",
" Reading Zr90 from /opt/xsdata/nndc_new/Zr90.h5\n",
" Reading U235 from /home/smharper/openmc/data/nndc_hdf5/U235.h5\n",
" Reading U238 from /home/smharper/openmc/data/nndc_hdf5/U238.h5\n",
" Reading O16 from /home/smharper/openmc/data/nndc_hdf5/O16.h5\n",
" Reading H1 from /home/smharper/openmc/data/nndc_hdf5/H1.h5\n",
" Reading B10 from /home/smharper/openmc/data/nndc_hdf5/B10.h5\n",
" Reading Zr90 from /home/smharper/openmc/data/nndc_hdf5/Zr90.h5\n",
" Maximum neutron transport energy: 20.0000 MeV for U235\n",
" Reading tallies XML file...\n",
" Building neighboring cells lists for each surface...\n",
@ -638,20 +636,20 @@
"\n",
" =======================> TIMING STATISTICS <=======================\n",
"\n",
" Total time for initialization = 3.8900E-01 seconds\n",
" Reading cross sections = 2.7000E-01 seconds\n",
" Total time in simulation = 4.6960E+00 seconds\n",
" Time in transport only = 4.6760E+00 seconds\n",
" Time in inactive batches = 6.6400E-01 seconds\n",
" Time in active batches = 4.0320E+00 seconds\n",
" Total time for initialization = 2.9900E-01 seconds\n",
" Reading cross sections = 1.8000E-01 seconds\n",
" Total time in simulation = 1.6156E+01 seconds\n",
" Time in transport only = 1.6145E+01 seconds\n",
" Time in inactive batches = 2.3940E+00 seconds\n",
" Time in active batches = 1.3762E+01 seconds\n",
" Time synchronizing fission bank = 1.0000E-03 seconds\n",
" Sampling source sites = 1.0000E-03 seconds\n",
" SEND/RECV source sites = 0.0000E+00 seconds\n",
" Time accumulating tallies = 0.0000E+00 seconds\n",
" Total time for finalization = 1.0000E-03 seconds\n",
" Total time elapsed = 5.0960E+00 seconds\n",
" Calculation Rate (inactive) = 18825.3 neutrons/second\n",
" Calculation Rate (active) = 9300.60 neutrons/second\n",
" Total time elapsed = 1.6476E+01 seconds\n",
" Calculation Rate (inactive) = 5221.39 neutrons/second\n",
" Calculation Rate (active) = 2724.89 neutrons/second\n",
"\n",
" ============================> RESULTS <============================\n",
"\n",
@ -768,8 +766,8 @@
"\n",
"# Get the leakage tally\n",
"leak = sp.get_tally(name='leakage')\n",
"leak = leak.summation(filter_type='surface', remove_filter=True)\n",
"leak = leak.summation(filter_type='mesh', remove_filter=True)\n",
"leak = leak.summation(filter_type=openmc.SurfaceFilter, remove_filter=True)\n",
"leak = leak.summation(filter_type=openmc.MeshFilter, remove_filter=True)\n",
"\n",
"# Compute k-infinity using tally arithmetic\n",
"keff = fiss_rate / (abs_rate + leak)\n",
@ -839,8 +837,8 @@
"# Compute resonance escape probability using tally arithmetic\n",
"therm_abs_rate = sp.get_tally(name='therm. abs. rate')\n",
"thermal_leak = sp.get_tally(name='thermal leakage')\n",
"thermal_leak = thermal_leak.summation(filter_type='surface', remove_filter=True)\n",
"thermal_leak = thermal_leak.summation(filter_type='mesh', remove_filter=True)\n",
"thermal_leak = thermal_leak.summation(filter_type=openmc.SurfaceFilter, remove_filter=True)\n",
"thermal_leak = thermal_leak.summation(filter_type=openmc.MeshFilter, remove_filter=True)\n",
"res_esc = (therm_abs_rate + thermal_leak) / (abs_rate + thermal_leak)\n",
"res_esc.get_pandas_dataframe()"
]
@ -1248,7 +1246,7 @@
"source": [
"# Compute microscopic multi-group cross-sections\n",
"flux = sp.get_tally(name='flux')\n",
"flux = flux.get_slice(filters=['cell'], filter_bins=[(fuel_cell.id,)])\n",
"flux = flux.get_slice(filters=[openmc.CellFilter], filter_bins=[(fuel_cell.id,)])\n",
"fuel_rxn_rates = sp.get_tally(name='fuel rxn rates')\n",
"mod_rxn_rates = sp.get_tally(name='moderator rxn rates')"
]
@ -1475,7 +1473,7 @@
],
"source": [
"# Show how to use Tally.get_values(...) with a CrossFilter and CrossScore\n",
"fast_scatter_xs = fuel_xs.get_values(filters=['energy'], \n",
"fast_scatter_xs = fuel_xs.get_values(filters=[openmc.EnergyFilter], \n",
" filter_bins=[((0.625e-6, 20.),)], \n",
" scores=['(scatter / flux)'])\n",
"print(fast_scatter_xs)"
@ -1734,9 +1732,18 @@
"# \"Slice\" the H-1 scatter data in the moderator Cell into a new derived Tally\n",
"need_to_slice = sp.get_tally(name='need-to-slice')\n",
"slice_test = need_to_slice.get_slice(scores=['scatter'], nuclides=['H1'],\n",
" filters=['cell'], filter_bins=[(moderator_cell.id,)])\n",
" filters=[openmc.CellFilter], filter_bins=[(moderator_cell.id,)])\n",
"slice_test.get_pandas_dataframe()"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": []
}
],
"metadata": {

14
docs/source/pythonapi/index.rst
View file

@ -133,7 +133,19 @@ Constructing Tallies
:nosignatures:
:template: myclass.rst
openmc.Filter
openmc.UniverseFilter
openmc.MaterialFilter
openmc.CellFilter
openmc.CellbornFilter
openmc.SurfaceFilter
openmc.MeshFilter
openmc.EnergyFilter
openmc.EnergyoutFilter
openmc.MuFilter
openmc.PolarFilter
openmc.AzimuthalFilter
openmc.DistribcellFilter
openmc.DelayedGroupFilter
openmc.Mesh
openmc.Trigger
openmc.Tally

6
examples/python/basic/build-xml.py
View file

@ -100,9 +100,9 @@ settings_file.export_to_xml()
###############################################################################
# Instantiate some tally Filters
cell_filter = openmc.Filter(type='cell', bins=100)
energy_filter = openmc.Filter(type='energy', bins=[0., 20.])
energyout_filter = openmc.Filter(type='energyout', bins=[0., 20.])
cell_filter = openmc.CellFilter(100)
energy_filter = openmc.EnergyFilter([0., 20.])
energyout_filter = openmc.EnergyoutFilter([0., 20.])
# Instantiate the first Tally
first_tally = openmc.Tally(tally_id=1, name='first tally')

2
examples/python/lattice/hexagonal/build-xml.py
View file

@ -159,7 +159,7 @@ plot_file.export_to_xml()
# Instantiate a distribcell Tally
tally = openmc.Tally(tally_id=1)
tally.filters = [openmc.Filter(type='distribcell', bins=[cell2.id])]
tally.filters = [openmc.DistribcellFilter(cell2.id)]
tally.scores = ['total']
# Instantiate a Tallies collection and export to XML

3
examples/python/lattice/nested/build-xml.py
View file

@ -162,8 +162,7 @@ mesh.lower_left = [-2, -2]
mesh.width = [1, 1]
# Instantiate tally Filter
mesh_filter = openmc.Filter()
mesh_filter.mesh = mesh
mesh_filter = openmc.MeshFilter(mesh)
# Instantiate the Tally
tally = openmc.Tally(tally_id=1)

3
examples/python/lattice/simple/build-xml.py
View file

@ -155,8 +155,7 @@ mesh.lower_left = [-2, -2]
mesh.width = [1, 1]
# Instantiate tally Filter
mesh_filter = openmc.Filter()
mesh_filter.mesh = mesh
mesh_filter = openmc.MeshFilter(mesh)
# Instantiate tally Trigger
trigger = openmc.Trigger(trigger_type='rel_err', threshold=1E-2)

5
examples/python/pincell/build-xml.py
View file

@ -185,9 +185,8 @@ mesh.lower_left = [-0.62992, -0.62992, -1.e50]
mesh.upper_right = [0.62992, 0.62992, 1.e50]
# Instantiate some tally Filters
energy_filter = openmc.Filter(type='energy', bins=[0., 4.e-6, 20.])
mesh_filter = openmc.Filter()
mesh_filter.mesh = mesh
energy_filter = openmc.EnergyFilter([0., 4.e-6, 20.])
mesh_filter = openmc.MeshFilter(mesh)
# Instantiate the Tally
tally = openmc.Tally(tally_id=1, name='tally 1')

6
examples/python/pincell_multigroup/build-xml.py
View file

@ -153,11 +153,9 @@ mesh.lower_left = [-0.63, -0.63, -1.e50]
mesh.upper_right = [0.63, 0.63, 1.e50]
# Instantiate some tally Filters
energy_filter = openmc.Filter(type='energy',
bins=[1E-11, 0.0635E-6, 10.0E-6, 1.0E-4, 1.0E-3,
energy_filter = openmc.EnergyFilter([1E-11, 0.0635E-6, 10.0E-6, 1.0E-4, 1.0E-3,
0.5, 1.0, 20.0])
mesh_filter = openmc.Filter()
mesh_filter.mesh = mesh
mesh_filter = openmc.MeshFilter(mesh)
# Instantiate the Tally
tally = openmc.Tally(tally_id=1, name='tally 1')

1
openmc/__init__.py
View file

@ -1,3 +1,4 @@
from openmc.arithmetic import *
from openmc.cell import *
from openmc.lattice import *
from openmc.element import *

32
openmc/arithmetic.py
View file

@ -4,7 +4,7 @@ from collections import Iterable
import numpy as np
from openmc import Filter, Nuclide
import openmc
from openmc.filter import _FILTER_TYPES
import openmc.checkvalue as cv
@ -171,7 +171,7 @@ class CrossNuclide(object):
string = ''
# If the Summary was linked, the left nuclide is a Nuclide object
if isinstance(self.left_nuclide, Nuclide):
if isinstance(self.left_nuclide, openmc.Nuclide):
string += '(' + self.left_nuclide.name
# If the Summary was not linked, the left nuclide is the ZAID
else:
@ -180,7 +180,7 @@ class CrossNuclide(object):
string += ' ' + self.binary_op + ' '
# If the Summary was linked, the right nuclide is a Nuclide object
if isinstance(self.right_nuclide, Nuclide):
if isinstance(self.right_nuclide, openmc.Nuclide):
string += self.right_nuclide.name + ')'
# If the Summary was not linked, the right nuclide is the ZAID
else:
@ -191,13 +191,13 @@ class CrossNuclide(object):
@left_nuclide.setter
def left_nuclide(self, left_nuclide):
cv.check_type('left_nuclide', left_nuclide,
(Nuclide, CrossNuclide, AggregateNuclide))
(openmc.Nuclide, CrossNuclide, AggregateNuclide))
self._left_nuclide = left_nuclide
@right_nuclide.setter
def right_nuclide(self, right_nuclide):
cv.check_type('right_nuclide', right_nuclide,
(Nuclide, CrossNuclide, AggregateNuclide))
(openmc.Nuclide, CrossNuclide, AggregateNuclide))
self._right_nuclide = right_nuclide
@binary_op.setter
@ -330,14 +330,14 @@ class CrossFilter(object):
@left_filter.setter
def left_filter(self, left_filter):
cv.check_type('left_filter', left_filter,
(Filter, CrossFilter, AggregateFilter))
(openmc.Filter, CrossFilter, AggregateFilter))
self._left_filter = left_filter
self._bins['left'] = left_filter.bins
@right_filter.setter
def right_filter(self, right_filter):
cv.check_type('right_filter', right_filter,
(Filter, CrossFilter, AggregateFilter))
(openmc.Filter, CrossFilter, AggregateFilter))
self._right_filter = right_filter
self._bins['right'] = right_filter.bins
@ -550,8 +550,8 @@ class AggregateNuclide(object):
# Append each nuclide in the aggregate to the string
string = '{0}('.format(self.aggregate_op)
names = [nuclide.name if isinstance(nuclide, Nuclide) else str(nuclide)
for nuclide in self.nuclides]
names = [nuclide.name if isinstance(nuclide, openmc.Nuclide)
else str(nuclide) for nuclide in self.nuclides]
string += ', '.join(map(str, names)) + ')'
return string
@ -567,15 +567,15 @@ class AggregateNuclide(object):
def name(self):
# Append each nuclide in the aggregate to the string
names = [nuclide.name if isinstance(nuclide, Nuclide) else str(nuclide)
for nuclide in self.nuclides]
names = [nuclide.name if isinstance(nuclide, openmc.Nuclide)
else str(nuclide) for nuclide in self.nuclides]
string = '(' + ', '.join(map(str, names)) + ')'
return string
@nuclides.setter
def nuclides(self, nuclides):
cv.check_iterable_type('nuclides', nuclides,
(basestring, Nuclide, CrossNuclide))
(basestring, openmc.Nuclide, CrossNuclide))
self._nuclides = nuclides
@aggregate_op.setter
@ -620,7 +620,8 @@ class AggregateFilter(object):
def __init__(self, aggregate_filter=None, bins=None, aggregate_op=None):
self._type = '{0}({1})'.format(aggregate_op, aggregate_filter.type)
self._type = '{0}({1})'.format(aggregate_op,
aggregate_filter.short_name.lower())
self._bins = None
self._stride = None
@ -699,7 +700,8 @@ class AggregateFilter(object):
@aggregate_filter.setter
def aggregate_filter(self, aggregate_filter):
cv.check_type('aggregate_filter', aggregate_filter, (Filter, CrossFilter))
cv.check_type('aggregate_filter', aggregate_filter,
(openmc.Filter, CrossFilter))
self._aggregate_filter = aggregate_filter
@bins.setter
@ -752,7 +754,7 @@ class AggregateFilter(object):
else:
return self.bins.index(filter_bin)
def get_pandas_dataframe(self, data_size, summary=None):
def get_pandas_dataframe(self, data_size, summary=None, **kwargs):
"""Builds a Pandas DataFrame for the AggregateFilter's bins.
This method constructs a Pandas DataFrame object for the AggregateFilter

1689
openmc/filter.py
View file

File diff suppressed because it is too large Load diff

43
openmc/mgxs/mdgxs.py
View file

@ -12,6 +12,7 @@ import numpy as np
import openmc
from openmc.mgxs import MGXS
from openmc.mgxs.mgxs import _DOMAIN_TO_FILTER
import openmc.checkvalue as cv
if sys.version_info[0] >= 3:
@ -194,10 +195,10 @@ class MDGXS(MGXS):
# Create the non-domain specific Filters for the Tallies
group_edges = self.energy_groups.group_edges
energy_filter = openmc.Filter('energy', group_edges)
energy_filter = openmc.EnergyFilter(group_edges)
if self.delayed_groups != None:
delayed_filter = openmc.Filter('delayedgroup', self.delayed_groups)
delayed_filter = openmc.DelayedGroupFilter(self.delayed_groups)
return [[energy_filter], [delayed_filter, energy_filter]]
else:
return [[energy_filter], [energy_filter]]
@ -325,14 +326,14 @@ class MDGXS(MGXS):
cv.check_iterable_type('subdomains', subdomains, Integral,
max_depth=3)
for subdomain in subdomains:
filters.append(self.domain_type)
filters.append(_DOMAIN_TO_FILTER[self.domain_type])
filter_bins.append((subdomain,))
# Construct list of energy group bounds tuples for all requested groups
if not isinstance(groups, basestring):
cv.check_iterable_type('groups', groups, Integral)
for group in groups:
filters.append('energy')
filters.append(openmc.EnergyFilter)
filter_bins.append(
(self.energy_groups.get_group_bounds(group),))
@ -340,7 +341,7 @@ class MDGXS(MGXS):
if not isinstance(delayed_groups, basestring):
cv.check_type('delayed groups', delayed_groups, list, int)
for delayed_group in delayed_groups:
filters.append('delayedgroup')
filters.append(openmc.DelayedGroupFilter)
filter_bins.append((delayed_group,))
# Construct a collection of the nuclides to retrieve from the xs tally
@ -447,11 +448,11 @@ class MDGXS(MGXS):
group_bounds = self.energy_groups.get_group_bounds(group)
energy_bins.append(group_bounds)
filter_bins.append(tuple(energy_bins))
filters.append('energy')
filters.append(openmc.EnergyFilter)
if len(delayed_groups) != 0:
filter_bins.append(tuple(delayed_groups))
filters.append('delayedgroup')
filters.append(openmc.DelayedGroupFilter)
# Clone this MGXS to initialize the sliced version
slice_xs = copy.deepcopy(self)
@ -974,10 +975,10 @@ class ChiDelayed(MDGXS):
def filters(self):
# Create the non-domain specific Filters for the Tallies
group_edges = self.energy_groups.group_edges
energyout = openmc.Filter('energyout', group_edges)
energyin = openmc.Filter('energy', [group_edges[0], group_edges[-1]])
energyout = openmc.EnergyoutFilter(group_edges)
energyin = openmc.EnergyFilter([group_edges[0], group_edges[-1]])
if self.delayed_groups != None:
delayed_filter = openmc.Filter('delayedgroup', self.delayed_groups)
delayed_filter = openmc.DelayedGroupFilter(self.delayed_groups)
return [[delayed_filter, energyin], [delayed_filter, energyout]]
else:
return [[energyin], [energyout]]
@ -1004,7 +1005,8 @@ class ChiDelayed(MDGXS):
delayed_nu_fission_in = self.tallies['delayed-nu-fission-in']
# Remove coarse energy filter to keep it out of tally arithmetic
energy_filter = delayed_nu_fission_in.find_filter('energy')
energy_filter = delayed_nu_fission_in.find_filter(
openmc.EnergyFilter)
delayed_nu_fission_in.remove_filter(energy_filter)
# Compute chi
@ -1049,7 +1051,7 @@ class ChiDelayed(MDGXS):
# Temporarily remove energy filter from delayed-nu-fission-in since its
# group structure will work in super MGXS.get_slice(...) method
delayed_nu_fission_in = self.tallies['delayed-nu-fission-in']
energy_filter = delayed_nu_fission_in.find_filter('energy')
energy_filter = delayed_nu_fission_in.find_filter(openmc.EnergyFilter)
delayed_nu_fission_in.remove_filter(energy_filter)
# Call super class method and null out derived tallies
@ -1068,11 +1070,11 @@ class ChiDelayed(MDGXS):
group_bounds = self.energy_groups.get_group_bounds(group)
energy_bins.append(group_bounds)
filter_bins.append(tuple(energy_bins))
filters.append('energyout')
filters.append(openmc.EnergyoutFilter)
if len(delayed_groups) != 0:
filter_bins.append(tuple(delayed_groups))
filters.append('delayedgroup')
filters.append(openmc.DelayedGroupFilter)
if filters != []:
@ -1214,14 +1216,14 @@ class ChiDelayed(MDGXS):
cv.check_iterable_type('subdomains', subdomains, Integral,
max_depth=3)
for subdomain in subdomains:
filters.append(self.domain_type)
filters.append(_DOMAIN_TO_FILTER[self.domain_type])
filter_bins.append((subdomain,))
# Construct list of energy group bounds tuples for all requested groups
if not isinstance(groups, basestring):
cv.check_iterable_type('groups', groups, Integral)
for group in groups:
filters.append('energyout')
filters.append(openmc.EnergyoutFilter)
filter_bins.append(
(self.energy_groups.get_group_bounds(group),))
@ -1229,7 +1231,7 @@ class ChiDelayed(MDGXS):
if not isinstance(delayed_groups, basestring):
cv.check_type('delayed groups', delayed_groups, list, int)
for delayed_group in delayed_groups:
filters.append('delayedgroup')
filters.append(openmc.DelayedGroupFilter)
filter_bins.append((delayed_group,))
# If chi delayed was computed for each nuclide in the domain
@ -1251,7 +1253,8 @@ class ChiDelayed(MDGXS):
(nuclides=nuclides)
# Remove coarse energy filter to keep it out of tally arithmetic
energy_filter = delayed_nu_fission_in.find_filter('energy')
energy_filter = delayed_nu_fission_in.find_filter(
openmc.EnergyFilter)
delayed_nu_fission_in.remove_filter(energy_filter)
# Compute chi and store it as the xs_tally attribute so we can
@ -1710,10 +1713,10 @@ class DecayRate(MDGXS):
# Create the non-domain specific Filters for the Tallies
group_edges = self.energy_groups.group_edges
energy_filter = openmc.Filter('energy', group_edges)
energy_filter = openmc.EnergyFilter(group_edges)
if self.delayed_groups != None:
delayed_filter = openmc.Filter('delayedgroup', self.delayed_groups)
delayed_filter = openmc.DelayedGroupFilter(self.delayed_groups)
return [[delayed_filter, energy_filter], [delayed_filter, energy_filter]]
else:
return [[energy_filter], [energy_filter]]

114
openmc/mgxs/mgxs.py
View file

@ -47,6 +47,13 @@ DOMAIN_TYPES = ['cell',
'material',
'mesh']
# Filter types corresponding to each domain
_DOMAIN_TO_FILTER = {'cell': openmc.CellFilter,
'distribcell': openmc.DistribcellFilter,
'universe': openmc.UniverseFilter,
'material': openmc.MaterialFilter,
'mesh': openmc.MeshFilter}
# Supported domain classes
_DOMAINS = (openmc.Cell,
openmc.Universe,
@ -242,7 +249,7 @@ class MGXS(object):
@property
def filters(self):
group_edges = self.energy_groups.group_edges
energy_filter = openmc.Filter('energy', group_edges)
energy_filter = openmc.EnergyFilter(group_edges)
return [[energy_filter]] * len(self.scores)
@property
@ -263,11 +270,11 @@ class MGXS(object):
self._tallies = OrderedDict()
# Create a domain Filter object
domain_filter = openmc.Filter(self.domain_type, self.domain.id)
# If a mesh domain, give the mesh to the domain filter
filter_type = _DOMAIN_TO_FILTER[self.domain_type]
if self.domain_type == 'mesh':
domain_filter.mesh = self.domain
domain_filter = filter_type(self.domain)
else:
domain_filter = filter_type(self.domain.id)
# Create each Tally needed to compute the multi group cross section
tally_metadata = zip(self.scores, self.tally_keys, self.filters)
@ -322,7 +329,12 @@ class MGXS(object):
@property
def num_subdomains(self):
domain_filter = self.xs_tally.find_filter(self.domain_type)
if self.domain_type.startswith('avg('):
domain_type = self.domain_type[4:-1]
else:
domain_type = self.domain_type
filter_type = _DOMAIN_TO_FILTER[domain_type]
domain_filter = self.xs_tally.find_filter(filter_type)
return domain_filter.num_bins
@property
@ -683,11 +695,11 @@ class MGXS(object):
# Use tally "slicing" to ensure that tallies correspond to our domain
# NOTE: This is important if tally merging was used
if self.domain_type == 'mesh':
filters = [self.domain_type]
filters = [_DOMAIN_TO_FILTER[self.domain_type]]
xyz = [range(1, x+1) for x in self.domain.dimension]
filter_bins = [tuple(itertools.product(*xyz))]
elif self.domain_type != 'distribcell':
filters = [self.domain_type]
filters = [_DOMAIN_TO_FILTER[self.domain_type]]
filter_bins = [(self.domain.id,)]
# Distribcell filters only accept single cell - neglect it when slicing
else:
@ -780,14 +792,14 @@ class MGXS(object):
cv.check_iterable_type('subdomains', subdomains, Integral,
max_depth=3)
for subdomain in subdomains:
filters.append(self.domain_type)
filters.append(_DOMAIN_TO_FILTER[self.domain_type])
filter_bins.append((subdomain,))
# Construct list of energy group bounds tuples for all requested groups
if not isinstance(groups, basestring):
cv.check_iterable_type('groups', groups, Integral)
for group in groups:
filters.append('energy')
filters.append(openmc.EnergyFilter)
filter_bins.append((self.energy_groups.get_group_bounds(group),))
# Construct a collection of the nuclides to retrieve from the xs tally
@ -895,7 +907,8 @@ class MGXS(object):
# Sum across all applicable fine energy group filters
for i, tally_filter in enumerate(tally.filters):
if 'energy' not in tally_filter.type:
if not isinstance(tally_filter, (openmc.EnergyFilter,
openmc.EnergyoutFilter)):
continue
elif len(tally_filter.bins) != len(fine_edges):
continue
@ -957,14 +970,16 @@ class MGXS(object):
if self.derived:
avg_xs._rxn_rate_tally = avg_xs.rxn_rate_tally.average(
filter_type=self.domain_type, filter_bins=subdomains)
filter_type=_DOMAIN_TO_FILTER[self.domain_type],
filter_bins=subdomains)
else:
avg_xs._rxn_rate_tally = None
avg_xs._xs_tally = None
# Average each of the tallies across subdomains
for tally_type, tally in avg_xs.tallies.items():
tally_avg = tally.average(filter_type=self.domain_type,
filt_type = _DOMAIN_TO_FILTER[self.domain_type]
tally_avg = tally.average(filter_type=filt_type,
filter_bins=subdomains)
avg_xs.tallies[tally_type] = tally_avg
@ -1011,7 +1026,7 @@ class MGXS(object):
group_bounds = self.energy_groups.get_group_bounds(group)
energy_bins.append(group_bounds)
filter_bins.append(tuple(energy_bins))
filters.append('energy')
filters.append(openmc.EnergyFilter)
# Clone this MGXS to initialize the sliced version
slice_xs = copy.deepcopy(self)
@ -1021,7 +1036,7 @@ class MGXS(object):
# Slice each of the tallies across nuclides and energy groups
for tally_type, tally in slice_xs.tallies.items():
slice_nuclides = [nuc for nuc in nuclides if nuc in tally.nuclides]
if len(groups) != 0 and tally.contains_filter('energy'):
if len(groups) != 0 and tally.contains_filter(openmc.EnergyFilter):
tally_slice = tally.get_slice(filters=filters,
filter_bins=filter_bins,
nuclides=slice_nuclides)
@ -1696,8 +1711,8 @@ class MatrixMGXS(MGXS):
def filters(self):
# Create the non-domain specific Filters for the Tallies
group_edges = self.energy_groups.group_edges
energy = openmc.Filter('energy', group_edges)
energyout = openmc.Filter('energyout', group_edges)
energy = openmc.EnergyFilter(group_edges)
energyout = openmc.EnergyoutFilter(group_edges)
return [[energy], [energy, energyout]]
@ -1775,14 +1790,14 @@ class MatrixMGXS(MGXS):
cv.check_iterable_type('subdomains', subdomains, Integral,
max_depth=3)
for subdomain in subdomains:
filters.append(self.domain_type)
filters.append(_DOMAIN_TO_FILTER[self.domain_type])
filter_bins.append((subdomain,))
# Construct list of energy group bounds tuples for all requested groups
if not isinstance(in_groups, basestring):
cv.check_iterable_type('groups', in_groups, Integral)
for group in in_groups:
filters.append('energy')
filters.append(openmc.EnergyFilter)
filter_bins.append((
self.energy_groups.get_group_bounds(group),))
@ -1790,7 +1805,7 @@ class MatrixMGXS(MGXS):
if not isinstance(out_groups, basestring):
cv.check_iterable_type('groups', out_groups, Integral)
for group in out_groups:
filters.append('energyout')
filters.append(openmc.EnergyoutFilter)
filter_bins.append((
self.energy_groups.get_group_bounds(group),))
@ -1902,9 +1917,10 @@ class MatrixMGXS(MGXS):
# Slice each of the tallies across energyout groups
for tally_type, tally in slice_xs.tallies.items():
if tally.contains_filter('energyout'):
tally_slice = tally.get_slice(filters=['energyout'],
filter_bins=filter_bins)
if tally.contains_filter(openmc.EnergyoutFilter):
tally_slice = tally.get_slice(
filters=[openmc.EnergyoutFilter],
filter_bins=filter_bins)
slice_xs.tallies[tally_type] = tally_slice
slice_xs.sparse = self.sparse
@ -2254,14 +2270,19 @@ class TransportXS(MGXS):
@property
def filters(self):
group_edges = self.energy_groups.group_edges
energy_filter = openmc.Filter('energy', group_edges)
energyout_filter = openmc.Filter('energyout', group_edges)
energy_filter = openmc.EnergyFilter(group_edges)
energyout_filter = openmc.EnergyoutFilter(group_edges)
return [[energy_filter], [energy_filter], [energyout_filter]]
@property
def rxn_rate_tally(self):
if self._rxn_rate_tally is None:
self.tallies['scatter-1'].filters[-1].type = 'energy'
# Switch EnergyoutFilter to EnergyFilter.
old_filt = self.tallies['scatter-1'].filters[-1]
new_filt = openmc.EnergyFilter(old_filt.bins)
new_filt.stride = old_filt.stride
self.tallies['scatter-1'].filters[-1] = new_filt
self._rxn_rate_tally = \
self.tallies['total'] - self.tallies['scatter-1']
self._rxn_rate_tally.sparse = self.sparse
@ -3353,8 +3374,8 @@ class ScatterMatrixXS(MatrixMGXS):
@property
def filters(self):
group_edges = self.energy_groups.group_edges
energy = openmc.Filter('energy', group_edges)
energyout = openmc.Filter('energyout', group_edges)
energy = openmc.EnergyFilter(group_edges)
energyout = openmc.EnergyoutFilter(group_edges)
if self.correction == 'P0' and self.legendre_order == 0:
filters = [[energy], [energy, energyout], [energyout]]
@ -3372,7 +3393,7 @@ class ScatterMatrixXS(MatrixMGXS):
if self.correction == 'P0' and self.legendre_order == 0:
scatter_p0 = self.tallies['{}-0'.format(self.rxn_type)]
scatter_p1 = self.tallies['{}-1'.format(self.rxn_type)]
energy_filter = scatter_p0.find_filter('energy')
energy_filter = scatter_p0.find_filter(openmc.EnergyFilter)
energy_filter = copy.deepcopy(energy_filter)
scatter_p1 = scatter_p1.diagonalize_filter(energy_filter)
self._rxn_rate_tally = scatter_p0 - scatter_p1
@ -3515,9 +3536,9 @@ class ScatterMatrixXS(MatrixMGXS):
# Slice each of the tallies across energyout groups
for tally_type, tally in slice_xs.tallies.items():
if tally.contains_filter('energyout'):
tally_slice = tally.get_slice(filters=['energyout'],
filter_bins=filter_bins)
if tally.contains_filter(openmc.EnergyoutFilter):
tally_slice = tally.get_slice(
filters=[openmc.EnergyoutFilter], filter_bins=filter_bins)
slice_xs.tallies[tally_type] = tally_slice
slice_xs.sparse = self.sparse
@ -3603,21 +3624,21 @@ class ScatterMatrixXS(MatrixMGXS):
if not isinstance(subdomains, basestring):
cv.check_iterable_type('subdomains', subdomains, Integral, max_depth=3)
for subdomain in subdomains:
filters.append(self.domain_type)
filters.append(_DOMAIN_TO_FILTER[self.domain_type])
filter_bins.append((subdomain,))
# Construct list of energy group bounds tuples for all requested groups
if not isinstance(in_groups, basestring):
cv.check_iterable_type('groups', in_groups, Integral)
for group in in_groups:
filters.append('energy')
filters.append(openmc.EnergyFilter)
filter_bins.append((self.energy_groups.get_group_bounds(group),))
# Construct list of energy group bounds tuples for all requested groups
if not isinstance(out_groups, basestring):
cv.check_iterable_type('groups', out_groups, Integral)
for group in out_groups:
filters.append('energyout')
filters.append(openmc.EnergyoutFilter)
filter_bins.append((self.energy_groups.get_group_bounds(group),))
# Construct CrossScore for requested scattering moment
@ -4121,8 +4142,8 @@ class MultiplicityMatrixXS(MatrixMGXS):
def filters(self):
# Create the non-domain specific Filters for the Tallies
group_edges = self.energy_groups.group_edges
energy = openmc.Filter('energy', group_edges)
energyout = openmc.Filter('energyout', group_edges)
energy = openmc.EnergyFilter(group_edges)
energyout = openmc.EnergyoutFilter(group_edges)
return [[energy, energyout], [energy, energyout]]
@ -4385,8 +4406,8 @@ class Chi(MGXS):
def filters(self):
# Create the non-domain specific Filters for the Tallies
group_edges = self.energy_groups.group_edges
energyout = openmc.Filter('energyout', group_edges)
energyin = openmc.Filter('energy', [group_edges[0], group_edges[-1]])
energyout = openmc.EnergyoutFilter(group_edges)
energyin = openmc.EnergyFilter([group_edges[0], group_edges[-1]])
return [[energyin], [energyout]]
@property
@ -4407,12 +4428,11 @@ class Chi(MGXS):
nu_fission_in = self.tallies['nu-fission-in']
# Remove coarse energy filter to keep it out of tally arithmetic
energy_filter = nu_fission_in.find_filter('energy')
energy_filter = nu_fission_in.find_filter(openmc.EnergyFilter)
nu_fission_in.remove_filter(energy_filter)
# Compute chi
self._xs_tally = self.rxn_rate_tally / nu_fission_in
super(Chi, self)._compute_xs()
# Add the coarse energy filter back to the nu-fission tally
nu_fission_in.filters.append(energy_filter)
@ -4448,7 +4468,7 @@ class Chi(MGXS):
# Temporarily remove energy filter from nu-fission-in since its
# group structure will work in super MGXS.get_slice(...) method
nu_fission_in = self.tallies['nu-fission-in']
energy_filter = nu_fission_in.find_filter('energy')
energy_filter = nu_fission_in.find_filter(openmc.EnergyFilter)
nu_fission_in.remove_filter(energy_filter)
# Call super class method and null out derived tallies
@ -4466,8 +4486,8 @@ class Chi(MGXS):
# Slice nu-fission-out tally along energyout filter
nu_fission_out = slice_xs.tallies['nu-fission-out']
tally_slice = nu_fission_out.get_slice(filters=['energyout'],
filter_bins=filter_bins)
tally_slice = nu_fission_out.get_slice(
filters=[openmc.EnergyoutFilter], filter_bins=filter_bins)
slice_xs._tallies['nu-fission-out'] = tally_slice
# Add energy filter back to nu-fission-in tallies
@ -4592,14 +4612,14 @@ class Chi(MGXS):
if not isinstance(subdomains, basestring):
cv.check_iterable_type('subdomains', subdomains, Integral, max_depth=3)
for subdomain in subdomains:
filters.append(self.domain_type)
filters.append(_DOMAIN_TO_FILTER[self.domain_type])
filter_bins.append((subdomain,))
# Construct list of energy group bounds tuples for all requested groups
if not isinstance(groups, basestring):
cv.check_iterable_type('groups', groups, Integral)
for group in groups:
filters.append('energyout')
filters.append(openmc.EnergyoutFilter)
filter_bins.append((self.energy_groups.get_group_bounds(group),))
# If chi was computed for each nuclide in the domain
@ -4619,7 +4639,7 @@ class Chi(MGXS):
nu_fission_out = nu_fission_out.summation(nuclides=nuclides)
# Remove coarse energy filter to keep it out of tally arithmetic
energy_filter = nu_fission_in.find_filter('energy')
energy_filter = nu_fission_in.find_filter(openmc.EnergyFilter)
nu_fission_in.remove_filter(energy_filter)
# Compute chi and store it as the xs_tally attribute so we can

36
openmc/statepoint.py
View file

@ -405,30 +405,11 @@ class StatePoint(object):
subbase = '{0}{1}/filter '.format(base, tally_key)
# Initialize all Filters
# Read all filters
for j in range(1, n_filters+1):
# Read the Filter type
filter_type = \
self._f['{0}{1}/type'.format(subbase, j)].value.decode()
n_bins = self._f['{0}{1}/n_bins'.format(subbase, j)].value
# Read the bin values
bins = self._f['{0}{1}/bins'.format(subbase, j)].value
# Create Filter object
new_filter = openmc.Filter(filter_type, bins)
new_filter.num_bins = n_bins
if filter_type == 'mesh':
mesh_ids = self._f['tallies/meshes/ids'].value
mesh_keys = self._f['tallies/meshes/keys'].value
key = mesh_keys[mesh_ids == bins][0]
new_filter.mesh = self.meshes[key]
# Add Filter to the Tally
subsubbase = '{0}{1}'.format(subbase, j)
new_filter = openmc.Filter.from_hdf5(self._f[subsubbase],
meshes=self.meshes)
tally.filters.append(new_filter)
# Read Nuclide bins
@ -695,24 +676,25 @@ class StatePoint(object):
tally.with_summary = True
for tally_filter in tally.filters:
if tally_filter.type in ['cell', 'distribcell']:
if isinstance(tally_filter, (openmc.CellFilter,
openmc.DistribcellFilter)):
distribcell_ids = []
for bin in tally_filter.bins:
distribcell_ids.append(summary.cells[bin].id)
tally_filter.bins = distribcell_ids
if tally_filter.type == 'distribcell':
if isinstance(tally_filter, (openmc.DistribcellFilter)):
cell_id = tally_filter.bins[0]
cell = summary.get_cell_by_id(cell_id)
tally_filter.distribcell_paths = cell.distribcell_paths
if tally_filter.type == 'universe':
if isinstance(tally_filter, openmc.UniverseFilter):
universe_ids = []
for bin in tally_filter.bins:
universe_ids.append(summary.universes[bin].id)
tally_filter.bins = universe_ids
if tally_filter.type == 'material':
if isinstance(tally_filter, openmc.MaterialFilter):
material_ids = []
for bin in tally_filter.bins:
material_ids.append(summary.materials[bin].id)

198
openmc/tallies.py
View file

@ -13,10 +13,7 @@ from xml.etree import ElementTree as ET
import numpy as np
from openmc import Filter, Trigger, Nuclide
from openmc.arithmetic import CrossScore, CrossNuclide, CrossFilter, \
AggregateScore, AggregateNuclide, AggregateFilter
from openmc.filter import _FILTER_TYPES
import openmc
import openmc.checkvalue as cv
from openmc.clean_xml import clean_xml_indentation
@ -36,9 +33,10 @@ _PRODUCT_TYPES = ['tensor', 'entrywise']
# The following indicate acceptable types when setting Tally.scores,
# Tally.nuclides, and Tally.filters
_SCORE_CLASSES = (basestring, CrossScore, AggregateScore)
_NUCLIDE_CLASSES = (basestring, Nuclide, CrossNuclide, AggregateNuclide)
_FILTER_CLASSES = (Filter, CrossFilter, AggregateFilter)
_SCORE_CLASSES = (basestring, openmc.CrossScore, openmc.AggregateScore)
_NUCLIDE_CLASSES = (basestring, openmc.Nuclide, openmc.CrossNuclide,
openmc.AggregateNuclide)
_FILTER_CLASSES = (openmc.Filter, openmc.CrossFilter, openmc.AggregateFilter)
# Valid types of estimators
ESTIMATOR_TYPES = ['tracklength', 'collision', 'analog']
@ -118,7 +116,7 @@ class Tally(object):
self._nuclides = cv.CheckedList(_NUCLIDE_CLASSES, 'tally nuclides')
self._scores = cv.CheckedList(_SCORE_CLASSES, 'tally scores')
self._estimator = None
self._triggers = cv.CheckedList(Trigger, 'tally triggers')
self._triggers = cv.CheckedList(openmc.Trigger, 'tally triggers')
self._num_realizations = 0
self._with_summary = False
@ -181,13 +179,13 @@ class Tally(object):
string += '{0: <16}{1}\n'.format('\tFilters', '=\t')
for self_filter in self.filters:
string += '{0: <16}\t\t{1}\t{2}\n'.format('', self_filter.type,
self_filter.bins)
string += '{0: <16}\t\t{1}\t{2}\n'.format('',
type(self_filter).__name__, self_filter.bins)
string += '{0: <16}{1}'.format('\tNuclides', '=\t')
for nuclide in self.nuclides:
if isinstance(nuclide, Nuclide):
if isinstance(nuclide, openmc.Nuclide):
string += '{0} '.format(nuclide.name)
else:
string += '{0} '.format(nuclide)
@ -396,7 +394,8 @@ class Tally(object):
@triggers.setter
def triggers(self, triggers):
cv.check_type('tally triggers', triggers, MutableSequence)
self._triggers = cv.CheckedList(Trigger, 'tally triggers', triggers)
self._triggers = cv.CheckedList(openmc.Trigger, 'tally triggers',
triggers)
def add_trigger(self, trigger):
"""Add a tally trigger to the tally
@ -700,8 +699,8 @@ class Tally(object):
return False
# Return False if only one tally has a delayed group filter
tally1_dg = self.contains_filter('delayedgroup')
tally2_dg = other.contains_filter('delayedgroup')
tally1_dg = self.contains_filter(openmc.DelayedGroupFilter)
tally2_dg = other.contains_filter(openmc.DelayedGroupFilter)
if sum([tally1_dg, tally2_dg]) == 1:
return False
@ -1026,21 +1025,13 @@ class Tally(object):
# Optional Tally filters
for self_filter in self.filters:
subelement = ET.SubElement(element, "filter")
subelement.set("type", str(self_filter.type))
if self_filter.bins is not None:
bins = ''
for bin in self_filter.bins:
bins += '{0} '.format(bin)
subelement.set("bins", bins.rstrip(' '))
element.append(self_filter.to_xml())
# Optional Nuclides
if len(self.nuclides) > 0:
nuclides = ''
for nuclide in self.nuclides:
if isinstance(nuclide, Nuclide):
if isinstance(nuclide, openmc.Nuclide):
nuclides += '{0} '.format(nuclide.name)
else:
nuclides += '{0} '.format(nuclide)
@ -1078,8 +1069,8 @@ class Tally(object):
Parameters
----------
filter_type : str
Type of the filter, e.g. 'mesh'
filter_type : openmc.FilterMeta
Type of the filter, e.g. MeshFilter
Returns
-------
@ -1093,7 +1084,7 @@ class Tally(object):
# Look through all of this Tally's Filters for the type requested
for test_filter in self.filters:
if test_filter.type == filter_type:
if type(test_filter) is filter_type:
filter_found = True
break
@ -1104,8 +1095,8 @@ class Tally(object):
Parameters
----------
filter_type : str
Type of the filter, e.g. 'mesh'
filter_type : openmc.FilterMeta
Type of the filter, e.g. MeshFilter
Returns
-------
@ -1124,10 +1115,17 @@ class Tally(object):
# Look through all of this Tally's Filters for the type requested
for test_filter in self.filters:
if test_filter.type == filter_type:
if type(test_filter) is filter_type:
filter_found = test_filter
break
# Also check to see if the desired filter is wrapped up in an
# aggregate
elif isinstance(test_filter, openmc.AggregateFilter):
if isinstance(test_filter.aggregate_filter, filter_type):
filter_found = test_filter
break
# If we did not find the Filter, throw an Exception
if filter_found is None:
msg = 'Unable to find filter type "{0}" in ' \
@ -1141,8 +1139,8 @@ class Tally(object):
Parameters
----------
filter_type : str
The type of Filter (e.g., 'cell', 'energy', etc.)
filter_type : openmc.FilterMeta
Type of the filter, e.g. MeshFilter
filter_bin : int or tuple
The bin is an integer ID for 'material', 'surface', 'cell',
'cellborn', and 'universe' Filters. The bin is an integer for the
@ -1192,7 +1190,7 @@ class Tally(object):
for i, test_nuclide in enumerate(self.nuclides):
# If the Summary was linked, then values are Nuclide objects
if isinstance(test_nuclide, Nuclide):
if isinstance(test_nuclide, openmc.Nuclide):
if test_nuclide.name == nuclide:
nuclide_index = i
break
@ -1251,19 +1249,19 @@ class Tally(object):
Parameters
----------
filters : list of str
A list of filter type strings
(e.g., ['mesh', 'energy']; default is [])
filter_bins : list of Iterables
filters : Iterable of openmc.FilterMeta
An iterable of filter types
(e.g., [MeshFilter, EnergyFilter]; default is [])
filter_bins : Iterable of tuple
A list of tuples of filter bins corresponding to the filter_types
parameter (e.g., [(1,), ((0., 0.625e-6),)]; default is []). Each
tuple contains bins for the corresponding filter type in the filters
parameter. Each bins is the integer ID for 'material', 'surface',
'cell', 'cellborn', and 'universe' Filters. Each bin is an integer
for the cell instance ID for 'distribcell' Filters. Each bin is a
2-tuple of floats for 'energy' and 'energyout' filters corresponding
parameter. Each bin is an integer ID for Material-, Surface-,
Cell-, Cellborn-, and Universe- Filters. Each bin is an integer
for the cell instance ID for DistribcellFilters. Each bin is a
2-tuple of floats for Energy- and Energyout- Filters corresponding
to the energy boundaries of the bin of interest. The bin is an
(x,y,z) 3-tuple for 'mesh' filters corresponding to the mesh cell
(x,y,z) 3-tuple for MeshFilters corresponding to the mesh cell
of interest. The order of the bins in the list must correspond to
the filter_types parameter.
@ -1274,8 +1272,8 @@ class Tally(object):
"""
cv.check_iterable_type('filters', filters, basestring)
cv.check_iterable_type('filter_bins', filter_bins, tuple)
cv.check_type('filters', filters, Iterable, openmc.FilterMeta)
cv.check_type('filter_bins', filter_bins, Iterable, tuple)
# Determine the score indices from any of the requested scores
if filters:
@ -1288,7 +1286,7 @@ class Tally(object):
# If a user-requested Filter, get the user-requested bins
for j, test_filter in enumerate(filters):
if self_filter.type == test_filter:
if isinstance(self_filter, test_filter):
bins = filter_bins[j]
user_filter = True
break
@ -1296,19 +1294,20 @@ class Tally(object):
# If not a user-requested Filter, get all bins
if not user_filter:
# Create list of 2- or 3-tuples tuples for mesh cell bins
if self_filter.type == 'mesh':
if isinstance(self_filter, openmc.MeshFilter):
dimension = self_filter.mesh.dimension
xyz = [range(1, x+1) for x in dimension]
bins = list(itertools.product(*xyz))
# Create list of 2-tuples for energy boundary bins
elif self_filter.type in ['energy', 'energyout']:
elif isinstance(self_filter, (openmc.EnergyFilter,
openmc.EnergyoutFilter)):
bins = []
for k in range(self_filter.num_bins):
bins.append((self_filter.bins[k], self_filter.bins[k+1]))
# Create list of cell instance IDs for distribcell Filters
elif self_filter.type == 'distribcell':
elif isinstance(self_filter, openmc.DistribcellFilter):
bins = np.arange(self_filter.num_bins)
# Create list of IDs for bins for all other filter types
@ -1320,7 +1319,7 @@ class Tally(object):
# Add indices for each bin in this Filter to the list
for j, bin in enumerate(bins):
filter_index = self.get_filter_index(self_filter.type, bin)
filter_index = self.get_filter_index(type(self_filter), bin)
filter_indices[i][j] = filter_index
# Account for stride in each of the previous filters
@ -1391,7 +1390,7 @@ class Tally(object):
"""
for score in scores:
if not isinstance(score, (basestring, CrossScore)):
if not isinstance(score, (basestring, openmc.CrossScore)):
msg = 'Unable to get score indices for score "{0}" in Tally ' \
'ID="{1}" since it is not a string or CrossScore'\
.format(score, self.id)
@ -1423,9 +1422,9 @@ class Tally(object):
scores : list of str
A list of one or more score strings
(e.g., ['absorption', 'nu-fission']; default is [])
filters : list of str
A list of filter type strings
(e.g., ['mesh', 'energy']; default is [])
filters : Iterable of openmc.FilterMeta
An iterable of filter types
(e.g., [MeshFilter, EnergyFilter]; default is [])
filter_bins : list of Iterables
A list of tuples of filter bins corresponding to the filter_types
parameter (e.g., [(1,), ((0., 0.625e-6),)]; default is []). Each
@ -1558,7 +1557,7 @@ class Tally(object):
# Append each Filter's DataFrame to the overall DataFrame
for self_filter in self.filters:
filter_df = self_filter.get_pandas_dataframe(
data_size, distribcell_paths)
data_size, distribcell_paths=distribcell_paths)
df = pd.concat([df, filter_df], axis=1)
# Include DataFrame column for nuclides if user requested it
@ -1567,9 +1566,9 @@ class Tally(object):
column_name = 'nuclide'
for nuclide in self.nuclides:
if isinstance(nuclide, Nuclide):
if isinstance(nuclide, openmc.Nuclide):
nuclides.append(nuclide.name)
elif isinstance(nuclide, AggregateNuclide):
elif isinstance(nuclide, openmc.AggregateNuclide):
nuclides.append(nuclide.name)
column_name = '{0}(nuclide)'.format(nuclide.aggregate_op)
else:
@ -1586,9 +1585,9 @@ class Tally(object):
column_name = 'score'
for score in self.scores:
if isinstance(score, (basestring, CrossScore)):
if isinstance(score, (basestring, openmc.CrossScore)):
scores.append(str(score))
elif isinstance(score, AggregateScore):
elif isinstance(score, openmc.AggregateScore):
scores.append(score.name)
column_name = '{0}(score)'.format(score.aggregate_op)
@ -1978,7 +1977,8 @@ class Tally(object):
else:
all_filters = [self_copy.filters, other_copy.filters]
for self_filter, other_filter in itertools.product(*all_filters):
new_filter = CrossFilter(self_filter, other_filter, binary_op)
new_filter = openmc.CrossFilter(self_filter, other_filter,
binary_op)
new_tally.filters.append(new_filter)
# Add nuclides to the new tally
@ -1989,7 +1989,7 @@ class Tally(object):
all_nuclides = [self_copy.nuclides, other_copy.nuclides]
for self_nuclide, other_nuclide in itertools.product(*all_nuclides):
new_nuclide = \
CrossNuclide(self_nuclide, other_nuclide, binary_op)
openmc.CrossNuclide(self_nuclide, other_nuclide, binary_op)
new_tally.nuclides.append(new_nuclide)
# Add scores to the new tally
@ -1999,7 +1999,8 @@ class Tally(object):
else:
all_scores = [self_copy.scores, other_copy.scores]
for self_score, other_score in itertools.product(*all_scores):
new_score = CrossScore(self_score, other_score, binary_op)
new_score = openmc.CrossScore(self_score, other_score,
binary_op)
new_tally.scores.append(new_score)
# Update the new tally's filter strides
@ -2227,13 +2228,13 @@ class Tally(object):
self._update_filter_strides()
# Construct lists of tuples for the bins in each of the two filters
filters = [filter1.type, filter2.type]
if filter1.type == 'distribcell':
filters = [type(filter1), type(filter2)]
if isinstance(filter1, openmc.DistribcellFilter):
filter1_bins = np.arange(filter1.num_bins)
else:
filter1_bins = [(filter1.get_bin(i)) for i in range(filter1.num_bins)]
filter1_bins = [filter1.get_bin(i) for i in range(filter1.num_bins)]
if filter2.type == 'distribcell':
if isinstance(filter2, openmc.DistribcellFilter):
filter2_bins = np.arange(filter2.num_bins)
else:
filter2_bins = [filter2.get_bin(i) for i in range(filter2.num_bins)]
@ -2353,11 +2354,11 @@ class Tally(object):
raise ValueError(msg)
# Check that the scores are valid
if not isinstance(score1, (basestring, CrossScore)):
if not isinstance(score1, (basestring, openmc.CrossScore)):
msg = 'Unable to swap score1 "{0}" in Tally ID="{1}" since it is ' \
'not a string or CrossScore'.format(score1, self.id)
raise ValueError(msg)
elif not isinstance(score2, (basestring, CrossScore)):
elif not isinstance(score2, (basestring, openmc.CrossScore)):
msg = 'Unable to swap score2 "{0}" in Tally ID="{1}" since it is ' \
'not a string or CrossScore'.format(score2, self.id)
raise ValueError(msg)
@ -2875,9 +2876,9 @@ class Tally(object):
scores : list of str
A list of one or more score strings
(e.g., ['absorption', 'nu-fission']; default is [])
filters : list of str
A list of filter type strings
(e.g., ['mesh', 'energy']; default is [])
filters : Iterable of openmc.FilterMeta
An iterable of filter types
(e.g., [MeshFilter, EnergyFilter]; default is [])
filter_bins : list of Iterables
A list of tuples of filter bins corresponding to the filter_types
parameter (e.g., [(1,), ((0., 0.625e-6),)]; default is []). Each
@ -2980,11 +2981,13 @@ class Tally(object):
for filter_bin in filter_bins[i]:
bin_index = find_filter.get_bin_index(filter_bin)
if filter_type in ['energy', 'energyout']:
if filter_type in [openmc.EnergyFilter,
openmc.EnergyoutFilter]:
bin_indices.extend([bin_index])
bin_indices.extend([bin_index, bin_index+1])
num_bins += 1
elif filter_type in ['distribcell', 'mesh']:
elif filter_type in [openmc.DistribcellFilter,
openmc.MeshFilter]:
bin_indices = [0]
num_bins = find_filter.num_bins
else:
@ -3016,9 +3019,8 @@ class Tally(object):
scores : list of str
A list of one or more score strings to sum across
(e.g., ['absorption', 'nu-fission']; default is [])
filter_type : str
A filter type string (e.g., 'cell', 'energy') corresponding to the
filter bins to sum across
filter_type : openmc.FilterMeta
Type of the filter, e.g. MeshFilter
filter_bins : Iterable of int or tuple
A list of the filter bins corresponding to the filter_type parameter
Each bin in the list is the integer ID for 'material', 'surface',
@ -3056,14 +3058,14 @@ class Tally(object):
std_dev = self.get_reshaped_data(value='std_dev')
# Sum across any filter bins specified by the user
if filter_type in _FILTER_TYPES:
if isinstance(filter_type, openmc.FilterMeta):
find_filter = self.find_filter(filter_type)
# If user did not specify filter bins, sum across all bins
if len(filter_bins) == 0:
bin_indices = np.arange(find_filter.num_bins)
if filter_type == 'distribcell':
if isinstance(find_filter, openmc.DistribcellFilter):
filter_bins = np.arange(find_filter.num_bins)
else:
num_bins = find_filter.num_bins
@ -3077,7 +3079,7 @@ class Tally(object):
# Sum across the bins in the user-specified filter
for i, self_filter in enumerate(self.filters):
if self_filter.type == filter_type:
if isinstance(self_filter, filter_type):
mean = np.take(mean, indices=bin_indices, axis=i)
std_dev = np.take(std_dev, indices=bin_indices, axis=i)
mean = np.sum(mean, axis=i, keepdims=True)
@ -3086,8 +3088,8 @@ class Tally(object):
# Add AggregateFilter to the tally sum
if not remove_filter:
filter_sum = \
AggregateFilter(self_filter, [tuple(filter_bins)], 'sum')
filter_sum = openmc.AggregateFilter(self_filter,
[tuple(filter_bins)], 'sum')
tally_sum.filters.append(filter_sum)
# Add a copy of each filter not summed across to the tally sum
@ -3109,7 +3111,7 @@ class Tally(object):
std_dev = np.sqrt(std_dev)
# Add AggregateNuclide to the tally sum
nuclide_sum = AggregateNuclide(nuclides, 'sum')
nuclide_sum = openmc.AggregateNuclide(nuclides, 'sum')
tally_sum.nuclides.append(nuclide_sum)
# Add a copy of this tally's nuclides to the tally sum
@ -3127,7 +3129,7 @@ class Tally(object):
std_dev = np.sqrt(std_dev)
# Add AggregateScore to the tally sum
score_sum = AggregateScore(scores, 'sum')
score_sum = openmc.AggregateScore(scores, 'sum')
tally_sum.scores.append(score_sum)
# Add a copy of this tally's scores to the tally sum
@ -3164,9 +3166,8 @@ class Tally(object):
scores : list of str
A list of one or more score strings to average across
(e.g., ['absorption', 'nu-fission']; default is [])
filter_type : str
A filter type string (e.g., 'cell', 'energy') corresponding to the
filter bins to average across
filter_type : openmc.FilterMeta
Type of the filter, e.g. MeshFilter
filter_bins : Iterable of int or tuple
A list of the filter bins corresponding to the filter_type parameter
Each bin in the list is the integer ID for 'material', 'surface',
@ -3204,14 +3205,14 @@ class Tally(object):
std_dev = self.get_reshaped_data(value='std_dev')
# Average across any filter bins specified by the user
if filter_type in _FILTER_TYPES:
if isinstance(filter_type, openmc.FilterMeta):
find_filter = self.find_filter(filter_type)
# If user did not specify filter bins, average across all bins
if len(filter_bins) == 0:
bin_indices = np.arange(find_filter.num_bins)
if filter_type == 'distribcell':
if isinstance(find_filter, openmc.DistribcellFilter):
filter_bins = np.arange(find_filter.num_bins)
else:
num_bins = find_filter.num_bins
@ -3225,7 +3226,7 @@ class Tally(object):
# Average across the bins in the user-specified filter
for i, self_filter in enumerate(self.filters):
if self_filter.type == filter_type:
if isinstance(self_filter, filter_type):
mean = np.take(mean, indices=bin_indices, axis=i)
std_dev = np.take(std_dev, indices=bin_indices, axis=i)
mean = np.mean(mean, axis=i, keepdims=True)
@ -3235,8 +3236,8 @@ class Tally(object):
# Add AggregateFilter to the tally avg
if not remove_filter:
filter_sum = \
AggregateFilter(self_filter, [tuple(filter_bins)], 'avg')
filter_sum = openmc.AggregateFilter(self_filter,
[tuple(filter_bins)], 'avg')
tally_avg.filters.append(filter_sum)
# Add a copy of each filter not averaged across to the tally avg
@ -3259,7 +3260,7 @@ class Tally(object):
std_dev = np.sqrt(std_dev)
# Add AggregateNuclide to the tally avg
nuclide_avg = AggregateNuclide(nuclides, 'avg')
nuclide_avg = openmc.AggregateNuclide(nuclides, 'avg')
tally_avg.nuclides.append(nuclide_avg)
# Add a copy of this tally's nuclides to the tally avg
@ -3278,7 +3279,7 @@ class Tally(object):
std_dev = np.sqrt(std_dev)
# Add AggregateScore to the tally avg
score_sum = AggregateScore(scores, 'avg')
score_sum = openmc.AggregateScore(scores, 'avg')
tally_avg.scores.append(score_sum)
# Add a copy of this tally's scores to the tally avg
@ -3553,13 +3554,14 @@ class Tallies(cv.CheckedList):
already_written = set()
for tally in self:
for f in tally.filters:
if f.type == 'mesh' and f.mesh not in already_written:
if len(f.mesh.name) > 0:
self._tallies_file.append(ET.Comment(f.mesh.name))
if isinstance(f, openmc.MeshFilter):
if f.mesh not in already_written:
if len(f.mesh.name) > 0:
self._tallies_file.append(ET.Comment(f.mesh.name))
xml_element = f.mesh.get_mesh_xml()
self._tallies_file.append(xml_element)
already_written.add(f.mesh)
xml_element = f.mesh.get_mesh_xml()
self._tallies_file.append(xml_element)
already_written.add(f.mesh)
def export_to_xml(self):
"""Create a tallies.xml file that can be used for a simulation.

2
src/tally_filter.F90
View file

@ -418,7 +418,7 @@ contains
call write_dataset(filter_group, "type", "mesh")
call write_dataset(filter_group, "n_bins", this % n_bins)
call write_dataset(filter_group, "bins", this % mesh )
call write_dataset(filter_group, "bins", meshes(this % mesh) % id)
end subroutine to_statepoint_mesh
function text_label_mesh(this, bin) result(label)

2
tests/test_asymmetric_lattice/test_asymmetric_lattice.py
View file

@ -49,7 +49,7 @@ class AsymmetricLatticeTestHarness(PyAPITestHarness):
self._input_set.geometry.root_universe = root_univ
# Initialize a "distribcell" filter for the fuel pin cell
distrib_filter = openmc.Filter(type='distribcell', bins=[27])
distrib_filter = openmc.DistribcellFilter(27)
# Initialize the tallies
tally = openmc.Tally(name='distribcell tally', tally_id=27)

9
tests/test_filter_mesh/test_filter_mesh.py
View file

@ -38,12 +38,9 @@ class FilterMeshTestHarness(HashedPyAPITestHarness):
mesh_3d.upper_right = [182.07, 182.07, 183.00]
# Initialize the filters
mesh_1d_filter = openmc.Filter(type='mesh')
mesh_2d_filter = openmc.Filter(type='mesh')
mesh_3d_filter = openmc.Filter(type='mesh')
mesh_1d_filter.mesh = mesh_1d
mesh_2d_filter.mesh = mesh_2d
mesh_3d_filter.mesh = mesh_3d
mesh_1d_filter = openmc.MeshFilter(mesh_1d)
mesh_2d_filter = openmc.MeshFilter(mesh_2d)
mesh_3d_filter = openmc.MeshFilter(mesh_3d)
# Initialized the tallies
tally = openmc.Tally(name='tally 1')

11
tests/test_mg_tallies/test_mg_tallies.py
View file

@ -17,14 +17,11 @@ class MGTalliesTestHarness(PyAPITestHarness):
mesh.upper_right = [21.42, 21.42, 100.0]
# Instantiate some tally filters
energy_filter = openmc.Filter(type='energy',
bins=[0.0, 20.0])
energyout_filter = openmc.Filter(type='energyout',
bins=[0.0, 20.0])
mesh_filter = openmc.Filter()
mesh_filter.mesh = mesh
energy_filter = openmc.EnergyFilter([0.0, 20.0])
energyout_filter = openmc.EnergyoutFilter([0.0, 20.0])
mesh_filter = openmc.MeshFilter(mesh)
mat_filter = openmc.Filter(type='material', bins=[1,2,3])
mat_filter = openmc.MaterialFilter([1,2,3])
tally1 = openmc.Tally(tally_id=1)
tally1.filters = [mesh_filter]

35
tests/test_tallies/test_tallies.py
View file

@ -4,7 +4,8 @@ import os
import sys
sys.path.insert(0, os.pardir)
from testing_harness import PyAPITestHarness
from openmc import Filter, Mesh, Tally, Tallies
from openmc.filter import *
from openmc import Mesh, Tally, Tallies
from openmc.source import Source
from openmc.stats import Box
@ -21,7 +22,7 @@ class TalliesTestHarness(PyAPITestHarness):
[-160, -160, -183], [160, 160, 183]))
azimuthal_bins = (-3.1416, -1.8850, -0.6283, 0.6283, 1.8850, 3.1416)
azimuthal_filter1 = Filter(type='azimuthal', bins=azimuthal_bins)
azimuthal_filter1 = AzimuthalFilter(azimuthal_bins)
azimuthal_tally1 = Tally()
azimuthal_tally1.filters = [azimuthal_filter1]
azimuthal_tally1.scores = ['flux']
@ -32,7 +33,7 @@ class TalliesTestHarness(PyAPITestHarness):
azimuthal_tally2.scores = ['flux']
azimuthal_tally2.estimator = 'analog'
azimuthal_filter2 = Filter(type='azimuthal', bins=(5,))
azimuthal_filter2 = AzimuthalFilter(5)
azimuthal_tally3 = Tally()
azimuthal_tally3.filters = [azimuthal_filter2]
azimuthal_tally3.scores = ['flux']
@ -42,28 +43,27 @@ class TalliesTestHarness(PyAPITestHarness):
mesh_2x2.lower_left = [-182.07, -182.07]
mesh_2x2.upper_right = [182.07, 182.07]
mesh_2x2.dimension = [2, 2]
mesh_filter = Filter(type='mesh')
mesh_filter.mesh = mesh_2x2
mesh_filter = MeshFilter(mesh_2x2)
azimuthal_tally4 = Tally()
azimuthal_tally4.filters = [azimuthal_filter2, mesh_filter]
azimuthal_tally4.scores = ['flux']
azimuthal_tally4.estimator = 'tracklength'
cellborn_tally = Tally()
cellborn_tally.filters = [Filter(type='cellborn', bins=(10, 21, 22, 23))]
cellborn_tally.filters = [CellbornFilter((10, 21, 22, 23))]
cellborn_tally.scores = ['total']
dg_tally = Tally()
dg_tally.filters = [Filter(type='delayedgroup', bins=(1, 2, 3, 4, 5, 6))]
dg_tally.filters = [DelayedGroupFilter((1, 2, 3, 4, 5, 6))]
dg_tally.scores = ['delayed-nu-fission']
four_groups = (0.0, 0.253e-6, 1.0e-3, 1.0, 20.0)
energy_filter = Filter(type='energy', bins=four_groups)
energy_filter = EnergyFilter(four_groups)
energy_tally = Tally()
energy_tally.filters = [energy_filter]
energy_tally.scores = ['total']
energyout_filter = Filter(type='energyout', bins=four_groups)
energyout_filter = EnergyoutFilter(four_groups)
energyout_tally = Tally()
energyout_tally.filters = [energyout_filter]
energyout_tally.scores = ['scatter']
@ -73,14 +73,14 @@ class TalliesTestHarness(PyAPITestHarness):
transfer_tally.scores = ['scatter', 'nu-fission']
material_tally = Tally()
material_tally.filters = [Filter(type='material', bins=(1, 2, 3, 4))]
material_tally.filters = [MaterialFilter((1, 2, 3, 4))]
material_tally.scores = ['total']
mu_tally1 = Tally()
mu_tally1.filters = [Filter(type='mu', bins=(-1.0, -0.5, 0.0, 0.5, 1.0))]
mu_tally1.filters = [MuFilter((-1.0, -0.5, 0.0, 0.5, 1.0))]
mu_tally1.scores = ['scatter', 'nu-scatter']
mu_filter = Filter(type='mu', bins=(5,))
mu_filter = MuFilter(5)
mu_tally2 = Tally()
mu_tally2.filters = [mu_filter]
mu_tally2.scores = ['scatter', 'nu-scatter']
@ -90,7 +90,7 @@ class TalliesTestHarness(PyAPITestHarness):
mu_tally3.scores = ['scatter', 'nu-scatter']
polar_bins = (0.0, 0.6283, 1.2566, 1.8850, 2.5132, 3.1416)
polar_filter = Filter(type='polar', bins=polar_bins)
polar_filter = PolarFilter(polar_bins)
polar_tally1 = Tally()
polar_tally1.filters = [polar_filter]
polar_tally1.scores = ['flux']
@ -101,7 +101,7 @@ class TalliesTestHarness(PyAPITestHarness):
polar_tally2.scores = ['flux']
polar_tally2.estimator = 'analog'
polar_filter2 = Filter(type='polar', bins=(5,))
polar_filter2 = PolarFilter((5,))
polar_tally3 = Tally()
polar_tally3.filters = [polar_filter2]
polar_tally3.scores = ['flux']
@ -113,11 +113,10 @@ class TalliesTestHarness(PyAPITestHarness):
polar_tally4.estimator = 'tracklength'
universe_tally = Tally()
universe_tally.filters = [
Filter(type='universe', bins=(1, 2, 3, 4, 6, 8))]
universe_tally.filters = [UniverseFilter((1, 2, 3, 4, 6, 8))]
universe_tally.scores = ['total']
cell_filter = Filter(type='cell', bins=(10, 21, 22, 23, 60))
cell_filter = CellFilter((10, 21, 22, 23, 60))
score_tallies = [Tally(), Tally(), Tally()]
for t in score_tallies:
t.filters = [cell_filter]
@ -130,7 +129,7 @@ class TalliesTestHarness(PyAPITestHarness):
score_tallies[1].estimator = 'analog'
score_tallies[2].estimator = 'collision'
cell_filter2 = Filter(type='cell', bins=(21, 22, 23, 27, 28, 29, 60))
cell_filter2 = CellFilter((21, 22, 23, 27, 28, 29, 60))
flux_tallies = [Tally() for i in range(4)]
for t in flux_tallies:
t.filters = [cell_filter2]

9
tests/test_tally_aggregation/test_tally_aggregation.py
View file

@ -21,9 +21,8 @@ class TallyAggregationTestHarness(PyAPITestHarness):
pu239 = openmc.Nuclide('Pu239')
# Initialize the filters
energy_filter = openmc.Filter(type='energy', bins=[0.0, 0.253e-6,
1.0e-3, 1.0, 20.0])
distrib_filter = openmc.Filter(type='distribcell', bins=[60])
energy_filter = openmc.EnergyFilter([0.0, 0.253e-6, 1.0e-3, 1.0, 20.0])
distrib_filter = openmc.DistribcellFilter(60)
# Initialized the tallies
tally = openmc.Tally(name='distribcell tally')
@ -50,12 +49,12 @@ class TallyAggregationTestHarness(PyAPITestHarness):
outstr = ''
# Sum across all energy filter bins
tally_sum = tally.summation(filter_type='energy')
tally_sum = tally.summation(filter_type=openmc.EnergyFilter)
outstr += ', '.join(map(str, tally_sum.mean))
outstr += ', '.join(map(str, tally_sum.std_dev))
# Sum across all distribcell filter bins
tally_sum = tally.summation(filter_type='distribcell')
tally_sum = tally.summation(filter_type=openmc.DistribcellFilter)
outstr += ', '.join(map(str, tally_sum.mean))
outstr += ', '.join(map(str, tally_sum.std_dev))

10
tests/test_tally_arithmetic/test_tally_arithmetic.py
View file

@ -31,12 +31,10 @@ class TallyArithmeticTestHarness(PyAPITestHarness):
mesh.upper_right = [160.0, 160.0, 183.0]
# Initialize the filters
energy_filter = openmc.Filter(type='energy', bins=(0.0, 0.253e-6,
1.0e-3, 1.0, 20.0))
material_filter = openmc.Filter(type='material', bins=(1, 3))
distrib_filter = openmc.Filter(type='distribcell', bins=(60))
mesh_filter = openmc.Filter(type='mesh')
mesh_filter.mesh = mesh
energy_filter = openmc.EnergyFilter((0.0, 0.253e-6, 1.0e-3, 1.0, 20.0))
material_filter = openmc.MaterialFilter((1, 3))
distrib_filter = openmc.DistribcellFilter(60)
mesh_filter = openmc.MeshFilter(mesh)
# Initialized the tallies
tally = openmc.Tally(name='tally 1')

25
tests/test_tally_slice_merge/test_tally_slice_merge.py
View file

@ -27,21 +27,20 @@ class TallySliceMergeTestHarness(PyAPITestHarness):
# Define filters for energy and spatial domain
low_energy = openmc.Filter(type='energy', bins=[0., 0.625e-6])
high_energy = openmc.Filter(type='energy', bins=[0.625e-6, 20.])
low_energy = openmc.EnergyFilter([0., 0.625e-6])
high_energy = openmc.EnergyFilter([0.625e-6, 20.])
merged_energies = low_energy.merge(high_energy)
cell_21 = openmc.Filter(type='cell', bins=[21])
cell_27 = openmc.Filter(type='cell', bins=[27])
distribcell_filter = openmc.Filter(type='distribcell', bins=[21])
cell_21 = openmc.CellFilter(21)
cell_27 = openmc.CellFilter(27)
distribcell_filter = openmc.DistribcellFilter(21)
mesh = openmc.Mesh(name='mesh')
mesh.type = 'regular'
mesh.dimension = [2, 2]
mesh.lower_left = [-50., -50.]
mesh.upper_right = [+50., +50.]
mesh_filter = openmc.Filter(type='mesh', bins=[mesh.id])
mesh_filter.mesh = mesh
mesh_filter = openmc.MeshFilter(mesh)
self.cell_filters = [cell_21, cell_27]
self.energy_filters = [low_energy, high_energy]
@ -105,12 +104,12 @@ class TallySliceMergeTestHarness(PyAPITestHarness):
# Slice the tallies by cell filter bins
cell_filter_prod = itertools.product(tallies, self.cell_filters)
tallies = map(lambda tf: tf[0].get_slice(filters=[tf[1].type],
tallies = map(lambda tf: tf[0].get_slice(filters=[type(tf[1])],
filter_bins=[tf[1].get_bin(0)]), cell_filter_prod)
# Slice the tallies by energy filter bins
energy_filter_prod = itertools.product(tallies, self.energy_filters)
tallies = map(lambda tf: tf[0].get_slice(filters=[tf[1].type],
tallies = map(lambda tf: tf[0].get_slice(filters=[type(tf[1])],
filter_bins=[(tf[1].get_bin(0),)]), energy_filter_prod)
# Slice the tallies by nuclide
@ -144,10 +143,10 @@ class TallySliceMergeTestHarness(PyAPITestHarness):
distribcell_tally = sp.get_tally(name='distribcell tally')
# Sum up a few subdomains from the distribcell tally
sum1 = distribcell_tally.summation(filter_type='distribcell',
sum1 = distribcell_tally.summation(filter_type=openmc.DistribcellFilter,
filter_bins=[0,100,2000,30000])
# Sum up a few subdomains from the distribcell tally
sum2 = distribcell_tally.summation(filter_type='distribcell',
sum2 = distribcell_tally.summation(filter_type=openmc.DistribcellFilter,
filter_bins=[500,5000,50000])
# Merge the distribcell tally slices
@ -161,10 +160,10 @@ class TallySliceMergeTestHarness(PyAPITestHarness):
mesh_tally = sp.get_tally(name='mesh tally')
# Sum up a few subdomains from the mesh tally
sum1 = mesh_tally.summation(filter_type='mesh',
sum1 = mesh_tally.summation(filter_type=openmc.MeshFilter,
filter_bins=[(1,1,1), (1,2,1)])
# Sum up a few subdomains from the mesh tally
sum2 = mesh_tally.summation(filter_type='mesh',
sum2 = mesh_tally.summation(filter_type=openmc.MeshFilter,
filter_bins=[(2,1,1), (2,2,1)])
# Merge the mesh tally slices