From bd9b32b804b60def8639f667bcdb35896a4a5882 Mon Sep 17 00:00:00 2001 From: Adam Nelson Date: Sat, 25 Feb 2017 14:36:09 -0500 Subject: [PATCH] Removed Nu* MGXS classes. --- .../pythonapi/examples/mgxs-part-i.ipynb | 54 +- .../pythonapi/examples/mgxs-part-ii.ipynb | 84 +-- .../pythonapi/examples/mgxs-part-iii.ipynb | 90 ++- openmc/mgxs/mgxs.py | 666 +++--------------- 4 files changed, 224 insertions(+), 670 deletions(-) diff --git a/docs/source/pythonapi/examples/mgxs-part-i.ipynb b/docs/source/pythonapi/examples/mgxs-part-i.ipynb index d076823be..2b3d5a77c 100644 --- a/docs/source/pythonapi/examples/mgxs-part-i.ipynb +++ b/docs/source/pythonapi/examples/mgxs-part-i.ipynb @@ -369,21 +369,19 @@ "\n", "* `TotalXS`\n", "* `TransportXS`\n", - "* `NuTransportXS`\n", "* `AbsorptionXS`\n", "* `CaptureXS`\n", "* `FissionXS`\n", - "* `NuFissionXS`\n", "* `KappaFissionXS`\n", "* `ScatterXS`\n", - "* `NuScatterXS`\n", "* `ScatterMatrixXS`\n", - "* `NuScatterMatrixXS`\n", "* `Chi`\n", "* `ChiPrompt`\n", "* `InverseVelocity`\n", "* `PromptNuFissionXS`\n", "\n", + "Of course, we know that the transport (`TransportXS`), fission (`FissionXS`), scattering (`ScatterXS`), and scattering-matrix (`ScatterMatrixXS`) cross sections can potentially incorporate neutron multiplication ($\\nu$). For these types, the multpiplication can be accomodated by setting the `nu` parameter to `True` as shown below.\n", + "\n", "These classes provide us with an interface to generate the tally inputs as well as perform post-processing of OpenMC's tally data to compute the respective multi-group cross sections. In this case, let's create the multi-group total, absorption and scattering cross sections with our 2-group structure." ] }, @@ -398,7 +396,11 @@ "# Instantiate a few different sections\n", "total = mgxs.TotalXS(domain=cell, groups=groups)\n", "absorption = mgxs.AbsorptionXS(domain=cell, groups=groups)\n", - "scattering = mgxs.ScatterXS(domain=cell, groups=groups)" + "scattering = mgxs.ScatterXS(domain=cell, groups=groups)\n", + "\n", + "# Note that if we wanted to incorporate neutron multiplication in the\n", + "# scattering cross section we would write the previous line as:\n", + "# scattering = mgxs.ScatterXS(domain=cell, groups=groups, nu=True)" ] }, { @@ -520,8 +522,8 @@ " Copyright | 2011-2017 Massachusetts Institute of Technology\n", " License | http://openmc.readthedocs.io/en/latest/license.html\n", " Version | 0.8.0\n", - " Git SHA1 | 54b65c8bda6af5788bd762b8cf9855d1a8008238\n", - " Date/Time | 2017-02-12 13:36:24\n", + " Git SHA1 | 60a1f157dae88b62e1865a5fe3efd7ef0773a068\n", + " Date/Time | 2017-02-25 14:26:54\n", " OpenMP Threads | 8\n", "\n", " ===========================================================================\n", @@ -592,7 +594,7 @@ " 42/1 1.13779 1.16177 +/- 0.00531\n", " 43/1 1.15066 1.16143 +/- 0.00516\n", " 44/1 1.12174 1.16026 +/- 0.00514\n", - " 45/1 1.17479 1.16068 +/- 0.00501\n", + " 45/1 1.17478 1.16068 +/- 0.00501\n", " 46/1 1.14146 1.16014 +/- 0.00489\n", " 47/1 1.20464 1.16135 +/- 0.00491\n", " 48/1 1.15119 1.16108 +/- 0.00479\n", @@ -607,20 +609,20 @@ "\n", " =======================> TIMING STATISTICS <=======================\n", "\n", - " Total time for initialization = 4.1327E-01 seconds\n", - " Reading cross sections = 3.2638E-01 seconds\n", - " Total time in simulation = 2.2324E+00 seconds\n", - " Time in transport only = 2.1226E+00 seconds\n", - " Time in inactive batches = 3.0650E-01 seconds\n", - " Time in active batches = 1.9259E+00 seconds\n", - " Time synchronizing fission bank = 2.7640E-03 seconds\n", - " Sampling source sites = 2.0198E-03 seconds\n", - " SEND/RECV source sites = 7.0929E-04 seconds\n", - " Time accumulating tallies = 4.5355E-05 seconds\n", - " Total time for finalization = 4.1885E-04 seconds\n", - " Total time elapsed = 2.6534E+00 seconds\n", - " Calculation Rate (inactive) = 81567.1 neutrons/second\n", - " Calculation Rate (active) = 51923.2 neutrons/second\n", + " Total time for initialization = 3.5070E-01 seconds\n", + " Reading cross sections = 2.4151E-01 seconds\n", + " Total time in simulation = 2.3276E+00 seconds\n", + " Time in transport only = 2.2350E+00 seconds\n", + " Time in inactive batches = 2.5677E-01 seconds\n", + " Time in active batches = 2.0708E+00 seconds\n", + " Time synchronizing fission bank = 2.7683E-03 seconds\n", + " Sampling source sites = 2.0233E-03 seconds\n", + " SEND/RECV source sites = 7.1007E-04 seconds\n", + " Time accumulating tallies = 5.0753E-05 seconds\n", + " Total time for finalization = 3.8695E-04 seconds\n", + " Total time elapsed = 2.6857E+00 seconds\n", + " Calculation Rate (inactive) = 97364.6 neutrons/second\n", + " Calculation Rate (active) = 48290.8 neutrons/second\n", "\n", " ============================> RESULTS <============================\n", "\n", @@ -901,7 +903,7 @@ " 6.250000e-01\n", " total\n", " (((total / flux) - (absorption / flux)) - (sca...\n", - " -2.664535e-15\n", + " -5.551115e-15\n", " 0.011292\n", " \n", " \n", @@ -911,7 +913,7 @@ " 2.000000e+07\n", " total\n", " (((total / flux) - (absorption / flux)) - (sca...\n", - " -3.330669e-16\n", + " -1.110223e-16\n", " 0.002570\n", " \n", " \n", @@ -924,8 +926,8 @@ "1 1 6.25e-01 2.00e+07 total \n", "\n", " score mean std. dev. \n", - "0 (((total / flux) - (absorption / flux)) - (sca... -2.66e-15 1.13e-02 \n", - "1 (((total / flux) - (absorption / flux)) - (sca... -3.33e-16 2.57e-03 " + "0 (((total / flux) - (absorption / flux)) - (sca... -5.55e-15 1.13e-02 \n", + "1 (((total / flux) - (absorption / flux)) - (sca... -1.11e-16 2.57e-03 " ] }, "execution_count": 22, diff --git a/docs/source/pythonapi/examples/mgxs-part-ii.ipynb b/docs/source/pythonapi/examples/mgxs-part-ii.ipynb index 359fd4eaa..a0e47fa12 100644 --- a/docs/source/pythonapi/examples/mgxs-part-ii.ipynb +++ b/docs/source/pythonapi/examples/mgxs-part-ii.ipynb @@ -34,7 +34,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "/home/romano/miniconda3/envs/python3/lib/python3.5/site-packages/matplotlib/__init__.py:1401: UserWarning: This call to matplotlib.use() has no effect\n", + "/usr/lib/python3.6/site-packages/matplotlib/__init__.py:1401: UserWarning: This call to matplotlib.use() has no effect\n", "because the backend has already been chosen;\n", "matplotlib.use() must be called *before* pylab, matplotlib.pyplot,\n", "or matplotlib.backends is imported for the first time.\n", @@ -342,8 +342,8 @@ " xs_library[cell.id] = {}\n", " xs_library[cell.id]['transport'] = mgxs.TransportXS(groups=fine_groups)\n", " xs_library[cell.id]['fission'] = mgxs.FissionXS(groups=fine_groups)\n", - " xs_library[cell.id]['nu-fission'] = mgxs.NuFissionXS(groups=fine_groups)\n", - " xs_library[cell.id]['nu-scatter'] = mgxs.NuScatterMatrixXS(groups=fine_groups)\n", + " xs_library[cell.id]['nu-fission'] = mgxs.FissionXS(groups=fine_groups, nu=True)\n", + " xs_library[cell.id]['nu-scatter'] = mgxs.ScatterMatrixXS(groups=fine_groups, nu=True)\n", " xs_library[cell.id]['chi'] = mgxs.Chi(groups=fine_groups)" ] }, @@ -454,9 +454,9 @@ " Copyright | 2011-2017 Massachusetts Institute of Technology\n", " License | http://openmc.readthedocs.io/en/latest/license.html\n", " Version | 0.8.0\n", - " Git SHA1 | dfc6f1d9bf1b31fc94dad1cb30bd672b25f47e04\n", - " Date/Time | 2017-02-21 15:07:51\n", - " OpenMP Threads | 4\n", + " Git SHA1 | 60a1f157dae88b62e1865a5fe3efd7ef0773a068\n", + " Date/Time | 2017-02-25 14:28:21\n", + " OpenMP Threads | 8\n", "\n", " ===========================================================================\n", " ========================> INITIALIZATION <=========================\n", @@ -466,11 +466,11 @@ " Reading geometry XML file...\n", " Reading materials XML file...\n", " Reading cross sections XML file...\n", - " Reading U235 from /home/romano/openmc/scripts/nndc_hdf5/U235.h5\n", - " Reading U238 from /home/romano/openmc/scripts/nndc_hdf5/U238.h5\n", - " Reading O16 from /home/romano/openmc/scripts/nndc_hdf5/O16.h5\n", - " Reading H1 from /home/romano/openmc/scripts/nndc_hdf5/H1.h5\n", - " Reading Zr90 from /home/romano/openmc/scripts/nndc_hdf5/Zr90.h5\n", + " Reading U235 from /opt/xsdata/nndc/U235.h5\n", + " Reading U238 from /opt/xsdata/nndc/U238.h5\n", + " Reading O16 from /opt/xsdata/nndc/O16.h5\n", + " Reading H1 from /opt/xsdata/nndc/H1.h5\n", + " Reading Zr90 from /opt/xsdata/nndc/Zr90.h5\n", " Maximum neutron transport energy: 2.00000E+07 eV for U235\n", " Reading tallies XML file...\n", " Building neighboring cells lists for each surface...\n", @@ -532,7 +532,7 @@ " 48/1 1.22204 1.22140 +/- 0.00239\n", " 49/1 1.22077 1.22139 +/- 0.00232\n", " 50/1 1.23166 1.22164 +/- 0.00228\n", - " Triggers unsatisfied, max unc./thresh. is 1.17623 for flux in tally 10057\n", + " Triggers unsatisfied, max unc./thresh. is 1.17623 for flux in tally 10050\n", " The estimated number of batches is 66\n", " Creating state point statepoint.050.h5...\n", " 51/1 1.20071 1.22113 +/- 0.00228\n", @@ -551,7 +551,7 @@ " 64/1 1.23955 1.22122 +/- 0.00200\n", " 65/1 1.21143 1.22104 +/- 0.00197\n", " 66/1 1.21791 1.22099 +/- 0.00194\n", - " Triggers unsatisfied, max unc./thresh. is 1.13207 for flux in tally 10057\n", + " Triggers unsatisfied, max unc./thresh. is 1.13207 for flux in tally 10050\n", " The estimated number of batches is 82\n", " 67/1 1.24897 1.22148 +/- 0.00196\n", " 68/1 1.22221 1.22149 +/- 0.00193\n", @@ -579,20 +579,20 @@ "\n", " =======================> TIMING STATISTICS <=======================\n", "\n", - " Total time for initialization = 3.6241E-01 seconds\n", - " Reading cross sections = 2.5754E-01 seconds\n", - " Total time in simulation = 9.0901E+01 seconds\n", - " Time in transport only = 9.0045E+01 seconds\n", - " Time in inactive batches = 2.9786E+00 seconds\n", - " Time in active batches = 8.7923E+01 seconds\n", - " Time synchronizing fission bank = 2.7221E-02 seconds\n", - " Sampling source sites = 1.6637E-02 seconds\n", - " SEND/RECV source sites = 1.0474E-02 seconds\n", - " Time accumulating tallies = 9.2191E-04 seconds\n", - " Total time for finalization = 1.2513E-02 seconds\n", - " Total time elapsed = 9.1307E+01 seconds\n", - " Calculation Rate (inactive) = 33572.9 neutrons/second\n", - " Calculation Rate (active) = 4549.45 neutrons/second\n", + " Total time for initialization = 3.2089E-01 seconds\n", + " Reading cross sections = 2.2960E-01 seconds\n", + " Total time in simulation = 3.1332E+01 seconds\n", + " Time in transport only = 3.1007E+01 seconds\n", + " Time in inactive batches = 1.6660E+00 seconds\n", + " Time in active batches = 2.9666E+01 seconds\n", + " Time synchronizing fission bank = 1.7043E-02 seconds\n", + " Sampling source sites = 1.1813E-02 seconds\n", + " SEND/RECV source sites = 5.1688E-03 seconds\n", + " Time accumulating tallies = 5.0509E-04 seconds\n", + " Total time for finalization = 1.6880E-02 seconds\n", + " Total time elapsed = 3.1699E+01 seconds\n", + " Calculation Rate (inactive) = 60024.2 neutrons/second\n", + " Calculation Rate (active) = 13483.6 neutrons/second\n", "\n", " ============================> RESULTS <============================\n", "\n", @@ -733,7 +733,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "/home/romano/openmc/openmc/tallies.py:1835: RuntimeWarning: invalid value encountered in true_divide\n", + "/home/nelsonag/git/openmc/openmc/tallies.py:1835: RuntimeWarning: invalid value encountered in true_divide\n", " self_rel_err = data['self']['std. dev.'] / data['self']['mean']\n" ] } @@ -803,7 +803,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "/home/romano/openmc/openmc/tallies.py:1835: RuntimeWarning: invalid value encountered in true_divide\n", + "/home/nelsonag/git/openmc/openmc/tallies.py:1835: RuntimeWarning: invalid value encountered in true_divide\n", " self_rel_err = data['self']['std. dev.'] / data['self']['mean']\n" ] }, @@ -1151,11 +1151,11 @@ "name": "stderr", "output_type": "stream", "text": [ - "/home/romano/openmc/openmc/tallies.py:1835: RuntimeWarning: invalid value encountered in true_divide\n", + "/home/nelsonag/git/openmc/openmc/tallies.py:1835: RuntimeWarning: invalid value encountered in true_divide\n", " self_rel_err = data['self']['std. dev.'] / data['self']['mean']\n", - "/home/romano/openmc/openmc/tallies.py:1836: RuntimeWarning: invalid value encountered in true_divide\n", + "/home/nelsonag/git/openmc/openmc/tallies.py:1836: RuntimeWarning: invalid value encountered in true_divide\n", " other_rel_err = data['other']['std. dev.'] / data['other']['mean']\n", - "/home/romano/openmc/openmc/tallies.py:1837: RuntimeWarning: invalid value encountered in true_divide\n", + "/home/nelsonag/git/openmc/openmc/tallies.py:1837: RuntimeWarning: invalid value encountered in true_divide\n", " new_tally._mean = data['self']['mean'] / data['other']['mean']\n" ] } @@ -1510,11 +1510,11 @@ "name": "stderr", "output_type": "stream", "text": [ - "/home/romano/openmc/openmc/tallies.py:1835: RuntimeWarning: invalid value encountered in true_divide\n", + "/home/nelsonag/git/openmc/openmc/tallies.py:1835: RuntimeWarning: invalid value encountered in true_divide\n", " self_rel_err = data['self']['std. dev.'] / data['self']['mean']\n", - "/home/romano/openmc/openmc/tallies.py:1836: RuntimeWarning: invalid value encountered in true_divide\n", + "/home/nelsonag/git/openmc/openmc/tallies.py:1836: RuntimeWarning: invalid value encountered in true_divide\n", " other_rel_err = data['other']['std. dev.'] / data['other']['mean']\n", - "/home/romano/openmc/openmc/tallies.py:1837: RuntimeWarning: invalid value encountered in true_divide\n", + "/home/nelsonag/git/openmc/openmc/tallies.py:1837: RuntimeWarning: invalid value encountered in true_divide\n", " new_tally._mean = data['self']['mean'] / data['other']['mean']\n" ] } @@ -1990,7 +1990,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "/home/romano/openmc/openmc/tallies.py:1835: RuntimeWarning: invalid value encountered in true_divide\n", + "/home/nelsonag/git/openmc/openmc/tallies.py:1835: RuntimeWarning: invalid value encountered in true_divide\n", " self_rel_err = data['self']['std. dev.'] / data['self']['mean']\n" ] }, @@ -2006,9 +2006,9 @@ }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAEWCAYAAABrDZDcAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nxhiT4P4fD4z+wrudGZ0AAAAASUVORK5CYII=\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAEWCAYAAABrDZDcAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nAmOMSXIWCIwxJsn9P9SaDatNFP39AAAAAElFTkSuQmCC\n", "text/plain": [ - "" + "" ] }, "metadata": {}, @@ -2091,9 +2091,9 @@ "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAADRCAYAAADcxUm6AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nK8T/B194ISi0+XToAAAAAElFTkSuQmCC\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAADRCAYAAADcxUm6AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n4C3won+7HwAAAABJRU5ErkJggg==\n", "text/plain": [ - "" + "" ] }, "metadata": {}, @@ -2123,7 +2123,7 @@ "metadata": { "anaconda-cloud": {}, "kernelspec": { - "display_name": "Python [default]", + "display_name": "Python 3", "language": "python", "name": "python3" }, @@ -2137,7 +2137,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.5.2" + "version": "3.6.0" } }, "nbformat": 4, diff --git a/docs/source/pythonapi/examples/mgxs-part-iii.ipynb b/docs/source/pythonapi/examples/mgxs-part-iii.ipynb index 69297d884..a41fb1374 100644 --- a/docs/source/pythonapi/examples/mgxs-part-iii.ipynb +++ b/docs/source/pythonapi/examples/mgxs-part-iii.ipynb @@ -32,7 +32,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "/home/romano/miniconda3/envs/python3/lib/python3.5/site-packages/matplotlib/__init__.py:1401: UserWarning: This call to matplotlib.use() has no effect\n", + "/usr/lib/python3.6/site-packages/matplotlib/__init__.py:1401: UserWarning: This call to matplotlib.use() has no effect\n", "because the backend has already been chosen;\n", "matplotlib.use() must be called *before* pylab, matplotlib.pyplot,\n", "or matplotlib.backends is imported for the first time.\n", @@ -458,7 +458,7 @@ "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAPoAAAD6AgMAAAD1grKuAAAABGdBTUEAALGPC/xhBQAAACBjSFJN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\nVDE1OjExOjU1LTA2OjAwJ5ulDQAAAABJRU5ErkJggg==\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAPoAAAD6AgMAAAD1grKuAAAABGdBTUEAALGPC/xhBQAAACBjSFJN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\nVDE0OjMyOjU5LTA1OjAwSHL3VwAAAABJRU5ErkJggg==\n", "text/plain": [ "" ] @@ -537,17 +537,13 @@ "Now, we must specify to the `Library` which types of cross sections to compute. In particular, the following are the multi-group cross section `MGXS` subclasses that are mapped to string codes accepted by the `Library` class:\n", "\n", "* `TotalXS` (`\"total\"`)\n", - "* `TransportXS` (`\"transport\"`)\n", - "* `NuTransportXS` (`\"nu-transport\"`)\n", + "* `TransportXS` (`\"transport\"` or `\"nu-transport` with `nu` set to `True`)\n", "* `AbsorptionXS` (`\"absorption\"`)\n", "* `CaptureXS` (`\"capture\"`)\n", - "* `FissionXS` (`\"fission\"`)\n", - "* `NuFissionXS` (`\"nu-fission\"`)\n", + "* `FissionXS` (`\"fission\"` or `\"nu-fission\"` with `nu` set to `True`)\n", "* `KappaFissionXS` (`\"kappa-fission\"`)\n", - "* `ScatterXS` (`\"scatter\"`)\n", - "* `NuScatterXS` (`\"nu-scatter\"`)\n", - "* `ScatterMatrixXS` (`\"scatter matrix\"`)\n", - "* `NuScatterMatrixXS` (`\"nu-scatter matrix\"`)\n", + "* `ScatterXS` (`\"scatter\"` or `\"nu-scatter\"` with `nu` set to `True`)\n", + "* `ScatterMatrixXS` (`\"scatter matrix\"` or `\"nu-scatter matrix\"` with `nu` set to `True`)\n", "* `Chi` (`\"chi\"`)\n", "* `ChiPrompt` (`\"chi prompt\"`)\n", "* `InverseVelocity` (`\"inverse-velocity\"`)\n", @@ -743,9 +739,9 @@ " Copyright | 2011-2017 Massachusetts Institute of Technology\n", " License | http://openmc.readthedocs.io/en/latest/license.html\n", " Version | 0.8.0\n", - " Git SHA1 | 7ca46e809ce01fe7857ae36072822a1718f01aaf\n", - " Date/Time | 2017-02-23 09:36:51\n", - " OpenMP Threads | 4\n", + " Git SHA1 | 60a1f157dae88b62e1865a5fe3efd7ef0773a068\n", + " Date/Time | 2017-02-25 14:32:59\n", + " OpenMP Threads | 8\n", "\n", " ===========================================================================\n", " ========================> INITIALIZATION <=========================\n", @@ -755,12 +751,12 @@ " Reading geometry XML file...\n", " Reading materials XML file...\n", " Reading cross sections XML file...\n", - " Reading U235 from /home/romano/openmc/scripts/nndc_hdf5/U235.h5\n", - " Reading U238 from /home/romano/openmc/scripts/nndc_hdf5/U238.h5\n", - " Reading O16 from /home/romano/openmc/scripts/nndc_hdf5/O16.h5\n", - " Reading H1 from /home/romano/openmc/scripts/nndc_hdf5/H1.h5\n", - " Reading B10 from /home/romano/openmc/scripts/nndc_hdf5/B10.h5\n", - " Reading Zr90 from /home/romano/openmc/scripts/nndc_hdf5/Zr90.h5\n", + " Reading U235 from /opt/xsdata/nndc/U235.h5\n", + " Reading U238 from /opt/xsdata/nndc/U238.h5\n", + " Reading O16 from /opt/xsdata/nndc/O16.h5\n", + " Reading H1 from /opt/xsdata/nndc/H1.h5\n", + " Reading B10 from /opt/xsdata/nndc/B10.h5\n", + " Reading Zr90 from /opt/xsdata/nndc/Zr90.h5\n", " Maximum neutron transport energy: 2.00000E+07 eV for U235\n", " Reading tallies XML file...\n", " Building neighboring cells lists for each surface...\n", @@ -831,20 +827,20 @@ "\n", " =======================> TIMING STATISTICS <=======================\n", "\n", - " Total time for initialization = 4.2238E-01 seconds\n", - " Reading cross sections = 3.1986E-01 seconds\n", - " Total time in simulation = 1.3628E+01 seconds\n", - " Time in transport only = 1.3342E+01 seconds\n", - " Time in inactive batches = 1.1012E+00 seconds\n", - " Time in active batches = 1.2527E+01 seconds\n", - " Time synchronizing fission bank = 3.7750E-03 seconds\n", - " Sampling source sites = 2.4760E-03 seconds\n", - " SEND/RECV source sites = 1.2253E-03 seconds\n", - " Time accumulating tallies = 6.5502E-04 seconds\n", - " Total time for finalization = 9.4890E-06 seconds\n", - " Total time elapsed = 1.4059E+01 seconds\n", - " Calculation Rate (inactive) = 22702.0 neutrons/second\n", - " Calculation Rate (active) = 7982.70 neutrons/second\n", + " Total time for initialization = 3.4863E-01 seconds\n", + " Reading cross sections = 2.6337E-01 seconds\n", + " Total time in simulation = 6.2906E+00 seconds\n", + " Time in transport only = 6.0984E+00 seconds\n", + " Time in inactive batches = 5.0785E-01 seconds\n", + " Time in active batches = 5.7827E+00 seconds\n", + " Time synchronizing fission bank = 2.6573E-03 seconds\n", + " Sampling source sites = 1.9038E-03 seconds\n", + " SEND/RECV source sites = 7.1726E-04 seconds\n", + " Time accumulating tallies = 2.9242E-04 seconds\n", + " Total time for finalization = 7.4980E-06 seconds\n", + " Total time elapsed = 6.6484E+00 seconds\n", + " Calculation Rate (inactive) = 49227.5 neutrons/second\n", + " Calculation Rate (active) = 17292.9 neutrons/second\n", "\n", " ============================> RESULTS <============================\n", "\n", @@ -971,7 +967,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "/home/romano/openmc/openmc/tallies.py:1835: RuntimeWarning: invalid value encountered in true_divide\n", + "/home/nelsonag/git/openmc/openmc/tallies.py:1835: RuntimeWarning: invalid value encountered in true_divide\n", " self_rel_err = data['self']['std. dev.'] / data['self']['mean']\n" ] }, @@ -1108,7 +1104,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "/home/romano/openmc/openmc/tallies.py:1506: RuntimeWarning: invalid value encountered in true_divide\n", + "/home/nelsonag/git/openmc/openmc/tallies.py:1506: RuntimeWarning: invalid value encountered in true_divide\n", " data = self.std_dev[indices] / self.mean[indices]\n" ] } @@ -1135,11 +1131,11 @@ "name": "stderr", "output_type": "stream", "text": [ - "/home/romano/openmc/openmc/tallies.py:1835: RuntimeWarning: invalid value encountered in true_divide\n", + "/home/nelsonag/git/openmc/openmc/tallies.py:1835: RuntimeWarning: invalid value encountered in true_divide\n", " self_rel_err = data['self']['std. dev.'] / data['self']['mean']\n", - "/home/romano/openmc/openmc/tallies.py:1836: RuntimeWarning: invalid value encountered in true_divide\n", + "/home/nelsonag/git/openmc/openmc/tallies.py:1836: RuntimeWarning: invalid value encountered in true_divide\n", " other_rel_err = data['other']['std. dev.'] / data['other']['mean']\n", - "/home/romano/openmc/openmc/tallies.py:1837: RuntimeWarning: invalid value encountered in true_divide\n", + "/home/nelsonag/git/openmc/openmc/tallies.py:1837: RuntimeWarning: invalid value encountered in true_divide\n", " new_tally._mean = data['self']['mean'] / data['other']['mean']\n" ] } @@ -1213,7 +1209,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "/home/romano/openmc/openmc/tallies.py:1835: RuntimeWarning: invalid value encountered in true_divide\n", + "/home/nelsonag/git/openmc/openmc/tallies.py:1835: RuntimeWarning: invalid value encountered in true_divide\n", " self_rel_err = data['self']['std. dev.'] / data['self']['mean']\n" ] }, @@ -1326,11 +1322,11 @@ "name": "stderr", "output_type": "stream", "text": [ - "/home/romano/openmc/openmc/tallies.py:1835: RuntimeWarning: invalid value encountered in true_divide\n", + "/home/nelsonag/git/openmc/openmc/tallies.py:1835: RuntimeWarning: invalid value encountered in true_divide\n", " self_rel_err = data['self']['std. dev.'] / data['self']['mean']\n", - "/home/romano/openmc/openmc/tallies.py:1836: RuntimeWarning: invalid value encountered in true_divide\n", + "/home/nelsonag/git/openmc/openmc/tallies.py:1836: RuntimeWarning: invalid value encountered in true_divide\n", " other_rel_err = data['other']['std. dev.'] / data['other']['mean']\n", - "/home/romano/openmc/openmc/tallies.py:1837: RuntimeWarning: invalid value encountered in true_divide\n", + "/home/nelsonag/git/openmc/openmc/tallies.py:1837: RuntimeWarning: invalid value encountered in true_divide\n", " new_tally._mean = data['self']['mean'] / data['other']['mean']\n" ] } @@ -1627,7 +1623,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 43, @@ -1636,9 +1632,9 @@ }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAX4AAADHCAYAAAAeaDj1AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nRU5ErkJggg==\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAX4AAADHCAYAAAAeaDj1AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nRK5CYII=\n", "text/plain": [ - "" + "" ] }, "metadata": {}, @@ -1665,7 +1661,7 @@ "metadata": { "anaconda-cloud": {}, "kernelspec": { - "display_name": "Python [default]", + "display_name": "Python 3", "language": "python", "name": "python3" }, @@ -1679,7 +1675,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.5.2" + "version": "3.6.0" } }, "nbformat": 4, diff --git a/openmc/mgxs/mgxs.py b/openmc/mgxs/mgxs.py index 33bdeb83a..284be6ca3 100644 --- a/openmc/mgxs/mgxs.py +++ b/openmc/mgxs/mgxs.py @@ -149,6 +149,8 @@ class MGXS(object): Name of the multi-group cross section rxn_type : str Reaction type (e.g., 'total', 'nu-fission', etc.) + nu : bool + If True, the cross section data will include neutron multiplication by_nuclide : bool If true, computes cross sections for each nuclide in domain domain : Material or Cell or Universe or Mesh @@ -230,6 +232,7 @@ class MGXS(object): self._derived = False self._hdf5_key = None self._valid_estimators = ESTIMATOR_TYPES + self._nu = False self.name = name self.by_nuclide = by_nuclide @@ -408,6 +411,10 @@ class MGXS(object): def rxn_type(self): return self._rxn_type + @property + def nu(self): + return self._nu + @property def by_nuclide(self): return self._by_nuclide @@ -573,6 +580,11 @@ class MGXS(object): cv.check_type('name', name, string_types) self._name = name + @nu.setter + def nu(self, nu): + cv.check_type('nu', nu, bool) + self._nu = nu + @by_nuclide.setter def by_nuclide(self, by_nuclide): cv.check_type('by_nuclide', by_nuclide, bool) @@ -704,7 +716,7 @@ class MGXS(object): elif mgxs_type == 'transport': mgxs = TransportXS(domain, domain_type, energy_groups) elif mgxs_type == 'nu-transport': - mgxs = NuTransportXS(domain, domain_type, energy_groups) + mgxs = TransportXS(domain, domain_type, energy_groups, nu=True) elif mgxs_type == 'absorption': mgxs = AbsorptionXS(domain, domain_type, energy_groups) elif mgxs_type == 'capture': @@ -712,17 +724,17 @@ class MGXS(object): elif mgxs_type == 'fission': mgxs = FissionXS(domain, domain_type, energy_groups) elif mgxs_type == 'nu-fission': - mgxs = NuFissionXS(domain, domain_type, energy_groups) + mgxs = FissionXS(domain, domain_type, energy_groups, nu=True) elif mgxs_type == 'kappa-fission': mgxs = KappaFissionXS(domain, domain_type, energy_groups) elif mgxs_type == 'scatter': mgxs = ScatterXS(domain, domain_type, energy_groups) elif mgxs_type == 'nu-scatter': - mgxs = NuScatterXS(domain, domain_type, energy_groups) + mgxs = ScatterXS(domain, domain_type, energy_groups, nu=True) elif mgxs_type == 'scatter matrix': mgxs = ScatterMatrixXS(domain, domain_type, energy_groups) elif mgxs_type == 'nu-scatter matrix': - mgxs = NuScatterMatrixXS(domain, domain_type, energy_groups) + mgxs = ScatterMatrixXS(domain, domain_type, energy_groups, nu=True) elif mgxs_type == 'multiplicity matrix': mgxs = MultiplicityMatrixXS(domain, domain_type, energy_groups) elif mgxs_type == 'nu-fission matrix': @@ -2001,6 +2013,8 @@ class MatrixMGXS(MGXS): Name of the multi-group cross section rxn_type : str Reaction type (e.g., 'total', 'nu-fission', etc.) + nu : bool + If True, the cross section data will include neutron multiplication by_nuclide : bool If true, computes cross sections for each nuclide in domain domain : Material or Cell or Universe or Mesh @@ -2555,9 +2569,8 @@ class TotalXS(MGXS): """ - def __init__(self, domain=None, domain_type=None, - groups=None, by_nuclide=False, name='', num_polar=1, - num_azimuthal=1): + def __init__(self, domain=None, domain_type=None, groups=None, + by_nuclide=False, name='', num_polar=1, num_azimuthal=1): super(TotalXS, self).__init__(domain, domain_type, groups, by_nuclide, name, num_polar, num_azimuthal) @@ -2607,6 +2620,9 @@ class TransportXS(MGXS): The domain type for spatial homogenization groups : openmc.mgxs.EnergyGroups The energy group structure for energy condensation + nu : bool + If True, the cross section data will include neutron multiplication; + defaults to True. by_nuclide : bool If true, computes cross sections for each nuclide in domain name : str, optional @@ -2625,6 +2641,8 @@ class TransportXS(MGXS): Name of the multi-group cross section rxn_type : str Reaction type (e.g., 'total', 'nu-fission', etc.) + nu : bool + If True, the cross section data will include neutron multiplication by_nuclide : bool If true, computes cross sections for each nuclide in domain domain : Material or Cell or Universe or Mesh @@ -2685,19 +2703,32 @@ class TransportXS(MGXS): """ - def __init__(self, domain=None, domain_type=None, - groups=None, by_nuclide=False, name='', num_polar=1, - num_azimuthal=1): + def __init__(self, domain=None, domain_type=None, groups=None, nu=False, + by_nuclide=False, name='', num_polar=1, num_azimuthal=1): super(TransportXS, self).__init__(domain, domain_type, groups, by_nuclide, name, num_polar, num_azimuthal) - self._rxn_type = 'transport' + if not nu: + self._rxn_type = 'transport' + else: + self._rxn_type = 'nu-transport' self._estimator = 'analog' self._valid_estimators = ['analog'] + self.nu = nu @property def scores(self): - return ['flux', 'total', 'scatter-1'] + if not self.nu: + return ['flux', 'total', 'scatter-1'] + else: + return ['flux', 'total', 'nu-scatter-1'] + + @property + def tally_keys(self): + if not self.nu: + return super(TransportXS, self).tally_keys + else: + return ['flux', 'total', 'scatter-1'] @property def filters(self): @@ -2724,131 +2755,6 @@ class TransportXS(MGXS): return self._rxn_rate_tally -class NuTransportXS(TransportXS): - r"""A transport-corrected total multi-group cross section which - accounts for neutron multiplicity in scattering reactions. - - This class can be used for both OpenMC input generation and tally data - post-processing to compute spatially-homogenized and energy-integrated - multi-group cross sections for multi-group neutronics calculations. At a - minimum, one needs to set the :attr:`NuTransportXS.energy_groups` and - :attr:`NuTransportXS.domain` properties. Tallies for the flux and - appropriate reaction rates over the specified domain are generated - automatically via the :attr:`NuTransportXS.tallies` property, which can then - be appended to a :class:`openmc.Tallies` instance. - - For post-processing, the :meth:`MGXS.load_from_statepoint` will pull in the - necessary data to compute multi-group cross sections from a - :class:`openmc.StatePoint` instance. The derived multi-group cross section - can then be obtained from the :attr:`NuTransportXS.xs_tally` property. - - The calculation of the transport-corrected cross section is the same as that - for :class:`TransportXS` except that the scattering multiplicity is - accounted for. - - Parameters - ---------- - domain : openmc.Material or openmc.Cell or openmc.Universe or openmc.Mesh - The domain for spatial homogenization - domain_type : {'material', 'cell', 'distribcell', 'universe', 'mesh'} - The domain type for spatial homogenization - groups : openmc.mgxs.EnergyGroups - The energy group structure for energy condensation - by_nuclide : bool - If true, computes cross sections for each nuclide in domain - name : str, optional - Name of the multi-group cross section. Used as a label to identify - tallies in OpenMC 'tallies.xml' file. - num_polar : Integral, optional - Number of equi-width polar angle bins for angle discretization; - defaults to one bin - num_azimuthal : Integral, optional - Number of equi-width azimuthal angle bins for angle discretization; - defaults to one bin - - Attributes - ---------- - name : str, optional - Name of the multi-group cross section - rxn_type : str - Reaction type (e.g., 'total', 'nu-fission', etc.) - by_nuclide : bool - If true, computes cross sections for each nuclide in domain - domain : Material or Cell or Universe or Mesh - Domain for spatial homogenization - domain_type : {'material', 'cell', 'distribcell', 'universe', 'mesh'} - Domain type for spatial homogenization - energy_groups : openmc.mgxs.EnergyGroups - Energy group structure for energy condensation - num_polar : Integral - Number of equi-width polar angle bins for angle discretization - num_azimuthal : Integral - Number of equi-width azimuthal angle bins for angle discretization - tally_trigger : openmc.Trigger - An (optional) tally precision trigger given to each tally used to - compute the cross section - scores : list of str - The scores in each tally used to compute the multi-group cross section - filters : list of openmc.Filter - The filters in each tally used to compute the multi-group cross section - tally_keys : list of str - The keys into the tallies dictionary for each tally used to compute - the multi-group cross section - estimator : 'analog' - The tally estimator used to compute the multi-group cross section - tallies : collections.OrderedDict - OpenMC tallies needed to compute the multi-group cross section. The keys - are strings listed in the :attr:`NuTransportXS.tally_keys` property and - values are instances of :class:`openmc.Tally`. - rxn_rate_tally : openmc.Tally - Derived tally for the reaction rate tally used in the numerator to - compute the multi-group cross section. This attribute is None - unless the multi-group cross section has been computed. - xs_tally : openmc.Tally - Derived tally for the multi-group cross section. This attribute - is None unless the multi-group cross section has been computed. - num_subdomains : int - The number of subdomains is unity for 'material', 'cell' and 'universe' - domain types. This is equal to the number of cell instances - for 'distribcell' domain types (it is equal to unity prior to loading - tally data from a statepoint file). - num_nuclides : int - The number of nuclides for which the multi-group cross section is - being tracked. This is unity if the by_nuclide attribute is False. - nuclides : Iterable of str or 'sum' - The optional user-specified nuclides for which to compute cross - sections (e.g., 'U238', 'O16'). If by_nuclide is True but nuclides - are not specified by the user, all nuclides in the spatial domain - are included. This attribute is 'sum' if by_nuclide is false. - sparse : bool - Whether or not the MGXS' tallies use SciPy's LIL sparse matrix format - for compressed data storage - loaded_sp : bool - Whether or not a statepoint file has been loaded with tally data - derived : bool - Whether or not the MGXS is merged from one or more other MGXS - hdf5_key : str - The key used to index multi-group cross sections in an HDF5 data store - - """ - - def __init__(self, domain=None, domain_type=None, - groups=None, by_nuclide=False, name='', num_polar=1, - num_azimuthal=1): - super(NuTransportXS, self).__init__(domain, domain_type, - groups, by_nuclide, name, - num_polar, num_azimuthal) - self._rxn_type = 'nu-transport' - - @property - def scores(self): - return ['flux', 'total', 'nu-scatter-1'] - - @property - def tally_keys(self): - return ['flux', 'total', 'scatter-1'] - - class AbsorptionXS(MGXS): r"""An absorption multi-group cross section. @@ -2966,9 +2872,8 @@ class AbsorptionXS(MGXS): """ - def __init__(self, domain=None, domain_type=None, - groups=None, by_nuclide=False, name='', num_polar=1, - num_azimuthal=1): + def __init__(self, domain=None, domain_type=None, groups=None, + by_nuclide=False, name='', num_polar=1, num_azimuthal=1): super(AbsorptionXS, self).__init__(domain, domain_type, groups, by_nuclide, name, num_polar, num_azimuthal) @@ -3094,9 +2999,8 @@ class CaptureXS(MGXS): """ - def __init__(self, domain=None, domain_type=None, - groups=None, by_nuclide=False, name='', num_polar=1, - num_azimuthal=1): + def __init__(self, domain=None, domain_type=None, groups=None, + by_nuclide=False, name='', num_polar=1, num_azimuthal=1): super(CaptureXS, self).__init__(domain, domain_type, groups, by_nuclide, name, num_polar, num_azimuthal) @@ -3150,6 +3054,9 @@ class FissionXS(MGXS): The domain type for spatial homogenization groups : openmc.mgxs.EnergyGroups The energy group structure for energy condensation + nu : bool + If True, the cross section data will include neutron multiplication; + defaults to False by_nuclide : bool If true, computes cross sections for each nuclide in domain name : str, optional @@ -3168,6 +3075,8 @@ class FissionXS(MGXS): Name of the multi-group cross section rxn_type : str Reaction type (e.g., 'total', 'nu-fission', etc.) + nu : bool + If True, the cross section data will include neutron multiplication by_nuclide : bool If true, computes cross sections for each nuclide in domain domain : Material or Cell or Universe or Mesh @@ -3228,136 +3137,15 @@ class FissionXS(MGXS): """ - def __init__(self, domain=None, domain_type=None, - groups=None, by_nuclide=False, name='', num_polar=1, - num_azimuthal=1): + def __init__(self, domain=None, domain_type=None, groups=None, nu=False, + by_nuclide=False, name='', num_polar=1, num_azimuthal=1): super(FissionXS, self).__init__(domain, domain_type, groups, by_nuclide, name, num_polar, num_azimuthal) - self._rxn_type = 'fission' - - -class NuFissionXS(MGXS): - r"""A fission neutron production multi-group cross section. - - This class can be used for both OpenMC input generation and tally data - post-processing to compute spatially-homogenized and energy-integrated - multi-group fission neutron production cross sections for multi-group - neutronics calculations. At a minimum, one needs to set the - :attr:`NuFissionXS.energy_groups` and :attr:`NuFissionXS.domain` - properties. Tallies for the flux and appropriate reaction rates over the - specified domain are generated automatically via the - :attr:`NuFissionXS.tallies` property, which can then be appended to a - :class:`openmc.Tallies` instance. - - For post-processing, the :meth:`MGXS.load_from_statepoint` will pull in the - necessary data to compute multi-group cross sections from a - :class:`openmc.StatePoint` instance. The derived multi-group cross section - can then be obtained from the :attr:`NuFissionXS.xs_tally` property. - - For a spatial domain :math:`V` and energy group :math:`[E_g,E_{g-1}]`, the - fission neutron production cross section is calculated as: - - .. math:: - - \frac{\int_{r \in V} dr \int_{4\pi} d\Omega \int_{E_g}^{E_{g-1}} dE \; - \nu\sigma_f (r, E) \psi (r, E, \Omega)}{\int_{r \in V} dr \int_{4\pi} - d\Omega \int_{E_g}^{E_{g-1}} dE \; \psi (r, E, \Omega)}. - - - Parameters - ---------- - domain : openmc.Material or openmc.Cell or openmc.Universe or openmc.Mesh - The domain for spatial homogenization - domain_type : {'material', 'cell', 'distribcell', 'universe', 'mesh'} - The domain type for spatial homogenization - groups : openmc.mgxs.EnergyGroups - The energy group structure for energy condensation - by_nuclide : bool - If true, computes cross sections for each nuclide in domain - name : str, optional - Name of the multi-group cross section. Used as a label to identify - tallies in OpenMC 'tallies.xml' file. - num_polar : Integral, optional - Number of equi-width polar angle bins for angle discretization; - defaults to one bin - num_azimuthal : Integral, optional - Number of equi-width azimuthal angle bins for angle discretization; - defaults to one bin - - Attributes - ---------- - name : str, optional - Name of the multi-group cross section - rxn_type : str - Reaction type (e.g., 'total', 'nu-fission', etc.) - by_nuclide : bool - If true, computes cross sections for each nuclide in domain - domain : Material or Cell or Universe or Mesh - Domain for spatial homogenization - domain_type : {'material', 'cell', 'distribcell', 'universe', 'mesh'} - Domain type for spatial homogenization - energy_groups : openmc.mgxs.EnergyGroups - Energy group structure for energy condensation - num_polar : Integral - Number of equi-width polar angle bins for angle discretization - num_azimuthal : Integral - Number of equi-width azimuthal angle bins for angle discretization - tally_trigger : openmc.Trigger - An (optional) tally precision trigger given to each tally used to - compute the cross section - scores : list of str - The scores in each tally used to compute the multi-group cross section - filters : list of openmc.Filter - The filters in each tally used to compute the multi-group cross section - tally_keys : list of str - The keys into the tallies dictionary for each tally used to compute - the multi-group cross section - estimator : {'tracklength', 'collision', 'analog'} - The tally estimator used to compute the multi-group cross section - tallies : collections.OrderedDict - OpenMC tallies needed to compute the multi-group cross section. The keys - are strings listed in the :attr:`NuFissionXS.tally_keys` property and - values are instances of :class:`openmc.Tally`. - rxn_rate_tally : openmc.Tally - Derived tally for the reaction rate tally used in the numerator to - compute the multi-group cross section. This attribute is None - unless the multi-group cross section has been computed. - xs_tally : openmc.Tally - Derived tally for the multi-group cross section. This attribute - is None unless the multi-group cross section has been computed. - num_subdomains : int - The number of subdomains is unity for 'material', 'cell' and 'universe' - domain types. This is equal to the number of cell instances - for 'distribcell' domain types (it is equal to unity prior to loading - tally data from a statepoint file). - num_nuclides : int - The number of nuclides for which the multi-group cross section is - being tracked. This is unity if the by_nuclide attribute is False. - nuclides : Iterable of str or 'sum' - The optional user-specified nuclides for which to compute cross - sections (e.g., 'U238', 'O16'). If by_nuclide is True but nuclides - are not specified by the user, all nuclides in the spatial domain - are included. This attribute is 'sum' if by_nuclide is false. - sparse : bool - Whether or not the MGXS' tallies use SciPy's LIL sparse matrix format - for compressed data storage - loaded_sp : bool - Whether or not a statepoint file has been loaded with tally data - derived : bool - Whether or not the MGXS is merged from one or more other MGXS - hdf5_key : str - The key used to index multi-group cross sections in an HDF5 data store - - """ - - def __init__(self, domain=None, domain_type=None, - groups=None, by_nuclide=False, name='', num_polar=1, - num_azimuthal=1): - super(NuFissionXS, self).__init__(domain, domain_type, - groups, by_nuclide, name, num_polar, - num_azimuthal) - self._rxn_type = 'nu-fission' + if not nu: + self._rxn_type = 'fission' + else: + self._rxn_type = 'nu-fission' class KappaFissionXS(MGXS): @@ -3479,9 +3267,8 @@ class KappaFissionXS(MGXS): """ - def __init__(self, domain=None, domain_type=None, - groups=None, by_nuclide=False, name='', num_polar=1, - num_azimuthal=1): + def __init__(self, domain=None, domain_type=None, groups=None, + by_nuclide=False, name='', num_polar=1, num_azimuthal=1): super(KappaFissionXS, self).__init__(domain, domain_type, groups, by_nuclide, name, num_polar, num_azimuthal) @@ -3526,6 +3313,9 @@ class ScatterXS(MGXS): The domain type for spatial homogenization groups : openmc.mgxs.EnergyGroups The energy group structure for energy condensation + nu : bool + If True, the cross section data will include neutron multiplication; + defaults to False by_nuclide : bool If true, computes cross sections for each nuclide in domain name : str, optional @@ -3544,6 +3334,8 @@ class ScatterXS(MGXS): Name of the multi-group cross section rxn_type : str Reaction type (e.g., 'total', 'nu-fission', etc.) + nu : bool + If True, the cross section data will include neutron multiplication by_nuclide : bool If true, computes cross sections for each nuclide in domain domain : Material or Cell or Universe or Mesh @@ -3604,142 +3396,21 @@ class ScatterXS(MGXS): """ - def __init__(self, domain=None, domain_type=None, - groups=None, by_nuclide=False, name='', num_polar=1, - num_azimuthal=1): + def __init__(self, domain=None, domain_type=None, groups=None, nu=False, + by_nuclide=False, name='', num_polar=1, num_azimuthal=1): super(ScatterXS, self).__init__(domain, domain_type, groups, by_nuclide, name, num_polar, num_azimuthal) - self._rxn_type = 'scatter' + if not nu: + self._rxn_type = 'scatter' + else: + self._rxn_type = 'nu-scatter' + # Only analog estimators are valid so change from the defaults + # to reflect this + self._estimator = 'analog' + self._valid_estimators = ['analog'] - -class NuScatterXS(MGXS): - r"""A scattering neutron production multi-group cross section. - - The neutron production from scattering is defined as the average number of - neutrons produced from all neutron-producing reactions except for fission. - - This class can be used for both OpenMC input generation and tally data - post-processing to compute spatially-homogenized and energy-integrated - multi-group cross sections for multi-group neutronics calculations. At a - minimum, one needs to set the :attr:`NuScatterXS.energy_groups` and - :attr:`NuScatterXS.domain` properties. Tallies for the flux and appropriate - reaction rates over the specified domain are generated automatically via the - :attr:`NuScatterXS.tallies` property, which can then be appended to a - :class:`openmc.Tallies` instance. - - For post-processing, the :meth:`MGXS.load_from_statepoint` will pull in the - necessary data to compute multi-group cross sections from a - :class:`openmc.StatePoint` instance. The derived multi-group cross section - can then be obtained from the :attr:`NuScatterXS.xs_tally` property. - - For a spatial domain :math:`V` and energy group :math:`[E_g,E_{g-1}]`, the - scattering neutron production cross section is calculated as: - - .. math:: - - \frac{\int_{r \in V} dr \int_{4\pi} d\Omega \int_{E_g}^{E_{g-1}} dE \; - \sum_i \upsilon_i \sigma_i (r, E) \psi (r, E, \Omega)}{\int_{r \in V} dr - \int_{4\pi} d\Omega \int_{E_g}^{E_{g-1}} dE \; \psi (r, E, \Omega)}. - - where :math:`\upsilon_i` is the multiplicity of the :math:`i`-th scattering - reaction. - - Parameters - ---------- - domain : openmc.Material or openmc.Cell or openmc.Universe or openmc.Mesh - The domain for spatial homogenization - domain_type : {'material', 'cell', 'distribcell', 'universe', 'mesh'} - The domain type for spatial homogenization - groups : openmc.mgxs.EnergyGroups - The energy group structure for energy condensation - by_nuclide : bool - If true, computes cross sections for each nuclide in domain - name : str, optional - Name of the multi-group cross section. Used as a label to identify - tallies in OpenMC 'tallies.xml' file. - num_polar : Integral, optional - Number of equi-width polar angle bins for angle discretization; - defaults to one bin - num_azimuthal : Integral, optional - Number of equi-width azimuthal angle bins for angle discretization; - defaults to one bin - - Attributes - ---------- - name : str, optional - Name of the multi-group cross section - rxn_type : str - Reaction type (e.g., 'total', 'nu-fission', etc.) - by_nuclide : bool - If true, computes cross sections for each nuclide in domain - domain : Material or Cell or Universe or Mesh - Domain for spatial homogenization - domain_type : {'material', 'cell', 'distribcell', 'universe', 'mesh'} - Domain type for spatial homogenization - energy_groups : openmc.mgxs.EnergyGroups - Energy group structure for energy condensation - num_polar : Integral - Number of equi-width polar angle bins for angle discretization - num_azimuthal : Integral - Number of equi-width azimuthal angle bins for angle discretization - tally_trigger : openmc.Trigger - An (optional) tally precision trigger given to each tally used to - compute the cross section - scores : list of str - The scores in each tally used to compute the multi-group cross section - filters : list of openmc.Filter - The filters in each tally used to compute the multi-group cross section - tally_keys : list of str - The keys into the tallies dictionary for each tally used to compute - the multi-group cross section - estimator : 'analog' - The tally estimator used to compute the multi-group cross section - tallies : collections.OrderedDict - OpenMC tallies needed to compute the multi-group cross section. The keys - are strings listed in the :attr:`NuScatterXS.tally_keys` property and - values are instances of :class:`openmc.Tally`. - rxn_rate_tally : openmc.Tally - Derived tally for the reaction rate tally used in the numerator to - compute the multi-group cross section. This attribute is None - unless the multi-group cross section has been computed. - xs_tally : openmc.Tally - Derived tally for the multi-group cross section. This attribute - is None unless the multi-group cross section has been computed. - num_subdomains : int - The number of subdomains is unity for 'material', 'cell' and 'universe' - domain types. This is equal to the number of cell instances - for 'distribcell' domain types (it is equal to unity prior to loading - tally data from a statepoint file). - num_nuclides : int - The number of nuclides for which the multi-group cross section is - being tracked. This is unity if the by_nuclide attribute is False. - nuclides : Iterable of str or 'sum' - The optional user-specified nuclides for which to compute cross - sections (e.g., 'U238', 'O16'). If by_nuclide is True but nuclides - are not specified by the user, all nuclides in the spatial domain - are included. This attribute is 'sum' if by_nuclide is false. - sparse : bool - Whether or not the MGXS' tallies use SciPy's LIL sparse matrix format - for compressed data storage - loaded_sp : bool - Whether or not a statepoint file has been loaded with tally data - derived : bool - Whether or not the MGXS is merged from one or more other MGXS - hdf5_key : str - The key used to index multi-group cross sections in an HDF5 data store - - """ - - def __init__(self, domain=None, domain_type=None, - groups=None, by_nuclide=False, name='', num_polar=1, - num_azimuthal=1): - super(NuScatterXS, self).__init__(domain, domain_type, - groups, by_nuclide, name, num_polar, - num_azimuthal) - self._rxn_type = 'nu-scatter' - self._estimator = 'analog' - self._valid_estimators = ['analog'] + self.nu = nu class ScatterMatrixXS(MatrixMGXS): @@ -3793,6 +3464,9 @@ class ScatterMatrixXS(MatrixMGXS): The domain type for spatial homogenization groups : openmc.mgxs.EnergyGroups The energy group structure for energy condensation + nu : bool + If True, the cross section data will include neutron multiplication; + defaults to False by_nuclide : bool If true, computes cross sections for each nuclide in domain name : str, optional @@ -3824,6 +3498,8 @@ class ScatterMatrixXS(MatrixMGXS): Name of the multi-group cross section rxn_type : str Reaction type (e.g., 'total', 'nu-fission', etc.) + nu : bool + If True, the cross section data will include neutron multiplication by_nuclide : bool If true, computes cross sections for each nuclide in domain domain : Material or Cell or Universe or Mesh @@ -3884,20 +3560,24 @@ class ScatterMatrixXS(MatrixMGXS): """ - def __init__(self, domain=None, domain_type=None, - groups=None, by_nuclide=False, name='', num_polar=1, - num_azimuthal=1): + def __init__(self, domain=None, domain_type=None, groups=None, nu=False, + by_nuclide=False, name='', num_polar=1, num_azimuthal=1): super(ScatterMatrixXS, self).__init__(domain, domain_type, groups, by_nuclide, name, num_azimuthal) - self._rxn_type = 'scatter' + if not nu: + self._rxn_type = 'scatter' + self._hdf5_key = 'scatter matrix' + else: + self._rxn_type = 'nu-scatter' + self._hdf5_key = 'nu-scatter matrix' self._correction = 'P0' self._scatter_format = 'legendre' self._legendre_order = 0 self._histogram_bins = 16 - self._hdf5_key = 'scatter matrix' self._estimator = 'analog' self._valid_estimators = ['analog'] + self.nu = nu def __deepcopy__(self, memo): clone = super(ScatterMatrixXS, self).__deepcopy__(memo) @@ -4601,128 +4281,6 @@ class ScatterMatrixXS(MatrixMGXS): print(string) -class NuScatterMatrixXS(ScatterMatrixXS): - """A scattering production matrix multi-group cross section for one or - more Legendre moments. - - This class can be used for both OpenMC input generation and tally data - post-processing to compute spatially-homogenized and energy-integrated - multi-group cross sections for multi-group neutronics calculations. At a - minimum, one needs to set the :attr:`NuScatterMatrixXS.energy_groups` and - :attr:`NuScatterMatrixXS.domain` properties. Tallies for the flux and - appropriate reaction rates over the specified domain are generated - automatically via the :attr:`NuScatterMatrixXS.tallies` property, which can - then be appended to a :class:`openmc.Tallies` instance. - - For post-processing, the :meth:`MGXS.load_from_statepoint` will pull in the - necessary data to compute multi-group cross sections from a - :class:`openmc.StatePoint` instance. The derived multi-group cross section - can then be obtained from the :attr:`NuScatterMatrixXS.xs_tally` property. - - The calculation of the scattering-production matrix is the same as that for - :class:`ScatterMatrixXS` except that the scattering multiplicity is - accounted for. - - Parameters - ---------- - domain : openmc.Material or openmc.Cell or openmc.Universe or openmc.Mesh - The domain for spatial homogenization - domain_type : {'material', 'cell', 'distribcell', 'universe', 'mesh'} - The domain type for spatial homogenization - groups : openmc.mgxs.EnergyGroups - The energy group structure for energy condensation - by_nuclide : bool - If true, computes cross sections for each nuclide in domain - name : str, optional - Name of the multi-group cross section. Used as a label to identify - tallies in OpenMC 'tallies.xml' file. - num_polar : Integral, optional - Number of equi-width polar angle bins for angle discretization; - defaults to one bin - num_azimuthal : Integral, optional - Number of equi-width azimuthal angle bins for angle discretization; - defaults to one bin - - Attributes - ---------- - correction : 'P0' or None - Apply the P0 correction to scattering matrices if set to 'P0' - legendre_order : int - The highest legendre moment in the scattering matrix (default is 0) - name : str, optional - Name of the multi-group cross section - rxn_type : str - Reaction type (e.g., 'total', 'nu-fission', etc.) - by_nuclide : bool - If true, computes cross sections for each nuclide in domain - domain : Material or Cell or Universe or Mesh - Domain for spatial homogenization - domain_type : {'material', 'cell', 'distribcell', 'universe', 'mesh'} - Domain type for spatial homogenization - energy_groups : openmc.mgxs.EnergyGroups - Energy group structure for energy condensation - num_polar : Integral - Number of equi-width polar angle bins for angle discretization - num_azimuthal : Integral - Number of equi-width azimuthal angle bins for angle discretization - tally_trigger : openmc.Trigger - An (optional) tally precision trigger given to each tally used to - compute the cross section - scores : list of str - The scores in each tally used to compute the multi-group cross section - filters : list of openmc.Filter - The filters in each tally used to compute the multi-group cross section - tally_keys : list of str - The keys into the tallies dictionary for each tally used to compute - the multi-group cross section - estimator : 'analog' - The tally estimator used to compute the multi-group cross section - tallies : collections.OrderedDict - OpenMC tallies needed to compute the multi-group cross section. The keys - are strings listed in the :attr:`NuScatterMatrixXS.tally_keys` property - and values are instances of :class:`openmc.Tally`. - rxn_rate_tally : openmc.Tally - Derived tally for the reaction rate tally used in the numerator to - compute the multi-group cross section. This attribute is None - unless the multi-group cross section has been computed. - xs_tally : openmc.Tally - Derived tally for the multi-group cross section. This attribute - is None unless the multi-group cross section has been computed. - num_subdomains : int - The number of subdomains is unity for 'material', 'cell' and 'universe' - domain types. This is equal to the number of cell instances - for 'distribcell' domain types (it is equal to unity prior to loading - tally data from a statepoint file). - num_nuclides : int - The number of nuclides for which the multi-group cross section is - being tracked. This is unity if the by_nuclide attribute is False. - nuclides : Iterable of str or 'sum' - The optional user-specified nuclides for which to compute cross - sections (e.g., 'U238', 'O16'). If by_nuclide is True but nuclides - are not specified by the user, all nuclides in the spatial domain - are included. This attribute is 'sum' if by_nuclide is false. - sparse : bool - Whether or not the MGXS' tallies use SciPy's LIL sparse matrix format - for compressed data storage - loaded_sp : bool - Whether or not a statepoint file has been loaded with tally data - derived : bool - Whether or not the MGXS is merged from one or more other MGXS - hdf5_key : str - The key used to index multi-group cross sections in an HDF5 data store - - """ - - def __init__(self, domain=None, domain_type=None, - groups=None, by_nuclide=False, name='', num_polar=1, - num_azimuthal=1): - super(NuScatterMatrixXS, self).__init__(domain, domain_type, - groups, by_nuclide, name, - num_polar, num_azimuthal) - self._rxn_type = 'nu-scatter' - self._hdf5_key = 'nu-scatter matrix' - - class MultiplicityMatrixXS(MatrixMGXS): r"""The scattering multiplicity matrix. @@ -4847,15 +4405,15 @@ class MultiplicityMatrixXS(MatrixMGXS): """ - def __init__(self, domain=None, domain_type=None, - groups=None, by_nuclide=False, name='', num_polar=1, - num_azimuthal=1): + def __init__(self, domain=None, domain_type=None, groups=None, + by_nuclide=False, name='', num_polar=1, num_azimuthal=1): super(MultiplicityMatrixXS, self).__init__(domain, domain_type, groups, by_nuclide, name, num_polar, num_azimuthal) self._rxn_type = 'multiplicity matrix' self._estimator = 'analog' self._valid_estimators = ['analog'] + self.nu = True @property def scores(self): @@ -5009,9 +4567,8 @@ class NuFissionMatrixXS(MatrixMGXS): """ - def __init__(self, domain=None, domain_type=None, - groups=None, by_nuclide=False, name='', num_polar=1, - num_azimuthal=1): + def __init__(self, domain=None, domain_type=None, groups=None, + by_nuclide=False, name='', num_polar=1, num_azimuthal=1): super(NuFissionMatrixXS, self).__init__(domain, domain_type, groups, by_nuclide, name, num_polar, num_azimuthal) @@ -5019,6 +4576,7 @@ class NuFissionMatrixXS(MatrixMGXS): self._hdf5_key = 'nu-fission matrix' self._estimator = 'analog' self._valid_estimators = ['analog'] + self.nu = True class Chi(MGXS): @@ -5138,14 +4696,14 @@ class Chi(MGXS): """ - def __init__(self, domain=None, domain_type=None, - groups=None, by_nuclide=False, name='', num_polar=1, - num_azimuthal=1): + def __init__(self, domain=None, domain_type=None, groups=None, + by_nuclide=False, name='', num_polar=1, num_azimuthal=1): super(Chi, self).__init__(domain, domain_type, groups, by_nuclide, name, num_polar, num_azimuthal) self._rxn_type = 'chi' self._estimator = 'analog' self._valid_estimators = ['analog'] + self.nu = True @property def _dont_squeeze(self): @@ -5691,9 +5249,8 @@ class ChiPrompt(Chi): """ - def __init__(self, domain=None, domain_type=None, - groups=None, by_nuclide=False, name='', num_polar=1, - num_azimuthal=1): + def __init__(self, domain=None, domain_type=None, groups=None, + by_nuclide=False, name='', num_polar=1, num_azimuthal=1): super(ChiPrompt, self).__init__(domain, domain_type, groups, by_nuclide, name, num_polar, num_azimuthal) @@ -5820,9 +5377,8 @@ class InverseVelocity(MGXS): """ - def __init__(self, domain=None, domain_type=None, - groups=None, by_nuclide=False, name='', num_polar=1, - num_azimuthal=1): + def __init__(self, domain=None, domain_type=None, groups=None, + by_nuclide=False, name='', num_polar=1, num_azimuthal=1): super(InverseVelocity, self).__init__(domain, domain_type, groups, by_nuclide, name, num_polar, num_azimuthal) @@ -5850,8 +5406,8 @@ class InverseVelocity(MGXS): if xs_type == 'macro': return 'second/cm' else: - raise ValueError('Unable to return the units of InverseVelocity for' - ' xs_type other than "macro"') + raise ValueError('Unable to return the units of InverseVelocity' + ' for xs_type other than "macro"') class PromptNuFissionXS(MGXS): @@ -5966,13 +5522,13 @@ class PromptNuFissionXS(MGXS): """ - def __init__(self, domain=None, domain_type=None, - groups=None, by_nuclide=False, name='', num_polar=1, - num_azimuthal=1): + def __init__(self, domain=None, domain_type=None, groups=None, + by_nuclide=False, name='', num_polar=1, num_azimuthal=1): super(PromptNuFissionXS, self).__init__(domain, domain_type, groups, by_nuclide, name, num_polar, num_azimuthal) self._rxn_type = 'prompt-nu-fission' + self.nu = True class PromptNuFissionMatrixXS(MatrixMGXS): @@ -6092,9 +5648,8 @@ class PromptNuFissionMatrixXS(MatrixMGXS): """ - def __init__(self, domain=None, domain_type=None, - groups=None, by_nuclide=False, name='', num_polar=1, - num_azimuthal=1): + def __init__(self, domain=None, domain_type=None, groups=None, + by_nuclide=False, name='', num_polar=1, num_azimuthal=1): super(PromptNuFissionMatrixXS, self).__init__(domain, domain_type, groups, by_nuclide, name, num_polar, num_azimuthal) @@ -6102,3 +5657,4 @@ class PromptNuFissionMatrixXS(MatrixMGXS): self._hdf5_key = 'prompt-nu-fission matrix' self._estimator = 'analog' self._valid_estimators = ['analog'] + self.nu = True