From d2018de8ec151e4f2239a402f0773bd5a0cd4d97 Mon Sep 17 00:00:00 2001 From: Adam Nelson Date: Sat, 30 Apr 2016 16:08:47 -0400 Subject: [PATCH 01/20] Added ability to set data of the multi-group xs library (openmc.mgxs_library) with MGXS class objects. These are accessible via set_* where * can include total, absorption... . These routines can either take numpy arrays as the former and current setters do, or the appropriate MGXS objects. Also made some changes to meet PEP8 - GUESS WHO HAS A LINTER!!! and finally fixed a documentation issue in settings.py where CROSS_SECTIONS was still referenced instead of OPENMC_CROSS_SECTIONS. --- openmc/mgxs_library.py | 593 ++++++++++++++++++++++++++++++++++++++--- openmc/settings.py | 7 +- 2 files changed, 555 insertions(+), 45 deletions(-) diff --git a/openmc/mgxs_library.py b/openmc/mgxs_library.py index d3e49b238e..b41a2030c4 100644 --- a/openmc/mgxs_library.py +++ b/openmc/mgxs_library.py @@ -1,19 +1,19 @@ from collections import Iterable from numbers import Real, Integral from xml.etree import ElementTree as ET -import warnings import sys -if sys.version_info[0] >= 3: - basestring = str import numpy as np import openmc -from openmc.mgxs import EnergyGroups +import openmc.mgxs from openmc.checkvalue import check_type, check_value, check_greater_than, \ - check_iterable_type + check_iterable_type from openmc.clean_xml import * +if sys.version_info[0] >= 3: + basestring = str + # Supported incoming particle MGXS angular treatment representations _REPRESENTATIONS = ['isotropic', 'angle'] @@ -133,9 +133,9 @@ class XSdata(object): angles and outer-dimension being the polar angles. absorption : numpy.ndarray Group-wise absorption cross section ordered by increasing group index - (i.e., fast to thermal). If ``representation`` is "isotropic", then the + (i.e., fast to thermal). If ``representation`` is "isotropic", then the length of this list should equal the number of groups described in the - ``groups`` attribute. If ``representation`` is "angle", then the length + ``groups`` attribute. If ``representation`` is "angle", then the length of this list should equal the number of groups times the number of azimuthal angles times the number of polar angles, with the inner-dimension being groups, intermediate-dimension being azimuthal @@ -152,7 +152,7 @@ class XSdata(object): multiplicity : numpy.ndarray Ratio of neutrons produced in scattering collisions to the neutrons which undergo scattering collisions; that is, the multiplicity provides - the code with a scaling factor to account for neutrons being produced in + the code with a scaling factor to account for neutrons produced in (n,xn) reactions. This information is assumed isotropic and therefore does not need to be repeated for every Legendre moment or histogram/tabular bin. This matrix follows the same arrangement as @@ -160,30 +160,30 @@ class XSdata(object): needed to provide the scattering type information. fission : numpy.ndarray Group-wise fission cross section ordered by increasing group index - (i.e., fast to thermal). If ``representation`` is "isotropic", then the + (i.e., fast to thermal). If ``representation`` is "isotropic", then the length of this list should equal the number of groups described in the - ``groups`` attribute. If ``representation`` is "angle", then the length + ``groups`` attribute. If ``representation`` is "angle", then the length of this list should equal the number of groups times the number of azimuthal angles times the number of polar angles, with the inner-dimension being groups, intermediate-dimension being azimuthal angles and outer-dimension being the polar angles. k_fission : numpy.ndarray - Group-wise kappa-fission cross section ordered by increasing group index - (i.e., fast to thermal). If ``representation`` is "isotropic", then the - length of this list should equal the number of groups described in the - ``groups`` attribute. If ``representation`` is "angle", then the length + Group-wise kappa-fission cross section ordered by increasing group + index (i.e., fast to thermal). If ``representation`` is "isotropic", + then the length of this list should equal the number of groups in the + ``groups`` attribute. If ``representation`` is "angle", then the length of this list should equal the number of groups times the number of azimuthal angles times the number of polar angles, with the inner-dimension being groups, intermediate-dimension being azimuthal angles and outer-dimension being the polar angles. chi : numpy.ndarray - Group-wise fission spectra ordered by increasing group index (i.e., fast - to thermal). This attribute should be used if making the common + Group-wise fission spectra ordered by increasing group index (i.e., + fast to thermal). This attribute should be used if making the common approximation that the fission spectra does not depend on incoming - energy. If the user does not wish to make this approximation, then this - should not be provided and this information included in the + energy. If the user does not wish to make this approximation, then + this should not be provided and this information included in the ``nu_fission`` element instead. If ``representation`` is "isotropic", - then the length of this list should equal the number of groups described + then the length of this list should equal the number of groups in the ``groups`` element. If ``representation`` is "angle", then the length of this list should equal the number of groups times the number of azimuthal angles times the number of polar angles, with the @@ -191,12 +191,13 @@ class XSdata(object): angles and outer-dimension being the polar angles. nu_fission : numpy.ndarray Group-wise fission production cross section vector (i.e., if ``chi`` is - provided), or is the group-wise fission production matrix. If providing + provided), or is the group-wise fission production matrix. If providing the vector, it should be ordered the same as the ``fission`` data. If providing the matrix, it should be ordered the same as the ``multiplicity`` matrix. """ + def __init__(self, name, energy_groups, representation="isotropic"): # Initialize class attributes self._name = name @@ -308,11 +309,11 @@ class XSdata(object): @energy_groups.setter def energy_groups(self, energy_groups): # Check validity of energy_groups - check_type("energy_groups", energy_groups, EnergyGroups) + check_type("energy_groups", energy_groups, openmc.mgxs.EnergyGroups) - # Check that there is one or more groups - if ((energy_groups.num_groups is None) or - (energy_groups.num_groups < 1)): + # Check that there are one or more groups + ng = energy_groups.num_groups + if ((ng is None) or (ng < 1)): msg = 'energy_groups object incorrectly initialized.' raise ValueError(msg) @@ -413,7 +414,8 @@ class XSdata(object): shape = (self._num_polar, self._num_azimuthal, self._energy_groups.num_groups) # check we have a numpy list - check_type("absorption", absorption, np.ndarray, expected_iter_type=Real) + check_type("absorption", absorption, np.ndarray, + expected_iter_type=Real) if absorption.shape == shape: self._absorption = np.copy(absorption) else: @@ -447,14 +449,15 @@ class XSdata(object): shape = (self._num_polar, self._num_azimuthal, self._energy_groups.num_groups) # check we have a numpy list - check_type("k_fission", k_fission, np.ndarray, expected_iter_type=Real) + check_type("k_fission", k_fission, np.ndarray, + expected_iter_type=Real) if k_fission.shape == shape: self._k_fission = np.copy(k_fission) if np.sum(self._k_fission) > 0.0: self._fissionable = True else: - msg = 'Shape of provided k_fission "{0}" does not match shape ' \ - 'required, "{1}"'.format(k_fission.shape, shape) + msg = 'Shape of provided k_fission "{0}" does not match ' \ + 'shape required, "{1}"'.format(k_fission.shape, shape) raise ValueError(msg) @chi.setter @@ -462,6 +465,7 @@ class XSdata(object): if not self._use_chi: msg = 'Providing chi when nu_fission already provided as matrix!' raise ValueError(msg) + if self._representation is 'isotropic': shape = (self._energy_groups.num_groups,) elif self._representation is 'angle': @@ -516,18 +520,21 @@ class XSdata(object): if multiplicity.shape == shape: self._multiplicity = np.copy(multiplicity) else: - msg = 'Shape of provided multiplicity "{0}" does not match shape ' \ - 'required, "{1}"'.format(multiplicity.shape, shape) + msg = 'Shape of provided multiplicity "{0}" does not match shape' \ + ' required, "{1}"'.format(multiplicity.shape, shape) raise ValueError(msg) @nu_fission.setter def nu_fission(self, nu_fission): + # The NuFissionXS class does not have the capability to produce + # a fission matrix and therefore if this path is pursued, we know + # chi must be used. # nu_fission can be given as a vector or a matrix # Vector is used when chi also exists. # Matrix is used when chi does not exist. # We have to check that the correct form is given, but only if # chi already has been set. If not, we just check that this is OK - # and set the use_chi flag. + # and set the use_chi flag accordingly # First lets set our dimensions here since they get used repeatedly # throughout this code. @@ -542,8 +549,8 @@ class XSdata(object): self._energy_groups.num_groups, self._energy_groups.num_groups) - # Begin by checking the case when chi has already been given and thus - # the rules for filling in nu_fission are set. + # Begin by checking the case when chi has already been given and + # thus the rules for filling in nu_fission are set. if self._use_chi is not None: if self._use_chi: shape = shape_vec @@ -553,23 +560,524 @@ class XSdata(object): msg = "Invalid Shape of Nu_fission!" raise ValueError(msg) else: - # Get shape of nu_fission so we can figure if we need chi or not + # Get shape of nu_fission to determine if we need chi or not if nu_fission.shape == shape_vec: self._use_chi = True - shape = shape_vec elif nu_fission.shape == shape_mat: self._use_chi = False - shape = shape_mat else: msg = "Invalid Shape of Nu_fission!" raise ValueError(msg) # check we have a numpy list - check_type("nu_fission", nu_fission, np.ndarray, expected_iter_type=Real) + check_type("nu_fission", nu_fission, np.ndarray, + expected_iter_type=Real) self._nu_fission = np.copy(nu_fission) if np.sum(self._nu_fission) > 0.0: self._fissionable = True + def set_total(self, total, **kwargs): + if isinstance(total, openmc.mgxs.TotalXS): + # Make sure passed MGXS object contains correct group structure + if self.energy_groups != total.energy_groups: + msg = 'Group structure of provided TotalXS does not match' \ + ' group structure of XSdata object' + raise ValueError(msg) + # Get openmc.mgxs.get_xs() arguments from kwargs + # nuclides, xs_type, and value will have sane defaults but can be + # overridden by kwards + if 'nuclides' in kwargs: + nuclides = kwargs['nuclides'] + else: + nuclides = 'sum' + if 'xs_type' in kwargs: + xs_type = kwargs['xs_type'] + else: + xs_type = 'macro' + if 'value' in kwargs: + value = kwargs['value'] + else: + value = 'mean' + # subdomains is required from the kwargs as this is specific to + # this XSdata object. + if 'subdomains' in kwargs: + subdomains = kwargs['subdomains'] + else: + msg = "Argument 'subdomains' is required" + raise ValueError(msg) + + if self._representation is 'isotropic': + self._total = total.get_xs(subdomains=subdomains, + nuclides=nuclides, xs_type=xs_type, + value=value) + elif self._representation is 'angle': + # Not yet implemented as MGXS do not yet support this + pass + + else: + if self._representation is 'isotropic': + shape = (self._energy_groups.num_groups,) + elif self._representation is 'angle': + shape = (self._num_polar, self._num_azimuthal, + self._energy_groups.num_groups) + # check we have a numpy list + check_type("total", total, np.ndarray, expected_iter_type=Real) + if total.shape == shape: + self._total = np.copy(total) + else: + msg = 'Shape of provided total "{0}" does not match shape ' \ + 'required, "{1}"'.format(total.shape, shape) + raise ValueError(msg) + + def set_absorption(self, absorption, **kwargs): + if isinstance(absorption, openmc.mgxs.AbsorptionXS): + # Make sure passed MGXS object contains correct group structure + if self.energy_groups != absorption.energy_groups: + msg = 'Group structure of provided AbsorptionXS does not ' \ + ' match group structure of XSdata object' + raise ValueError(msg) + # Get openmc.mgxs.get_xs() arguments from kwargs + # nuclides, xs_type, and value will have sane defaults but can be + # overridden by kwards + if 'nuclides' in kwargs: + nuclides = kwargs['nuclides'] + else: + nuclides = 'sum' + if 'xs_type' in kwargs: + xs_type = kwargs['xs_type'] + else: + xs_type = 'macro' + if 'value' in kwargs: + value = kwargs['value'] + else: + value = 'mean' + # subdomains is required from the kwargs as this is specific to + # this XSdata object. + if 'subdomains' in kwargs: + subdomains = kwargs['subdomains'] + else: + msg = "Argument 'subdomains' is required" + raise ValueError(msg) + + if self._representation is 'isotropic': + self._absorption = absorption.get_xs(subdomains=subdomains, + nuclides=nuclides, + xs_type=xs_type, + value=value) + elif self._representation is 'angle': + # Not yet implemented as MGXS do not yet support this + pass + + else: + if self._representation is 'isotropic': + shape = (self._energy_groups.num_groups,) + elif self._representation is 'angle': + shape = (self._num_polar, self._num_azimuthal, + self._energy_groups.num_groups) + # check we have a numpy list + check_type("absorption", absorption, np.ndarray, expected_iter_type=Real) + if absorption.shape == shape: + self._absorption = np.copy(absorption) + else: + msg = 'Shape of provided absorption "{0}" does not match shape ' \ + 'required, "{1}"'.format(absorption.shape, shape) + raise ValueError(msg) + + def set_fission(self, fission, **kwargs): + if isinstance(fission, openmc.mgxs.FissionXS): + # Make sure passed MGXS object contains correct group structure + if self.energy_groups != fission.energy_groups: + msg = 'Group structure of provided FissionXS does not match ' \ + 'group structure of XSdata object' + raise ValueError(msg) + # Get openmc.mgxs.get_xs() arguments from kwargs + # nuclides, xs_type, and value will have sane defaults but can be + # overridden by kwards + if 'nuclides' in kwargs: + nuclides = kwargs['nuclides'] + else: + nuclides = 'sum' + if 'xs_type' in kwargs: + xs_type = kwargs['xs_type'] + else: + xs_type = 'macro' + if 'value' in kwargs: + value = kwargs['value'] + else: + value = 'mean' + # subdomains is required from the kwargs as this is specific to + # this XSdata object. + if 'subdomains' in kwargs: + subdomains = kwargs['subdomains'] + else: + msg = "Argument 'subdomains' is required" + raise ValueError(msg) + + if self._representation is 'isotropic': + self._fission = fission.get_xs(subdomains=subdomains, + nuclides=nuclides, + xs_type=xs_type, + value=value) + elif self._representation is 'angle': + # Not yet implemented as MGXS do not yet support this + pass + + else: + if self._representation is 'isotropic': + shape = (self._energy_groups.num_groups,) + elif self._representation is 'angle': + shape = (self._num_polar, self._num_azimuthal, + self._energy_groups.num_groups) + # check we have a numpy list + check_type("fission", fission, np.ndarray, expected_iter_type=Real) + if fission.shape == shape: + self._fission = np.copy(fission) + if np.sum(self._fission) > 0.0: + self._fissionable = True + else: + msg = 'Shape of provided fission "{0}" does not match shape ' \ + 'required, "{1}"'.format(fission.shape, shape) + raise ValueError(msg) + + def set_k_fission(self, k_fission, **kwargs): + if isinstance(k_fission, openmc.mgxs.KappaFissionXS): + # Make sure passed MGXS object contains correct group structure + if self.energy_groups != k_fission.energy_groups: + msg = 'Group structure of provided KappaFissionXS does not ' \ + 'match group structure of XSdata object' + raise ValueError(msg) + # Get openmc.mgxs.get_xs() arguments from kwargs + # nuclides, xs_type, and value will have sane defaults but can be + # overridden by kwards + if 'nuclides' in kwargs: + nuclides = kwargs['nuclides'] + else: + nuclides = 'sum' + if 'xs_type' in kwargs: + xs_type = kwargs['xs_type'] + else: + xs_type = 'macro' + if 'value' in kwargs: + value = kwargs['value'] + else: + value = 'mean' + # subdomains is required from the kwargs as this is specific to + # this XSdata object. + if 'subdomains' in kwargs: + subdomains = kwargs['subdomains'] + else: + msg = "Argument 'subdomains' is required" + raise ValueError(msg) + + if self._representation is 'isotropic': + self._k_fission = k_fission.get_xs(subdomains=subdomains, + nuclides=nuclides, + xs_type=xs_type, + value=value) + elif self._representation is 'angle': + # Not yet implemented as MGXS do not yet support this + pass + + else: + if self._representation is 'isotropic': + shape = (self._energy_groups.num_groups,) + elif self._representation is 'angle': + shape = (self._num_polar, self._num_azimuthal, + self._energy_groups.num_groups) + # check we have a numpy list + check_type("k_fission", k_fission, np.ndarray, + expected_iter_type=Real) + if k_fission.shape == shape: + self._k_fission = np.copy(k_fission) + if np.sum(self._k_fission) > 0.0: + self._fissionable = True + else: + msg = 'Shape of provided k_fission "{0}" does not match ' \ + 'shape required, "{1}"'.format(k_fission.shape, shape) + raise ValueError(msg) + + def set_chi(self, chi, **kwargs): + if not self._use_chi: + msg = 'Providing chi when nu_fission already provided as matrix!' + raise ValueError(msg) + + if isinstance(chi, openmc.mgxs.Chi): + # Make sure passed MGXS object contains correct group structure + if self.energy_groups != chi.energy_groups: + msg = 'Group structure of provided Chi does not ' \ + 'match group structure of XSdata object' + raise ValueError(msg) + # Get openmc.mgxs.get_xs() arguments from kwargs + # nuclides, xs_type, and value will have sane defaults but can be + # overridden by kwards + if 'nuclides' in kwargs: + nuclides = kwargs['nuclides'] + else: + nuclides = 'sum' + if 'xs_type' in kwargs: + xs_type = kwargs['xs_type'] + else: + xs_type = 'macro' + if 'value' in kwargs: + value = kwargs['value'] + else: + value = 'mean' + # subdomains is required from the kwargs as this is specific to + # this XSdata object. + if 'subdomains' in kwargs: + subdomains = kwargs['subdomains'] + else: + msg = "Argument 'subdomains' is required" + raise ValueError(msg) + + if self._representation is 'isotropic': + self._chi = chi.get_xs(subdomains=subdomains, + nuclides=nuclides, + xs_type=xs_type, + value=value) + elif self._representation is 'angle': + # Not yet implemented as MGXS do not yet support this + pass + + else: + if self._representation is 'isotropic': + shape = (self._energy_groups.num_groups,) + elif self._representation is 'angle': + shape = (self._num_polar, self._num_azimuthal, + self._energy_groups.num_groups) + # check we have a numpy list + check_type("chi", chi, np.ndarray, expected_iter_type=Real) + if chi.shape == shape: + self._chi = np.copy(chi) + else: + msg = 'Shape of provided chi "{0}" does not match shape ' \ + 'required, "{1}"'.format(chi.shape, shape) + raise ValueError(msg) + if self._use_chi is not None: + self._use_chi = True + + def set_scatter(self, scatter, **kwargs): + if isinstance(scatter, openmc.mgxs.ScatterMatrixXS): + # Make sure passed MGXS object contains correct group structure + if self.energy_groups != scatter.energy_groups: + msg = 'Group structure of provided ScatterMatrixXS does not ' \ + 'match group structure of XSdata object' + raise ValueError(msg) + # Get openmc.mgxs.get_xs() arguments from kwargs + # nuclides, xs_type, and value will have sane defaults but can be + # overridden by kwards + if 'nuclides' in kwargs: + nuclides = kwargs['nuclides'] + else: + nuclides = 'sum' + if 'xs_type' in kwargs: + xs_type = kwargs['xs_type'] + else: + xs_type = 'macro' + if 'value' in kwargs: + value = kwargs['value'] + else: + value = 'mean' + # subdomains is required from the kwargs as this is specific to + # this XSdata object. + if 'subdomains' in kwargs: + subdomains = kwargs['subdomains'] + else: + msg = "Argument 'subdomains' is required" + raise ValueError(msg) + + if self._representation is 'isotropic': + self._scatter = scatter.get_xs(subdomains=subdomains, + nuclides=nuclides, + xs_type=xs_type, + value=value) + elif self._representation is 'angle': + # Not yet implemented as MGXS do not yet support this + pass + + else: + if self._representation is 'isotropic': + shape = (self.num_orders, self._energy_groups.num_groups, + self._energy_groups.num_groups) + max_depth = 3 + elif self._representation is 'angle': + shape = (self._num_polar, self._num_azimuthal, self.num_orders, + self._energy_groups.num_groups, + self._energy_groups.num_groups) + max_depth = 5 + # check we have a numpy list + check_iterable_type("scatter", scatter, expected_type=Real, + max_depth=max_depth) + if scatter.shape == shape: + self._scatter = np.copy(scatter) + else: + msg = 'Shape of provided scatter "{0}" does not match shape ' \ + 'required, "{1}"'.format(scatter.shape, shape) + raise ValueError(msg) + + def set_multiplicity(self, multiplicity, scatter=None, **kwargs): + if isinstance(multiplicity, openmc.mgxs.NuScatterMatrixXS): + if not isinstance(scatter, openmc.mgxs.ScatterMatrixXS): + msg = "Argument 'scatter' must be provided." + raise ValueError(msg) + # Make sure passed MGXS objects contain correct group structure + if self.energy_groups != multiplicity.energy_groups: + msg = 'Group structure of provided NuScatterMatrixXS does not ' \ + 'match group structure of XSdata object' + raise ValueError(msg) + if self.energy_groups != scatter.energy_groups: + msg = 'Group structure of provided ScatterMatrixXS does not ' \ + 'match group structure of XSdata object' + raise ValueError(msg) + # Get openmc.mgxs.get_xs() arguments from kwargs + # nuclides, xs_type, and value will have sane defaults but can be + # overridden by kwards + if 'nuclides' in kwargs: + nuclides = kwargs['nuclides'] + else: + nuclides = 'sum' + if 'xs_type' in kwargs: + xs_type = kwargs['xs_type'] + else: + xs_type = 'macro' + if 'value' in kwargs: + value = kwargs['value'] + else: + value = 'mean' + # subdomains is required from the kwargs as this is specific to + # this XSdata object. + if 'subdomains' in kwargs: + subdomains = kwargs['subdomains'] + else: + msg = "Argument 'subdomains' is required" + raise ValueError(msg) + + if self._representation is 'isotropic': + nuscatt = multiplicity.get_xs(subdomains=subdomains, + nuclides=nuclides, + xs_type=xs_type, + value=value) + scatt = scatter.get_xs(subdomains=subdomains, + nuclides=nuclides, + xs_type=xs_type, + value=value) + self._multiplicity = np.divide(nuscatt, scatt) + elif self._representation is 'angle': + # Not yet implemented as MGXS do not yet support this + pass + + else: + if self._representation is 'isotropic': + shape = (self._energy_groups.num_groups, + self._energy_groups.num_groups) + max_depth = 2 + elif self._representation is 'angle': + shape = (self._num_polar, self._num_azimuthal, + self._energy_groups.num_groups, + self._energy_groups.num_groups) + max_depth = 4 + # check we have a numpy list + check_iterable_type("multiplicity", multiplicity, expected_type=Real, + max_depth=max_depth) + if multiplicity.shape == shape: + self._multiplicity = np.copy(multiplicity) + else: + msg = 'Shape of provided multiplicity "{0}" does not match shape' \ + ' required, "{1}"'.format(multiplicity.shape, shape) + raise ValueError(msg) + + def set_nu_fission(self, nu_fission, **kwargs): + # The NuFissionXS class does not have the capability to produce + # a fission matrix and therefore if this path is pursued, we know + # chi must be used. + if isinstance(nu_fission, openmc.mgxs.NuFissionXS): + # Make sure passed MGXS object contains correct group structure + if self.energy_groups != nu_fission.energy_groups: + msg = 'Group structure of provided NuFissionXS does not match'\ + ' group structure of XSdata object' + raise ValueError(msg) + # Get openmc.mgxs.get_xs() arguments from kwargs + # nuclides, xs_type, and value will have sane defaults but can be + # overridden by kwards + if 'nuclides' in kwargs: + nuclides = kwargs['nuclides'] + else: + nuclides = 'sum' + if 'xs_type' in kwargs: + xs_type = kwargs['xs_type'] + else: + xs_type = 'macro' + if 'value' in kwargs: + value = kwargs['value'] + else: + value = 'mean' + # subdomains is required from the kwargs as this is specific to + # this XSdata object. + if 'subdomains' in kwargs: + subdomains = kwargs['subdomains'] + else: + msg = "Argument 'subdomains' is required" + raise ValueError(msg) + + if self._representation is 'isotropic': + self._nu_fission = nu_fission.get_xs(subdomains=subdomains, + nuclides=nuclides, + xs_type=xs_type, + value=value) + elif self._representation is 'angle': + # Not yet implemented as MGXS do not yet support this + pass + + self._use_chi = True + + else: + # nu_fission can be given as a vector or a matrix + # Vector is used when chi also exists. + # Matrix is used when chi does not exist. + # We have to check that the correct form is given, but only if + # chi already has been set. If not, we just check that this is OK + # and set the use_chi flag accordingly + + # First lets set our dimensions here since they get used repeatedly + # throughout this code. + if self._representation is 'isotropic': + shape_vec = (self._energy_groups.num_groups,) + shape_mat = (self._energy_groups.num_groups, + self._energy_groups.num_groups) + elif self._representation is 'angle': + shape_vec = (self._num_polar, self._num_azimuthal, + self._energy_groups.num_groups) + shape_mat = (self._num_polar, self._num_azimuthal, + self._energy_groups.num_groups, + self._energy_groups.num_groups) + + # Begin by checking the case when chi has already been given and + # thus the rules for filling in nu_fission are set. + if self._use_chi is not None: + if self._use_chi: + shape = shape_vec + else: + shape = shape_mat + if nu_fission.shape != shape: + msg = "Invalid Shape of Nu_fission!" + raise ValueError(msg) + else: + # Get shape of nu_fission to determine if we need chi or not + if nu_fission.shape == shape_vec: + self._use_chi = True + elif nu_fission.shape == shape_mat: + self._use_chi = False + else: + msg = "Invalid Shape of Nu_fission!" + raise ValueError(msg) + + # check we have a numpy list + check_type("nu_fission", nu_fission, np.ndarray, + expected_iter_type=Real) + self._nu_fission = np.copy(nu_fission) + if np.sum(self._nu_fission) > 0.0: + self._fissionable = True + def _get_xsdata_xml(self): element = ET.Element("xsdata") element.set("name", self._name) @@ -649,7 +1157,8 @@ class XSdata(object): class MGXSLibrary(object): """Multi-Group Cross Sections file used for an OpenMC simulation. - Corresponds directly to the MG version of the cross_sections.xml input file. + Corresponds directly to the MG version of the cross_sections.xml input + file. Attributes ---------- @@ -684,7 +1193,7 @@ class MGXSLibrary(object): @energy_groups.setter def energy_groups(self, energy_groups): - check_type("energy groups", energy_groups, EnergyGroups) + check_type("energy groups", energy_groups, openmc.mgxs.EnergyGroups) self._energy_groups = energy_groups def add_xsdata(self, xsdata): @@ -721,8 +1230,8 @@ class MGXSLibrary(object): """ if not isinstance(xsdatas, Iterable): - msg = 'Unable to create OpenMC xsdatas.xml file from "{0}" which ' \ - 'is not iterable'.format(xsdatas) + msg = 'Unable to create OpenMC xsdatas.xml file from "{0}" which' \ + ' is not iterable'.format(xsdatas) raise ValueError(msg) for xsdata in xsdatas: @@ -793,4 +1302,4 @@ class MGXSLibrary(object): # Write the XML Tree to the xsdatas.xml file tree = ET.ElementTree(self._cross_sections_file) tree.write(filename, xml_declaration=True, - encoding='utf-8', method="xml") + encoding='utf-8', method="xml") diff --git a/openmc/settings.py b/openmc/settings.py index ec38bf54c3..e64935d7aa 100644 --- a/openmc/settings.py +++ b/openmc/settings.py @@ -70,9 +70,10 @@ class Settings(object): deviation. cross_sections : str Indicates the path to an XML cross section listing file (usually named - cross_sections.xml). If it is not set, the :envvar:`CROSS_SECTIONS` - environment variable will be used for continuous-energy calculations - and :envvar:`MG_CROSS_SECTIONS` will be used for multi-group + cross_sections.xml). If it is not set, the + :envvar:`OPENMC_CROSS_SECTIONS` environment variable will be used for + continuous-energy calculations and + :envvar:`OPENMC_MG_CROSS_SECTIONS` will be used for multi-group calculations to find the path to the XML cross section file. energy_grid : {'nuclide', 'logarithm', 'material-union'} Set the method used to search energy grids. From e1f70b40d40fcc302c833bb6a1349846f4cbcd65 Mon Sep 17 00:00:00 2001 From: Adam Nelson Date: Sun, 1 May 2016 10:23:20 -0400 Subject: [PATCH 02/20] Incorporated ability to transfer from Library to MGXS_Library. Didnt test yet. --- openmc/mgxs/library.py | 168 +++++++++++++++++++++++++++++++++++++ openmc/mgxs_library.py | 184 ++++++++++++++++++++--------------------- 2 files changed, 260 insertions(+), 92 deletions(-) diff --git a/openmc/mgxs/library.py b/openmc/mgxs/library.py index f3bf2018dc..7e6f07ce21 100644 --- a/openmc/mgxs/library.py +++ b/openmc/mgxs/library.py @@ -4,6 +4,8 @@ import copy import pickle from numbers import Integral from collections import OrderedDict +import numpy as np +import warnings.warn as warn import openmc import openmc.mgxs @@ -712,3 +714,169 @@ class Library(object): # Load and return pickled Library object return pickle.load(open(full_filename, 'rb')) + + def write_mg_library(self, xs_type='micro', domain_names=None, xs_ids=None, + filename='mg_cross_sections', directory='./'): + """Create a cross-section data library file for the Multi-Group + mode of OpenMC. + + Parameters + ---------- + xs_type: {'macro', 'micro'} + Provide the macro or micro cross section in units of cm^-1 or + barns. Defaults to 'macro'. If the Library object is not tallied by + nuclide this will be set to 'macro' regardless + domain_names : Iterable of str + List of names to apply to the xsdata entries in the + resultant mgxs data file. Defaults to "set1", "set2", ... + xs_ids : str or Iterable of str + Cross section set identifier (i.e., "71c") for all + data sets (if only str) or for each individual one + (if iterable of str). Defaults to '1g' + filename : str + Filename for the pickle file. Defaults to 'mg_cross_sections'. + directory : str + Directory for the pickle file. Defaults to './' (the + current working directory). + + See also + -------- + Library.dump_to_file(mgxs_lib, filename, directory) + + """ + + # Check data types provided + + cv.check_value('xs_type', xs_type, ['macro', 'micro']) + if not self.by_nuclide: + xs_type = 'macro' + if domain_names is not None: + cv.check_iterable_type('domain_names', filename, basestring) + if xs_ids is not None: + if isinstance(xs_ids, basestring): + # If we only have a string lets convert it now to a list + # of strings. + xs_ids = [xs_ids for i in range(len(self.domains))] + else: + cv.check_iterable_type('xs_ids', xs_ids, basestring) + else: + xs_ids = ['.1g'] + cv.check_type('filename', filename, basestring) + cv.check_type('directory', directory, basestring) + + # Make directory if it does not exist + if not os.path.exists(directory): + os.makedirs(directory) + + full_filename = os.path.join(directory, filename + '.xml') + full_filename = full_filename.replace(' ', '-') + + # Initialize file + mgxs_file = openmc.MGXSLibrary(self.energy_groups) + + # Set the scattering order as isotropic until + # support for higher orders are included + order = 0 + + # Build XSdata objects + xsdatas = [] + for i in range(len(self.domains)): + id = self.domains[i].id + if not self.by_nuclide: + # Use k instead of i simply because k will be used for + # the nuclide index in the else part of this conditional + # and using k allows us to use the same code. + k = i + # Build & add metadata to XSdata object + # (Use i here because k in nuclides will add chars to this) + if domain_names is None: + name = 'set' + str(i + 1) + else: + name = domain_names[i] + name += xs_ids[k] + xsdata = openmc.XSdata(name, self.energy_groups) + xsdata.order = order + + # Now get xs data itself + if 'total' in self.mgxs_types: + xsdata.set_total(self.all_mgxs[id]['total'], + xs_type=xs_type, subdomains=(k + 1,)) + if 'absorption' in self.mgxs_types: + xsdata.set_absorption(self.all_mgxs[id]['absorption'], + xs_type=xs_type, subdomains=(k + 1,)) + if 'fission' in self.mgxs_types: + xsdata.set_fission(self.all_mgxs[id]['fission'], + xs_type=xs_type, subdomains=(k + 1,)) + if 'kappa-fission' in self.mgxs_types: + xsdata.set_k_fission(self.all_mgxs[id]['kappa-fission'], + xs_type=xs_type, subdomains=(k + 1,)) + if 'chi' in self.mgxs_types: + xsdata.set_chi(self.all_mgxs[id]['chi'], + xs_type=xs_type, subdomains=(k + 1,)) + if 'nu-fission' in self.mgxs_types: + xsdata.set_nu_fission(self.all_mgxs[id]['nu-fission'], + xs_type=xs_type, subdomains=(k + 1,)) + # multiplicity requires scatter and nu-scatter + if (('scatter' in self.mgxs_types) and ('nu-scatter' in + self.mgxs_types)): + xsdata.set_multiplicity(self.all_mgxs[id]['nu-scatter'], + self.all_mgxs[id]['scatter'], + xs_type=xs_type, + subdomains=(k + 1,)) + using_multiplicity = True + else: + using_multiplicity = False + + if using_multiplicity: + xsdata.set_scatter(self.all_mgxs[id]['scatter'], + xs_type=xs_type, + subdomains=(k + 1,)) + else: + if 'nu-scatter' in self.mgxs_types: + xsdata.set_scatter(self.all_mgxs[id]['nu-scatter'], + xs_type=xs_type, + subdomains=(k + 1,)) + # Since we are not using multiplicity, then + # scattering multiplication (nu-scatter) must be + # accounted for approximately by using an adjusted + # absorption cross section. + if self.total is not None: + xsdata.absorption = \ + np.subtract(xsdata.total, + np.sum(xsdata.scatter[0, :, :], + axis=1)) + else: + # Total isnt included so we cant do the above + # approximation w/out changing absorption instead. + # That can be done with: + # SigA' = SigA - (nuSigS - SigS) + # Doing so would mean essentially duplicating + # set_scatter from MGXSLibrary to obtain the + # SigS, which would be big and ugly once + # angle filters are available. + # Instead, raise a warning about the + # lack of neutron balance and then use scatter + # instead of nu-scatter + if 'scatter' in self.mgxs_types: + msg = "To properly use the 'nu-scatter' " + \ + "MGXS type and maintain neutron " + \ + "balance, a 'total' MGXS type " + \ + "should be provided." + warn(msg) + xsdata.set_scatter( + self.all_mgxs[id]['scatter'], + xs_type=xs_type, subdomains=(k + 1,)) + else: + # Welp, cant do that either. Quit while ahead. + msg = "Total X/S must be provided if using" + \ + " nu-scatter as the scattering data" + raise ValueError(msg) + + xsdatas.append(xsdata) + else: + pass + + # Add XSdatas to file + + # Finally, write the file + mgxs_file.export_to_xml(full_filename) diff --git a/openmc/mgxs_library.py b/openmc/mgxs_library.py index b41a2030c4..eae6aa4c15 100644 --- a/openmc/mgxs_library.py +++ b/openmc/mgxs_library.py @@ -739,6 +739,98 @@ class XSdata(object): 'required, "{1}"'.format(fission.shape, shape) raise ValueError(msg) + def set_nu_fission(self, nu_fission, **kwargs): + # The NuFissionXS class does not have the capability to produce + # a fission matrix and therefore if this path is pursued, we know + # chi must be used. + if isinstance(nu_fission, openmc.mgxs.NuFissionXS): + # Make sure passed MGXS object contains correct group structure + if self.energy_groups != nu_fission.energy_groups: + msg = 'Group structure of provided NuFissionXS does not match'\ + ' group structure of XSdata object' + raise ValueError(msg) + # Get openmc.mgxs.get_xs() arguments from kwargs + # nuclides, xs_type, and value will have sane defaults but can be + # overridden by kwards + if 'nuclides' in kwargs: + nuclides = kwargs['nuclides'] + else: + nuclides = 'sum' + if 'xs_type' in kwargs: + xs_type = kwargs['xs_type'] + else: + xs_type = 'macro' + if 'value' in kwargs: + value = kwargs['value'] + else: + value = 'mean' + # subdomains is required from the kwargs as this is specific to + # this XSdata object. + if 'subdomains' in kwargs: + subdomains = kwargs['subdomains'] + else: + msg = "Argument 'subdomains' is required" + raise ValueError(msg) + + if self._representation is 'isotropic': + self._nu_fission = nu_fission.get_xs(subdomains=subdomains, + nuclides=nuclides, + xs_type=xs_type, + value=value) + elif self._representation is 'angle': + # Not yet implemented as MGXS do not yet support this + pass + + self._use_chi = True + + else: + # nu_fission can be given as a vector or a matrix + # Vector is used when chi also exists. + # Matrix is used when chi does not exist. + # We have to check that the correct form is given, but only if + # chi already has been set. If not, we just check that this is OK + # and set the use_chi flag accordingly + + # First lets set our dimensions here since they get used repeatedly + # throughout this code. + if self._representation is 'isotropic': + shape_vec = (self._energy_groups.num_groups,) + shape_mat = (self._energy_groups.num_groups, + self._energy_groups.num_groups) + elif self._representation is 'angle': + shape_vec = (self._num_polar, self._num_azimuthal, + self._energy_groups.num_groups) + shape_mat = (self._num_polar, self._num_azimuthal, + self._energy_groups.num_groups, + self._energy_groups.num_groups) + + # Begin by checking the case when chi has already been given and + # thus the rules for filling in nu_fission are set. + if self._use_chi is not None: + if self._use_chi: + shape = shape_vec + else: + shape = shape_mat + if nu_fission.shape != shape: + msg = "Invalid Shape of Nu_fission!" + raise ValueError(msg) + else: + # Get shape of nu_fission to determine if we need chi or not + if nu_fission.shape == shape_vec: + self._use_chi = True + elif nu_fission.shape == shape_mat: + self._use_chi = False + else: + msg = "Invalid Shape of Nu_fission!" + raise ValueError(msg) + + # check we have a numpy list + check_type("nu_fission", nu_fission, np.ndarray, + expected_iter_type=Real) + self._nu_fission = np.copy(nu_fission) + if np.sum(self._nu_fission) > 0.0: + self._fissionable = True + def set_k_fission(self, k_fission, **kwargs): if isinstance(k_fission, openmc.mgxs.KappaFissionXS): # Make sure passed MGXS object contains correct group structure @@ -986,98 +1078,6 @@ class XSdata(object): ' required, "{1}"'.format(multiplicity.shape, shape) raise ValueError(msg) - def set_nu_fission(self, nu_fission, **kwargs): - # The NuFissionXS class does not have the capability to produce - # a fission matrix and therefore if this path is pursued, we know - # chi must be used. - if isinstance(nu_fission, openmc.mgxs.NuFissionXS): - # Make sure passed MGXS object contains correct group structure - if self.energy_groups != nu_fission.energy_groups: - msg = 'Group structure of provided NuFissionXS does not match'\ - ' group structure of XSdata object' - raise ValueError(msg) - # Get openmc.mgxs.get_xs() arguments from kwargs - # nuclides, xs_type, and value will have sane defaults but can be - # overridden by kwards - if 'nuclides' in kwargs: - nuclides = kwargs['nuclides'] - else: - nuclides = 'sum' - if 'xs_type' in kwargs: - xs_type = kwargs['xs_type'] - else: - xs_type = 'macro' - if 'value' in kwargs: - value = kwargs['value'] - else: - value = 'mean' - # subdomains is required from the kwargs as this is specific to - # this XSdata object. - if 'subdomains' in kwargs: - subdomains = kwargs['subdomains'] - else: - msg = "Argument 'subdomains' is required" - raise ValueError(msg) - - if self._representation is 'isotropic': - self._nu_fission = nu_fission.get_xs(subdomains=subdomains, - nuclides=nuclides, - xs_type=xs_type, - value=value) - elif self._representation is 'angle': - # Not yet implemented as MGXS do not yet support this - pass - - self._use_chi = True - - else: - # nu_fission can be given as a vector or a matrix - # Vector is used when chi also exists. - # Matrix is used when chi does not exist. - # We have to check that the correct form is given, but only if - # chi already has been set. If not, we just check that this is OK - # and set the use_chi flag accordingly - - # First lets set our dimensions here since they get used repeatedly - # throughout this code. - if self._representation is 'isotropic': - shape_vec = (self._energy_groups.num_groups,) - shape_mat = (self._energy_groups.num_groups, - self._energy_groups.num_groups) - elif self._representation is 'angle': - shape_vec = (self._num_polar, self._num_azimuthal, - self._energy_groups.num_groups) - shape_mat = (self._num_polar, self._num_azimuthal, - self._energy_groups.num_groups, - self._energy_groups.num_groups) - - # Begin by checking the case when chi has already been given and - # thus the rules for filling in nu_fission are set. - if self._use_chi is not None: - if self._use_chi: - shape = shape_vec - else: - shape = shape_mat - if nu_fission.shape != shape: - msg = "Invalid Shape of Nu_fission!" - raise ValueError(msg) - else: - # Get shape of nu_fission to determine if we need chi or not - if nu_fission.shape == shape_vec: - self._use_chi = True - elif nu_fission.shape == shape_mat: - self._use_chi = False - else: - msg = "Invalid Shape of Nu_fission!" - raise ValueError(msg) - - # check we have a numpy list - check_type("nu_fission", nu_fission, np.ndarray, - expected_iter_type=Real) - self._nu_fission = np.copy(nu_fission) - if np.sum(self._nu_fission) > 0.0: - self._fissionable = True - def _get_xsdata_xml(self): element = ET.Element("xsdata") element.set("name", self._name) From 1f17718de845d70732485418de27ee307bb63de2 Mon Sep 17 00:00:00 2001 From: Adam Nelson Date: Sun, 1 May 2016 13:53:21 -0400 Subject: [PATCH 03/20] Tested, works (!!!!). Next up will be some useful features found during this testing --- openmc/mgxs/library.py | 32 ++++++++++++++++++-------------- openmc/mgxs_library.py | 14 ++++++++------ 2 files changed, 26 insertions(+), 20 deletions(-) diff --git a/openmc/mgxs/library.py b/openmc/mgxs/library.py index 7e6f07ce21..0ce7348b97 100644 --- a/openmc/mgxs/library.py +++ b/openmc/mgxs/library.py @@ -5,7 +5,7 @@ import pickle from numbers import Integral from collections import OrderedDict import numpy as np -import warnings.warn as warn +from warnings import warn import openmc import openmc.mgxs @@ -715,7 +715,7 @@ class Library(object): # Load and return pickled Library object return pickle.load(open(full_filename, 'rb')) - def write_mg_library(self, xs_type='micro', domain_names=None, xs_ids=None, + def write_mg_library(self, xs_type='macro', domain_names=None, xs_ids=None, filename='mg_cross_sections', directory='./'): """Create a cross-section data library file for the Multi-Group mode of OpenMC. @@ -725,7 +725,7 @@ class Library(object): xs_type: {'macro', 'micro'} Provide the macro or micro cross section in units of cm^-1 or barns. Defaults to 'macro'. If the Library object is not tallied by - nuclide this will be set to 'macro' regardless + nuclide this will be set to 'macro' regardless. domain_names : Iterable of str List of names to apply to the xsdata entries in the resultant mgxs data file. Defaults to "set1", "set2", ... @@ -760,7 +760,7 @@ class Library(object): else: cv.check_iterable_type('xs_ids', xs_ids, basestring) else: - xs_ids = ['.1g'] + xs_ids = ['1g'] cv.check_type('filename', filename, basestring) cv.check_type('directory', directory, basestring) @@ -781,6 +781,7 @@ class Library(object): # Build XSdata objects xsdatas = [] for i in range(len(self.domains)): + id = self.domains[i].id if not self.by_nuclide: # Use k instead of i simply because k will be used for @@ -793,7 +794,7 @@ class Library(object): name = 'set' + str(i + 1) else: name = domain_names[i] - name += xs_ids[k] + name += '.' + xs_ids[k] xsdata = openmc.XSdata(name, self.energy_groups) xsdata.order = order @@ -817,10 +818,10 @@ class Library(object): xsdata.set_nu_fission(self.all_mgxs[id]['nu-fission'], xs_type=xs_type, subdomains=(k + 1,)) # multiplicity requires scatter and nu-scatter - if (('scatter' in self.mgxs_types) and ('nu-scatter' in - self.mgxs_types)): - xsdata.set_multiplicity(self.all_mgxs[id]['nu-scatter'], - self.all_mgxs[id]['scatter'], + if ((('scatter matrix' in self.mgxs_types) and + ('nu-scatter matrix' in self.mgxs_types))): + xsdata.set_multiplicity(self.all_mgxs[id]['nu-scatter matrix'], + self.all_mgxs[id]['scatter matrix'], xs_type=xs_type, subdomains=(k + 1,)) using_multiplicity = True @@ -828,12 +829,12 @@ class Library(object): using_multiplicity = False if using_multiplicity: - xsdata.set_scatter(self.all_mgxs[id]['scatter'], + xsdata.set_scatter(self.all_mgxs[id]['scatter matrix'], xs_type=xs_type, subdomains=(k + 1,)) else: if 'nu-scatter' in self.mgxs_types: - xsdata.set_scatter(self.all_mgxs[id]['nu-scatter'], + xsdata.set_scatter(self.all_mgxs[id]['nu-scatter matrix'], xs_type=xs_type, subdomains=(k + 1,)) # Since we are not using multiplicity, then @@ -858,8 +859,9 @@ class Library(object): # lack of neutron balance and then use scatter # instead of nu-scatter if 'scatter' in self.mgxs_types: - msg = "To properly use the 'nu-scatter' " + \ - "MGXS type and maintain neutron " + \ + msg = "To properly use the " + \ + "'nu-scatter matrix' MGXS type " + \ + "and maintain neutron " + \ "balance, a 'total' MGXS type " + \ "should be provided." warn(msg) @@ -869,7 +871,8 @@ class Library(object): else: # Welp, cant do that either. Quit while ahead. msg = "Total X/S must be provided if using" + \ - " nu-scatter as the scattering data" + " 'nu-scatter matrix' as the " + \ + "scattering data" raise ValueError(msg) xsdatas.append(xsdata) @@ -877,6 +880,7 @@ class Library(object): pass # Add XSdatas to file + mgxs_file.add_xsdatas(xsdatas) # Finally, write the file mgxs_file.export_to_xml(full_filename) diff --git a/openmc/mgxs_library.py b/openmc/mgxs_library.py index eae6aa4c15..ef12c6c8ab 100644 --- a/openmc/mgxs_library.py +++ b/openmc/mgxs_library.py @@ -462,9 +462,10 @@ class XSdata(object): @chi.setter def chi(self, chi): - if not self._use_chi: - msg = 'Providing chi when nu_fission already provided as matrix!' - raise ValueError(msg) + if self._use_chi is not None: + if not self._use_chi: + msg = 'Providing chi when nu_fission already provided as matrix!' + raise ValueError(msg) if self._representation is 'isotropic': shape = (self._energy_groups.num_groups,) @@ -889,9 +890,10 @@ class XSdata(object): raise ValueError(msg) def set_chi(self, chi, **kwargs): - if not self._use_chi: - msg = 'Providing chi when nu_fission already provided as matrix!' - raise ValueError(msg) + if self._use_chi is not None: + if not self._use_chi: + msg = 'Providing chi when nu_fission already provided as matrix!' + raise ValueError(msg) if isinstance(chi, openmc.mgxs.Chi): # Make sure passed MGXS object contains correct group structure From 192523743f8519759f863362927eb8674950dce0 Mon Sep 17 00:00:00 2001 From: Adam Nelson Date: Sun, 1 May 2016 15:20:13 -0400 Subject: [PATCH 04/20] Implemented microscopic nuclidic writing for mgxs_library. May have exposed a bug in OpenMC, need to understand. --- openmc/mgxs/library.py | 177 +++++++++++++++++++++++++++++------------ 1 file changed, 125 insertions(+), 52 deletions(-) diff --git a/openmc/mgxs/library.py b/openmc/mgxs/library.py index 0ce7348b97..1e9156ce58 100644 --- a/openmc/mgxs/library.py +++ b/openmc/mgxs/library.py @@ -15,6 +15,11 @@ import openmc.checkvalue as cv if sys.version_info[0] >= 3: basestring = str +# The following represent the most accurate MGXS generation strategy +# for use in the MG mode of OpenMC. +OPENMC_MG_MGXS_TYPES = ['total', 'absorption', 'nu-fission', 'chi', + 'scatter matrix', 'nu-scatter matrix'] + class Library(object): """A multi-group cross section library for some energy group structure. @@ -748,7 +753,10 @@ class Library(object): # Check data types provided cv.check_value('xs_type', xs_type, ['macro', 'micro']) - if not self.by_nuclide: + # Construct the collection of the nuclides to report + if self.by_nuclide: + nuclides = self.all_mgxs[1][self.mgxs_types[-1]].get_all_nuclides() + else: xs_type = 'macro' if domain_names is not None: cv.check_iterable_type('domain_names', filename, basestring) @@ -781,62 +789,58 @@ class Library(object): # Build XSdata objects xsdatas = [] for i in range(len(self.domains)): - id = self.domains[i].id if not self.by_nuclide: - # Use k instead of i simply because k will be used for - # the nuclide index in the else part of this conditional - # and using k allows us to use the same code. - k = i # Build & add metadata to XSdata object # (Use i here because k in nuclides will add chars to this) if domain_names is None: name = 'set' + str(i + 1) else: name = domain_names[i] - name += '.' + xs_ids[k] + name += '.' + xs_ids[i] xsdata = openmc.XSdata(name, self.energy_groups) xsdata.order = order # Now get xs data itself if 'total' in self.mgxs_types: xsdata.set_total(self.all_mgxs[id]['total'], - xs_type=xs_type, subdomains=(k + 1,)) + xs_type=xs_type, subdomains=(i + 1,)) if 'absorption' in self.mgxs_types: xsdata.set_absorption(self.all_mgxs[id]['absorption'], - xs_type=xs_type, subdomains=(k + 1,)) + xs_type=xs_type, subdomains=(i + 1,)) if 'fission' in self.mgxs_types: xsdata.set_fission(self.all_mgxs[id]['fission'], - xs_type=xs_type, subdomains=(k + 1,)) + xs_type=xs_type, subdomains=(i + 1,)) if 'kappa-fission' in self.mgxs_types: xsdata.set_k_fission(self.all_mgxs[id]['kappa-fission'], - xs_type=xs_type, subdomains=(k + 1,)) + xs_type=xs_type, subdomains=(i + 1,)) if 'chi' in self.mgxs_types: xsdata.set_chi(self.all_mgxs[id]['chi'], - xs_type=xs_type, subdomains=(k + 1,)) + xs_type=xs_type, subdomains=(i + 1,)) if 'nu-fission' in self.mgxs_types: xsdata.set_nu_fission(self.all_mgxs[id]['nu-fission'], - xs_type=xs_type, subdomains=(k + 1,)) + xs_type=xs_type, subdomains=(i + 1,)) # multiplicity requires scatter and nu-scatter if ((('scatter matrix' in self.mgxs_types) and ('nu-scatter matrix' in self.mgxs_types))): - xsdata.set_multiplicity(self.all_mgxs[id]['nu-scatter matrix'], - self.all_mgxs[id]['scatter matrix'], - xs_type=xs_type, - subdomains=(k + 1,)) + xsdata.set_multiplicity( + self.all_mgxs[id]['nu-scatter matrix'], + self.all_mgxs[id]['scatter matrix'], + xs_type=xs_type, subdomains=(i + 1,)) + xsdata.multiplicity = np.nan_to_num(xsdata.multiplicity) using_multiplicity = True else: using_multiplicity = False if using_multiplicity: - xsdata.set_scatter(self.all_mgxs[id]['scatter matrix'], + xsdata.set_scatter(self.all_mgxs[id]['nu-scatter matrix'], xs_type=xs_type, - subdomains=(k + 1,)) + subdomains=(i + 1,)) else: - if 'nu-scatter' in self.mgxs_types: - xsdata.set_scatter(self.all_mgxs[id]['nu-scatter matrix'], - xs_type=xs_type, - subdomains=(k + 1,)) + if 'nu-scatter matrix' in self.mgxs_types: + xsdata.set_scatter( + self.all_mgxs[id]['nu-scatter matrix'], + xs_type=xs_type, subdomains=(i + 1,)) # Since we are not using multiplicity, then # scattering multiplication (nu-scatter) must be # accounted for approximately by using an adjusted @@ -846,41 +850,110 @@ class Library(object): np.subtract(xsdata.total, np.sum(xsdata.scatter[0, :, :], axis=1)) - else: - # Total isnt included so we cant do the above - # approximation w/out changing absorption instead. - # That can be done with: - # SigA' = SigA - (nuSigS - SigS) - # Doing so would mean essentially duplicating - # set_scatter from MGXSLibrary to obtain the - # SigS, which would be big and ugly once - # angle filters are available. - # Instead, raise a warning about the - # lack of neutron balance and then use scatter - # instead of nu-scatter - if 'scatter' in self.mgxs_types: - msg = "To properly use the " + \ - "'nu-scatter matrix' MGXS type " + \ - "and maintain neutron " + \ - "balance, a 'total' MGXS type " + \ - "should be provided." - warn(msg) - xsdata.set_scatter( - self.all_mgxs[id]['scatter'], - xs_type=xs_type, subdomains=(k + 1,)) - else: - # Welp, cant do that either. Quit while ahead. - msg = "Total X/S must be provided if using" + \ - " 'nu-scatter matrix' as the " + \ - "scattering data" - raise ValueError(msg) + else: + msg = "No nu-scatter matrix data was provided. " + \ + "This means neutron balance cannot be " + \ + "achieved since (n,xn) multiplication is " + \ + "ignored." + warn(msg) + xsdata.set_scatter(self.all_mgxs[id]['scatter matrix'], + xs_type=xs_type, + subdomains=(i + 1,)) xsdatas.append(xsdata) else: - pass + for nuclide in nuclides: + # Build & add metadata to XSdata object + if domain_names is None: + name = 'set' + str(i + 1) + else: + name = domain_names[i] + name += '_' + nuclide + name += '.' + xs_ids[i] + xsdata = openmc.XSdata(name, self.energy_groups) + xsdata.order = order + + # Now get xs data itself + if 'total' in self.mgxs_types: + xsdata.set_total(self.all_mgxs[id]['total'], + xs_type=xs_type, subdomains=(i + 1,), + nuclides=[nuclide]) + if 'absorption' in self.mgxs_types: + xsdata.set_absorption(self.all_mgxs[id]['absorption'], + xs_type=xs_type, + subdomains=(i + 1,), + nuclides=[nuclide]) + if 'fission' in self.mgxs_types: + xsdata.set_fission(self.all_mgxs[id]['fission'], + xs_type=xs_type, + subdomains=(i + 1,), + nuclides=[nuclide]) + if 'kappa-fission' in self.mgxs_types: + xsdata.set_k_fission( + self.all_mgxs[id]['kappa-fission'], + xs_type=xs_type, subdomains=(i + 1,), + nuclides=[nuclide]) + if 'chi' in self.mgxs_types: + xsdata.set_chi(self.all_mgxs[id]['chi'], + xs_type=xs_type, subdomains=(i + 1,), + nuclides=[nuclide]) + if 'nu-fission' in self.mgxs_types: + xsdata.set_nu_fission(self.all_mgxs[id]['nu-fission'], + xs_type=xs_type, + subdomains=(i + 1,), + nuclides=[nuclide]) + # multiplicity requires scatter and nu-scatter + if ((('scatter matrix' in self.mgxs_types) and + ('nu-scatter matrix' in self.mgxs_types))): + xsdata.set_multiplicity( + self.all_mgxs[id]['nu-scatter matrix'], + self.all_mgxs[id]['scatter matrix'], + xs_type=xs_type, subdomains=(i + 1,), + nuclides=[nuclide]) + xsdata.multiplicity = \ + np.nan_to_num(xsdata.multiplicity) + using_multiplicity = True + else: + using_multiplicity = False + + if using_multiplicity: + xsdata.set_scatter( + self.all_mgxs[id]['nu-scatter matrix'], + xs_type=xs_type, subdomains=(i + 1,), + nuclides=[nuclide]) + else: + if 'nu-scatter matrix' in self.mgxs_types: + xsdata.set_scatter( + self.all_mgxs[id]['nu-scatter matrix'], + xs_type=xs_type, subdomains=(i + 1,), + nuclides=[nuclide]) + # Since we are not using multiplicity, then + # scattering multiplication (nu-scatter) must be + # accounted for approximately by using an adjusted + # absorption cross section. + if self.total is not None: + xsdata.absorption = \ + np.subtract(xsdata.total, + np.sum(xsdata.scatter[0, :, :], + axis=1)) + else: + msg = "No nu-scatter matrix data was provided. " +\ + "This means neutron balance cannot be " + \ + "achieved since (n,xn) multiplication is " +\ + "ignored." + warn(msg) + xsdata.set_scatter( + self.all_mgxs[id]['scatter matrix'], + xs_type=xs_type, + subdomains=(i + 1,), + nuclides=[nuclide]) + + xsdatas.append(xsdata) # Add XSdatas to file mgxs_file.add_xsdatas(xsdatas) # Finally, write the file mgxs_file.export_to_xml(full_filename) + + From 2220fb02a7e65d2d03f16d5bbfce6233a24b1259 Mon Sep 17 00:00:00 2001 From: Adam Nelson Date: Tue, 3 May 2016 04:40:59 -0400 Subject: [PATCH 05/20] Added zaid and awr data to summary so that openmc.mgxs.Library can access that information and pass it forward to the outputted microscopic library. --- openmc/mgxs/library.py | 5 +++++ openmc/mgxs_library.py | 36 ++++++++++++++++++++++++++++++++++ openmc/summary.py | 16 +++++++++++++-- src/summary.F90 | 44 ++++++++++++++++++++++++++++++++++++++++++ 4 files changed, 99 insertions(+), 2 deletions(-) diff --git a/openmc/mgxs/library.py b/openmc/mgxs/library.py index 1e9156ce58..0ceb154b89 100644 --- a/openmc/mgxs/library.py +++ b/openmc/mgxs/library.py @@ -410,6 +410,7 @@ class Library(object): self._sp_filename = statepoint._f.filename self._openmc_geometry = statepoint.summary.openmc_geometry + self._nuclides = statepoint.summary.nuclides if statepoint.run_mode == 'k-eigenvalue': self._keff = statepoint.k_combined[0] @@ -872,6 +873,10 @@ class Library(object): name += '.' + xs_ids[i] xsdata = openmc.XSdata(name, self.energy_groups) xsdata.order = order + print(self._nuclides) + print(nuclide) + xsdata.zaid = self._nuclides[nuclide][0] + xsdata.awr = self._nuclides[nuclide][1] # Now get xs data itself if 'total' in self.mgxs_types: diff --git a/openmc/mgxs_library.py b/openmc/mgxs_library.py index ef12c6c8ab..9f16888c1f 100644 --- a/openmc/mgxs_library.py +++ b/openmc/mgxs_library.py @@ -204,6 +204,8 @@ class XSdata(object): self._energy_groups = energy_groups self._representation = representation self._alias = None + self._zaid = None + self._awr = None self._kT = None self._fissionable = False self._scatt_type = 'legendre' @@ -237,6 +239,14 @@ class XSdata(object): def alias(self): return self._alias + @property + def zaid(self): + return self._zaid + + @property + def awr(self): + return self._awr + @property def kT(self): return self._kT @@ -334,6 +344,20 @@ class XSdata(object): else: self._alias = self._name + @zaid.setter + def zaid(self, zaid): + # Check type and value + check_type("zaid", zaid, Integral) + check_greater_than("zaid", zaid, 0, equality=False) + self._zaid = zaid + + @awr.setter + def awr(self, awr): + # Check validity of type and that the awr value is > 0 + check_type("awr", awr, Real) + check_greater_than("awr", awr, 0.0, equality=False) + self._awr = awr + @kT.setter def kT(self, kT): # Check validity of type and that the kT value is >= 0 @@ -1092,6 +1116,18 @@ class XSdata(object): subelement = ET.SubElement(element, 'kT') subelement.text = str(self._kT) + if self._zaid is not None: + subelement = ET.SubElement(element, 'zaid') + subelement.text = str(self._zaid) + + if self._awr is not None: + subelement = ET.SubElement(element, 'awr') + subelement.text = str(self._awr) + + if self._kT is not None: + subelement = ET.SubElement(element, 'kT') + subelement.text = str(self._kT) + if self._fissionable is not None: subelement = ET.SubElement(element, 'fissionable') subelement.text = str(self._fissionable) diff --git a/openmc/summary.py b/openmc/summary.py index 9b1c451f39..f33397d724 100644 --- a/openmc/summary.py +++ b/openmc/summary.py @@ -38,6 +38,7 @@ class Summary(object): self._opencg_geometry = None self._read_metadata() + self._read_nuclides() self._read_geometry() self._read_tallies() @@ -55,8 +56,8 @@ class Summary(object): def _read_metadata(self): # Read OpenMC version self.version = [self._f['version_major'].value, - self._f['version_minor'].value, - self._f['version_release'].value] + self._f['version_minor'].value, + self._f['version_release'].value] # Read date and time self.date_and_time = self._f['date_and_time'][...] @@ -70,6 +71,17 @@ class Summary(object): self.gen_per_batch = self._f['gen_per_batch'].value self.n_procs = self._f['n_procs'].value + def _read_nuclides(self): + self.nuclides = {} + n_nuclides = self._f['nuclides/n_nuclides_total'].value + names = self._f['nuclides/names'].value + awrs = self._f['nuclides/awrs'].value + zaids = self._f['nuclides/zaids'].value + for n in range(n_nuclides): + name = names[n].decode() + name = name[:name.find('.')] + self.nuclides[name] = (zaids[n], awrs[n]) + def _read_geometry(self): # Read in and initialize the Materials and Geometry self._read_materials() diff --git a/src/summary.F90 b/src/summary.F90 index 4502058cad..9defcc92fd 100644 --- a/src/summary.F90 +++ b/src/summary.F90 @@ -68,6 +68,7 @@ contains "description", "Number of generations per batch") end if + call write_nuclides(file_id) call write_geometry(file_id) call write_materials(file_id) if (n_tallies > 0) then @@ -105,6 +106,49 @@ contains end subroutine write_header +!=============================================================================== +! WRITE_NUCLIDES +!=============================================================================== + + subroutine write_nuclides(file_id) + integer(HID_T), intent(in) :: file_id + integer(HID_T) :: nuclide_group + integer :: i + character(12), allocatable :: nucnames(:) + real(8), allocatable :: awrs(:) + integer, allocatable :: zaids(:) + + ! Use H5LT interface to write useful data from nuclide objects + nuclide_group = create_group(file_id, "nuclides") + call write_dataset(nuclide_group, "n_nuclides_total", n_nuclides_total) + + ! Build array of nuclide names, awrs, and zaids + allocate(nucnames(n_nuclides_total)) + allocate(awrs(n_nuclides_total)) + allocate(zaids(n_nuclides_total)) + do i = 1, n_nuclides_total + if (run_CE) then + nucnames(i) = xs_listings(nuclides(i) % listing) % alias + awrs(i) = nuclides(i) % awr + zaids(i) = nuclides(i) % zaid + else + nucnames(i) = xs_listings(nuclides_MG(i) % obj % listing) % alias + awrs(i) = nuclides_MG(i) % obj % awr + zaids(i) = nuclides_MG(i) % obj % zaid + end if + end do + + ! Write nuclide names, awrs and zaids + call write_dataset(nuclide_group, "names", nucnames) + call write_dataset(nuclide_group, "awrs", awrs) + call write_dataset(nuclide_group, "zaids", zaids) + + call close_group(nuclide_group) + + deallocate(nucnames, awrs, zaids) + + end subroutine write_nuclides + !=============================================================================== ! WRITE_GEOMETRY !=============================================================================== From 179e9ab147e505563d118ed58096b3d225160ffa Mon Sep 17 00:00:00 2001 From: Adam Nelson Date: Thu, 5 May 2016 20:08:42 -0400 Subject: [PATCH 06/20] Added ability to use transport-corrected x/s and cleaned up some comments --- openmc/mgxs/library.py | 144 +++++++++++++++++++++++++++++------------ openmc/mgxs_library.py | 5 +- 2 files changed, 106 insertions(+), 43 deletions(-) diff --git a/openmc/mgxs/library.py b/openmc/mgxs/library.py index 0ceb154b89..34221f707c 100644 --- a/openmc/mgxs/library.py +++ b/openmc/mgxs/library.py @@ -722,8 +722,9 @@ class Library(object): return pickle.load(open(full_filename, 'rb')) def write_mg_library(self, xs_type='macro', domain_names=None, xs_ids=None, - filename='mg_cross_sections', directory='./'): - """Create a cross-section data library file for the Multi-Group + filename='mg_cross_sections', directory='./', + return_names=True): + """Creates a cross-section data library file for the Multi-Group mode of OpenMC. Parameters @@ -744,6 +745,23 @@ class Library(object): directory : str Directory for the pickle file. Defaults to './' (the current working directory). + return_names : bool + Flag to indicate if the user would like the names of the + materials generated by this function returned with completion. + Defaults to True. + + Returns + ------- + mat_names : Iterable of str + Iterable of material names generated during this routine and + applies to the cross section library. Note this is returned if + the return_names parameter is provided. + + Raises + ------ + ValueError + When the Library object is initialized with insufficient types of + cross sections for the Library. See also -------- @@ -751,14 +769,8 @@ class Library(object): """ - # Check data types provided - + # Check the provided parameters cv.check_value('xs_type', xs_type, ['macro', 'micro']) - # Construct the collection of the nuclides to report - if self.by_nuclide: - nuclides = self.all_mgxs[1][self.mgxs_types[-1]].get_all_nuclides() - else: - xs_type = 'macro' if domain_names is not None: cv.check_iterable_type('domain_names', filename, basestring) if xs_ids is not None: @@ -769,14 +781,19 @@ class Library(object): else: cv.check_iterable_type('xs_ids', xs_ids, basestring) else: - xs_ids = ['1g'] + xs_ids = ['1g' for i in range(len(self.domains))] cv.check_type('filename', filename, basestring) cv.check_type('directory', directory, basestring) - # Make directory if it does not exist + # Construct the collection of the nuclides to report + if self.by_nuclide: + nuclides = self.all_mgxs[1][self.mgxs_types[-1]].get_all_nuclides() + else: + xs_type = 'macro' + + # Make directory if it does not exist and build our filename if not os.path.exists(directory): os.makedirs(directory) - full_filename = os.path.join(directory, filename + '.xml') full_filename = full_filename.replace(' ', '-') @@ -784,12 +801,15 @@ class Library(object): mgxs_file = openmc.MGXSLibrary(self.energy_groups) # Set the scattering order as isotropic until - # support for higher orders are included + # support for higher orders are included in openmc.mgxs order = 0 # Build XSdata objects xsdatas = [] + + mat_names = {} for i in range(len(self.domains)): + id = self.domains[i].id if not self.by_nuclide: # Build & add metadata to XSdata object @@ -802,32 +822,46 @@ class Library(object): xsdata = openmc.XSdata(name, self.energy_groups) xsdata.order = order + mat_names[id] = name + # Now get xs data itself - if 'total' in self.mgxs_types: + if 'transport' in self.mgxs_types: + if self.correction == 'P0': + xsdata.set_total(self.all_mgxs[id]['transport'], + xs_type=xs_type, subdomains=(id,)) + else: + msg = "The use of a transport cross section " + \ + "requires the correction attribute to be" + \ + "set to 'P0' to produce valid cross " + \ + "section libraries" + raise ValueError(msg) + elif 'total' in self.mgxs_types: xsdata.set_total(self.all_mgxs[id]['total'], - xs_type=xs_type, subdomains=(i + 1,)) + xs_type=xs_type, subdomains=(id,)) if 'absorption' in self.mgxs_types: xsdata.set_absorption(self.all_mgxs[id]['absorption'], - xs_type=xs_type, subdomains=(i + 1,)) + xs_type=xs_type, + subdomains=(id,)) if 'fission' in self.mgxs_types: xsdata.set_fission(self.all_mgxs[id]['fission'], - xs_type=xs_type, subdomains=(i + 1,)) + xs_type=xs_type, subdomains=(id,)) if 'kappa-fission' in self.mgxs_types: xsdata.set_k_fission(self.all_mgxs[id]['kappa-fission'], - xs_type=xs_type, subdomains=(i + 1,)) + xs_type=xs_type, subdomains=(id,)) if 'chi' in self.mgxs_types: xsdata.set_chi(self.all_mgxs[id]['chi'], - xs_type=xs_type, subdomains=(i + 1,)) + xs_type=xs_type, subdomains=(id,)) if 'nu-fission' in self.mgxs_types: xsdata.set_nu_fission(self.all_mgxs[id]['nu-fission'], - xs_type=xs_type, subdomains=(i + 1,)) + xs_type=xs_type, + subdomains=(id,)) # multiplicity requires scatter and nu-scatter if ((('scatter matrix' in self.mgxs_types) and ('nu-scatter matrix' in self.mgxs_types))): xsdata.set_multiplicity( self.all_mgxs[id]['nu-scatter matrix'], self.all_mgxs[id]['scatter matrix'], - xs_type=xs_type, subdomains=(i + 1,)) + xs_type=xs_type, subdomains=(id,)) xsdata.multiplicity = np.nan_to_num(xsdata.multiplicity) using_multiplicity = True else: @@ -836,21 +870,29 @@ class Library(object): if using_multiplicity: xsdata.set_scatter(self.all_mgxs[id]['nu-scatter matrix'], xs_type=xs_type, - subdomains=(i + 1,)) + subdomains=(id,)) else: if 'nu-scatter matrix' in self.mgxs_types: xsdata.set_scatter( self.all_mgxs[id]['nu-scatter matrix'], - xs_type=xs_type, subdomains=(i + 1,)) + xs_type=xs_type, subdomains=(id,)) # Since we are not using multiplicity, then # scattering multiplication (nu-scatter) must be # accounted for approximately by using an adjusted # absorption cross section. - if self.total is not None: + # We can not do this with a transport x/s so check + # for that. + if 'total' in self.mgxs_types: xsdata.absorption = \ np.subtract(xsdata.total, np.sum(xsdata.scatter[0, :, :], axis=1)) + else: + msg = "Absorption cross section must be " + \ + "provided if using a transport cross" + \ + " section and while not providing a " + \ + "scattering matrix" + raise ValueError(msg) else: msg = "No nu-scatter matrix data was provided. " + \ "This means neutron balance cannot be " + \ @@ -859,10 +901,11 @@ class Library(object): warn(msg) xsdata.set_scatter(self.all_mgxs[id]['scatter matrix'], xs_type=xs_type, - subdomains=(i + 1,)) + subdomains=(id,)) xsdatas.append(xsdata) else: + mat_names[id] = {} for nuclide in nuclides: # Build & add metadata to XSdata object if domain_names is None: @@ -871,41 +914,53 @@ class Library(object): name = domain_names[i] name += '_' + nuclide name += '.' + xs_ids[i] + + mat_names[id][nuclide] = name + xsdata = openmc.XSdata(name, self.energy_groups) xsdata.order = order - print(self._nuclides) - print(nuclide) xsdata.zaid = self._nuclides[nuclide][0] - xsdata.awr = self._nuclides[nuclide][1] + xsdata.awr = self._nuclides[nuclide][1] # Now get xs data itself - if 'total' in self.mgxs_types: + if 'transport' in self.mgxs_types: + if self.correction == 'P0': + xsdata.set_total(self.all_mgxs[id]['transport'], + xs_type=xs_type, subdomains=(id,), + nuclides=[nuclide]) + else: + msg = "The use of a transport cross section " + \ + "requires the correction attribute to be" + \ + "set to 'P0' to produce valid cross " + \ + "section libraries" + raise ValueError(msg) + elif 'total' in self.mgxs_types: xsdata.set_total(self.all_mgxs[id]['total'], - xs_type=xs_type, subdomains=(i + 1,), + xs_type=xs_type, subdomains=(id,), nuclides=[nuclide]) if 'absorption' in self.mgxs_types: xsdata.set_absorption(self.all_mgxs[id]['absorption'], xs_type=xs_type, - subdomains=(i + 1,), + subdomains=(id,), nuclides=[nuclide]) if 'fission' in self.mgxs_types: xsdata.set_fission(self.all_mgxs[id]['fission'], xs_type=xs_type, - subdomains=(i + 1,), + subdomains=(id,), nuclides=[nuclide]) if 'kappa-fission' in self.mgxs_types: xsdata.set_k_fission( self.all_mgxs[id]['kappa-fission'], - xs_type=xs_type, subdomains=(i + 1,), + xs_type=xs_type, subdomains=(id,), nuclides=[nuclide]) if 'chi' in self.mgxs_types: xsdata.set_chi(self.all_mgxs[id]['chi'], - xs_type=xs_type, subdomains=(i + 1,), + xs_type=xs_type, subdomains=(id,), nuclides=[nuclide]) if 'nu-fission' in self.mgxs_types: xsdata.set_nu_fission(self.all_mgxs[id]['nu-fission'], xs_type=xs_type, - subdomains=(i + 1,), + subdomains=(id,), nuclides=[nuclide]) # multiplicity requires scatter and nu-scatter if ((('scatter matrix' in self.mgxs_types) and @@ -913,7 +968,7 @@ class Library(object): xsdata.set_multiplicity( self.all_mgxs[id]['nu-scatter matrix'], self.all_mgxs[id]['scatter matrix'], - xs_type=xs_type, subdomains=(i + 1,), + xs_type=xs_type, subdomains=(id,), nuclides=[nuclide]) xsdata.multiplicity = \ np.nan_to_num(xsdata.multiplicity) @@ -924,23 +979,29 @@ class Library(object): if using_multiplicity: xsdata.set_scatter( self.all_mgxs[id]['nu-scatter matrix'], - xs_type=xs_type, subdomains=(i + 1,), + xs_type=xs_type, subdomains=(id,), nuclides=[nuclide]) else: if 'nu-scatter matrix' in self.mgxs_types: xsdata.set_scatter( self.all_mgxs[id]['nu-scatter matrix'], - xs_type=xs_type, subdomains=(i + 1,), + xs_type=xs_type, subdomains=(id,), nuclides=[nuclide]) # Since we are not using multiplicity, then # scattering multiplication (nu-scatter) must be # accounted for approximately by using an adjusted # absorption cross section. - if self.total is not None: + if 'total' in self.mgxs_types: xsdata.absorption = \ np.subtract(xsdata.total, np.sum(xsdata.scatter[0, :, :], axis=1)) + else: + msg = "Absorption cross section must be " + \ + "provided if using a transport cross" + \ + " section and while not providing a " + \ + "scattering matrix" + raise ValueError(msg) else: msg = "No nu-scatter matrix data was provided. " +\ "This means neutron balance cannot be " + \ @@ -950,7 +1011,7 @@ class Library(object): xsdata.set_scatter( self.all_mgxs[id]['scatter matrix'], xs_type=xs_type, - subdomains=(i + 1,), + subdomains=(id,), nuclides=[nuclide]) xsdatas.append(xsdata) @@ -961,4 +1022,5 @@ class Library(object): # Finally, write the file mgxs_file.export_to_xml(full_filename) - + if return_names: + return mat_names diff --git a/openmc/mgxs_library.py b/openmc/mgxs_library.py index 9f16888c1f..bae23b0bc6 100644 --- a/openmc/mgxs_library.py +++ b/openmc/mgxs_library.py @@ -602,10 +602,11 @@ class XSdata(object): self._fissionable = True def set_total(self, total, **kwargs): - if isinstance(total, openmc.mgxs.TotalXS): + if (isinstance(total, openmc.mgxs.TotalXS) or + isinstance(total, openmc.mgxs.TransportXS)): # Make sure passed MGXS object contains correct group structure if self.energy_groups != total.energy_groups: - msg = 'Group structure of provided TotalXS does not match' \ + msg = 'Group structure of provided data does not match' \ ' group structure of XSdata object' raise ValueError(msg) # Get openmc.mgxs.get_xs() arguments from kwargs From 7a671655865aefa8b99847cf843dc9b5fbd70514 Mon Sep 17 00:00:00 2001 From: Adam Nelson Date: Sat, 7 May 2016 14:36:32 -0400 Subject: [PATCH 07/20] Finished generating ipython notebook and incorporating in to docs --- .../pythonapi/examples/mgxs-part-iv.ipynb | 1871 +++++++++++++++++ .../pythonapi/examples/mgxs-part-iv.rst | 13 + docs/source/pythonapi/index.rst | 1 + openmc/summary.py | 1 + 4 files changed, 1886 insertions(+) create mode 100644 docs/source/pythonapi/examples/mgxs-part-iv.ipynb create mode 100644 docs/source/pythonapi/examples/mgxs-part-iv.rst diff --git a/docs/source/pythonapi/examples/mgxs-part-iv.ipynb b/docs/source/pythonapi/examples/mgxs-part-iv.ipynb new file mode 100644 index 0000000000..bc85af5c24 --- /dev/null +++ b/docs/source/pythonapi/examples/mgxs-part-iv.ipynb @@ -0,0 +1,1871 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This Notebook illustrates the use of the openmc.mgxs.Library class specifically for application in OpenMC's multi-group mode. This example notebook follows the same process as was done in MGXS Part III, but instead uses OpenMC as the multi-group solver. This Notebook illustrates the following features:\n", + "\n", + " Calculation of multi-group cross sections for a fuel assembly\n", + " Automated creation, manipulation and storage of MGXS with openmc.mgxs.Library\n", + " Validation of multi-group cross sections with OpenMC\n", + " Steady-state pin-by-pin fission rates comparison between Continuous-Energy mode and Multi-Group OpenMC.\n", + "\n", + "Note: This Notebook illustrates the use of Pandas DataFrames to containerize multi-group cross section data. We recommend using Pandas >v0.15.0 or later since OpenMC's Python API leverages the multi-indexing feature included in the most recent releases of Pandas.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Generate Input Files" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "import math\n", + "import pickle\n", + "\n", + "from IPython.display import Image\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import os\n", + "\n", + "import openmc\n", + "import openmc.mgxs\n", + "\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "First we need to define materials that will be used in the problem. Before defining a material, we must create nuclides that are used in the material." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# Instantiate some Nuclides\n", + "h1 = openmc.Nuclide('H-1')\n", + "b10 = openmc.Nuclide('B-10')\n", + "o16 = openmc.Nuclide('O-16')\n", + "u235 = openmc.Nuclide('U-235')\n", + "u238 = openmc.Nuclide('U-238')\n", + "zr90 = openmc.Nuclide('Zr-90')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "With the nuclides we defined, we will now create three materials for the fuel, water, and cladding of the fuel pins." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "# 1.6 enriched fuel\n", + "fuel = openmc.Material(name='1.6% Fuel')\n", + "fuel.set_density('g/cm3', 10.31341)\n", + "fuel.add_nuclide(u235, 3.7503e-4)\n", + "fuel.add_nuclide(u238, 2.2625e-2)\n", + "fuel.add_nuclide(o16, 4.6007e-2)\n", + "\n", + "# borated water\n", + "water = openmc.Material(name='Borated Water')\n", + "water.set_density('g/cm3', 0.740582)\n", + "water.add_nuclide(h1, 4.9457e-2)\n", + "water.add_nuclide(o16, 2.4732e-2)\n", + "water.add_nuclide(b10, 8.0042e-6)\n", + "\n", + "# zircaloy\n", + "zircaloy = openmc.Material(name='Zircaloy')\n", + "zircaloy.set_density('g/cm3', 6.55)\n", + "zircaloy.add_nuclide(zr90, 7.2758e-3)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "With our three materials, we can now create a Materials object that can be exported to an actual XML file." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# Instantiate a Materials object\n", + "materials_file = openmc.Materials((fuel, water, zircaloy))\n", + "materials_file.default_xs = '71c'\n", + "\n", + "# Export to \"materials.xml\"\n", + "materials_file.export_to_xml()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now let's move on to the geometry. This problem will be a square array of fuel pins and control rod guide tubes for which we can use OpenMC's lattice/universe feature. The basic universe will have three regions for the fuel, the clad, and the surrounding coolant. The first step is to create the bounding surfaces for fuel and clad, as well as the outer bounding surfaces of the problem." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# Create cylinders for the fuel and clad\n", + "fuel_outer_radius = openmc.ZCylinder(x0=0.0, y0=0.0, R=0.39218)\n", + "clad_outer_radius = openmc.ZCylinder(x0=0.0, y0=0.0, R=0.45720)\n", + "\n", + "# Create boundary planes to surround the geometry\n", + "min_x = openmc.XPlane(x0=-10.71, boundary_type='reflective')\n", + "max_x = openmc.XPlane(x0=+10.71, boundary_type='reflective')\n", + "min_y = openmc.YPlane(y0=-10.71, boundary_type='reflective')\n", + "max_y = openmc.YPlane(y0=+10.71, boundary_type='reflective')\n", + "min_z = openmc.ZPlane(z0=-10., boundary_type='reflective')\n", + "max_z = openmc.ZPlane(z0=+10., boundary_type='reflective')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "With the surfaces defined, we can now construct a fuel pin cell from cells that are defined by intersections of half-spaces created by the surfaces." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "# Create a Universe to encapsulate a fuel pin\n", + "fuel_pin_universe = openmc.Universe(name='1.6% Fuel Pin')\n", + "\n", + "# Create fuel Cell\n", + "fuel_cell = openmc.Cell(name='1.6% Fuel')\n", + "fuel_cell.fill = fuel\n", + "fuel_cell.region = -fuel_outer_radius\n", + "fuel_pin_universe.add_cell(fuel_cell)\n", + "\n", + "# Create a clad Cell\n", + "clad_cell = openmc.Cell(name='1.6% Clad')\n", + "clad_cell.fill = zircaloy\n", + "clad_cell.region = +fuel_outer_radius & -clad_outer_radius\n", + "fuel_pin_universe.add_cell(clad_cell)\n", + "\n", + "# Create a moderator Cell\n", + "moderator_cell = openmc.Cell(name='1.6% Moderator')\n", + "moderator_cell.fill = water\n", + "moderator_cell.region = +clad_outer_radius\n", + "fuel_pin_universe.add_cell(moderator_cell)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Likewise, we can construct a control rod guide tube with the same surfaces." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "# Create a Universe to encapsulate a control rod guide tube\n", + "guide_tube_universe = openmc.Universe(name='Guide Tube')\n", + "\n", + "# Create guide tube Cell\n", + "guide_tube_cell = openmc.Cell(name='Guide Tube Water')\n", + "guide_tube_cell.fill = water\n", + "guide_tube_cell.region = -fuel_outer_radius\n", + "guide_tube_universe.add_cell(guide_tube_cell)\n", + "\n", + "# Create a clad Cell\n", + "clad_cell = openmc.Cell(name='Guide Clad')\n", + "clad_cell.fill = zircaloy\n", + "clad_cell.region = +fuel_outer_radius & -clad_outer_radius\n", + "guide_tube_universe.add_cell(clad_cell)\n", + "\n", + "# Create a moderator Cell\n", + "moderator_cell = openmc.Cell(name='Guide Tube Moderator')\n", + "moderator_cell.fill = water\n", + "moderator_cell.region = +clad_outer_radius\n", + "guide_tube_universe.add_cell(moderator_cell)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Using the pin cell universe, we can construct a 17x17 rectangular lattice with a 1.26 cm pitch." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# Create fuel assembly Lattice\n", + "assembly = openmc.RectLattice(name='1.6% Fuel Assembly')\n", + "assembly.dimension = (17, 17)\n", + "assembly.pitch = (1.26, 1.26)\n", + "assembly.lower_left = [-1.26 * 17. / 2.0] * 2" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Next, we create a NumPy array of fuel pin and guide tube universes for the lattice." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# Create array indices for guide tube locations in lattice\n", + "template_x = np.array([5, 8, 11, 3, 13, 2, 5, 8, 11, 14, 2, 5, 8,\n", + " 11, 14, 2, 5, 8, 11, 14, 3, 13, 5, 8, 11])\n", + "template_y = np.array([2, 2, 2, 3, 3, 5, 5, 5, 5, 5, 8, 8, 8, 8,\n", + " 8, 11, 11, 11, 11, 11, 13, 13, 14, 14, 14])\n", + "\n", + "# Initialize an empty 17x17 array of the lattice universes\n", + "universes = np.empty((17, 17), dtype=openmc.Universe)\n", + "\n", + "# Fill the array with the fuel pin and guide tube universes\n", + "universes[:,:] = fuel_pin_universe\n", + "universes[template_x, template_y] = guide_tube_universe\n", + "\n", + "# Store the array of universes in the lattice\n", + "assembly.universes = universes" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "OpenMC requires that there is a \"root\" universe. Let us create a root cell that is filled by the pin cell universe and then assign it to the root universe." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "# Create root Cell\n", + "root_cell = openmc.Cell(name='root cell')\n", + "root_cell.fill = assembly\n", + "\n", + "# Add boundary planes\n", + "root_cell.region = +min_x & -max_x & +min_y & -max_y & +min_z & -max_z\n", + "\n", + "# Create root Universe\n", + "root_universe = openmc.Universe(universe_id=0, name='root universe')\n", + "root_universe.add_cell(root_cell)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We now must create a geometry that is assigned a root universe and export it to XML." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# Create Geometry and set root Universe\n", + "geometry = openmc.Geometry()\n", + "geometry.root_universe = root_universe\n", + "# Export to \"geometry.xml\"\n", + "geometry.export_to_xml()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "With the geometry and materials finished, we now just need to define simulation parameters. In this case, we will use 10 inactive batches and 40 active batches each with 2500 particles." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# OpenMC simulation parameters\n", + "batches = 200\n", + "inactive = 10\n", + "particles = 5000\n", + "\n", + "# Instantiate a Settings object\n", + "settings_file = openmc.Settings()\n", + "settings_file.batches = batches\n", + "settings_file.inactive = inactive\n", + "settings_file.particles = particles\n", + "settings_file.output = {'tallies': False}\n", + "\n", + "# Create an initial uniform spatial source distribution over fissionable zones\n", + "bounds = [-10.71, -10.71, -10, 10.71, 10.71, 10.]\n", + "uniform_dist = openmc.stats.Box(bounds[:3], bounds[3:], only_fissionable=True)\n", + "settings_file.source = openmc.source.Source(space=uniform_dist)\n", + "\n", + "# Export to \"settings.xml\"\n", + "settings_file.export_to_xml()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let us also create a Plots file that we can use to verify that our fuel assembly geometry was created successfully." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# Instantiate a Plot\n", + "plot = openmc.Plot(plot_id=1)\n", + "plot.filename = 'materials-xy'\n", + "plot.origin = [0, 0, 0]\n", + "plot.pixels = [250, 250]\n", + "plot.width = [-10.71*2, -10.71*2]\n", + "plot.color = 'mat'\n", + "\n", + "# Instantiate a Plots object, add Plot, and export to \"plots.xml\"\n", + "plot_file = openmc.Plots([plot])\n", + "plot_file.export_to_xml()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "With the plots.xml file, we can now generate and view the plot. OpenMC outputs plots in .ppm format, which can be converted into a compressed format like .png with the convert utility." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "0" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Run openmc in plotting mode\n", + "openmc.plot_geometry(output=False)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAPoAAAD6AgMAAAD1grKuAAAABGdBTUEAALGPC/xhBQAAACBjSFJN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\nVDE0OjIyOjAzLTA0OjAw01pE9wAAAABJRU5ErkJggg==\n", + "text/plain": [ + "" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Convert OpenMC's funky ppm to png\n", + "!convert materials-xy.ppm materials-xy.png\n", + "\n", + "# Display the materials plot inline\n", + "Image(filename='materials-xy.png')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As we can see from the plot, we have a nice array of fuel and guide tube pin cells with fuel, cladding, and water!\n", + "\n", + "# Create an MGXS Library\n", + "\n", + "Now we are ready to generate multi-group cross sections! First, let's define a 2-group structure using the built-in EnergyGroups class." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# Instantiate a 2-group EnergyGroups object\n", + "groups = openmc.mgxs.EnergyGroups()\n", + "groups.group_edges = np.array([0., 0.625e-6, 20.])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Next, we will instantiate an openmc.mgxs.Library for the energy groups with our the fuel assembly geometry." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# Initialize an 2-group MGXS Library for OpenMOC\n", + "mgxs_lib = openmc.mgxs.Library(geometry)\n", + "mgxs_lib.energy_groups = groups" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now, we must specify to the Library which types of cross sections to compute. OpenMC's multi-group mode can accept isotropic flux-weighted cross sections or angle-dependent cross sections, as well as supporting anisotropic scattering represented by either Legendre polynomials, histogram, or tabular angular distributions. At this time the MGXS Library class only supports the generation of isotropic flux-weighted cross sections and P0 scattering, so that is what will be used for this example. Therefore, we will create the following multi-group cross sections needed to run an OpenMC simulation to verify the accuracy of our cross sections: \"transport\", \"absorption\", \"nu-fission\", '\"fission\", \"nu-scatter matrix\", \"scatter matrix\", and \"chi\".\n", + "\"scatter matrix\" is needed in addition to \"nu-scatter matrix\" because OpenMC's multi-group mode can treat scattering multiplication (i.e., (n,xn) reactions)) explicitly instead of adjusting the absorption cross section to maintain neutron balance, and using this explicit treatment would require tallying of both types of scattering matrices." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# Specify multi-group cross section types to compute\n", + "mgxs_lib.mgxs_types = ['transport', 'absorption', 'nu-fission', 'fission',\n", + " 'nu-scatter matrix', 'scatter matrix', 'chi']" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we must specify the type of domain over which we would like the `Library` to compute multi-group cross sections. The domain type corresponds to the type of tally filter to be used in the tallies created to compute multi-group cross sections. At the present time, the `Library` supports \"material,\" \"cell,\" and \"universe\" domain types. We will use a \"cell\" domain type here to compute cross sections in each of the cells in the fuel assembly geometry.\n", + "\n", + "**Note:** By default, the `Library` class will instantiate `MGXS` objects for each and every domain (material, cell or universe) in the geometry of interest. However, one may specify a subset of these domains to the `Library.domains` property. In our case, we wish to compute multi-group cross sections in each and every cell since they will be needed in our downstream multi-group OpenMC calculation on the identical combinatorial geometry mesh." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "# Specify a \"cell\" domain type for the cross section tally filters\n", + "mgxs_lib.domain_type = \"cell\"\n", + "\n", + "# Specify the cell domains over which to compute multi-group cross sections\n", + "mgxs_lib.domains = geometry.get_all_material_cells()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We will instruct the library to not compute cross sections on a nuclide-by-nuclide basis, and instead to focus on generating material-specific macroscopic cross sections.\n", + "\n", + "**NOTE:** The default value of the `by_nuclide` parameter is `False`, so the following step is not necessary but is included for illustrative purposes." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# Do not compute cross sections on a nuclide-by-nuclide basis\n", + "mgxs_lib.by_nuclide = False" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Lastly, we use the `Library` to construct the tallies needed to compute all of the requested multi-group cross sections in each domain and nuclide." + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# Construct all tallies needed for the multi-group cross section library\n", + "mgxs_lib.build_library()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The tallies can now be export to a \"tallies.xml\" input file for OpenMC.\n", + "\n", + "**NOTE:** At this point the `Library` has constructed nearly 100 distinct Tally objects. The overhead to tally in OpenMC scales as O(N) for N tallies, which can become a bottleneck for large tally datasets. To compensate for this, the Python API's `Tally`, `Filter` and `Tallies` classes allow for the smart merging of tallies when possible. The `Library` class supports this runtime optimization with the use of the optional `merge` parameter (`False` by default) for the `Library.add_to_tallies_file(...)` method, as shown below." + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# Create a \"tallies.xml\" file for the MGXS Library\n", + "tallies_file = openmc.Tallies()\n", + "mgxs_lib.add_to_tallies_file(tallies_file, merge=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In addition, we instantiate a fission rate mesh tally to compare with the multi-group result." + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# Instantiate a tally Mesh\n", + "mesh = openmc.Mesh(mesh_id=1)\n", + "mesh.type = 'regular'\n", + "mesh.dimension = [17, 17]\n", + "mesh.lower_left = [-10.71, -10.71]\n", + "mesh.upper_right = [+10.71, +10.71]\n", + "\n", + "# Instantiate tally Filter\n", + "mesh_filter = openmc.Filter()\n", + "mesh_filter.mesh = mesh\n", + "\n", + "# Instantiate the Tally\n", + "tally = openmc.Tally(name='mesh tally')\n", + "tally.filters = [mesh_filter]\n", + "tally.scores = ['fission']\n", + "\n", + "# Add tally to collection\n", + "tallies_file.append(tally)" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# Export all tallies to a \"tallies.xml\" file\n", + "tallies_file.export_to_xml()" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + " .d88888b. 888b d888 .d8888b.\n", + " d88P\" \"Y88b 8888b d8888 d88P Y88b\n", + " 888 888 88888b.d88888 888 888\n", + " 888 888 88888b. .d88b. 88888b. 888Y88888P888 888 \n", + " 888 888 888 \"88b d8P Y8b 888 \"88b 888 Y888P 888 888 \n", + " 888 888 888 888 88888888 888 888 888 Y8P 888 888 888\n", + " Y88b. .d88P 888 d88P Y8b. 888 888 888 \" 888 Y88b d88P\n", + " \"Y88888P\" 88888P\" \"Y8888 888 888 888 888 \"Y8888P\"\n", + "__________________888______________________________________________________\n", + " 888\n", + " 888\n", + "\n", + " Copyright: 2011-2016 Massachusetts Institute of Technology\n", + " License: http://openmc.readthedocs.org/en/latest/license.html\n", + " Version: 0.7.1\n", + " Git SHA1: 179e9ab147e505563d118ed58096b3d225160ffa\n", + " Date/Time: 2016-05-07 14:22:04\n", + " OpenMP Threads: 4\n", + "\n", + " ===========================================================================\n", + " ========================> INITIALIZATION <=========================\n", + " ===========================================================================\n", + "\n", + " Reading settings XML file...\n", + " Reading cross sections XML file...\n", + " Reading geometry XML file...\n", + " Reading materials XML file...\n", + " Reading tallies XML file...\n", + " Building neighboring cells lists for each surface...\n", + " Loading ACE cross section table: 92235.71c\n", + " Loading ACE cross section table: 92238.71c\n", + " Loading ACE cross section table: 8016.71c\n", + " Loading ACE cross section table: 1001.71c\n", + " Loading ACE cross section table: 5010.71c\n", + " Loading ACE cross section table: 40090.71c\n", + " Maximum neutron transport energy: 20.0000 MeV for 92235.71c\n", + " Initializing source particles...\n", + "\n", + " ===========================================================================\n", + " ====================> K EIGENVALUE SIMULATION <====================\n", + " ===========================================================================\n", + "\n", + " Bat./Gen. k Average k \n", + " ========= ======== ==================== \n", + " 1/1 1.05162 \n", + " 2/1 1.05369 \n", + " 3/1 1.02989 \n", + " 4/1 1.00126 \n", + " 5/1 1.03151 \n", + " 6/1 1.00183 \n", + " 7/1 0.99379 \n", + " 8/1 1.04193 \n", + " 9/1 1.01578 \n", + " 10/1 1.03349 \n", + " 11/1 1.03354 \n", + " 12/1 1.03646 1.03500 +/- 0.00146\n", + " 13/1 1.00873 1.02624 +/- 0.00880\n", + " 14/1 1.04263 1.03034 +/- 0.00745\n", + " 15/1 1.01556 1.02738 +/- 0.00648\n", + " 16/1 1.04897 1.03098 +/- 0.00640\n", + " 17/1 1.01796 1.02912 +/- 0.00572\n", + " 18/1 1.02276 1.02833 +/- 0.00502\n", + " 19/1 1.04003 1.02963 +/- 0.00461\n", + " 20/1 1.00695 1.02736 +/- 0.00471\n", + " 21/1 1.00012 1.02488 +/- 0.00493\n", + " 22/1 1.03580 1.02579 +/- 0.00459\n", + " 23/1 1.03427 1.02644 +/- 0.00427\n", + " 24/1 1.06024 1.02886 +/- 0.00463\n", + " 25/1 1.00742 1.02743 +/- 0.00454\n", + " 26/1 1.02556 1.02731 +/- 0.00425\n", + " 27/1 1.02207 1.02700 +/- 0.00401\n", + " 28/1 1.05847 1.02875 +/- 0.00416\n", + " 29/1 1.01125 1.02783 +/- 0.00404\n", + " 30/1 1.03213 1.02804 +/- 0.00384\n", + " 31/1 1.02241 1.02778 +/- 0.00366\n", + " 32/1 1.02675 1.02773 +/- 0.00349\n", + " 33/1 1.05484 1.02891 +/- 0.00354\n", + " 34/1 1.01893 1.02849 +/- 0.00341\n", + " 35/1 0.99044 1.02697 +/- 0.00361\n", + " 36/1 1.02602 1.02693 +/- 0.00347\n", + " 37/1 1.04107 1.02746 +/- 0.00338\n", + " 38/1 1.03237 1.02763 +/- 0.00326\n", + " 39/1 1.01489 1.02719 +/- 0.00318\n", + " 40/1 1.01065 1.02664 +/- 0.00312\n", + " 41/1 1.03722 1.02698 +/- 0.00304\n", + " 42/1 1.04339 1.02750 +/- 0.00298\n", + " 43/1 1.00921 1.02694 +/- 0.00294\n", + " 44/1 1.04576 1.02750 +/- 0.00291\n", + " 45/1 1.02580 1.02745 +/- 0.00283\n", + " 46/1 1.03464 1.02765 +/- 0.00275\n", + " 47/1 1.01552 1.02732 +/- 0.00270\n", + " 48/1 1.03357 1.02748 +/- 0.00263\n", + " 49/1 1.03439 1.02766 +/- 0.00257\n", + " 50/1 1.04281 1.02804 +/- 0.00253\n", + " 51/1 1.02902 1.02806 +/- 0.00247\n", + " 52/1 1.02245 1.02793 +/- 0.00241\n", + " 53/1 1.05271 1.02851 +/- 0.00243\n", + " 54/1 0.98630 1.02755 +/- 0.00256\n", + " 55/1 1.02690 1.02753 +/- 0.00250\n", + " 56/1 1.04107 1.02783 +/- 0.00246\n", + " 57/1 1.03029 1.02788 +/- 0.00241\n", + " 58/1 1.01874 1.02769 +/- 0.00237\n", + " 59/1 1.04211 1.02798 +/- 0.00234\n", + " 60/1 0.99584 1.02734 +/- 0.00238\n", + " 61/1 1.05166 1.02782 +/- 0.00238\n", + " 62/1 1.05572 1.02835 +/- 0.00239\n", + " 63/1 1.02694 1.02833 +/- 0.00235\n", + " 64/1 1.03314 1.02842 +/- 0.00231\n", + " 65/1 1.05850 1.02896 +/- 0.00233\n", + " 66/1 1.01100 1.02864 +/- 0.00231\n", + " 67/1 1.03784 1.02880 +/- 0.00227\n", + " 68/1 1.04084 1.02901 +/- 0.00224\n", + " 69/1 1.03932 1.02919 +/- 0.00221\n", + " 70/1 1.02564 1.02913 +/- 0.00218\n", + " 71/1 1.00027 1.02865 +/- 0.00219\n", + " 72/1 1.02385 1.02858 +/- 0.00216\n", + " 73/1 1.04885 1.02890 +/- 0.00215\n", + " 74/1 1.00298 1.02849 +/- 0.00215\n", + " 75/1 1.02009 1.02836 +/- 0.00212\n", + " 76/1 1.04505 1.02862 +/- 0.00211\n", + " 77/1 1.02889 1.02862 +/- 0.00207\n", + " 78/1 1.01306 1.02839 +/- 0.00206\n", + " 79/1 1.01817 1.02824 +/- 0.00203\n", + " 80/1 1.00533 1.02792 +/- 0.00203\n", + " 81/1 1.04439 1.02815 +/- 0.00201\n", + " 82/1 1.02212 1.02806 +/- 0.00199\n", + " 83/1 0.99419 1.02760 +/- 0.00201\n", + " 84/1 1.07132 1.02819 +/- 0.00207\n", + " 85/1 1.02710 1.02818 +/- 0.00204\n", + " 86/1 1.01702 1.02803 +/- 0.00202\n", + " 87/1 1.02134 1.02794 +/- 0.00200\n", + " 88/1 1.05231 1.02826 +/- 0.00200\n", + " 89/1 1.05290 1.02857 +/- 0.00200\n", + " 90/1 1.05751 1.02893 +/- 0.00200\n", + " 91/1 1.03970 1.02906 +/- 0.00198\n", + " 92/1 0.99678 1.02867 +/- 0.00200\n", + " 93/1 1.04471 1.02886 +/- 0.00198\n", + " 94/1 1.00820 1.02862 +/- 0.00198\n", + " 95/1 1.05823 1.02896 +/- 0.00198\n", + " 96/1 1.05118 1.02922 +/- 0.00198\n", + " 97/1 1.03617 1.02930 +/- 0.00196\n", + " 98/1 1.00585 1.02904 +/- 0.00195\n", + " 99/1 1.06663 1.02946 +/- 0.00198\n", + " 100/1 1.01802 1.02933 +/- 0.00196\n", + " 101/1 1.02695 1.02931 +/- 0.00194\n", + " 102/1 1.01642 1.02917 +/- 0.00192\n", + " 103/1 1.02567 1.02913 +/- 0.00190\n", + " 104/1 1.03519 1.02919 +/- 0.00188\n", + " 105/1 1.02439 1.02914 +/- 0.00186\n", + " 106/1 1.03779 1.02923 +/- 0.00184\n", + " 107/1 1.01304 1.02906 +/- 0.00183\n", + " 108/1 1.02541 1.02903 +/- 0.00181\n", + " 109/1 1.04297 1.02917 +/- 0.00180\n", + " 110/1 1.00442 1.02892 +/- 0.00180\n", + " 111/1 1.03102 1.02894 +/- 0.00178\n", + " 112/1 1.00380 1.02870 +/- 0.00178\n", + " 113/1 1.04010 1.02881 +/- 0.00177\n", + " 114/1 1.01297 1.02865 +/- 0.00176\n", + " 115/1 1.00130 1.02839 +/- 0.00176\n", + " 116/1 1.02001 1.02831 +/- 0.00174\n", + " 117/1 1.03847 1.02841 +/- 0.00173\n", + " 118/1 1.00371 1.02818 +/- 0.00173\n", + " 119/1 1.02650 1.02817 +/- 0.00171\n", + " 120/1 1.00767 1.02798 +/- 0.00171\n", + " 121/1 1.00408 1.02776 +/- 0.00171\n", + " 122/1 1.00235 1.02754 +/- 0.00171\n", + " 123/1 1.01212 1.02740 +/- 0.00170\n", + " 124/1 1.03278 1.02745 +/- 0.00168\n", + " 125/1 1.00818 1.02728 +/- 0.00168\n", + " 126/1 1.02132 1.02723 +/- 0.00166\n", + " 127/1 1.03677 1.02731 +/- 0.00165\n", + " 128/1 1.04148 1.02743 +/- 0.00164\n", + " 129/1 1.01245 1.02730 +/- 0.00163\n", + " 130/1 1.04172 1.02742 +/- 0.00162\n", + " 131/1 1.04519 1.02757 +/- 0.00162\n", + " 132/1 1.02495 1.02755 +/- 0.00160\n", + " 133/1 0.99747 1.02731 +/- 0.00161\n", + " 134/1 1.02411 1.02728 +/- 0.00160\n", + " 135/1 1.05750 1.02752 +/- 0.00160\n", + " 136/1 1.02341 1.02749 +/- 0.00159\n", + " 137/1 1.02212 1.02745 +/- 0.00158\n", + " 138/1 1.03464 1.02750 +/- 0.00157\n", + " 139/1 1.05920 1.02775 +/- 0.00157\n", + " 140/1 1.01911 1.02768 +/- 0.00156\n", + " 141/1 1.03076 1.02771 +/- 0.00155\n", + " 142/1 1.03648 1.02777 +/- 0.00154\n", + " 143/1 1.00382 1.02759 +/- 0.00154\n", + " 144/1 1.00366 1.02741 +/- 0.00154\n", + " 145/1 1.01638 1.02733 +/- 0.00153\n", + " 146/1 1.02418 1.02731 +/- 0.00152\n", + " 147/1 0.99267 1.02706 +/- 0.00153\n", + " 148/1 1.02575 1.02705 +/- 0.00152\n", + " 149/1 0.98560 1.02675 +/- 0.00153\n", + " 150/1 1.02725 1.02675 +/- 0.00152\n", + " 151/1 1.03723 1.02683 +/- 0.00151\n", + " 152/1 1.00857 1.02670 +/- 0.00151\n", + " 153/1 1.00642 1.02656 +/- 0.00151\n", + " 154/1 1.03461 1.02661 +/- 0.00150\n", + " 155/1 1.00088 1.02643 +/- 0.00150\n", + " 156/1 1.02589 1.02643 +/- 0.00149\n", + " 157/1 1.02494 1.02642 +/- 0.00148\n", + " 158/1 1.03303 1.02646 +/- 0.00147\n", + " 159/1 1.02276 1.02644 +/- 0.00146\n", + " 160/1 1.03293 1.02648 +/- 0.00145\n", + " 161/1 1.04758 1.02662 +/- 0.00144\n", + " 162/1 1.01033 1.02652 +/- 0.00144\n", + " 163/1 1.03883 1.02660 +/- 0.00143\n", + " 164/1 1.00519 1.02646 +/- 0.00143\n", + " 165/1 1.05958 1.02667 +/- 0.00144\n", + " 166/1 1.03849 1.02675 +/- 0.00143\n", + " 167/1 1.02306 1.02672 +/- 0.00142\n", + " 168/1 1.02693 1.02672 +/- 0.00141\n", + " 169/1 1.02584 1.02672 +/- 0.00140\n", + " 170/1 0.99388 1.02651 +/- 0.00141\n", + " 171/1 0.99376 1.02631 +/- 0.00141\n", + " 172/1 1.00453 1.02618 +/- 0.00141\n", + " 173/1 1.04516 1.02629 +/- 0.00141\n", + " 174/1 1.02402 1.02628 +/- 0.00140\n", + " 175/1 0.99012 1.02606 +/- 0.00141\n", + " 176/1 1.02084 1.02603 +/- 0.00140\n", + " 177/1 1.03959 1.02611 +/- 0.00139\n", + " 178/1 1.01719 1.02606 +/- 0.00139\n", + " 179/1 1.01671 1.02600 +/- 0.00138\n", + " 180/1 1.03691 1.02606 +/- 0.00137\n", + " 181/1 1.04276 1.02616 +/- 0.00137\n", + " 182/1 1.02002 1.02613 +/- 0.00136\n", + " 183/1 1.03081 1.02615 +/- 0.00135\n", + " 184/1 1.02432 1.02614 +/- 0.00135\n", + " 185/1 1.02225 1.02612 +/- 0.00134\n", + " 186/1 1.04722 1.02624 +/- 0.00134\n", + " 187/1 0.98045 1.02598 +/- 0.00135\n", + " 188/1 1.02555 1.02598 +/- 0.00135\n", + " 189/1 1.03645 1.02604 +/- 0.00134\n", + " 190/1 1.00407 1.02592 +/- 0.00134\n", + " 191/1 1.03033 1.02594 +/- 0.00133\n", + " 192/1 1.04175 1.02603 +/- 0.00133\n", + " 193/1 1.00555 1.02592 +/- 0.00132\n", + " 194/1 1.00183 1.02578 +/- 0.00132\n", + " 195/1 1.04328 1.02588 +/- 0.00132\n", + " 196/1 1.03041 1.02590 +/- 0.00131\n", + " 197/1 1.04791 1.02602 +/- 0.00131\n", + " 198/1 1.01366 1.02596 +/- 0.00130\n", + " 199/1 1.04471 1.02605 +/- 0.00130\n", + " 200/1 1.02416 1.02604 +/- 0.00129\n", + " Creating state point statepoint.200.h5...\n", + "\n", + " ===========================================================================\n", + " ======================> SIMULATION FINISHED <======================\n", + " ===========================================================================\n", + "\n", + "\n", + " =======================> TIMING STATISTICS <=======================\n", + "\n", + " Total time for initialization = 1.4810E+00 seconds\n", + " Reading cross sections = 1.1600E+00 seconds\n", + " Total time in simulation = 9.8823E+01 seconds\n", + " Time in transport only = 9.8622E+01 seconds\n", + " Time in inactive batches = 2.1290E+00 seconds\n", + " Time in active batches = 9.6694E+01 seconds\n", + " Time synchronizing fission bank = 1.4000E-02 seconds\n", + " Sampling source sites = 1.1000E-02 seconds\n", + " SEND/RECV source sites = 3.0000E-03 seconds\n", + " Time accumulating tallies = 2.0000E-03 seconds\n", + " Total time for finalization = 0.0000E+00 seconds\n", + " Total time elapsed = 1.0031E+02 seconds\n", + " Calculation Rate (inactive) = 23485.2 neutrons/second\n", + " Calculation Rate (active) = 9824.81 neutrons/second\n", + "\n", + " ============================> RESULTS <============================\n", + "\n", + " k-effective (Collision) = 1.02505 +/- 0.00122\n", + " k-effective (Track-length) = 1.02604 +/- 0.00129\n", + " k-effective (Absorption) = 1.02501 +/- 0.00111\n", + " Combined k-effective = 1.02544 +/- 0.00091\n", + " Leakage Fraction = 0.00000 +/- 0.00000\n", + "\n" + ] + }, + { + "data": { + "text/plain": [ + "0" + ] + }, + "execution_count": 25, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Run OpenMC\n", + "openmc.run()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To make the files available and not be over-written when running the multi-group calculation, we will now rename the statepoint and summary files." + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# Move the StatePoint File\n", + "ce_spfile = './ce.h5'\n", + "os.rename('statepoint.' + str(batches) + '.h5', ce_spfile)\n", + "# Move the Summary file\n", + "ce_sumfile = './ce_summary.h5'\n", + "os.rename('summary.h5', ce_sumfile)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Tally Data Processing\n", + "\n", + "Our simulation ran successfully and created statepoint and summary output files. We begin our analysis by instantiating a `StatePoint` object." + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# Load the statepoint file\n", + "sp = openmc.StatePoint(ce_spfile)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Next we will save the value of keff from the continuous-energy calculation for later comparison" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "ce_keff = sp.k_combined" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In addition to the statepoint file, our simulation also created a summary file which encapsulates information about the materials and geometry. This is necessary for the `openmc.mgxs` module to properly process the tally data. We first create a `Summary` object and link it with the statepoint." + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "su = openmc.Summary(ce_sumfile)\n", + "sp.link_with_summary(su)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Next we will extract our fission distribution results from the statepoint for later comparison." + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "# Get the OpenMC fission rate mesh tally data\n", + "mesh_tally = sp.get_tally(name='mesh tally')\n", + "openmc_fission_rates = mesh_tally.get_values(scores=['fission'])\n", + "\n", + "# Reshape array to 2D for plotting\n", + "openmc_fission_rates.shape = (17,17)\n", + "\n", + "# Normalize to the average pin power\n", + "openmc_fission_rates /= np.mean(openmc_fission_rates)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The statepoint is now ready to be analyzed by the `Library`. We simply have to load the tallies from the statepoint into the `Library` and our `MGXS` objects will compute the cross sections for us under-the-hood." + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "# Initialize MGXS Library with OpenMC statepoint data\n", + "mgxs_lib.load_from_statepoint(sp)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The next step will be to prepare the input for OpenMC to use our newly created multi-group data." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Multi-Group OpenMC Calculation" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We will now use the `Library` to produce a multi-group cross section data set for use by the OpenMC multi-group solver. " + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/nelsonag/git/openmc/openmc/tallies.py:1996: RuntimeWarning: invalid value encountered in true_divide\n", + " self_rel_err = data['self']['std. dev.'] / data['self']['mean']\n", + "/home/nelsonag/git/openmc/openmc/tallies.py:1997: RuntimeWarning: invalid value encountered in true_divide\n", + " other_rel_err = data['other']['std. dev.'] / data['other']['mean']\n", + "/home/nelsonag/git/openmc/openmc/tallies.py:1998: RuntimeWarning: invalid value encountered in true_divide\n", + " new_tally._mean = data['self']['mean'] / data['other']['mean']\n" + ] + }, + { + "data": { + "text/plain": [ + "{10000: 'fuel.2g',\n", + " 10001: 'fuel_clad.2g',\n", + " 10002: 'fuel_mod.2g',\n", + " 10003: 'gt_inmod.2g',\n", + " 10004: 'gt_clad.2g',\n", + " 10005: 'gt_outmod.2g'}" + ] + }, + "execution_count": 32, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "mgxs_lib.write_mg_library(filename='mgxs', xs_type='macro',\n", + " domain_names=['fuel', 'fuel_clad', 'fuel_mod',\n", + " 'gt_inmod', 'gt_clad', 'gt_outmod'],\n", + " xs_ids='2g')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we will need to recreate similar xml files from above, beginning with materials.xml" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "# Instantiate our Macroscopic Data\n", + "fuel_macro = openmc.Macroscopic('fuel')\n", + "fuel_clad_macro = openmc.Macroscopic('fuel_clad')\n", + "fuel_mod_macro = openmc.Macroscopic('fuel_mod')\n", + "gt_inmod_macro = openmc.Macroscopic('gt_inmod')\n", + "gt_clad_macro = openmc.Macroscopic('gt_clad')\n", + "gt_outmod_macro = openmc.Macroscopic('gt_outmod')\n", + "\n", + "# Now define the materials\n", + "\n", + "# 1.6 enriched fuel UO2\n", + "fuel = openmc.Material(name='1.6% Fuel UO2')\n", + "fuel.set_density('macro', 1.0)\n", + "fuel.add_macroscopic(fuel_macro)\n", + "\n", + "# 1.6 enriched fuel cladding\n", + "fuel_clad = openmc.Material(name='1.6% Fuel Clad')\n", + "fuel_clad.set_density('macro', 1.0)\n", + "fuel_clad.add_macroscopic(fuel_clad_macro)\n", + "\n", + "# 1.6 enriched fuel moderator\n", + "fuel_mod = openmc.Material(name='1.6% Fuel Water')\n", + "fuel_mod.set_density('macro', 1.0)\n", + "fuel_mod.add_macroscopic(fuel_mod_macro)\n", + "\n", + "# Guide Tube Inner Moderator\n", + "gt_inmod = openmc.Material(name='GT Inner Water')\n", + "gt_inmod.set_density('macro', 1.0)\n", + "gt_inmod.add_macroscopic(gt_inmod_macro)\n", + "\n", + "# Guide Tube Cladding\n", + "gt_clad = openmc.Material(name='GT Clad')\n", + "gt_clad.set_density('macro', 1.0)\n", + "gt_clad.add_macroscopic(gt_clad_macro)\n", + "\n", + "# Guide Tube Outer Moderator\n", + "gt_outmod = openmc.Material(name='GT Outer Water')\n", + "gt_outmod.set_density('macro', 1.0)\n", + "gt_outmod.add_macroscopic(gt_outmod_macro)\n", + "\n", + "# Finally, instantiate our Materials object\n", + "materials_file = openmc.Materials((fuel, fuel_clad, fuel_mod,\n", + " gt_inmod, gt_clad, gt_outmod))\n", + "materials_file.default_xs = '2g'\n", + "\n", + "# Export to \"materials.xml\"\n", + "materials_file.export_to_xml()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "For our geometry files we will simply repeat what as done for continuous-energy mode, except change the cell fill (i.e., the material) to use our newly defined materials." + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "# Create a Universe to encapsulate a fuel pin\n", + "fuel_pin_universe = openmc.Universe(name='1.6% Fuel Pin')\n", + "\n", + "# Create fuel Cell\n", + "fuel_cell = openmc.Cell(name='1.6% Fuel')\n", + "fuel_cell.fill = fuel\n", + "fuel_cell.region = -fuel_outer_radius\n", + "fuel_pin_universe.add_cell(fuel_cell)\n", + "\n", + "# Create a clad Cell\n", + "clad_cell = openmc.Cell(name='1.6% Clad')\n", + "clad_cell.fill = fuel_clad\n", + "clad_cell.region = +fuel_outer_radius & -clad_outer_radius\n", + "fuel_pin_universe.add_cell(clad_cell)\n", + "\n", + "# Create a moderator Cell\n", + "moderator_cell = openmc.Cell(name='1.6% Moderator')\n", + "moderator_cell.fill = fuel_mod\n", + "moderator_cell.region = +clad_outer_radius\n", + "fuel_pin_universe.add_cell(moderator_cell)\n", + "\n", + "# Create a Universe to encapsulate a control rod guide tube\n", + "guide_tube_universe = openmc.Universe(name='Guide Tube')\n", + "\n", + "# Create guide tube Cell\n", + "guide_tube_cell = openmc.Cell(name='Guide Tube Water')\n", + "guide_tube_cell.fill = gt_inmod\n", + "guide_tube_cell.region = -fuel_outer_radius\n", + "guide_tube_universe.add_cell(guide_tube_cell)\n", + "\n", + "# Create a clad Cell\n", + "clad_cell = openmc.Cell(name='Guide Clad')\n", + "clad_cell.fill = gt_clad\n", + "clad_cell.region = +fuel_outer_radius & -clad_outer_radius\n", + "guide_tube_universe.add_cell(clad_cell)\n", + "\n", + "# Create a moderator Cell\n", + "moderator_cell = openmc.Cell(name='Guide Tube Moderator')\n", + "moderator_cell.fill = gt_outmod\n", + "moderator_cell.region = +clad_outer_radius\n", + "guide_tube_universe.add_cell(moderator_cell)\n", + "\n", + "# Create fuel assembly Lattice\n", + "assembly = openmc.RectLattice(name='1.6% Fuel Assembly')\n", + "assembly.dimension = (17, 17)\n", + "assembly.pitch = (1.26, 1.26)\n", + "assembly.lower_left = [-1.26 * 17. / 2.0] * 2\n", + "\n", + "# Create array indices for guide tube locations in lattice\n", + "template_x = np.array([5, 8, 11, 3, 13, 2, 5, 8, 11, 14, 2, 5, 8,\n", + " 11, 14, 2, 5, 8, 11, 14, 3, 13, 5, 8, 11])\n", + "template_y = np.array([2, 2, 2, 3, 3, 5, 5, 5, 5, 5, 8, 8, 8, 8,\n", + " 8, 11, 11, 11, 11, 11, 13, 13, 14, 14, 14])\n", + "\n", + "# Initialize an empty 17x17 array of the lattice universes\n", + "universes = np.empty((17, 17), dtype=openmc.Universe)\n", + "\n", + "# Fill the array with the fuel pin and guide tube universes\n", + "universes[:,:] = fuel_pin_universe\n", + "universes[template_x, template_y] = guide_tube_universe\n", + "\n", + "# Store the array of universes in the lattice\n", + "assembly.universes = universes\n", + "\n", + "# Create root Cell\n", + "root_cell = openmc.Cell(name='root cell')\n", + "root_cell.fill = assembly\n", + "\n", + "# Add boundary planes\n", + "root_cell.region = +min_x & -max_x & +min_y & -max_y & +min_z & -max_z\n", + "\n", + "# Create root Universe\n", + "root_universe = openmc.Universe(universe_id=0, name='root universe')\n", + "root_universe.add_cell(root_cell)\n", + "\n", + "# Create Geometry and set root Universe\n", + "geometry = openmc.Geometry()\n", + "geometry.root_universe = root_universe\n", + "# Export to \"geometry.xml\"\n", + "geometry.export_to_xml()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Next, we can make the changes we need to the settings file.\n", + "These changes are limited to telling OpenMC we will be running a multi-group calculation and pointing to the location of our multi-group cross section file." + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# Set the location of the cross sections file\n", + "settings_file.cross_sections = './mgxs.xml'\n", + "settings_file.energy_mode = 'multi-group'\n", + "\n", + "# Export to \"settings.xml\"\n", + "settings_file.export_to_xml()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Finally, lets tell OpenMC we want to tally fissions over a mesh for comparison. " + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# Instantiate a tally Mesh\n", + "mesh = openmc.Mesh(mesh_id=1)\n", + "mesh.type = 'regular'\n", + "mesh.dimension = [17, 17]\n", + "mesh.lower_left = [-10.71, -10.71]\n", + "mesh.upper_right = [+10.71, +10.71]\n", + "\n", + "# Instantiate tally Filter\n", + "mesh_filter = openmc.Filter()\n", + "mesh_filter.mesh = mesh\n", + "\n", + "# Instantiate the Tally\n", + "tally = openmc.Tally(name='mesh tally')\n", + "tally.filters = [mesh_filter]\n", + "tally.scores = ['fission']\n", + "\n", + "# Add tally to collection\n", + "tallies_file.append(tally)\n", + "\n", + "# Export all tallies to a \"tallies.xml\" file\n", + "tallies_file.export_to_xml()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Before we run the calculation we will close the StatePoint file (as we are about to over-write it), and then we can run the multi-group calculation." + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + " .d88888b. 888b d888 .d8888b.\n", + " d88P\" \"Y88b 8888b d8888 d88P Y88b\n", + " 888 888 88888b.d88888 888 888\n", + " 888 888 88888b. .d88b. 88888b. 888Y88888P888 888 \n", + " 888 888 888 \"88b d8P Y8b 888 \"88b 888 Y888P 888 888 \n", + " 888 888 888 888 88888888 888 888 888 Y8P 888 888 888\n", + " Y88b. .d88P 888 d88P Y8b. 888 888 888 \" 888 Y88b d88P\n", + " \"Y88888P\" 88888P\" \"Y8888 888 888 888 888 \"Y8888P\"\n", + "__________________888______________________________________________________\n", + " 888\n", + " 888\n", + "\n", + " Copyright: 2011-2016 Massachusetts Institute of Technology\n", + " License: http://openmc.readthedocs.org/en/latest/license.html\n", + " Version: 0.7.1\n", + " Git SHA1: 179e9ab147e505563d118ed58096b3d225160ffa\n", + " Date/Time: 2016-05-07 14:23:45\n", + " OpenMP Threads: 4\n", + "\n", + " ===========================================================================\n", + " ========================> INITIALIZATION <=========================\n", + " ===========================================================================\n", + "\n", + " Reading settings XML file...\n", + " Reading cross sections XML file...\n", + " Reading geometry XML file...\n", + " Reading materials XML file...\n", + " Reading tallies XML file...\n", + " Building neighboring cells lists for each surface...\n", + " Loading Cross Section Data...\n", + " Loading fuel.2g Data...\n", + " Loading fuel_clad.2g Data...\n", + " Loading fuel_mod.2g Data...\n", + " Loading gt_inmod.2g Data...\n", + " Loading gt_clad.2g Data...\n", + " Loading gt_outmod.2g Data...\n", + " Initializing source particles...\n", + "\n", + " ===========================================================================\n", + " ====================> K EIGENVALUE SIMULATION <====================\n", + " ===========================================================================\n", + "\n", + " Bat./Gen. k Average k \n", + " ========= ======== ==================== \n", + " 1/1 1.01863 \n", + " 2/1 1.02630 \n", + " 3/1 1.03077 \n", + " 4/1 0.99715 \n", + " 5/1 1.02328 \n", + " 6/1 1.02283 \n", + " 7/1 1.00540 \n", + " 8/1 1.02232 \n", + " 9/1 0.99782 \n", + " 10/1 1.00838 \n", + " 11/1 1.01803 \n", + " 12/1 1.02530 1.02167 +/- 0.00363\n", + " 13/1 1.00514 1.01616 +/- 0.00589\n", + " 14/1 0.98994 1.00960 +/- 0.00777\n", + " 15/1 1.01028 1.00974 +/- 0.00602\n", + " 16/1 1.04607 1.01580 +/- 0.00780\n", + " 17/1 1.03300 1.01825 +/- 0.00703\n", + " 18/1 1.03149 1.01991 +/- 0.00631\n", + " 19/1 0.98692 1.01624 +/- 0.00667\n", + " 20/1 1.05205 1.01982 +/- 0.00695\n", + " 21/1 1.01572 1.01945 +/- 0.00630\n", + " 22/1 1.02517 1.01993 +/- 0.00577\n", + " 23/1 1.00274 1.01861 +/- 0.00547\n", + " 24/1 1.04739 1.02066 +/- 0.00547\n", + " 25/1 1.01883 1.02054 +/- 0.00509\n", + " 26/1 1.02021 1.02052 +/- 0.00476\n", + " 27/1 1.04696 1.02207 +/- 0.00474\n", + " 28/1 1.02751 1.02238 +/- 0.00448\n", + " 29/1 1.09537 1.02622 +/- 0.00572\n", + " 30/1 1.03685 1.02675 +/- 0.00545\n", + " 31/1 0.99812 1.02539 +/- 0.00536\n", + " 32/1 1.02526 1.02538 +/- 0.00511\n", + " 33/1 1.05466 1.02665 +/- 0.00505\n", + " 34/1 1.04816 1.02755 +/- 0.00491\n", + " 35/1 1.00148 1.02651 +/- 0.00483\n", + " 36/1 1.02315 1.02638 +/- 0.00464\n", + " 37/1 1.05771 1.02754 +/- 0.00461\n", + " 38/1 1.01675 1.02715 +/- 0.00446\n", + " 39/1 1.03707 1.02749 +/- 0.00432\n", + " 40/1 1.01903 1.02721 +/- 0.00418\n", + " 41/1 1.00332 1.02644 +/- 0.00412\n", + " 42/1 1.02533 1.02641 +/- 0.00399\n", + " 43/1 0.98531 1.02516 +/- 0.00406\n", + " 44/1 1.00406 1.02454 +/- 0.00399\n", + " 45/1 1.01057 1.02414 +/- 0.00389\n", + " 46/1 1.02755 1.02424 +/- 0.00378\n", + " 47/1 1.02783 1.02433 +/- 0.00368\n", + " 48/1 1.00003 1.02369 +/- 0.00364\n", + " 49/1 1.00442 1.02320 +/- 0.00358\n", + " 50/1 1.03215 1.02342 +/- 0.00350\n", + " 51/1 1.01672 1.02326 +/- 0.00341\n", + " 52/1 1.03702 1.02359 +/- 0.00335\n", + " 53/1 1.02063 1.02352 +/- 0.00327\n", + " 54/1 1.04596 1.02403 +/- 0.00323\n", + " 55/1 1.01926 1.02392 +/- 0.00316\n", + " 56/1 1.03058 1.02407 +/- 0.00310\n", + " 57/1 1.06126 1.02486 +/- 0.00313\n", + " 58/1 1.06411 1.02568 +/- 0.00317\n", + " 59/1 1.03278 1.02582 +/- 0.00311\n", + " 60/1 1.04472 1.02620 +/- 0.00307\n", + " 61/1 1.00186 1.02572 +/- 0.00305\n", + " 62/1 1.01133 1.02545 +/- 0.00300\n", + " 63/1 1.03713 1.02567 +/- 0.00295\n", + " 64/1 1.01363 1.02544 +/- 0.00291\n", + " 65/1 0.98126 1.02464 +/- 0.00296\n", + " 66/1 1.01500 1.02447 +/- 0.00292\n", + " 67/1 1.02437 1.02447 +/- 0.00286\n", + " 68/1 1.05057 1.02492 +/- 0.00285\n", + " 69/1 1.04903 1.02533 +/- 0.00283\n", + " 70/1 1.02199 1.02527 +/- 0.00278\n", + " 71/1 1.00536 1.02494 +/- 0.00276\n", + " 72/1 1.01658 1.02481 +/- 0.00272\n", + " 73/1 1.00866 1.02455 +/- 0.00268\n", + " 74/1 1.01800 1.02445 +/- 0.00264\n", + " 75/1 0.99176 1.02395 +/- 0.00265\n", + " 76/1 1.03336 1.02409 +/- 0.00262\n", + " 77/1 1.02699 1.02413 +/- 0.00258\n", + " 78/1 1.01596 1.02401 +/- 0.00254\n", + " 79/1 1.02292 1.02400 +/- 0.00250\n", + " 80/1 1.04804 1.02434 +/- 0.00249\n", + " 81/1 0.99494 1.02393 +/- 0.00249\n", + " 82/1 1.02646 1.02396 +/- 0.00246\n", + " 83/1 1.01223 1.02380 +/- 0.00243\n", + " 84/1 1.02572 1.02383 +/- 0.00239\n", + " 85/1 1.02709 1.02387 +/- 0.00236\n", + " 86/1 1.00315 1.02360 +/- 0.00235\n", + " 87/1 1.01809 1.02353 +/- 0.00232\n", + " 88/1 1.01566 1.02342 +/- 0.00229\n", + " 89/1 1.01093 1.02327 +/- 0.00227\n", + " 90/1 1.02812 1.02333 +/- 0.00224\n", + " 91/1 1.02288 1.02332 +/- 0.00221\n", + " 92/1 1.04070 1.02353 +/- 0.00219\n", + " 93/1 1.03697 1.02370 +/- 0.00217\n", + " 94/1 1.03486 1.02383 +/- 0.00215\n", + " 95/1 1.06359 1.02430 +/- 0.00218\n", + " 96/1 1.04811 1.02457 +/- 0.00217\n", + " 97/1 1.01303 1.02444 +/- 0.00215\n", + " 98/1 1.01243 1.02430 +/- 0.00213\n", + " 99/1 1.03238 1.02439 +/- 0.00211\n", + " 100/1 1.02054 1.02435 +/- 0.00208\n", + " 101/1 1.00402 1.02413 +/- 0.00207\n", + " 102/1 1.03800 1.02428 +/- 0.00206\n", + " 103/1 1.02541 1.02429 +/- 0.00203\n", + " 104/1 1.06867 1.02476 +/- 0.00207\n", + " 105/1 1.03192 1.02484 +/- 0.00205\n", + " 106/1 1.00100 1.02459 +/- 0.00204\n", + " 107/1 1.01098 1.02445 +/- 0.00202\n", + " 108/1 1.02930 1.02450 +/- 0.00200\n", + " 109/1 1.02173 1.02447 +/- 0.00198\n", + " 110/1 1.01411 1.02437 +/- 0.00197\n", + " 111/1 1.03920 1.02452 +/- 0.00195\n", + " 112/1 1.01984 1.02447 +/- 0.00193\n", + " 113/1 1.03912 1.02461 +/- 0.00192\n", + " 114/1 1.04124 1.02477 +/- 0.00191\n", + " 115/1 1.04802 1.02499 +/- 0.00190\n", + " 116/1 1.04129 1.02515 +/- 0.00189\n", + " 117/1 1.03072 1.02520 +/- 0.00187\n", + " 118/1 1.05167 1.02544 +/- 0.00187\n", + " 119/1 0.99954 1.02521 +/- 0.00187\n", + " 120/1 1.00093 1.02499 +/- 0.00187\n", + " 121/1 1.04929 1.02520 +/- 0.00186\n", + " 122/1 1.04556 1.02539 +/- 0.00185\n", + " 123/1 1.03298 1.02545 +/- 0.00184\n", + " 124/1 1.01603 1.02537 +/- 0.00182\n", + " 125/1 1.03522 1.02546 +/- 0.00181\n", + " 126/1 1.05644 1.02572 +/- 0.00181\n", + " 127/1 1.03754 1.02582 +/- 0.00180\n", + " 128/1 1.01524 1.02573 +/- 0.00179\n", + " 129/1 1.01263 1.02562 +/- 0.00178\n", + " 130/1 0.99835 1.02540 +/- 0.00178\n", + " 131/1 1.01268 1.02529 +/- 0.00177\n", + " 132/1 1.03975 1.02541 +/- 0.00175\n", + " 133/1 1.00702 1.02526 +/- 0.00175\n", + " 134/1 1.02335 1.02525 +/- 0.00173\n", + " 135/1 1.04378 1.02539 +/- 0.00173\n", + " 136/1 1.04610 1.02556 +/- 0.00172\n", + " 137/1 1.02284 1.02554 +/- 0.00171\n", + " 138/1 1.05720 1.02578 +/- 0.00171\n", + " 139/1 1.00965 1.02566 +/- 0.00170\n", + " 140/1 1.03719 1.02575 +/- 0.00169\n", + " 141/1 1.02413 1.02574 +/- 0.00168\n", + " 142/1 1.03125 1.02578 +/- 0.00167\n", + " 143/1 1.03641 1.02586 +/- 0.00166\n", + " 144/1 1.02137 1.02582 +/- 0.00164\n", + " 145/1 1.01522 1.02575 +/- 0.00163\n", + " 146/1 1.05163 1.02594 +/- 0.00163\n", + " 147/1 1.03612 1.02601 +/- 0.00162\n", + " 148/1 1.03346 1.02606 +/- 0.00161\n", + " 149/1 1.02306 1.02604 +/- 0.00160\n", + " 150/1 1.01764 1.02598 +/- 0.00159\n", + " 151/1 1.01787 1.02592 +/- 0.00158\n", + " 152/1 1.03263 1.02597 +/- 0.00157\n", + " 153/1 1.01877 1.02592 +/- 0.00156\n", + " 154/1 1.02870 1.02594 +/- 0.00155\n", + " 155/1 1.03071 1.02597 +/- 0.00154\n", + " 156/1 1.04229 1.02609 +/- 0.00153\n", + " 157/1 1.03973 1.02618 +/- 0.00152\n", + " 158/1 1.02180 1.02615 +/- 0.00151\n", + " 159/1 1.01067 1.02604 +/- 0.00151\n", + " 160/1 1.02888 1.02606 +/- 0.00150\n", + " 161/1 1.01711 1.02600 +/- 0.00149\n", + " 162/1 1.01087 1.02590 +/- 0.00148\n", + " 163/1 1.01886 1.02586 +/- 0.00147\n", + " 164/1 1.02210 1.02583 +/- 0.00146\n", + " 165/1 1.04020 1.02593 +/- 0.00146\n", + " 166/1 1.03658 1.02600 +/- 0.00145\n", + " 167/1 1.03222 1.02603 +/- 0.00144\n", + " 168/1 1.03247 1.02608 +/- 0.00143\n", + " 169/1 0.99739 1.02590 +/- 0.00143\n", + " 170/1 1.02464 1.02589 +/- 0.00142\n", + " 171/1 1.04623 1.02601 +/- 0.00142\n", + " 172/1 1.04328 1.02612 +/- 0.00142\n", + " 173/1 1.00812 1.02601 +/- 0.00141\n", + " 174/1 1.01224 1.02593 +/- 0.00141\n", + " 175/1 1.00882 1.02582 +/- 0.00140\n", + " 176/1 1.01286 1.02574 +/- 0.00140\n", + " 177/1 1.02048 1.02571 +/- 0.00139\n", + " 178/1 1.04269 1.02581 +/- 0.00138\n", + " 179/1 1.05862 1.02601 +/- 0.00139\n", + " 180/1 1.02924 1.02603 +/- 0.00138\n", + " 181/1 1.01491 1.02596 +/- 0.00137\n", + " 182/1 1.04255 1.02606 +/- 0.00137\n", + " 183/1 0.99191 1.02586 +/- 0.00137\n", + " 184/1 1.00392 1.02573 +/- 0.00137\n", + " 185/1 1.02982 1.02576 +/- 0.00137\n", + " 186/1 1.02682 1.02576 +/- 0.00136\n", + " 187/1 1.01484 1.02570 +/- 0.00135\n", + " 188/1 1.02825 1.02572 +/- 0.00134\n", + " 189/1 0.98954 1.02551 +/- 0.00135\n", + " 190/1 1.00522 1.02540 +/- 0.00135\n", + " 191/1 1.03762 1.02547 +/- 0.00134\n", + " 192/1 1.02091 1.02544 +/- 0.00134\n", + " 193/1 1.04549 1.02555 +/- 0.00133\n", + " 194/1 1.05531 1.02572 +/- 0.00134\n", + " 195/1 1.01479 1.02566 +/- 0.00133\n", + " 196/1 1.01337 1.02559 +/- 0.00132\n", + " 197/1 0.99187 1.02541 +/- 0.00133\n", + " 198/1 1.01280 1.02534 +/- 0.00132\n", + " 199/1 1.00049 1.02521 +/- 0.00132\n", + " 200/1 1.01879 1.02518 +/- 0.00132\n", + " Creating state point statepoint.200.h5...\n", + "\n", + " ===========================================================================\n", + " ======================> SIMULATION FINISHED <======================\n", + " ===========================================================================\n", + "\n", + "\n", + " =======================> TIMING STATISTICS <=======================\n", + "\n", + " Total time for initialization = 6.3000E-02 seconds\n", + " Reading cross sections = 5.0000E-03 seconds\n", + " Total time in simulation = 7.3280E+01 seconds\n", + " Time in transport only = 7.3104E+01 seconds\n", + " Time in inactive batches = 1.1200E+00 seconds\n", + " Time in active batches = 7.2160E+01 seconds\n", + " Time synchronizing fission bank = 2.5000E-02 seconds\n", + " Sampling source sites = 1.8000E-02 seconds\n", + " SEND/RECV source sites = 7.0000E-03 seconds\n", + " Time accumulating tallies = 0.0000E+00 seconds\n", + " Total time for finalization = 0.0000E+00 seconds\n", + " Total time elapsed = 7.3353E+01 seconds\n", + " Calculation Rate (inactive) = 44642.9 neutrons/second\n", + " Calculation Rate (active) = 13165.2 neutrons/second\n", + "\n", + " ============================> RESULTS <============================\n", + "\n", + " k-effective (Collision) = 1.02597 +/- 0.00117\n", + " k-effective (Track-length) = 1.02518 +/- 0.00132\n", + " k-effective (Absorption) = 1.02581 +/- 0.00070\n", + " Combined k-effective = 1.02562 +/- 0.00068\n", + " Leakage Fraction = 0.00000 +/- 0.00000\n", + "\n" + ] + }, + { + "data": { + "text/plain": [ + "0" + ] + }, + "execution_count": 37, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Close the StatePoint File\n", + "sp._f.close()\n", + "\n", + "# Run the Multi-Group OpenMC Simulation\n", + "openmc.run()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Results Comparison\n", + "Now we can compare the multi-group and continuous-energy results.\n", + "\n", + "We will begin by loading the multi-group statepoint file we just finished writing and extracting the calculated keff." + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "# Load the last statepoint file and keff value\n", + "mgsp = openmc.StatePoint('statepoint.' + str(batches) + '.h5')\n", + "mgsu = openmc.Summary('summary.h5')\n", + "mgsp.link_with_summary(mgsu)\n", + "mg_keff = mgsp.k_combined" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Lets compare the two eigenvalues, including their bias" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Continuous-Energy keff = 1.025440\n", + "Multi-Group keff = 1.025621\n", + "bias [pcm]: -18.1\n" + ] + } + ], + "source": [ + "bias = 1.0E5 * (ce_keff[0] - mg_keff[0])\n", + "\n", + "print('Continuous-Energy keff = {0:1.6f}'.format(ce_keff[0]))\n", + "print('Multi-Group keff = {0:1.6f}'.format(mg_keff[0]))\n", + "print('bias [pcm]: {0:1.1f}'.format(bias))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We see quite good agreement with only an 18pcm difference between the two." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Flux and Pin Power Visualizations" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Next we will visualize the mesh tally results obtained from both the Continuous-Energy and Multi-Group OpenMC calculations.\n", + "\n", + "First, we extract volume-integrated fission rates from the Multi-Group calculation's mesh fission rate tally for each pin cell in the fuel assembly." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we can do the same for the Multi-Group results." + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "# Get the OpenMC fission rate mesh tally data\n", + "mg_mesh_tally = mgsp.get_tally(name='mesh tally')\n", + "mgopenmc_fission_rates = mg_mesh_tally.get_values(scores=['fission'])\n", + "\n", + "# Reshape array to 2D for plotting\n", + "mgopenmc_fission_rates.shape = (17,17)\n", + "\n", + "# Normalize to the average pin power\n", + "mgopenmc_fission_rates /= np.mean(mgopenmc_fission_rates)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we can easily use Matplotlib to visualize the two fission rates side-by-side." + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 41, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAADDCAYAAACS2+oqAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nRKQklNBFREpCCV1EpCSU0EVESuL/ASY96jLsHTMbAAAAAElFTkSuQmCC\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the CE fission rates in the left subplot\n", + "fig = plt.subplot(121)\n", + "plt.imshow(openmc_fission_rates, interpolation='none', cmap='jet')\n", + "plt.title('Continuous-Energy Fission Rates')\n", + "\n", + "# Plot the MG fission rates in the right subplot\n", + "fig2 = plt.subplot(122)\n", + "plt.imshow(mgopenmc_fission_rates, interpolation='none', cmap='jet')\n", + "plt.title('Multi-Group Fission Rates')\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": true + }, + "source": [ + "We also see very good agreement between the fission rate distributions." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.5.1" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/docs/source/pythonapi/examples/mgxs-part-iv.rst b/docs/source/pythonapi/examples/mgxs-part-iv.rst new file mode 100644 index 0000000000..e243255217 --- /dev/null +++ b/docs/source/pythonapi/examples/mgxs-part-iv.rst @@ -0,0 +1,13 @@ +.. _notebook_mgxs_part_iv: + +==================================================== +MGXS Part IV: Multi-Group Mode Cross-Section Library +==================================================== + +.. only:: html + + .. notebook:: mgxs-part-iv.ipynb + +.. only:: latex + + IPython notebooks must be viewed in the online HTML documentation. diff --git a/docs/source/pythonapi/index.rst b/docs/source/pythonapi/index.rst index 1631976e67..3c4899cd2b 100644 --- a/docs/source/pythonapi/index.rst +++ b/docs/source/pythonapi/index.rst @@ -26,6 +26,7 @@ Example Jupyter Notebooks examples/mgxs-part-i examples/mgxs-part-ii examples/mgxs-part-iii + examples/mgxs-part-iv ------------------------------------ :mod:`openmc` -- Basic Functionality diff --git a/openmc/summary.py b/openmc/summary.py index f33397d724..af164a12cf 100644 --- a/openmc/summary.py +++ b/openmc/summary.py @@ -41,6 +41,7 @@ class Summary(object): self._read_nuclides() self._read_geometry() self._read_tallies() + self._f.close() @property def openmc_geometry(self): From 187d332dc38e41814f75b3c87024a5524b38e5b3 Mon Sep 17 00:00:00 2001 From: Adam Nelson Date: Sat, 7 May 2016 14:40:57 -0400 Subject: [PATCH 08/20] Changed OPENMC_MG_MGXS_TYPES to use transport instead of total --- openmc/mgxs/library.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/openmc/mgxs/library.py b/openmc/mgxs/library.py index 34221f707c..d74c8ced3d 100644 --- a/openmc/mgxs/library.py +++ b/openmc/mgxs/library.py @@ -17,7 +17,7 @@ if sys.version_info[0] >= 3: # The following represent the most accurate MGXS generation strategy # for use in the MG mode of OpenMC. -OPENMC_MG_MGXS_TYPES = ['total', 'absorption', 'nu-fission', 'chi', +OPENMC_MG_MGXS_TYPES = ['transport', 'absorption', 'nu-fission', 'chi', 'scatter matrix', 'nu-scatter matrix'] From 3079b5f6df0eb7c5c1b86b11be67b35b3ff518fd Mon Sep 17 00:00:00 2001 From: Adam Nelson Date: Tue, 10 May 2016 04:45:02 -0400 Subject: [PATCH 09/20] Simplification of mgxs_library - not done yet --- openmc/mgxs_library.py | 703 +++++++++++------------------------------ 1 file changed, 191 insertions(+), 512 deletions(-) diff --git a/openmc/mgxs_library.py b/openmc/mgxs_library.py index bae23b0bc6..ba9ba75b05 100644 --- a/openmc/mgxs_library.py +++ b/openmc/mgxs_library.py @@ -99,6 +99,12 @@ class XSdata(object): Unique identifier for the xsdata object alias : str Separate unique identifier for the xsdata object + zaid : int + 1000*(atomic number) + mass number. As an example, the zaid of U-235 + would be 92235. + awr : float + Atomic-weight-ratio of an isotope. That is, the ratio of the mass + of the isotope to the mass of a single neutron. kT : float Temperature (in units of MeV). energy_groups : openmc.mgxs.EnergyGroups @@ -198,7 +204,7 @@ class XSdata(object): """ - def __init__(self, name, energy_groups, representation="isotropic"): + def __init__(self, name, energy_groups, representation='isotropic'): # Initialize class attributes self._name = name self._energy_groups = energy_groups @@ -319,15 +325,7 @@ class XSdata(object): @energy_groups.setter def energy_groups(self, energy_groups): # Check validity of energy_groups - check_type("energy_groups", energy_groups, openmc.mgxs.EnergyGroups) - - # Check that there are one or more groups - ng = energy_groups.num_groups - if ((ng is None) or (ng < 1)): - - msg = 'energy_groups object incorrectly initialized.' - raise ValueError(msg) - + check_type('energy_groups', energy_groups, openmc.mgxs.EnergyGroups) self._energy_groups = energy_groups @representation.setter @@ -347,48 +345,48 @@ class XSdata(object): @zaid.setter def zaid(self, zaid): # Check type and value - check_type("zaid", zaid, Integral) - check_greater_than("zaid", zaid, 0, equality=False) + check_type('zaid', zaid, Integral) + check_greater_than('zaid', zaid, 0, equality=False) self._zaid = zaid @awr.setter def awr(self, awr): # Check validity of type and that the awr value is > 0 - check_type("awr", awr, Real) - check_greater_than("awr", awr, 0.0, equality=False) + check_type('awr', awr, Real) + check_greater_than('awr', awr, 0.0, equality=False) self._awr = awr @kT.setter def kT(self, kT): # Check validity of type and that the kT value is >= 0 - check_type("kT", kT, Real) - check_greater_than("kT", kT, 0.0, equality=True) + check_type('kT', kT, Real) + check_greater_than('kT', kT, 0.0, equality=True) self._kT = kT @scatt_type.setter def scatt_type(self, scatt_type): # check to see it is of a valid type and value - check_value("scatt_type", scatt_type, ['legendre', 'histogram', + check_value('scatt_type', scatt_type, ['legendre', 'histogram', 'tabular']) self._scatt_type = scatt_type @order.setter def order(self, order): # Check type and value - check_type("order", order, Integral) - check_greater_than("order", order, 0, equality=True) + check_type('order', order, Integral) + check_greater_than('order', order, 0, equality=True) self._order = order @tabular_legendre.setter def tabular_legendre(self, tabular_legendre): # Check to make sure this is a dict and it has our keys with the # right values. - check_type("tabular_legendre", tabular_legendre, dict) + check_type('tabular_legendre', tabular_legendre, dict) if 'enable' in tabular_legendre: enable = tabular_legendre['enable'] check_type('enable', enable, bool) else: - msg = "enable must be provided in tabular_legendre" + msg = 'enable must be provided in tabular_legendre' raise ValueError(msg) if 'num_points' in tabular_legendre: num_points = tabular_legendre['num_points'] @@ -404,14 +402,14 @@ class XSdata(object): @num_polar.setter def num_polar(self, num_polar): # Make sure we have positive ints - check_value("num_polar", num_polar, Integral) - check_greater_than("num_polar", num_polar, 0) + check_value('num_polar', num_polar, Integral) + check_greater_than('num_polar', num_polar, 0) self._num_polar = num_polar @num_azimuthal.setter def num_azimuthal(self, num_azimuthal): - check_value("num_azimuthal", num_azimuthal, Integral) - check_greater_than("num_azimuthal", num_azimuthal, 0) + check_value('num_azimuthal', num_azimuthal, Integral) + check_greater_than('num_azimuthal', num_azimuthal, 0) self._num_azimuthal = num_azimuthal @total.setter @@ -422,7 +420,7 @@ class XSdata(object): shape = (self._num_polar, self._num_azimuthal, self._energy_groups.num_groups) # check we have a numpy list - check_type("total", total, np.ndarray, expected_iter_type=Real) + check_type('total', total, np.ndarray, expected_iter_type=Real) if total.shape == shape: self._total = np.copy(total) else: @@ -438,7 +436,7 @@ class XSdata(object): shape = (self._num_polar, self._num_azimuthal, self._energy_groups.num_groups) # check we have a numpy list - check_type("absorption", absorption, np.ndarray, + check_type('absorption', absorption, np.ndarray, expected_iter_type=Real) if absorption.shape == shape: self._absorption = np.copy(absorption) @@ -455,7 +453,7 @@ class XSdata(object): shape = (self._num_polar, self._num_azimuthal, self._energy_groups.num_groups) # check we have a numpy list - check_type("fission", fission, np.ndarray, expected_iter_type=Real) + check_type('fission', fission, np.ndarray, expected_iter_type=Real) if fission.shape == shape: self._fission = np.copy(fission) if np.sum(self._fission) > 0.0: @@ -473,7 +471,7 @@ class XSdata(object): shape = (self._num_polar, self._num_azimuthal, self._energy_groups.num_groups) # check we have a numpy list - check_type("k_fission", k_fission, np.ndarray, + check_type('k_fission', k_fission, np.ndarray, expected_iter_type=Real) if k_fission.shape == shape: self._k_fission = np.copy(k_fission) @@ -497,7 +495,7 @@ class XSdata(object): shape = (self._num_polar, self._num_azimuthal, self._energy_groups.num_groups) # check we have a numpy list - check_type("chi", chi, np.ndarray, expected_iter_type=Real) + check_type('chi', chi, np.ndarray, expected_iter_type=Real) if chi.shape == shape: self._chi = np.copy(chi) else: @@ -519,7 +517,7 @@ class XSdata(object): self._energy_groups.num_groups) max_depth = 5 # check we have a numpy list - check_iterable_type("scatter", scatter, expected_type=Real, + check_iterable_type('scatter', scatter, expected_type=Real, max_depth=max_depth) if scatter.shape == shape: self._scatter = np.copy(scatter) @@ -540,7 +538,7 @@ class XSdata(object): self._energy_groups.num_groups) max_depth = 4 # check we have a numpy list - check_iterable_type("multiplicity", multiplicity, expected_type=Real, + check_iterable_type('multiplicity', multiplicity, expected_type=Real, max_depth=max_depth) if multiplicity.shape == shape: self._multiplicity = np.copy(multiplicity) @@ -582,7 +580,7 @@ class XSdata(object): else: shape = shape_mat if nu_fission.shape != shape: - msg = "Invalid Shape of Nu_fission!" + msg = 'Invalid Shape of Nu_fission!' raise ValueError(msg) else: # Get shape of nu_fission to determine if we need chi or not @@ -591,523 +589,204 @@ class XSdata(object): elif nu_fission.shape == shape_mat: self._use_chi = False else: - msg = "Invalid Shape of Nu_fission!" + msg = 'Invalid Shape of Nu_fission!' raise ValueError(msg) # check we have a numpy list - check_type("nu_fission", nu_fission, np.ndarray, + check_type('nu_fission', nu_fission, np.ndarray, expected_iter_type=Real) self._nu_fission = np.copy(nu_fission) if np.sum(self._nu_fission) > 0.0: self._fissionable = True - def set_total(self, total, **kwargs): - if (isinstance(total, openmc.mgxs.TotalXS) or - isinstance(total, openmc.mgxs.TransportXS)): - # Make sure passed MGXS object contains correct group structure - if self.energy_groups != total.energy_groups: - msg = 'Group structure of provided data does not match' \ - ' group structure of XSdata object' - raise ValueError(msg) - # Get openmc.mgxs.get_xs() arguments from kwargs - # nuclides, xs_type, and value will have sane defaults but can be - # overridden by kwards - if 'nuclides' in kwargs: - nuclides = kwargs['nuclides'] - else: - nuclides = 'sum' - if 'xs_type' in kwargs: - xs_type = kwargs['xs_type'] - else: - xs_type = 'macro' - if 'value' in kwargs: - value = kwargs['value'] - else: - value = 'mean' - # subdomains is required from the kwargs as this is specific to - # this XSdata object. - if 'subdomains' in kwargs: - subdomains = kwargs['subdomains'] - else: - msg = "Argument 'subdomains' is required" - raise ValueError(msg) + def set_total(self, total, subdomain, nuclide='sum', xs_type='macro'): + if not isinstance(total, (openmc.mgxs.TotalXS, + openmc.mgxs.TransportXS)): + msg = 'Method must be passed an openmc.mgxs.TotalXS or ' \ + 'openmc.mgxs.TransportXS object' + raise TypeError(msg) - if self._representation is 'isotropic': - self._total = total.get_xs(subdomains=subdomains, - nuclides=nuclides, xs_type=xs_type, - value=value) - elif self._representation is 'angle': - # Not yet implemented as MGXS do not yet support this - pass + # Make sure passed MGXS object contains correct group structure + if self.energy_groups != total.energy_groups: + msg = 'Group structure of provided data does not match' \ + ' group structure of XSdata object' + raise ValueError(msg) - else: - if self._representation is 'isotropic': - shape = (self._energy_groups.num_groups,) - elif self._representation is 'angle': - shape = (self._num_polar, self._num_azimuthal, - self._energy_groups.num_groups) - # check we have a numpy list - check_type("total", total, np.ndarray, expected_iter_type=Real) - if total.shape == shape: - self._total = np.copy(total) - else: - msg = 'Shape of provided total "{0}" does not match shape ' \ - 'required, "{1}"'.format(total.shape, shape) - raise ValueError(msg) + if self._representation is 'isotropic': + self._total = total.get_xs(subdomain=subdomains, nuclides=nuclide, + xs_type=xs_type) + elif self._representation is 'angle': + msg = 'Angular-Dependent MGXS have not yet been implemented' + raise ValueError(msg) - def set_absorption(self, absorption, **kwargs): - if isinstance(absorption, openmc.mgxs.AbsorptionXS): - # Make sure passed MGXS object contains correct group structure - if self.energy_groups != absorption.energy_groups: - msg = 'Group structure of provided AbsorptionXS does not ' \ - ' match group structure of XSdata object' - raise ValueError(msg) - # Get openmc.mgxs.get_xs() arguments from kwargs - # nuclides, xs_type, and value will have sane defaults but can be - # overridden by kwards - if 'nuclides' in kwargs: - nuclides = kwargs['nuclides'] - else: - nuclides = 'sum' - if 'xs_type' in kwargs: - xs_type = kwargs['xs_type'] - else: - xs_type = 'macro' - if 'value' in kwargs: - value = kwargs['value'] - else: - value = 'mean' - # subdomains is required from the kwargs as this is specific to - # this XSdata object. - if 'subdomains' in kwargs: - subdomains = kwargs['subdomains'] - else: - msg = "Argument 'subdomains' is required" - raise ValueError(msg) + def set_absorption(self, absorption, subdomain, nuclide='sum', + xs_type='macro'): + if not isinstance(absorption, openmc.mgxs.AbsorptionXS): + msg = 'Method must be passed an openmc.mgxs.AbsorptionXS' + raise TypeError(msg) - if self._representation is 'isotropic': - self._absorption = absorption.get_xs(subdomains=subdomains, - nuclides=nuclides, - xs_type=xs_type, - value=value) - elif self._representation is 'angle': - # Not yet implemented as MGXS do not yet support this - pass + # Make sure passed MGXS object contains correct group structure + if self.energy_groups != absorption.energy_groups: + msg = 'Group structure of provided data does not match' \ + ' group structure of XSdata object' + raise ValueError(msg) - else: - if self._representation is 'isotropic': - shape = (self._energy_groups.num_groups,) - elif self._representation is 'angle': - shape = (self._num_polar, self._num_azimuthal, - self._energy_groups.num_groups) - # check we have a numpy list - check_type("absorption", absorption, np.ndarray, expected_iter_type=Real) - if absorption.shape == shape: - self._absorption = np.copy(absorption) - else: - msg = 'Shape of provided absorption "{0}" does not match shape ' \ - 'required, "{1}"'.format(absorption.shape, shape) - raise ValueError(msg) + if self._representation is 'isotropic': + self._absorption = absorption.get_xs(subdomains=subdomain, + nuclides=nuclide, + xs_type=xs_type) + elif self._representation is 'angle': + msg = 'Angular-Dependent MGXS have not yet been implemented' + raise ValueError(msg) - def set_fission(self, fission, **kwargs): - if isinstance(fission, openmc.mgxs.FissionXS): - # Make sure passed MGXS object contains correct group structure - if self.energy_groups != fission.energy_groups: - msg = 'Group structure of provided FissionXS does not match ' \ - 'group structure of XSdata object' - raise ValueError(msg) - # Get openmc.mgxs.get_xs() arguments from kwargs - # nuclides, xs_type, and value will have sane defaults but can be - # overridden by kwards - if 'nuclides' in kwargs: - nuclides = kwargs['nuclides'] - else: - nuclides = 'sum' - if 'xs_type' in kwargs: - xs_type = kwargs['xs_type'] - else: - xs_type = 'macro' - if 'value' in kwargs: - value = kwargs['value'] - else: - value = 'mean' - # subdomains is required from the kwargs as this is specific to - # this XSdata object. - if 'subdomains' in kwargs: - subdomains = kwargs['subdomains'] - else: - msg = "Argument 'subdomains' is required" - raise ValueError(msg) + def set_fission(self, fission, subdomain, nuclide='sum', xs_type='macro'): + if not isinstance(fission, openmc.mgxs.FissionXS): + msg = 'Method must be passed an openmc.mgxs.FissionXS' + raise TypeError(msg) - if self._representation is 'isotropic': - self._fission = fission.get_xs(subdomains=subdomains, - nuclides=nuclides, - xs_type=xs_type, - value=value) - elif self._representation is 'angle': - # Not yet implemented as MGXS do not yet support this - pass + # Make sure passed MGXS object contains correct group structure + if self.energy_groups != fission.energy_groups: + msg = 'Group structure of provided data does not match' \ + ' group structure of XSdata object' + raise ValueError(msg) - else: - if self._representation is 'isotropic': - shape = (self._energy_groups.num_groups,) - elif self._representation is 'angle': - shape = (self._num_polar, self._num_azimuthal, - self._energy_groups.num_groups) - # check we have a numpy list - check_type("fission", fission, np.ndarray, expected_iter_type=Real) - if fission.shape == shape: - self._fission = np.copy(fission) - if np.sum(self._fission) > 0.0: - self._fissionable = True - else: - msg = 'Shape of provided fission "{0}" does not match shape ' \ - 'required, "{1}"'.format(fission.shape, shape) - raise ValueError(msg) + if self._representation is 'isotropic': + self._fission = fission.get_xs(subdomains=subdomain, + nuclides=nuclide, + xs_type=xs_type) + elif self._representation is 'angle': + msg = 'Angular-Dependent MGXS have not yet been implemented' + raise ValueError(msg) - def set_nu_fission(self, nu_fission, **kwargs): + def set_nu_fission(self, nu_fission, subdomain, nuclide='sum', + xs_type='macro'): # The NuFissionXS class does not have the capability to produce # a fission matrix and therefore if this path is pursued, we know # chi must be used. - if isinstance(nu_fission, openmc.mgxs.NuFissionXS): - # Make sure passed MGXS object contains correct group structure - if self.energy_groups != nu_fission.energy_groups: - msg = 'Group structure of provided NuFissionXS does not match'\ - ' group structure of XSdata object' - raise ValueError(msg) - # Get openmc.mgxs.get_xs() arguments from kwargs - # nuclides, xs_type, and value will have sane defaults but can be - # overridden by kwards - if 'nuclides' in kwargs: - nuclides = kwargs['nuclides'] - else: - nuclides = 'sum' - if 'xs_type' in kwargs: - xs_type = kwargs['xs_type'] - else: - xs_type = 'macro' - if 'value' in kwargs: - value = kwargs['value'] - else: - value = 'mean' - # subdomains is required from the kwargs as this is specific to - # this XSdata object. - if 'subdomains' in kwargs: - subdomains = kwargs['subdomains'] - else: - msg = "Argument 'subdomains' is required" - raise ValueError(msg) + if not isinstance(nu_fission, openmc.mgxs.NuFissionXS): + msg = 'Method must be passed an openmc.mgxs.NuFissionXS' + raise TypeError(msg) - if self._representation is 'isotropic': - self._nu_fission = nu_fission.get_xs(subdomains=subdomains, - nuclides=nuclides, - xs_type=xs_type, - value=value) - elif self._representation is 'angle': - # Not yet implemented as MGXS do not yet support this - pass + # Make sure passed MGXS object contains correct group structure + if self.energy_groups != nu_fission.energy_groups: + msg = 'Group structure of provided data does not match' \ + ' group structure of XSdata object' + raise ValueError(msg) - self._use_chi = True + if self._representation is 'isotropic': + self._nu_fission = nu_fission.get_xs(subdomains=subdomain, + nuclides=nuclide, + xs_type=xs_type) + elif self._representation is 'angle': + msg = 'Angular-Dependent MGXS have not yet been implemented' + raise ValueError(msg) - else: - # nu_fission can be given as a vector or a matrix - # Vector is used when chi also exists. - # Matrix is used when chi does not exist. - # We have to check that the correct form is given, but only if - # chi already has been set. If not, we just check that this is OK - # and set the use_chi flag accordingly + self._use_chi = True - # First lets set our dimensions here since they get used repeatedly - # throughout this code. - if self._representation is 'isotropic': - shape_vec = (self._energy_groups.num_groups,) - shape_mat = (self._energy_groups.num_groups, - self._energy_groups.num_groups) - elif self._representation is 'angle': - shape_vec = (self._num_polar, self._num_azimuthal, - self._energy_groups.num_groups) - shape_mat = (self._num_polar, self._num_azimuthal, - self._energy_groups.num_groups, - self._energy_groups.num_groups) - - # Begin by checking the case when chi has already been given and - # thus the rules for filling in nu_fission are set. - if self._use_chi is not None: - if self._use_chi: - shape = shape_vec - else: - shape = shape_mat - if nu_fission.shape != shape: - msg = "Invalid Shape of Nu_fission!" - raise ValueError(msg) - else: - # Get shape of nu_fission to determine if we need chi or not - if nu_fission.shape == shape_vec: - self._use_chi = True - elif nu_fission.shape == shape_mat: - self._use_chi = False - else: - msg = "Invalid Shape of Nu_fission!" - raise ValueError(msg) - - # check we have a numpy list - check_type("nu_fission", nu_fission, np.ndarray, - expected_iter_type=Real) - self._nu_fission = np.copy(nu_fission) if np.sum(self._nu_fission) > 0.0: self._fissionable = True - def set_k_fission(self, k_fission, **kwargs): - if isinstance(k_fission, openmc.mgxs.KappaFissionXS): - # Make sure passed MGXS object contains correct group structure - if self.energy_groups != k_fission.energy_groups: - msg = 'Group structure of provided KappaFissionXS does not ' \ - 'match group structure of XSdata object' - raise ValueError(msg) - # Get openmc.mgxs.get_xs() arguments from kwargs - # nuclides, xs_type, and value will have sane defaults but can be - # overridden by kwards - if 'nuclides' in kwargs: - nuclides = kwargs['nuclides'] - else: - nuclides = 'sum' - if 'xs_type' in kwargs: - xs_type = kwargs['xs_type'] - else: - xs_type = 'macro' - if 'value' in kwargs: - value = kwargs['value'] - else: - value = 'mean' - # subdomains is required from the kwargs as this is specific to - # this XSdata object. - if 'subdomains' in kwargs: - subdomains = kwargs['subdomains'] - else: - msg = "Argument 'subdomains' is required" - raise ValueError(msg) + def set_k_fission(self, k_fission, subdomain, nuclide='sum', + xs_type='macro'): + if not isinstance(k_fission, openmc.mgxs.KappaFissionXS): + msg = 'Method must be passed an openmc.mgxs.KappaFissionXS' + raise TypeError(msg) - if self._representation is 'isotropic': - self._k_fission = k_fission.get_xs(subdomains=subdomains, - nuclides=nuclides, - xs_type=xs_type, - value=value) - elif self._representation is 'angle': - # Not yet implemented as MGXS do not yet support this - pass + # Make sure passed MGXS object contains correct group structure + if self.energy_groups != k_fission.energy_groups: + msg = 'Group structure of provided data does not match' \ + ' group structure of XSdata object' + raise ValueError(msg) - else: - if self._representation is 'isotropic': - shape = (self._energy_groups.num_groups,) - elif self._representation is 'angle': - shape = (self._num_polar, self._num_azimuthal, - self._energy_groups.num_groups) - # check we have a numpy list - check_type("k_fission", k_fission, np.ndarray, - expected_iter_type=Real) - if k_fission.shape == shape: - self._k_fission = np.copy(k_fission) - if np.sum(self._k_fission) > 0.0: - self._fissionable = True - else: - msg = 'Shape of provided k_fission "{0}" does not match ' \ - 'shape required, "{1}"'.format(k_fission.shape, shape) - raise ValueError(msg) + if self._representation is 'isotropic': + self._k_fission = k_fission.get_xs(subdomains=subdomain, + nuclides=nuclide, + xs_type=xs_type) + elif self._representation is 'angle': + msg = 'Angular-Dependent MGXS have not yet been implemented' + raise ValueError(msg) - def set_chi(self, chi, **kwargs): + def set_chi(self, chi, subdomain, nuclide='sum', xs_type='macro'): if self._use_chi is not None: if not self._use_chi: - msg = 'Providing chi when nu_fission already provided as matrix!' + msg = 'Providing chi when nu_fission already provided as a ' \ + 'matrix!' raise ValueError(msg) - if isinstance(chi, openmc.mgxs.Chi): - # Make sure passed MGXS object contains correct group structure - if self.energy_groups != chi.energy_groups: - msg = 'Group structure of provided Chi does not ' \ - 'match group structure of XSdata object' - raise ValueError(msg) - # Get openmc.mgxs.get_xs() arguments from kwargs - # nuclides, xs_type, and value will have sane defaults but can be - # overridden by kwards - if 'nuclides' in kwargs: - nuclides = kwargs['nuclides'] - else: - nuclides = 'sum' - if 'xs_type' in kwargs: - xs_type = kwargs['xs_type'] - else: - xs_type = 'macro' - if 'value' in kwargs: - value = kwargs['value'] - else: - value = 'mean' - # subdomains is required from the kwargs as this is specific to - # this XSdata object. - if 'subdomains' in kwargs: - subdomains = kwargs['subdomains'] - else: - msg = "Argument 'subdomains' is required" - raise ValueError(msg) + if not isinstance(chi, openmc.mgxs.Chi): + msg = 'Method must be passed an openmc.mgxs.Chi' + raise TypeError(msg) - if self._representation is 'isotropic': - self._chi = chi.get_xs(subdomains=subdomains, - nuclides=nuclides, - xs_type=xs_type, - value=value) - elif self._representation is 'angle': - # Not yet implemented as MGXS do not yet support this - pass + # Make sure passed MGXS object contains correct group structure + if self.energy_groups != chi.energy_groups: + msg = 'Group structure of provided data does not match' \ + ' group structure of XSdata object' + raise ValueError(msg) - else: - if self._representation is 'isotropic': - shape = (self._energy_groups.num_groups,) - elif self._representation is 'angle': - shape = (self._num_polar, self._num_azimuthal, - self._energy_groups.num_groups) - # check we have a numpy list - check_type("chi", chi, np.ndarray, expected_iter_type=Real) - if chi.shape == shape: - self._chi = np.copy(chi) - else: - msg = 'Shape of provided chi "{0}" does not match shape ' \ - 'required, "{1}"'.format(chi.shape, shape) - raise ValueError(msg) - if self._use_chi is not None: - self._use_chi = True + if self._representation is 'isotropic': + self._chi = chi.get_xs(subdomains=subdomain, + nuclides=nuclide, + xs_type=xs_type) + elif self._representation is 'angle': + msg = 'Angular-Dependent MGXS have not yet been implemented' + raise ValueError(msg) - def set_scatter(self, scatter, **kwargs): - if isinstance(scatter, openmc.mgxs.ScatterMatrixXS): - # Make sure passed MGXS object contains correct group structure - if self.energy_groups != scatter.energy_groups: - msg = 'Group structure of provided ScatterMatrixXS does not ' \ - 'match group structure of XSdata object' - raise ValueError(msg) - # Get openmc.mgxs.get_xs() arguments from kwargs - # nuclides, xs_type, and value will have sane defaults but can be - # overridden by kwards - if 'nuclides' in kwargs: - nuclides = kwargs['nuclides'] - else: - nuclides = 'sum' - if 'xs_type' in kwargs: - xs_type = kwargs['xs_type'] - else: - xs_type = 'macro' - if 'value' in kwargs: - value = kwargs['value'] - else: - value = 'mean' - # subdomains is required from the kwargs as this is specific to - # this XSdata object. - if 'subdomains' in kwargs: - subdomains = kwargs['subdomains'] - else: - msg = "Argument 'subdomains' is required" - raise ValueError(msg) + if self._use_chi is not None: + self._use_chi = True - if self._representation is 'isotropic': - self._scatter = scatter.get_xs(subdomains=subdomains, - nuclides=nuclides, - xs_type=xs_type, - value=value) - elif self._representation is 'angle': - # Not yet implemented as MGXS do not yet support this - pass + def set_scatter(self, scatter, subdomain, nuclide='sum', xs_type='macro'): + if not isinstance(scatter, openmc.mgxs.ScatterMatrixXS): + msg = 'Method must be passed an openmc.mgxs.ScatterMatrixXS' + raise TypeError(msg) - else: - if self._representation is 'isotropic': - shape = (self.num_orders, self._energy_groups.num_groups, - self._energy_groups.num_groups) - max_depth = 3 - elif self._representation is 'angle': - shape = (self._num_polar, self._num_azimuthal, self.num_orders, - self._energy_groups.num_groups, - self._energy_groups.num_groups) - max_depth = 5 - # check we have a numpy list - check_iterable_type("scatter", scatter, expected_type=Real, - max_depth=max_depth) - if scatter.shape == shape: - self._scatter = np.copy(scatter) - else: - msg = 'Shape of provided scatter "{0}" does not match shape ' \ - 'required, "{1}"'.format(scatter.shape, shape) - raise ValueError(msg) + # Make sure passed MGXS object contains correct group structure + if self.energy_groups != scatter.energy_groups: + msg = 'Group structure of provided data does not match' \ + ' group structure of XSdata object' + raise ValueError(msg) - def set_multiplicity(self, multiplicity, scatter=None, **kwargs): - if isinstance(multiplicity, openmc.mgxs.NuScatterMatrixXS): - if not isinstance(scatter, openmc.mgxs.ScatterMatrixXS): - msg = "Argument 'scatter' must be provided." - raise ValueError(msg) - # Make sure passed MGXS objects contain correct group structure - if self.energy_groups != multiplicity.energy_groups: - msg = 'Group structure of provided NuScatterMatrixXS does not ' \ - 'match group structure of XSdata object' - raise ValueError(msg) - if self.energy_groups != scatter.energy_groups: - msg = 'Group structure of provided ScatterMatrixXS does not ' \ - 'match group structure of XSdata object' - raise ValueError(msg) - # Get openmc.mgxs.get_xs() arguments from kwargs - # nuclides, xs_type, and value will have sane defaults but can be - # overridden by kwards - if 'nuclides' in kwargs: - nuclides = kwargs['nuclides'] - else: - nuclides = 'sum' - if 'xs_type' in kwargs: - xs_type = kwargs['xs_type'] - else: - xs_type = 'macro' - if 'value' in kwargs: - value = kwargs['value'] - else: - value = 'mean' - # subdomains is required from the kwargs as this is specific to - # this XSdata object. - if 'subdomains' in kwargs: - subdomains = kwargs['subdomains'] - else: - msg = "Argument 'subdomains' is required" - raise ValueError(msg) + if self._representation is 'isotropic': + self._scatter = scatter.get_xs(subdomains=subdomain, + nuclides=nuclide, + xs_type=xs_type) + elif self._representation is 'angle': + msg = 'Angular-Dependent MGXS have not yet been implemented' + raise ValueError(msg) - if self._representation is 'isotropic': - nuscatt = multiplicity.get_xs(subdomains=subdomains, - nuclides=nuclides, - xs_type=xs_type, - value=value) - scatt = scatter.get_xs(subdomains=subdomains, - nuclides=nuclides, - xs_type=xs_type, - value=value) - self._multiplicity = np.divide(nuscatt, scatt) - elif self._representation is 'angle': - # Not yet implemented as MGXS do not yet support this - pass + def set_multiplicity(self, multiplicity, scatter, subdomain, + nuclide='sum', xs_type='macro'): + if not isinstance(multiplicity, openmc.mgxs.ScatterMatrixXS): + msg = 'Method must be passed an openmc.mgxs.ScatterMatrixXS' + raise TypeError(msg) + if not isinstance(scatter, openmc.mgxs.ScatterMatrixXS): + msg = 'Method must be passed an openmc.mgxs.ScatterMatrixXS' + raise TypeError(msg) - else: - if self._representation is 'isotropic': - shape = (self._energy_groups.num_groups, - self._energy_groups.num_groups) - max_depth = 2 - elif self._representation is 'angle': - shape = (self._num_polar, self._num_azimuthal, - self._energy_groups.num_groups, - self._energy_groups.num_groups) - max_depth = 4 - # check we have a numpy list - check_iterable_type("multiplicity", multiplicity, expected_type=Real, - max_depth=max_depth) - if multiplicity.shape == shape: - self._multiplicity = np.copy(multiplicity) - else: - msg = 'Shape of provided multiplicity "{0}" does not match shape' \ - ' required, "{1}"'.format(multiplicity.shape, shape) - raise ValueError(msg) + # Make sure passed MGXS objects contain correct group structure + if self.energy_groups != multiplicity.energy_groups: + msg = 'Group structure of "multiplicity" does not match' \ + ' group structure of XSdata object' + raise ValueError(msg) + if self.energy_groups != scatter.energy_groups: + msg = 'Group structure of "scatter" does not match' \ + ' group structure of XSdata object' + raise ValueError(msg) + + if self._representation is 'isotropic': + nuscatt = multiplicity.get_xs(subdomains=subdomain, + nuclides=nuclide, + xs_type=xs_type) + scatt = scatter.get_xs(subdomains=subdomain, + nuclides=nuclide, + xs_type=xs_type) + self._multiplicity = np.divide(nuscatt, scatt) + elif self._representation is 'angle': + msg = 'Angular-Dependent MGXS have not yet been implemented' + raise ValueError(msg) def _get_xsdata_xml(self): - element = ET.Element("xsdata") - element.set("name", self._name) + element = ET.Element('xsdata') + element.set('name', self._name) if self._alias is not None: subelement = ET.SubElement(element, 'alias') @@ -1213,7 +892,7 @@ class MGXSLibrary(object): self._xsdatas = [] self._energy_groups = energy_groups self._inverse_velocities = None - self._cross_sections_file = ET.Element("cross_sections") + self._cross_sections_file = ET.Element('cross_sections') @property def inverse_velocities(self): @@ -1232,7 +911,7 @@ class MGXSLibrary(object): @energy_groups.setter def energy_groups(self, energy_groups): - check_type("energy groups", energy_groups, openmc.mgxs.EnergyGroups) + check_type('energy groups', energy_groups, openmc.mgxs.EnergyGroups) self._energy_groups = energy_groups def add_xsdata(self, xsdata): @@ -1295,19 +974,19 @@ class MGXSLibrary(object): def _create_groups_subelement(self): if self._energy_groups is not None: - element = ET.SubElement(self._cross_sections_file, "groups") + element = ET.SubElement(self._cross_sections_file, 'groups') element.text = str(self._energy_groups.num_groups) def _create_group_structure_subelement(self): if self._energy_groups is not None: element = ET.SubElement(self._cross_sections_file, - "group_structure") + 'group_structure') element.text = ' '.join(map(str, self._energy_groups.group_edges)) def _create_inverse_velocities_subelement(self): if self._inverse_velocities is not None: element = ET.SubElement(self._cross_sections_file, - "inverse_velocities") + 'inverse_velocities') element.text = ' '.join(map(str, self._inverse_velocities)) def _create_xsdata_subelements(self): @@ -1341,4 +1020,4 @@ class MGXSLibrary(object): # Write the XML Tree to the xsdatas.xml file tree = ET.ElementTree(self._cross_sections_file) tree.write(filename, xml_declaration=True, - encoding='utf-8', method="xml") + encoding='utf-8', method='xml') From 98a02d5d5048308eb608c1513d2f4bd6ee40ede8 Mon Sep 17 00:00:00 2001 From: Adam Nelson Date: Wed, 11 May 2016 21:19:30 -0400 Subject: [PATCH 10/20] Simplifications as per comments from @wbinventor and @paulromano. Next is updating notebook --- openmc/mgxs/library.py | 372 ++++++++++------------- openmc/mgxs_library.py | 671 ++++++++++++++++++++++++++++------------- 2 files changed, 620 insertions(+), 423 deletions(-) diff --git a/openmc/mgxs/library.py b/openmc/mgxs/library.py index dfa55b3a59..991a98f62c 100644 --- a/openmc/mgxs/library.py +++ b/openmc/mgxs/library.py @@ -15,14 +15,9 @@ import openmc.checkvalue as cv if sys.version_info[0] >= 3: basestring = str -# The following represent the most accurate MGXS generation strategy -# for use in the MG mode of OpenMC. -OPENMC_MG_MGXS_TYPES = ['transport', 'absorption', 'nu-fission', 'chi', - 'scatter matrix', 'nu-scatter matrix'] - class Library(object): - """A multi-group cross section library for some energy group structure. + '''A multi-group cross section library for some energy group structure. This class can be used for both OpenMC input generation and tally data post-processing to compute spatially-homogenized and energy-integrated @@ -84,7 +79,7 @@ class Library(object): Whether or not the Library's tallies use SciPy's LIL sparse matrix format for compressed data storage - """ + ''' def __init__(self, openmc_geometry, by_nuclide=False, mgxs_types=None, name=''): @@ -252,7 +247,8 @@ class Library(object): @domain_type.setter def domain_type(self, domain_type): - cv.check_value('domain type', domain_type, tuple(openmc.mgxs.DOMAIN_TYPES)) + cv.check_value('domain type', domain_type, + tuple(openmc.mgxs.DOMAIN_TYPES)) self._domain_type = domain_type @domains.setter @@ -304,7 +300,7 @@ class Library(object): @sparse.setter def sparse(self, sparse): - """Convert tally data from NumPy arrays to SciPy list of lists (LIL) + '''Convert tally data from NumPy arrays to SciPy list of lists (LIL) sparse matrices, and vice versa. This property may be used to reduce the amount of data in memory during @@ -312,7 +308,7 @@ class Library(object): matrices internally within the Tally object. All tally data access properties and methods will return data as a dense NumPy array. - """ + ''' cv.check_type('sparse', sparse, bool) @@ -325,14 +321,14 @@ class Library(object): self._sparse = sparse def build_library(self): - """Initialize MGXS objects in each domain and for each reaction type + '''Initialize MGXS objects in each domain and for each reaction type in the library. This routine will populate the all_mgxs instance attribute dictionary with MGXS subclass objects keyed by each domain ID (e.g., Material IDs) and cross section type (e.g., 'nu-fission', 'total', etc.). - """ + ''' # Initialize MGXS for each domain and mgxs type and store in dictionary for domain in self.domains: @@ -355,7 +351,7 @@ class Library(object): self.all_mgxs[domain.id][mgxs_type] = mgxs def add_to_tallies_file(self, tallies_file, merge=True): - """Add all tallies from all MGXS objects to a tallies file. + '''Add all tallies from all MGXS objects to a tallies file. NOTE: This assumes that :meth:`Library.build_library` has been called @@ -363,12 +359,12 @@ class Library(object): ---------- tallies_file : openmc.Tallies A Tallies collection to add each MGXS' tallies to generate a - "tallies.xml" input file for OpenMC + 'tallies.xml' input file for OpenMC merge : bool Indicate whether tallies should be merged when possible. Defaults to True. - """ + ''' cv.check_type('tallies_file', tallies_file, openmc.Tallies) @@ -380,7 +376,7 @@ class Library(object): tallies_file.append(tally, merge=merge) def load_from_statepoint(self, statepoint): - """Extracts tallies in an OpenMC StatePoint with the data needed to + '''Extracts tallies in an OpenMC StatePoint with the data needed to compute multi-group cross sections. This method is needed to compute cross section data from tallies @@ -399,7 +395,7 @@ class Library(object): When this method is called with a statepoint that has not been linked with a summary object. - """ + ''' cv.check_type('statepoint', statepoint, openmc.StatePoint) @@ -423,7 +419,7 @@ class Library(object): mgxs.sparse = self.sparse def get_mgxs(self, domain, mgxs_type): - """Return the MGXS object for some domain and reaction rate type. + '''Return the MGXS object for some domain and reaction rate type. This routine searches the library for an MGXS object for the spatial domain and reaction rate type requested by the user. @@ -448,7 +444,7 @@ class Library(object): If no MGXS object can be found for the requested domain or multi-group cross section type - """ + ''' if self.domain_type == 'material': cv.check_type('domain', domain, (openmc.Material, Integral)) @@ -464,7 +460,7 @@ class Library(object): if domain_id == domain.id: break else: - msg = 'Unable to find MGXS for {0} "{1}" in ' \ + msg = 'Unable to find MGXS for "{0}" "{1}" in ' \ 'library'.format(self.domain_type, domain_id) raise ValueError(msg) else: @@ -478,7 +474,7 @@ class Library(object): return self.all_mgxs[domain_id][mgxs_type] def get_condensed_library(self, coarse_groups): - """Construct an energy-condensed version of this library. + '''Construct an energy-condensed version of this library. This routine condenses each of the multi-group cross sections in the library to a coarse energy group structure. NOTE: This routine must @@ -505,7 +501,7 @@ class Library(object): -------- MGXS.get_condensed_xs(coarse_groups) - """ + ''' if self.sp_filename is None: msg = 'Unable to get a condensed coarse group cross section ' \ @@ -534,7 +530,7 @@ class Library(object): return condensed_library def get_subdomain_avg_library(self): - """Construct a subdomain-averaged version of this library. + '''Construct a subdomain-averaged version of this library. This routine averages each multi-group cross section across distribcell instances. The method performs spatial homogenization to compute the @@ -557,7 +553,7 @@ class Library(object): -------- MGXS.get_subdomain_avg_xs(subdomains) - """ + ''' if self.sp_filename is None: msg = 'Unable to get a subdomain-averaged cross section ' \ @@ -585,7 +581,7 @@ class Library(object): def build_hdf5_store(self, filename='mgxs.h5', directory='mgxs', subdomains='all', nuclides='all', xs_type='macro', row_column='inout'): - """Export the multi-group cross section library to an HDF5 binary file. + '''Export the multi-group cross section library to an HDF5 binary file. This method constructs an HDF5 file which stores the library's multi-group cross section data. The data is stored in a hierarchy of @@ -628,7 +624,7 @@ class Library(object): -------- MGXS.build_hdf5_store(filename, directory, xs_type) - """ + ''' if self.sp_filename is None: msg = 'Unable to export multi-group cross section library ' \ @@ -648,7 +644,7 @@ class Library(object): full_filename = os.path.join(directory, filename) full_filename = full_filename.replace(' ', '-') f = h5py.File(full_filename, 'w') - f.attrs["# groups"] = self.num_groups + f.attrs['# groups'] = self.num_groups f.close() # Export MGXS for each domain and mgxs type to an HDF5 file @@ -663,7 +659,7 @@ class Library(object): nuclides=nuclides, row_column=row_column) def dump_to_file(self, filename='mgxs', directory='mgxs'): - """Store this Library object in a pickle binary file. + '''Store this Library object in a pickle binary file. Parameters ---------- @@ -676,7 +672,7 @@ class Library(object): -------- Library.load_from_file(filename, directory) - """ + ''' cv.check_type('filename', filename, basestring) cv.check_type('directory', directory, basestring) @@ -693,7 +689,7 @@ class Library(object): @staticmethod def load_from_file(filename='mgxs', directory='mgxs'): - """Load a Library object from a pickle binary file. + '''Load a Library object from a pickle binary file. Parameters ---------- @@ -711,7 +707,7 @@ class Library(object): -------- Library.dump_to_file(mgxs_lib, filename, directory) - """ + ''' cv.check_type('filename', filename, basestring) cv.check_type('directory', directory, basestring) @@ -729,7 +725,7 @@ class Library(object): def write_mg_library(self, xs_type='macro', domain_names=None, xs_ids=None, filename='mg_cross_sections', directory='./', return_names=True): - """Creates a cross-section data library file for the Multi-Group + '''Creates a cross-section data library file for the Multi-Group mode of OpenMC. Parameters @@ -740,11 +736,11 @@ class Library(object): nuclide this will be set to 'macro' regardless. domain_names : Iterable of str List of names to apply to the xsdata entries in the - resultant mgxs data file. Defaults to "set1", "set2", ... + resultant mgxs data file. Defaults to 'set1', 'set2', ... xs_ids : str or Iterable of str - Cross section set identifier (i.e., "71c") for all + Cross section set identifier (i.e., '71c') for all data sets (if only str) or for each individual one - (if iterable of str). Defaults to '1g' + (if iterable of str). Defaults to '1m'. filename : str Filename for the pickle file. Defaults to 'mg_cross_sections'. directory : str @@ -772,7 +768,11 @@ class Library(object): -------- Library.dump_to_file(mgxs_lib, filename, directory) - """ + ''' + + # Check to ensure the Library contains the correct + # multi-group cross section types + self.check_library_for_openmc_mgxs() # Check the provided parameters cv.check_value('xs_type', xs_type, ['macro', 'micro']) @@ -786,14 +786,18 @@ class Library(object): else: cv.check_iterable_type('xs_ids', xs_ids, basestring) else: - xs_ids = ['1g' for i in range(len(self.domains))] + xs_ids = ['1m' for i in range(len(self.domains))] cv.check_type('filename', filename, basestring) cv.check_type('directory', directory, basestring) + # Make sure statepoint has been loaded + if self._sp_filename is None: + msg = 'A StatePoint must be loaded before calling ' \ + 'the write_mg_library() function' + raise ValueError(msg) + # Construct the collection of the nuclides to report - if self.by_nuclide: - nuclides = self.all_mgxs[1][self.mgxs_types[-1]].get_all_nuclides() - else: + if not self.by_nuclide: xs_type = 'macro' # Make directory if it does not exist and build our filename @@ -813,213 +817,98 @@ class Library(object): xsdatas = [] mat_names = {} - for i in range(len(self.domains)): + for i, domain in enumerate(self.domains): - id = self.domains[i].id - if not self.by_nuclide: + mat_names[domain.id] = {} + if self.by_nuclide: + nuclides = list(domain.get_all_nuclides().keys()) + else: + nuclides = ['total'] + for nuclide in nuclides: # Build & add metadata to XSdata object - # (Use i here because k in nuclides will add chars to this) if domain_names is None: name = 'set' + str(i + 1) else: name = domain_names[i] + if nuclide is not 'total': + name += '_' + nuclide name += '.' + xs_ids[i] + + # Store the name + mat_names[domain.id][nuclide] = name + xsdata = openmc.XSdata(name, self.energy_groups) xsdata.order = order + if nuclide is not 'total': + xsdata.zaid = self._nuclides[nuclide][0] + xsdata.awr = self._nuclides[nuclide][1] - mat_names[id] = name - + nuclide = [nuclide] # Now get xs data itself if 'transport' in self.mgxs_types: - if self.correction == 'P0': - xsdata.set_total(self.all_mgxs[id]['transport'], - xs_type=xs_type, subdomains=(id,)) - else: - msg = "The use of a transport cross section " + \ - "requires the correction attribute to be" + \ - "set to 'P0' to produce valid cross " + \ - "section libraries" - raise ValueError(msg) + mymgxs = self.get_mgxs(domain, 'transport') + xsdata.set_total_mgxs(mymgxs, xs_type=xs_type, + nuclide=nuclide) elif 'total' in self.mgxs_types: - xsdata.set_total(self.all_mgxs[id]['total'], - xs_type=xs_type, subdomains=(id,)) + mymgxs = self.get_mgxs(domain, 'total') + xsdata.set_total_mgxs(mymgxs, xs_type=xs_type, + nuclide=nuclide) if 'absorption' in self.mgxs_types: - xsdata.set_absorption(self.all_mgxs[id]['absorption'], - xs_type=xs_type, - subdomains=(id,)) + mymgxs = self.get_mgxs(domain, 'absorption') + xsdata.set_absorption_mgxs(mymgxs, xs_type=xs_type, + nuclide=nuclide) if 'fission' in self.mgxs_types: - xsdata.set_fission(self.all_mgxs[id]['fission'], - xs_type=xs_type, subdomains=(id,)) + mymgxs = self.get_mgxs(domain, 'fission') + xsdata.set_fission_mgxs(mymgxs, xs_type=xs_type, + nuclide=nuclide) if 'kappa-fission' in self.mgxs_types: - xsdata.set_k_fission(self.all_mgxs[id]['kappa-fission'], - xs_type=xs_type, subdomains=(id,)) + mymgxs = self.get_mgxs(domain, 'kappa-fission') + xsdata.set_kappa_fission_mgxs(mymgxs, xs_type=xs_type, + nuclide=nuclide) if 'chi' in self.mgxs_types: - xsdata.set_chi(self.all_mgxs[id]['chi'], - xs_type=xs_type, subdomains=(id,)) + mymgxs = self.get_mgxs(domain, 'chi') + xsdata.set_chi_mgxs(mymgxs, xs_type=xs_type, + nuclide=nuclide) if 'nu-fission' in self.mgxs_types: - xsdata.set_nu_fission(self.all_mgxs[id]['nu-fission'], - xs_type=xs_type, - subdomains=(id,)) + mymgxs = self.get_mgxs(domain, 'nu-fission') + xsdata.set_nu_fission_mgxs(mymgxs, xs_type=xs_type, + nuclide=nuclide) # multiplicity requires scatter and nu-scatter if ((('scatter matrix' in self.mgxs_types) and ('nu-scatter matrix' in self.mgxs_types))): - xsdata.set_multiplicity( - self.all_mgxs[id]['nu-scatter matrix'], - self.all_mgxs[id]['scatter matrix'], - xs_type=xs_type, subdomains=(id,)) - xsdata.multiplicity = np.nan_to_num(xsdata.multiplicity) + scatt_mgxs = self.get_mgxs(domain, + 'scatter matrix') + nuscatt_mgxs = self.get_mgxs(domain, + 'nu-scatter matrix') + xsdata.set_multiplicity_mgxs(nuscatt_mgxs, scatt_mgxs, + xs_type=xs_type, + nuclide=nuclide) using_multiplicity = True else: using_multiplicity = False if using_multiplicity: - xsdata.set_scatter(self.all_mgxs[id]['nu-scatter matrix'], - xs_type=xs_type, - subdomains=(id,)) + nuscatt_mgxs = self.get_mgxs(domain, + 'nu-scatter matrix') + xsdata.set_scatter_mgxs(nuscatt_mgxs, xs_type=xs_type, + nuclide=nuclide) else: if 'nu-scatter matrix' in self.mgxs_types: - xsdata.set_scatter( - self.all_mgxs[id]['nu-scatter matrix'], - xs_type=xs_type, subdomains=(id,)) + nuscatt_mgxs = self.get_mgxs(domain, + 'nu-scatter matrix') + xsdata.set_scatter_mgxs(nuscatt_mgxs, xs_type=xs_type, + nuclide=nuclide) + # Since we are not using multiplicity, then # scattering multiplication (nu-scatter) must be # accounted for approximately by using an adjusted # absorption cross section. - # We can not do this with a transport x/s so check - # for that. if 'total' in self.mgxs_types: xsdata.absorption = \ np.subtract(xsdata.total, np.sum(xsdata.scatter[0, :, :], axis=1)) - else: - msg = "Absorption cross section must be " + \ - "provided if using a transport cross" + \ - " section and while not providing a " + \ - "scattering matrix" - raise ValueError(msg) - else: - msg = "No nu-scatter matrix data was provided. " + \ - "This means neutron balance cannot be " + \ - "achieved since (n,xn) multiplication is " + \ - "ignored." - warn(msg) - xsdata.set_scatter(self.all_mgxs[id]['scatter matrix'], - xs_type=xs_type, - subdomains=(id,)) - xsdatas.append(xsdata) - else: - mat_names[id] = {} - for nuclide in nuclides: - # Build & add metadata to XSdata object - if domain_names is None: - name = 'set' + str(i + 1) - else: - name = domain_names[i] - name += '_' + nuclide - name += '.' + xs_ids[i] - - mat_names[id][nuclide] = name - - xsdata = openmc.XSdata(name, self.energy_groups) - xsdata.order = order - xsdata.zaid = self._nuclides[nuclide][0] - xsdata.awr = self._nuclides[nuclide][1] - - # Now get xs data itself - if 'transport' in self.mgxs_types: - if self.correction == 'P0': - xsdata.set_total(self.all_mgxs[id]['transport'], - xs_type=xs_type, subdomains=(id,), - nuclides=[nuclide]) - else: - msg = "The use of a transport cross section " + \ - "requires the correction attribute to be" + \ - "set to 'P0' to produce valid cross " + \ - "section libraries" - raise ValueError(msg) - elif 'total' in self.mgxs_types: - xsdata.set_total(self.all_mgxs[id]['total'], - xs_type=xs_type, subdomains=(id,), - nuclides=[nuclide]) - if 'absorption' in self.mgxs_types: - xsdata.set_absorption(self.all_mgxs[id]['absorption'], - xs_type=xs_type, - subdomains=(id,), - nuclides=[nuclide]) - if 'fission' in self.mgxs_types: - xsdata.set_fission(self.all_mgxs[id]['fission'], - xs_type=xs_type, - subdomains=(id,), - nuclides=[nuclide]) - if 'kappa-fission' in self.mgxs_types: - xsdata.set_k_fission( - self.all_mgxs[id]['kappa-fission'], - xs_type=xs_type, subdomains=(id,), - nuclides=[nuclide]) - if 'chi' in self.mgxs_types: - xsdata.set_chi(self.all_mgxs[id]['chi'], - xs_type=xs_type, subdomains=(id,), - nuclides=[nuclide]) - if 'nu-fission' in self.mgxs_types: - xsdata.set_nu_fission(self.all_mgxs[id]['nu-fission'], - xs_type=xs_type, - subdomains=(id,), - nuclides=[nuclide]) - # multiplicity requires scatter and nu-scatter - if ((('scatter matrix' in self.mgxs_types) and - ('nu-scatter matrix' in self.mgxs_types))): - xsdata.set_multiplicity( - self.all_mgxs[id]['nu-scatter matrix'], - self.all_mgxs[id]['scatter matrix'], - xs_type=xs_type, subdomains=(id,), - nuclides=[nuclide]) - xsdata.multiplicity = \ - np.nan_to_num(xsdata.multiplicity) - using_multiplicity = True - else: - using_multiplicity = False - - if using_multiplicity: - xsdata.set_scatter( - self.all_mgxs[id]['nu-scatter matrix'], - xs_type=xs_type, subdomains=(id,), - nuclides=[nuclide]) - else: - if 'nu-scatter matrix' in self.mgxs_types: - xsdata.set_scatter( - self.all_mgxs[id]['nu-scatter matrix'], - xs_type=xs_type, subdomains=(id,), - nuclides=[nuclide]) - # Since we are not using multiplicity, then - # scattering multiplication (nu-scatter) must be - # accounted for approximately by using an adjusted - # absorption cross section. - if 'total' in self.mgxs_types: - xsdata.absorption = \ - np.subtract(xsdata.total, - np.sum(xsdata.scatter[0, :, :], - axis=1)) - else: - msg = "Absorption cross section must be " + \ - "provided if using a transport cross" + \ - " section and while not providing a " + \ - "scattering matrix" - raise ValueError(msg) - else: - msg = "No nu-scatter matrix data was provided. " +\ - "This means neutron balance cannot be " + \ - "achieved since (n,xn) multiplication is " +\ - "ignored." - warn(msg) - xsdata.set_scatter( - self.all_mgxs[id]['scatter matrix'], - xs_type=xs_type, - subdomains=(id,), - nuclides=[nuclide]) - - xsdatas.append(xsdata) # Add XSdatas to file mgxs_file.add_xsdatas(xsdatas) @@ -1029,3 +918,68 @@ class Library(object): if return_names: return mat_names + + def check_library_for_openmc_mgxs(self): + """This routine will check the MGXS Types within the provided + Library to ensure the data types provided can be used to create + a MGXS Library for OpenMC's Multi-Group mode via the + `Library.write_mg_library` method. + The rules to check include: + - Fission is not required as a fixed source problem could be + the target. + - Absorption is required. + - A nu-scatter matrix is required. + - Having both nu-scatter (of any order) and scatter + (at least isotropic) matrices is preferred + - If only nu-scatter, need total (not transport), to + be used in adjusting absorption + (i.e., reduced_abs = tot - nuscatt) + - Either total or transport should be present. + - Both can be available if one wants, but we should + use whatever corresponds to Library.correction (if P0: transport) + + Raises + ------ + ValueError + When the Library object is initialized with insufficient types of + cross sections for the Library. + + See also + -------- + Library.write_mg_library(...) + + """ + + error_flag = False + # Ensure absorption is present + if 'absorption' not in self.mgxs_types: + error_flag = True + msg = 'Absorption MGXS type is required but not provided.' + warn(msg) + # Ensure nu-scattering matrix is required + if 'nu-scatter matrix' not in self.mgxs_types: + error_flag = True + msg = 'Nu-Scatter Matrix MGXS type is required but not provided.' + warn(msg) + else: + # Ok, now see the status of scatter + if 'scatter matrix' not in self.mgxs_types: + # We dont have both nu-scatter and scatter, therefore + # we need total, and not transport. + if 'total' not in self.mgxs_types: + error_flag = True + msg = 'Total MGXS type is required if a ' \ + 'scattering matrix is not provided.' + warn(msg) + # Total or transport can be present, but if using + # self.correction=="P0", then we should use transport. + if (((self.correction is "P0") and + ('transport' not in self.mgxs_types))): + error_flag = True + msg = 'Transport MGXS type is required since a "P0" correction ' \ + 'is applied, but a Transport MGXS is not provided.' + warn(msg) + + if error_flag: + msg = "Invalid MGXS configuration encountered." + raise ValueError(msg) diff --git a/openmc/mgxs_library.py b/openmc/mgxs_library.py index ba9ba75b05..f9353f9cc7 100644 --- a/openmc/mgxs_library.py +++ b/openmc/mgxs_library.py @@ -122,12 +122,23 @@ class XSdata(object): Legendre polynomial form). Dict contains two keys: 'enable' and 'num_points'. 'enable' is a boolean and 'num_points' is the number of points to use, if 'enable' is True. + representation : {'isotropic', 'angle'} + Method used in generating the MGXS (isotropic or angle-dependent flux + weighting). num_azimuthal : int Number of equal width angular bins that the azimuthal angular domain is subdivided into. This only applies when ``representation`` is "angle". num_polar : int Number of equal width angular bins that the polar angular domain is subdivided into. This only applies when ``representation`` is "angle". + vector_shape : iterable of int + Dimensionality of vector multi-group cross sections (e.g., the total + cross section). The return result depends on the value of + ``representation``. + matrix_shape : iterable of int + Dimensionality of matrix multi-group cross sections (e.g., the + scattering matrix cross section). The return result depends on the + value of ``representation``. total : numpy.ndarray Group-wise total cross section ordered by increasing group index (i.e., fast to thermal). If ``representation`` is "isotropic", then the length @@ -173,7 +184,7 @@ class XSdata(object): azimuthal angles times the number of polar angles, with the inner-dimension being groups, intermediate-dimension being azimuthal angles and outer-dimension being the polar angles. - k_fission : numpy.ndarray + kappa_fission : numpy.ndarray Group-wise kappa-fission cross section ordered by increasing group index (i.e., fast to thermal). If ``representation`` is "isotropic", then the length of this list should equal the number of groups in the @@ -225,7 +236,7 @@ class XSdata(object): self._multiplicity = None self._fission = None self._nu_fission = None - self._k_fission = None + self._kappa_fission = None self._chi = None self._use_chi = None @@ -302,8 +313,8 @@ class XSdata(object): return self._nu_fission @property - def k_fission(self): - return self._k_fission + def kappa_fission(self): + return self._kappa_fission @property def chi(self): @@ -317,6 +328,24 @@ class XSdata(object): else: return self._order + @property + def vector_shape(self): + if self.representation is 'isotropic': + return (self.energy_groups.num_groups,) + elif self.representation is 'angle': + return (self.num_polar, self.num_azimuthal, + self.energy_groups.num_groups) + + @property + def matrix_shape(self): + if self.representation is 'isotropic': + return (self.energy_groups.num_groups, + self.energy_groups.num_groups) + elif self.representation is 'angle': + return (self.num_polar, self.num_azimuthal, + self.energy_groups.num_groups, + self.energy_groups.num_groups) + @name.setter def name(self, name): check_type('name for XSdata', name, basestring) @@ -326,6 +355,11 @@ class XSdata(object): def energy_groups(self, energy_groups): # Check validity of energy_groups check_type('energy_groups', energy_groups, openmc.mgxs.EnergyGroups) + + if energy_group.group_edges is None: + msg = 'Unable to assign an EnergyGroups object ' + \ + 'with uninitialized group edges' + raise ValueError(msg) self._energy_groups = energy_groups @representation.setter @@ -414,141 +448,196 @@ class XSdata(object): @total.setter def total(self, total): - if self._representation is 'isotropic': - shape = (self._energy_groups.num_groups,) - elif self._representation is 'angle': - shape = (self._num_polar, self._num_azimuthal, - self._energy_groups.num_groups) + """This method sets the total cross section by performing a + deep-copy of the provided ndarray. + + Parameters + ---------- + total: ndarray + Array of group-wise cross sections to apply + + Raises + ------ + ValueError + When invalid parameters are passed. + """ + # check we have a numpy list check_type('total', total, np.ndarray, expected_iter_type=Real) - if total.shape == shape: - self._total = np.copy(total) - else: - msg = 'Shape of provided total "{0}" does not match shape ' \ - 'required, "{1}"'.format(total.shape, shape) - raise ValueError(msg) + # Check the dimensions of the data + check_value('total shape', total.shape, self.vector_shape) + + self._total = np.copy(total) @absorption.setter def absorption(self, absorption): - if self._representation is 'isotropic': - shape = (self._energy_groups.num_groups,) - elif self._representation is 'angle': - shape = (self._num_polar, self._num_azimuthal, - self._energy_groups.num_groups) + """This method sets the absorption cross section by performing a + deep-copy of the provided ndarray. + + Parameters + ---------- + absorption: ndarray + Array of group-wise cross sections to apply + + Raises + ------ + ValueError + When invalid parameters are passed. + """ # check we have a numpy list check_type('absorption', absorption, np.ndarray, expected_iter_type=Real) - if absorption.shape == shape: - self._absorption = np.copy(absorption) - else: - msg = 'Shape of provided absorption "{0}" does not match shape ' \ - 'required, "{1}"'.format(absorption.shape, shape) - raise ValueError(msg) + # Check the dimensions of the data + check_value('absorption shape', absorption.shape, self.vector_shape) + + self._absorption = np.copy(absorption) @fission.setter def fission(self, fission): - if self._representation is 'isotropic': - shape = (self._energy_groups.num_groups,) - elif self._representation is 'angle': - shape = (self._num_polar, self._num_azimuthal, - self._energy_groups.num_groups) - # check we have a numpy list - check_type('fission', fission, np.ndarray, expected_iter_type=Real) - if fission.shape == shape: - self._fission = np.copy(fission) - if np.sum(self._fission) > 0.0: - self._fissionable = True - else: - msg = 'Shape of provided fission "{0}" does not match shape ' \ - 'required, "{1}"'.format(fission.shape, shape) - raise ValueError(msg) + """This method sets the fission cross section by performing a + deep-copy of the provided ndarray. - @k_fission.setter - def k_fission(self, k_fission): - if self._representation is 'isotropic': - shape = (self._energy_groups.num_groups,) - elif self._representation is 'angle': - shape = (self._num_polar, self._num_azimuthal, - self._energy_groups.num_groups) + Parameters + ---------- + fission: ndarray + Array of group-wise cross sections to apply + + Raises + ------ + ValueError + When invalid parameters are passed. + """ # check we have a numpy list - check_type('k_fission', k_fission, np.ndarray, + check_type('fission', fission, np.ndarray, expected_iter_type=Real) - if k_fission.shape == shape: - self._k_fission = np.copy(k_fission) - if np.sum(self._k_fission) > 0.0: - self._fissionable = True - else: - msg = 'Shape of provided k_fission "{0}" does not match ' \ - 'shape required, "{1}"'.format(k_fission.shape, shape) - raise ValueError(msg) + # Check the dimensions of the data + check_value('fission shape', fission.shape, self.vector_shape) + + self._fission = np.copy(fission) + + if np.sum(self._fission) > 0.0: + self._fissionable = True + + @kappa_fission.setter + def kappa_fission(self, kappa_fission): + """This method sets the kappa_fission cross section by performing a + deep-copy of the provided ndarray. + + Parameters + ---------- + kappa_fission: ndarray + Array of group-wise cross sections to apply + + Raises + ------ + ValueError + When invalid parameters are passed. + """ + # check we have a numpy list + check_type('kappa_fission', fission, np.ndarray, + expected_iter_type=Real) + # Check the dimensions of the data + check_value('kappa fission shape', kappa_fission.shape, + self.vector_shape) + + self._kappa_fission = np.copy(fission) + + if np.sum(self._kappa_fission) > 0.0: + self._fissionable = True @chi.setter def chi(self, chi): + """This method sets the chi cross section by performing a + deep-copy of the provided ndarray. + + Parameters + ---------- + chi: ndarray + Array of group-wise cross sections to apply + + Raises + ------ + ValueError + When invalid parameters are passed. + """ if self._use_chi is not None: if not self._use_chi: - msg = 'Providing chi when nu_fission already provided as matrix!' + msg = 'Providing chi when nu_fission already provided as a' \ + 'matrix' raise ValueError(msg) - if self._representation is 'isotropic': - shape = (self._energy_groups.num_groups,) - elif self._representation is 'angle': - shape = (self._num_polar, self._num_azimuthal, - self._energy_groups.num_groups) # check we have a numpy list check_type('chi', chi, np.ndarray, expected_iter_type=Real) - if chi.shape == shape: - self._chi = np.copy(chi) - else: - msg = 'Shape of provided chi "{0}" does not match shape ' \ - 'required, "{1}"'.format(chi.shape, shape) - raise ValueError(msg) + # Check the dimensions of the data + check_value('chi shape', chi.shape, self.vector_shape) + + self._chi = np.copy(chi) + if self._use_chi is not None: self._use_chi = True @scatter.setter def scatter(self, scatter): - if self._representation is 'isotropic': - shape = (self.num_orders, self._energy_groups.num_groups, - self._energy_groups.num_groups) - max_depth = 3 - elif self._representation is 'angle': - shape = (self._num_polar, self._num_azimuthal, self.num_orders, - self._energy_groups.num_groups, - self._energy_groups.num_groups) - max_depth = 5 + """This method sets the scattering matrix cross sections + by performing a deep-copy of the provided ndarray. + + Parameters + ---------- + scatter : ndarrays + Array of group-wise cross sections to apply + + Raises + ------ + ValueError + When invalid parameters are passed. + """ # check we have a numpy list - check_iterable_type('scatter', scatter, expected_type=Real, - max_depth=max_depth) - if scatter.shape == shape: - self._scatter = np.copy(scatter) - else: - msg = 'Shape of provided scatter "{0}" does not match shape ' \ - 'required, "{1}"'.format(scatter.shape, shape) - raise ValueError(msg) + check_type('scatter', scatter, np.ndarray, expected_iter_type=Real, + max_depth=len(scatter.shape)) + # Check the dimensions of the data + check_value('scatter shape', scatter.shape, self.matrix_shape) + + self._scatter = np.copy(scatter) @multiplicity.setter def multiplicity(self, multiplicity): - if self._representation is 'isotropic': - shape = (self._energy_groups.num_groups, - self._energy_groups.num_groups) - max_depth = 2 - elif self._representation is 'angle': - shape = (self._num_polar, self._num_azimuthal, - self._energy_groups.num_groups, - self._energy_groups.num_groups) - max_depth = 4 + """This method sets the scattering multiplicity matrix cross sections + by performing a deep-copy of the provided ndarray. + + Parameters + ---------- + multiplicity : ndarrays + Array of group-wise cross sections to apply + + Raises + ------ + ValueError + When invalid parameters are passed. + """ # check we have a numpy list - check_iterable_type('multiplicity', multiplicity, expected_type=Real, - max_depth=max_depth) - if multiplicity.shape == shape: - self._multiplicity = np.copy(multiplicity) - else: - msg = 'Shape of provided multiplicity "{0}" does not match shape' \ - ' required, "{1}"'.format(multiplicity.shape, shape) - raise ValueError(msg) + check_type('multiplicity', multiplicity, np.ndarray, + expected_iter_type=Real, max_depth=len(multiplicity.shape)) + # Check the dimensions of the data + check_value('multiplicity shape', multiplicity.shape, + self.matrix_shape) + + self._multiplicity = np.copy(multiplicity) @nu_fission.setter def nu_fission(self, nu_fission): + """This method sets the nu_fission cross section by performing a + deep-copy of the provided ndarray. + + Parameters + ---------- + nu_fission: ndarray + Array of group-wise cross sections to apply + + Raises + ------ + ValueError + When invalid parameters are passed. + """ # The NuFissionXS class does not have the capability to produce # a fission matrix and therefore if this path is pursued, we know # chi must be used. @@ -559,47 +648,54 @@ class XSdata(object): # chi already has been set. If not, we just check that this is OK # and set the use_chi flag accordingly - # First lets set our dimensions here since they get used repeatedly - # throughout this code. - if self._representation is 'isotropic': - shape_vec = (self._energy_groups.num_groups,) - shape_mat = (self._energy_groups.num_groups, - self._energy_groups.num_groups) - elif self._representation is 'angle': - shape_vec = (self._num_polar, self._num_azimuthal, - self._energy_groups.num_groups) - shape_mat = (self._num_polar, self._num_azimuthal, - self._energy_groups.num_groups, - self._energy_groups.num_groups) - - # Begin by checking the case when chi has already been given and - # thus the rules for filling in nu_fission are set. - if self._use_chi is not None: - if self._use_chi: - shape = shape_vec - else: - shape = shape_mat - if nu_fission.shape != shape: - msg = 'Invalid Shape of Nu_fission!' - raise ValueError(msg) - else: - # Get shape of nu_fission to determine if we need chi or not - if nu_fission.shape == shape_vec: - self._use_chi = True - elif nu_fission.shape == shape_mat: - self._use_chi = False - else: - msg = 'Invalid Shape of Nu_fission!' - raise ValueError(msg) - - # check we have a numpy list + # First, check we have a numpy list check_type('nu_fission', nu_fission, np.ndarray, - expected_iter_type=Real) + expected_iter_type=Real, max_depth=len(nu_fission.shape)) + + if self._use_chi is not None: + # Check the dimensions of the data + if self._use_chi: + check_value('nu_fission shape', nu_fission.shape, + self.vector_shape) + else: + check_value('nu_fission shape', nu_fission.shape, + self.matrix_shape) + else: + # Make sure the dimensions are at least right + check_value('nu_fission shape', nu_fission.shape, + (self.vector_shape, self.matrix_shape)) + # Then find out which one we have so we can set use_chi + if nu_fission.shape == self.vector_shape: + self._use_chi = True + else: + self._use_chi = False + self._nu_fission = np.copy(nu_fission) if np.sum(self._nu_fission) > 0.0: self._fissionable = True - def set_total(self, total, subdomain, nuclide='sum', xs_type='macro'): + def set_total_mgxs(self, total, nuclide='total', xs_type='macro'): + """This method allows for an openmc.mgxs.TotalXS or + openmc.mgxs.TransportXS to be used to set the total cross section + for this XSdata object. + + Parameters + ---------- + total: {openmc.mgxs.TotalXS, openmc.mgxs.TransportXS} + MGXS Object containing the total or transport cross section + for the domain of interest. + nuclide : str + Individual nuclide (or 'total' if obtaining material-wise data) + to gather data for. Defaults to 'total'. + xs_type: {'macro', 'micro'} + Provide the macro or micro cross section in units of cm^-1 or + barns. Defaults to 'macro'. + + Raises + ------ + ValueError + When invalid parameters are passed. + """ if not isinstance(total, (openmc.mgxs.TotalXS, openmc.mgxs.TransportXS)): msg = 'Method must be passed an openmc.mgxs.TotalXS or ' \ @@ -607,59 +703,119 @@ class XSdata(object): raise TypeError(msg) # Make sure passed MGXS object contains correct group structure - if self.energy_groups != total.energy_groups: - msg = 'Group structure of provided data does not match' \ - ' group structure of XSdata object' - raise ValueError(msg) + check_value('energy_groups', total.energy_groups, [self.energy_groups]) + + # Make sure passed MGXS object has correct domain type + check_value('domain_type', total.domain_type, + ['universe', 'cell', 'material']) if self._representation is 'isotropic': - self._total = total.get_xs(subdomain=subdomains, nuclides=nuclide, - xs_type=xs_type) + self._total = total.get_xs(nuclides=nuclide, xs_type=xs_type) elif self._representation is 'angle': msg = 'Angular-Dependent MGXS have not yet been implemented' raise ValueError(msg) - def set_absorption(self, absorption, subdomain, nuclide='sum', - xs_type='macro'): + def set_absorption_mgxs(self, absorption, nuclide='total', xs_type='macro'): + """This method allows for an openmc.mgxs.AbsorptionXS + to be used to set the absorption cross section for this XSdata object. + + Parameters + ---------- + absorption: openmc.mgxs.AbsorptionXS + MGXS Object containing the absorption cross section + for the domain of interest. + nuclide : str + Individual nuclide (or 'total' if obtaining material-wise data) + to gather data for. Defaults to 'total'. + xs_type: {'macro', 'micro'} + Provide the macro or micro cross section in units of cm^-1 or + barns. Defaults to 'macro'. + + Raises + ------ + ValueError + When invalid parameters are passed. + """ if not isinstance(absorption, openmc.mgxs.AbsorptionXS): msg = 'Method must be passed an openmc.mgxs.AbsorptionXS' raise TypeError(msg) # Make sure passed MGXS object contains correct group structure - if self.energy_groups != absorption.energy_groups: - msg = 'Group structure of provided data does not match' \ - ' group structure of XSdata object' - raise ValueError(msg) + check_value('energy_groups', absorption.energy_groups, + [self.energy_groups]) + + # Make sure passed MGXS object has correct domain type + check_value('domain_type', absorption.domain_type, + ['universe', 'cell', 'material']) if self._representation is 'isotropic': - self._absorption = absorption.get_xs(subdomains=subdomain, - nuclides=nuclide, + self._absorption = absorption.get_xs(nuclides=nuclide, xs_type=xs_type) elif self._representation is 'angle': msg = 'Angular-Dependent MGXS have not yet been implemented' raise ValueError(msg) - def set_fission(self, fission, subdomain, nuclide='sum', xs_type='macro'): + def set_fission_mgxs(self, fission, nuclide='total', xs_type='macro'): + """This method allows for an openmc.mgxs.FissionXS + to be used to set the fission cross section for this XSdata object. + + Parameters + ---------- + fission: openmc.mgxs.FissionXS + MGXS Object containing the fission cross section + for the domain of interest. + nuclide : str + Individual nuclide (or 'total' if obtaining material-wise data) + to gather data for. Defaults to 'total'. + xs_type: {'macro', 'micro'} + Provide the macro or micro cross section in units of cm^-1 or + barns. Defaults to 'macro'. + + Raises + ------ + ValueError + When invalid parameters are passed. + """ if not isinstance(fission, openmc.mgxs.FissionXS): msg = 'Method must be passed an openmc.mgxs.FissionXS' raise TypeError(msg) # Make sure passed MGXS object contains correct group structure - if self.energy_groups != fission.energy_groups: - msg = 'Group structure of provided data does not match' \ - ' group structure of XSdata object' - raise ValueError(msg) + check_value('energy_groups', fission.energy_groups, + [self.energy_groups]) + + # Make sure passed MGXS object has correct domain type + check_value('domain_type', fission.domain_type, + ['universe', 'cell', 'material']) if self._representation is 'isotropic': - self._fission = fission.get_xs(subdomains=subdomain, - nuclides=nuclide, + self._fission = fission.get_xs(nuclides=nuclide, xs_type=xs_type) elif self._representation is 'angle': msg = 'Angular-Dependent MGXS have not yet been implemented' raise ValueError(msg) - def set_nu_fission(self, nu_fission, subdomain, nuclide='sum', - xs_type='macro'): + def set_nu_fission_mgxs(self, nu_fission, nuclide='total', xs_type='macro'): + """This method allows for an openmc.mgxs.NuFissionXS + to be used to set the nu-fission cross section for this XSdata object. + + Parameters + ---------- + nu_fission: openmc.mgxs.NuFissionXS + MGXS Object containing the nu-fission cross section + for the domain of interest. + nuclide : str + Individual nuclide (or 'total' if obtaining material-wise data) + to gather data for. Defaults to 'total'. + xs_type: {'macro', 'micro'} + Provide the macro or micro cross section in units of cm^-1 or + barns. Defaults to 'macro'. + + Raises + ------ + ValueError + When invalid parameters are passed. + """ # The NuFissionXS class does not have the capability to produce # a fission matrix and therefore if this path is pursued, we know # chi must be used. @@ -668,14 +824,15 @@ class XSdata(object): raise TypeError(msg) # Make sure passed MGXS object contains correct group structure - if self.energy_groups != nu_fission.energy_groups: - msg = 'Group structure of provided data does not match' \ - ' group structure of XSdata object' - raise ValueError(msg) + check_value('energy_groups', nu_fission.energy_groups, + [self.energy_groups]) + + # Make sure passed MGXS object has correct domain type + check_value('domain_type', nu_fission.domain_type, + ['universe', 'cell', 'material']) if self._representation is 'isotropic': - self._nu_fission = nu_fission.get_xs(subdomains=subdomain, - nuclides=nuclide, + self._nu_fission = nu_fission.get_xs(nuclides=nuclide, xs_type=xs_type) elif self._representation is 'angle': msg = 'Angular-Dependent MGXS have not yet been implemented' @@ -686,27 +843,68 @@ class XSdata(object): if np.sum(self._nu_fission) > 0.0: self._fissionable = True - def set_k_fission(self, k_fission, subdomain, nuclide='sum', - xs_type='macro'): + def set_kappa_fission_mgxs(self, k_fission, nuclide='total', + xs_type='macro'): + """This method allows for an openmc.mgxs.KappaFissionXS + to be used to set the kappa-fission cross section for this XSdata + object. + + Parameters + ---------- + kappa_fission: openmc.mgxs.KappaFissionXS + MGXS Object containing the kappa-fission cross section + for the domain of interest. + nuclide : str + Individual nuclide (or 'total' if obtaining material-wise data) + to gather data for. Defaults to 'total'. + xs_type: {'macro', 'micro'} + Provide the macro or micro cross section in units of cm^-1 or + barns. Defaults to 'macro'. + + Raises + ------ + ValueError + When invalid parameters are passed. + """ if not isinstance(k_fission, openmc.mgxs.KappaFissionXS): msg = 'Method must be passed an openmc.mgxs.KappaFissionXS' raise TypeError(msg) # Make sure passed MGXS object contains correct group structure - if self.energy_groups != k_fission.energy_groups: - msg = 'Group structure of provided data does not match' \ - ' group structure of XSdata object' - raise ValueError(msg) + check_value('energy_groups', k_fission.energy_groups, + [self.energy_groups]) + + # Make sure passed MGXS object has correct domain type + check_value('domain_type', k_fission.domain_type, + ['universe', 'cell', 'material']) if self._representation is 'isotropic': - self._k_fission = k_fission.get_xs(subdomains=subdomain, - nuclides=nuclide, - xs_type=xs_type) + self._kappa_fission = k_fission.get_xs(nuclides=nuclide, + xs_type=xs_type) elif self._representation is 'angle': msg = 'Angular-Dependent MGXS have not yet been implemented' raise ValueError(msg) - def set_chi(self, chi, subdomain, nuclide='sum', xs_type='macro'): + def set_chi_mgxs(self, chi, nuclide='total', xs_type='macro'): + """This method allows for an openmc.mgxs.Chi + to be used to set chi for this XSdata object. + + Parameters + ---------- + chi: openmc.mgxs.Chi + MGXS Object containing chi for the domain of interest. + nuclide : str + Individual nuclide (or 'total' if obtaining material-wise data) + to gather data for. Defaults to 'total'. + xs_type: {'macro', 'micro'} + Provide the macro or micro cross section in units of cm^-1 or + barns. Defaults to 'macro'. + + Raises + ------ + ValueError + When invalid parameters are passed. + """ if self._use_chi is not None: if not self._use_chi: msg = 'Providing chi when nu_fission already provided as a ' \ @@ -718,14 +916,14 @@ class XSdata(object): raise TypeError(msg) # Make sure passed MGXS object contains correct group structure - if self.energy_groups != chi.energy_groups: - msg = 'Group structure of provided data does not match' \ - ' group structure of XSdata object' - raise ValueError(msg) + check_value('energy_groups', chi.energy_groups, [self.energy_groups]) + + # Make sure passed MGXS object has correct domain type + check_value('domain_type', chi.domain_type, + ['universe', 'cell', 'material']) if self._representation is 'isotropic': - self._chi = chi.get_xs(subdomains=subdomain, - nuclides=nuclide, + self._chi = chi.get_xs(nuclides=nuclide, xs_type=xs_type) elif self._representation is 'angle': msg = 'Angular-Dependent MGXS have not yet been implemented' @@ -734,55 +932,102 @@ class XSdata(object): if self._use_chi is not None: self._use_chi = True - def set_scatter(self, scatter, subdomain, nuclide='sum', xs_type='macro'): + def set_scatter_mgxs(self, scatter, nuclide='total', xs_type='macro'): + """This method allows for an openmc.mgxs.ScatterMatrixXS + to be used to set the scatter matrix cross section for this XSdata + object. + + Parameters + ---------- + scatter: openmc.mgxs.ScatterMatrixXS + MGXS Object containing the scatter matrix cross section + for the domain of interest. + nuclide : str + Individual nuclide (or 'total' if obtaining material-wise data) + to gather data for. Defaults to 'total'. + xs_type: {'macro', 'micro'} + Provide the macro or micro cross section in units of cm^-1 or + barns. Defaults to 'macro'. + + Raises + ------ + ValueError + When invalid parameters are passed. + """ if not isinstance(scatter, openmc.mgxs.ScatterMatrixXS): msg = 'Method must be passed an openmc.mgxs.ScatterMatrixXS' raise TypeError(msg) # Make sure passed MGXS object contains correct group structure - if self.energy_groups != scatter.energy_groups: - msg = 'Group structure of provided data does not match' \ - ' group structure of XSdata object' - raise ValueError(msg) + check_value('energy_groups', scatter.energy_groups, + [self.energy_groups]) + + # Make sure passed MGXS object has correct domain type + check_value('domain_type', scatter.domain_type, + ['universe', 'cell', 'material']) if self._representation is 'isotropic': - self._scatter = scatter.get_xs(subdomains=subdomain, - nuclides=nuclide, + self._scatter = scatter.get_xs(nuclides=nuclide, xs_type=xs_type) elif self._representation is 'angle': msg = 'Angular-Dependent MGXS have not yet been implemented' raise ValueError(msg) - def set_multiplicity(self, multiplicity, scatter, subdomain, - nuclide='sum', xs_type='macro'): - if not isinstance(multiplicity, openmc.mgxs.ScatterMatrixXS): + def set_multiplicity_mgxs(self, nuscatter, scatter, nuclide='total', + xs_type='macro'): + """This method allows for an openmc.mgxs.NuScatterMatrixXS and + openmc.mgxs.ScatterMatrixXS to be used to set the scattering + multiplicity for this XSdata object. + + Parameters + ---------- + nuscatter: openmc.mgxs.NuScatterMatrixXS + MGXS Object containing the nu-scattering matrix cross section + for the domain of interest. + scatter: openmc.mgxs.ScatterMatrixXS + MGXS Object containing the scattering matrix cross section + for the domain of interest. + nuclide : str + Individual nuclide (or 'total' if obtaining material-wise data) + to gather data for. Defaults to 'total'. + xs_type: {'macro', 'micro'} + Provide the macro or micro cross section in units of cm^-1 or + barns. Defaults to 'macro'. + + Raises + ------ + ValueError + When invalid parameters are passed. + """ + if not isinstance(nuscatter, openmc.mgxs.NuScatterMatrixXS): msg = 'Method must be passed an openmc.mgxs.ScatterMatrixXS' raise TypeError(msg) if not isinstance(scatter, openmc.mgxs.ScatterMatrixXS): msg = 'Method must be passed an openmc.mgxs.ScatterMatrixXS' raise TypeError(msg) - # Make sure passed MGXS objects contain correct group structure - if self.energy_groups != multiplicity.energy_groups: - msg = 'Group structure of "multiplicity" does not match' \ - ' group structure of XSdata object' - raise ValueError(msg) - if self.energy_groups != scatter.energy_groups: - msg = 'Group structure of "scatter" does not match' \ - ' group structure of XSdata object' - raise ValueError(msg) + # Make sure passed MGXS object contains correct group structure + check_value('energy_groups', nuscatter.energy_groups, + [self.energy_groups]) + check_value('energy_groups', scatter.energy_groups, + [self.energy_groups]) + + # Make sure passed MGXS object has correct domain type + check_value('domain_type', nuscatter.domain_type, + ['universe', 'cell', 'material']) + check_value('domain_type', scatter.domain_type, + ['universe', 'cell', 'material']) if self._representation is 'isotropic': - nuscatt = multiplicity.get_xs(subdomains=subdomain, - nuclides=nuclide, - xs_type=xs_type) - scatt = scatter.get_xs(subdomains=subdomain, - nuclides=nuclide, + nuscatt = nuscatter.get_xs(nuclides=nuclide, + xs_type=xs_type) + scatt = scatter.get_xs(nuclides=nuclide, xs_type=xs_type) self._multiplicity = np.divide(nuscatt, scatt) elif self._representation is 'angle': msg = 'Angular-Dependent MGXS have not yet been implemented' raise ValueError(msg) + self._multiplicity = np.nan_to_num(self._multiplicity) def _get_xsdata_xml(self): element = ET.Element('xsdata') @@ -858,9 +1103,9 @@ class XSdata(object): subelement = ET.SubElement(element, 'fission') subelement.text = ndarray_to_string(self._fission) - if self._k_fission is not None: + if self._kappa_fission is not None: subelement = ET.SubElement(element, 'k_fission') - subelement.text = ndarray_to_string(self._k_fission) + subelement.text = ndarray_to_string(self._kappa_fission) if self._nu_fission is not None: subelement = ET.SubElement(element, 'nu_fission') @@ -947,10 +1192,8 @@ class MGXSLibrary(object): """ - if not isinstance(xsdatas, Iterable): - msg = 'Unable to create OpenMC xsdatas.xml file from "{0}" which' \ - ' is not iterable'.format(xsdatas) - raise ValueError(msg) + # Check we have an iterable of XSdatas + check_iterable_type('xsdatas', xsdatas, XSdata) for xsdata in xsdatas: self.add_xsdata(xsdata) From 6bbf83a9b6010bcabc8467d16d1c9013164b431e Mon Sep 17 00:00:00 2001 From: Adam Nelson Date: Thu, 12 May 2016 05:16:21 -0400 Subject: [PATCH 11/20] Revised docstrings and added some check_type commands instead of isinstance --- openmc/mgxs/library.py | 78 ++++++++-------- openmc/mgxs_library.py | 203 +++++++++++++++++++---------------------- 2 files changed, 134 insertions(+), 147 deletions(-) diff --git a/openmc/mgxs/library.py b/openmc/mgxs/library.py index 991a98f62c..82b7616735 100644 --- a/openmc/mgxs/library.py +++ b/openmc/mgxs/library.py @@ -17,7 +17,7 @@ if sys.version_info[0] >= 3: class Library(object): - '''A multi-group cross section library for some energy group structure. + """A multi-group cross section library for some energy group structure. This class can be used for both OpenMC input generation and tally data post-processing to compute spatially-homogenized and energy-integrated @@ -79,7 +79,7 @@ class Library(object): Whether or not the Library's tallies use SciPy's LIL sparse matrix format for compressed data storage - ''' + """ def __init__(self, openmc_geometry, by_nuclide=False, mgxs_types=None, name=''): @@ -300,7 +300,7 @@ class Library(object): @sparse.setter def sparse(self, sparse): - '''Convert tally data from NumPy arrays to SciPy list of lists (LIL) + """Convert tally data from NumPy arrays to SciPy list of lists (LIL) sparse matrices, and vice versa. This property may be used to reduce the amount of data in memory during @@ -308,7 +308,7 @@ class Library(object): matrices internally within the Tally object. All tally data access properties and methods will return data as a dense NumPy array. - ''' + """ cv.check_type('sparse', sparse, bool) @@ -321,14 +321,14 @@ class Library(object): self._sparse = sparse def build_library(self): - '''Initialize MGXS objects in each domain and for each reaction type + """Initialize MGXS objects in each domain and for each reaction type in the library. This routine will populate the all_mgxs instance attribute dictionary with MGXS subclass objects keyed by each domain ID (e.g., Material IDs) and cross section type (e.g., 'nu-fission', 'total', etc.). - ''' + """ # Initialize MGXS for each domain and mgxs type and store in dictionary for domain in self.domains: @@ -351,7 +351,7 @@ class Library(object): self.all_mgxs[domain.id][mgxs_type] = mgxs def add_to_tallies_file(self, tallies_file, merge=True): - '''Add all tallies from all MGXS objects to a tallies file. + """Add all tallies from all MGXS objects to a tallies file. NOTE: This assumes that :meth:`Library.build_library` has been called @@ -364,7 +364,7 @@ class Library(object): Indicate whether tallies should be merged when possible. Defaults to True. - ''' + """ cv.check_type('tallies_file', tallies_file, openmc.Tallies) @@ -376,7 +376,7 @@ class Library(object): tallies_file.append(tally, merge=merge) def load_from_statepoint(self, statepoint): - '''Extracts tallies in an OpenMC StatePoint with the data needed to + """Extracts tallies in an OpenMC StatePoint with the data needed to compute multi-group cross sections. This method is needed to compute cross section data from tallies @@ -395,7 +395,7 @@ class Library(object): When this method is called with a statepoint that has not been linked with a summary object. - ''' + """ cv.check_type('statepoint', statepoint, openmc.StatePoint) @@ -419,7 +419,7 @@ class Library(object): mgxs.sparse = self.sparse def get_mgxs(self, domain, mgxs_type): - '''Return the MGXS object for some domain and reaction rate type. + """Return the MGXS object for some domain and reaction rate type. This routine searches the library for an MGXS object for the spatial domain and reaction rate type requested by the user. @@ -444,7 +444,7 @@ class Library(object): If no MGXS object can be found for the requested domain or multi-group cross section type - ''' + """ if self.domain_type == 'material': cv.check_type('domain', domain, (openmc.Material, Integral)) @@ -474,7 +474,7 @@ class Library(object): return self.all_mgxs[domain_id][mgxs_type] def get_condensed_library(self, coarse_groups): - '''Construct an energy-condensed version of this library. + """Construct an energy-condensed version of this library. This routine condenses each of the multi-group cross sections in the library to a coarse energy group structure. NOTE: This routine must @@ -501,7 +501,7 @@ class Library(object): -------- MGXS.get_condensed_xs(coarse_groups) - ''' + """ if self.sp_filename is None: msg = 'Unable to get a condensed coarse group cross section ' \ @@ -530,7 +530,7 @@ class Library(object): return condensed_library def get_subdomain_avg_library(self): - '''Construct a subdomain-averaged version of this library. + """Construct a subdomain-averaged version of this library. This routine averages each multi-group cross section across distribcell instances. The method performs spatial homogenization to compute the @@ -553,7 +553,7 @@ class Library(object): -------- MGXS.get_subdomain_avg_xs(subdomains) - ''' + """ if self.sp_filename is None: msg = 'Unable to get a subdomain-averaged cross section ' \ @@ -581,7 +581,7 @@ class Library(object): def build_hdf5_store(self, filename='mgxs.h5', directory='mgxs', subdomains='all', nuclides='all', xs_type='macro', row_column='inout'): - '''Export the multi-group cross section library to an HDF5 binary file. + """Export the multi-group cross section library to an HDF5 binary file. This method constructs an HDF5 file which stores the library's multi-group cross section data. The data is stored in a hierarchy of @@ -624,7 +624,7 @@ class Library(object): -------- MGXS.build_hdf5_store(filename, directory, xs_type) - ''' + """ if self.sp_filename is None: msg = 'Unable to export multi-group cross section library ' \ @@ -659,7 +659,7 @@ class Library(object): nuclides=nuclides, row_column=row_column) def dump_to_file(self, filename='mgxs', directory='mgxs'): - '''Store this Library object in a pickle binary file. + """Store this Library object in a pickle binary file. Parameters ---------- @@ -672,7 +672,7 @@ class Library(object): -------- Library.load_from_file(filename, directory) - ''' + """ cv.check_type('filename', filename, basestring) cv.check_type('directory', directory, basestring) @@ -689,7 +689,7 @@ class Library(object): @staticmethod def load_from_file(filename='mgxs', directory='mgxs'): - '''Load a Library object from a pickle binary file. + """Load a Library object from a pickle binary file. Parameters ---------- @@ -707,7 +707,7 @@ class Library(object): -------- Library.dump_to_file(mgxs_lib, filename, directory) - ''' + """ cv.check_type('filename', filename, basestring) cv.check_type('directory', directory, basestring) @@ -725,7 +725,7 @@ class Library(object): def write_mg_library(self, xs_type='macro', domain_names=None, xs_ids=None, filename='mg_cross_sections', directory='./', return_names=True): - '''Creates a cross-section data library file for the Multi-Group + """Creates a cross-section data library file for the Multi-Group mode of OpenMC. Parameters @@ -768,7 +768,7 @@ class Library(object): -------- Library.dump_to_file(mgxs_lib, filename, directory) - ''' + """ # Check to ensure the Library contains the correct # multi-group cross section types @@ -904,10 +904,11 @@ class Library(object): # accounted for approximately by using an adjusted # absorption cross section. if 'total' in self.mgxs_types: - xsdata.absorption = \ + xsdata._absorption = \ np.subtract(xsdata.total, np.sum(xsdata.scatter[0, :, :], axis=1)) + xsdatas.append(xsdata) # Add XSdatas to file @@ -925,24 +926,20 @@ class Library(object): a MGXS Library for OpenMC's Multi-Group mode via the `Library.write_mg_library` method. The rules to check include: - - Fission is not required as a fixed source problem could be - the target. - - Absorption is required. + - Either total or transport should be present. + - Both can be available if one wants, but we should + use whatever corresponds to Library.correction (if P0: transport) + - Absorption and total (or transport) are required. + - A nu-fission cross section and chi values are not required as a + fixed source problem could be the target. + - Fission and kappa-fission are not required as they are only + needed to support tallies the user may wish to request. - A nu-scatter matrix is required. - Having both nu-scatter (of any order) and scatter (at least isotropic) matrices is preferred - If only nu-scatter, need total (not transport), to be used in adjusting absorption (i.e., reduced_abs = tot - nuscatt) - - Either total or transport should be present. - - Both can be available if one wants, but we should - use whatever corresponds to Library.correction (if P0: transport) - - Raises - ------ - ValueError - When the Library object is initialized with insufficient types of - cross sections for the Library. See also -------- @@ -979,7 +976,12 @@ class Library(object): msg = 'Transport MGXS type is required since a "P0" correction ' \ 'is applied, but a Transport MGXS is not provided.' warn(msg) + elif (((self.correction is None) and + ('total' not in self.mgxs_types))): + error_flag = True + msg = 'Total MGXS type is required, but not provided.' + warn(msg) if error_flag: - msg = "Invalid MGXS configuration encountered." + msg = 'Invalid MGXS configuration encountered.' raise ValueError(msg) diff --git a/openmc/mgxs_library.py b/openmc/mgxs_library.py index f9353f9cc7..29d0bfdd7d 100644 --- a/openmc/mgxs_library.py +++ b/openmc/mgxs_library.py @@ -449,17 +449,18 @@ class XSdata(object): @total.setter def total(self, total): """This method sets the total cross section by performing a - deep-copy of the provided ndarray. + deep-copy of the provided ndarray. If the angular + representation is "isotropic" the shape of the input array + must be the number of energy groups. If the angular + representation is "angle" then the shape of the input + array must be the number of polar angles, number azimuthal + angles and energy groups. Parameters ---------- total: ndarray Array of group-wise cross sections to apply - Raises - ------ - ValueError - When invalid parameters are passed. """ # check we have a numpy list @@ -472,18 +473,20 @@ class XSdata(object): @absorption.setter def absorption(self, absorption): """This method sets the absorption cross section by performing a - deep-copy of the provided ndarray. + deep-copy of the provided ndarray. If the angular + representation is "isotropic" the shape of the input array + must be the number of energy groups. If the angular + representation is "angle" then the shape of the input + array must be the number of polar angles, number azimuthal + angles and energy groups. Parameters ---------- absorption: ndarray Array of group-wise cross sections to apply - Raises - ------ - ValueError - When invalid parameters are passed. """ + # check we have a numpy list check_type('absorption', absorption, np.ndarray, expected_iter_type=Real) @@ -495,18 +498,20 @@ class XSdata(object): @fission.setter def fission(self, fission): """This method sets the fission cross section by performing a - deep-copy of the provided ndarray. + deep-copy of the provided ndarray. If the angular + representation is "isotropic" the shape of the input array + must be the number of energy groups. If the angular + representation is "angle" then the shape of the input + array must be the number of polar angles, number azimuthal + angles and energy groups. Parameters ---------- fission: ndarray Array of group-wise cross sections to apply - Raises - ------ - ValueError - When invalid parameters are passed. """ + # check we have a numpy list check_type('fission', fission, np.ndarray, expected_iter_type=Real) @@ -521,18 +526,20 @@ class XSdata(object): @kappa_fission.setter def kappa_fission(self, kappa_fission): """This method sets the kappa_fission cross section by performing a - deep-copy of the provided ndarray. + deep-copy of the provided ndarray. If the angular + representation is "isotropic" the shape of the input array + must be the number of energy groups. If the angular + representation is "angle" then the shape of the input + array must be the number of polar angles, number azimuthal + angles and energy groups. Parameters ---------- kappa_fission: ndarray Array of group-wise cross sections to apply - Raises - ------ - ValueError - When invalid parameters are passed. """ + # check we have a numpy list check_type('kappa_fission', fission, np.ndarray, expected_iter_type=Real) @@ -548,18 +555,20 @@ class XSdata(object): @chi.setter def chi(self, chi): """This method sets the chi cross section by performing a - deep-copy of the provided ndarray. + deep-copy of the provided ndarray. If the angular + representation is "isotropic" the shape of the input array + must be the number of energy groups. If the angular + representation is "angle" then the shape of the input + array must be the number of polar angles, number azimuthal + angles and energy groups. Parameters ---------- chi: ndarray - Array of group-wise cross sections to apply + Array of group-wise chi values to apply - Raises - ------ - ValueError - When invalid parameters are passed. """ + if self._use_chi is not None: if not self._use_chi: msg = 'Providing chi when nu_fission already provided as a' \ @@ -580,40 +589,50 @@ class XSdata(object): def scatter(self, scatter): """This method sets the scattering matrix cross sections by performing a deep-copy of the provided ndarray. + If the angular representation is "isotropic" the shape of + the input array must be the number of scattering orders, the + number of energy groups, and the number of energy groups. If + the angular representation is "angle" then the shape of the input + array must be the number of polar angles, number azimuthal + angles, number of scattering orders, energy groups, and energy groups. Parameters ---------- scatter : ndarrays - Array of group-wise cross sections to apply + Array of cross sections to apply - Raises - ------ - ValueError - When invalid parameters are passed. """ + # check we have a numpy list check_type('scatter', scatter, np.ndarray, expected_iter_type=Real, max_depth=len(scatter.shape)) # Check the dimensions of the data - check_value('scatter shape', scatter.shape, self.matrix_shape) + check_value('scatter shape', scatter.shape, self.pn_matrix_shape) self._scatter = np.copy(scatter) @multiplicity.setter def multiplicity(self, multiplicity): """This method sets the scattering multiplicity matrix cross sections - by performing a deep-copy of the provided ndarray. + by performing a deep-copy of the provided ndarray. Multiplicity, + in OpenMC parlance, is a factor used to account for the production + of neutrons introduced by scattering multiplication reactions, i.e., + (n,xn) events. In this sense, the multiplication matrix is simply + defined as the ratio of the nu-scatter and scatter matrices. + If the angular representation is "isotropic" the shape of + the input array must be the number of energy groups and the number + of energy groups. If the angular representation is "angle" then the + shape of the input array must be the number of polar angles, + number azimuthal angles, number of scattering orders, energy groups, + and energy groups. Parameters ---------- multiplicity : ndarrays - Array of group-wise cross sections to apply + Array of scattering multiplications to apply - Raises - ------ - ValueError - When invalid parameters are passed. """ + # check we have a numpy list check_type('multiplicity', multiplicity, np.ndarray, expected_iter_type=Real, max_depth=len(multiplicity.shape)) @@ -626,18 +645,20 @@ class XSdata(object): @nu_fission.setter def nu_fission(self, nu_fission): """This method sets the nu_fission cross section by performing a - deep-copy of the provided ndarray. + deep-copy of the provided ndarray. If the angular + representation is "isotropic" the shape of the input array + must be the number of energy groups. If the angular + representation is "angle" then the shape of the input + array must be the number of polar angles, number azimuthal + angles and energy groups. Parameters ---------- nu_fission: ndarray Array of group-wise cross sections to apply - Raises - ------ - ValueError - When invalid parameters are passed. """ + # The NuFissionXS class does not have the capability to produce # a fission matrix and therefore if this path is pursued, we know # chi must be used. @@ -691,16 +712,10 @@ class XSdata(object): Provide the macro or micro cross section in units of cm^-1 or barns. Defaults to 'macro'. - Raises - ------ - ValueError - When invalid parameters are passed. """ - if not isinstance(total, (openmc.mgxs.TotalXS, - openmc.mgxs.TransportXS)): - msg = 'Method must be passed an openmc.mgxs.TotalXS or ' \ - 'openmc.mgxs.TransportXS object' - raise TypeError(msg) + + check_type('total', total, (openmc.mgxs.TotalXS, + openmc.mgxs.TransportXS)) # Make sure passed MGXS object contains correct group structure check_value('energy_groups', total.energy_groups, [self.energy_groups]) @@ -715,7 +730,8 @@ class XSdata(object): msg = 'Angular-Dependent MGXS have not yet been implemented' raise ValueError(msg) - def set_absorption_mgxs(self, absorption, nuclide='total', xs_type='macro'): + def set_absorption_mgxs(self, absorption, nuclide='total', + xs_type='macro'): """This method allows for an openmc.mgxs.AbsorptionXS to be used to set the absorption cross section for this XSdata object. @@ -731,14 +747,9 @@ class XSdata(object): Provide the macro or micro cross section in units of cm^-1 or barns. Defaults to 'macro'. - Raises - ------ - ValueError - When invalid parameters are passed. """ - if not isinstance(absorption, openmc.mgxs.AbsorptionXS): - msg = 'Method must be passed an openmc.mgxs.AbsorptionXS' - raise TypeError(msg) + + check_type('absorption', absorption, openmc.mgxs.AbsorptionXS) # Make sure passed MGXS object contains correct group structure check_value('energy_groups', absorption.energy_groups, @@ -771,14 +782,9 @@ class XSdata(object): Provide the macro or micro cross section in units of cm^-1 or barns. Defaults to 'macro'. - Raises - ------ - ValueError - When invalid parameters are passed. """ - if not isinstance(fission, openmc.mgxs.FissionXS): - msg = 'Method must be passed an openmc.mgxs.FissionXS' - raise TypeError(msg) + + check_type('fission', fission, openmc.mgxs.FissionXS) # Make sure passed MGXS object contains correct group structure check_value('energy_groups', fission.energy_groups, @@ -795,7 +801,8 @@ class XSdata(object): msg = 'Angular-Dependent MGXS have not yet been implemented' raise ValueError(msg) - def set_nu_fission_mgxs(self, nu_fission, nuclide='total', xs_type='macro'): + def set_nu_fission_mgxs(self, nu_fission, nuclide='total', + xs_type='macro'): """This method allows for an openmc.mgxs.NuFissionXS to be used to set the nu-fission cross section for this XSdata object. @@ -811,17 +818,12 @@ class XSdata(object): Provide the macro or micro cross section in units of cm^-1 or barns. Defaults to 'macro'. - Raises - ------ - ValueError - When invalid parameters are passed. """ + # The NuFissionXS class does not have the capability to produce # a fission matrix and therefore if this path is pursued, we know # chi must be used. - if not isinstance(nu_fission, openmc.mgxs.NuFissionXS): - msg = 'Method must be passed an openmc.mgxs.NuFissionXS' - raise TypeError(msg) + check_type('nu_fission', nu_fission, openmc.mgxs.NuFissionXS) # Make sure passed MGXS object contains correct group structure check_value('energy_groups', nu_fission.energy_groups, @@ -861,14 +863,9 @@ class XSdata(object): Provide the macro or micro cross section in units of cm^-1 or barns. Defaults to 'macro'. - Raises - ------ - ValueError - When invalid parameters are passed. """ - if not isinstance(k_fission, openmc.mgxs.KappaFissionXS): - msg = 'Method must be passed an openmc.mgxs.KappaFissionXS' - raise TypeError(msg) + + check_type('k_fission', k_fission, openmc.mgxs.KappaFissionXS) # Make sure passed MGXS object contains correct group structure check_value('energy_groups', k_fission.energy_groups, @@ -900,20 +897,15 @@ class XSdata(object): Provide the macro or micro cross section in units of cm^-1 or barns. Defaults to 'macro'. - Raises - ------ - ValueError - When invalid parameters are passed. """ + if self._use_chi is not None: if not self._use_chi: msg = 'Providing chi when nu_fission already provided as a ' \ 'matrix!' raise ValueError(msg) - if not isinstance(chi, openmc.mgxs.Chi): - msg = 'Method must be passed an openmc.mgxs.Chi' - raise TypeError(msg) + check_type('chi', chi, openmc.mgxs.Chi) # Make sure passed MGXS object contains correct group structure check_value('energy_groups', chi.energy_groups, [self.energy_groups]) @@ -949,14 +941,9 @@ class XSdata(object): Provide the macro or micro cross section in units of cm^-1 or barns. Defaults to 'macro'. - Raises - ------ - ValueError - When invalid parameters are passed. """ - if not isinstance(scatter, openmc.mgxs.ScatterMatrixXS): - msg = 'Method must be passed an openmc.mgxs.ScatterMatrixXS' - raise TypeError(msg) + + check_type('scatter', scatter, openmc.mgxs.ScatterMatrixXS) # Make sure passed MGXS object contains correct group structure check_value('energy_groups', scatter.energy_groups, @@ -967,8 +954,9 @@ class XSdata(object): ['universe', 'cell', 'material']) if self._representation is 'isotropic': - self._scatter = scatter.get_xs(nuclides=nuclide, - xs_type=xs_type) + self._scatter = np.array([scatter.get_xs(nuclides=nuclide, + xs_type=xs_type)]) + elif self._representation is 'angle': msg = 'Angular-Dependent MGXS have not yet been implemented' raise ValueError(msg) @@ -977,7 +965,11 @@ class XSdata(object): xs_type='macro'): """This method allows for an openmc.mgxs.NuScatterMatrixXS and openmc.mgxs.ScatterMatrixXS to be used to set the scattering - multiplicity for this XSdata object. + multiplicity for this XSdata object. Multiplicity, + in OpenMC parlance, is a factor used to account for the production + of neutrons introduced by scattering multiplication reactions, i.e., + (n,xn) events. In this sense, the multiplication matrix is simply + defined as the ratio of the nu-scatter and scatter matrices. Parameters ---------- @@ -994,17 +986,10 @@ class XSdata(object): Provide the macro or micro cross section in units of cm^-1 or barns. Defaults to 'macro'. - Raises - ------ - ValueError - When invalid parameters are passed. """ - if not isinstance(nuscatter, openmc.mgxs.NuScatterMatrixXS): - msg = 'Method must be passed an openmc.mgxs.ScatterMatrixXS' - raise TypeError(msg) - if not isinstance(scatter, openmc.mgxs.ScatterMatrixXS): - msg = 'Method must be passed an openmc.mgxs.ScatterMatrixXS' - raise TypeError(msg) + + check_type('nuscatter', nuscatter, openmc.mgxs.NuScatterMatrixXS) + check_type('scatter', scatter, openmc.mgxs.ScatterMatrixXS) # Make sure passed MGXS object contains correct group structure check_value('energy_groups', nuscatter.energy_groups, From e9fc744ba597a28d72dcbe204f60167e85eaa3c8 Mon Sep 17 00:00:00 2001 From: Adam Nelson Date: Thu, 12 May 2016 21:34:03 -0400 Subject: [PATCH 12/20] Updated example notebook and changed default value of return_names in write_mg_library to False and updated the docstring accordingly. --- .../pythonapi/examples/mgxs-part-iv.ipynb | 1423 ++++++++++++----- openmc/mgxs/library.py | 4 +- 2 files changed, 997 insertions(+), 430 deletions(-) diff --git a/docs/source/pythonapi/examples/mgxs-part-iv.ipynb b/docs/source/pythonapi/examples/mgxs-part-iv.ipynb index bc85af5c24..823d67ae16 100644 --- a/docs/source/pythonapi/examples/mgxs-part-iv.ipynb +++ b/docs/source/pythonapi/examples/mgxs-part-iv.ipynb @@ -6,10 +6,10 @@ "source": [ "This Notebook illustrates the use of the openmc.mgxs.Library class specifically for application in OpenMC's multi-group mode. This example notebook follows the same process as was done in MGXS Part III, but instead uses OpenMC as the multi-group solver. This Notebook illustrates the following features:\n", "\n", - " Calculation of multi-group cross sections for a fuel assembly\n", - " Automated creation, manipulation and storage of MGXS with openmc.mgxs.Library\n", - " Validation of multi-group cross sections with OpenMC\n", - " Steady-state pin-by-pin fission rates comparison between Continuous-Energy mode and Multi-Group OpenMC.\n", + " - Calculation of multi-group cross sections for a fuel assembly\n", + " - Automated creation, manipulation and storage of MGXS with openmc.mgxs.Library\n", + " - Validation of multi-group cross sections with OpenMC\n", + " - Steady-state pin-by-pin fission rates comparison between Continuous-Energy mode and Multi-Group OpenMC.\n", "\n", "Note: This Notebook illustrates the use of Pandas DataFrames to containerize multi-group cross section data. We recommend using Pandas >v0.15.0 or later since OpenMC's Python API leverages the multi-indexing feature included in the most recent releases of Pandas.\n" ] @@ -170,22 +170,22 @@ "outputs": [], "source": [ "# Create a Universe to encapsulate a fuel pin\n", - "fuel_pin_universe = openmc.Universe(name='1.6% Fuel Pin')\n", + "fuel_pin_universe = openmc.Universe(name='1.6% Fuel Pin', universe_id=10)\n", "\n", "# Create fuel Cell\n", - "fuel_cell = openmc.Cell(name='1.6% Fuel')\n", + "fuel_cell = openmc.Cell(name='1.6% Fuel', cell_id=1)\n", "fuel_cell.fill = fuel\n", "fuel_cell.region = -fuel_outer_radius\n", "fuel_pin_universe.add_cell(fuel_cell)\n", "\n", "# Create a clad Cell\n", - "clad_cell = openmc.Cell(name='1.6% Clad')\n", + "clad_cell = openmc.Cell(name='1.6% Clad', cell_id=2)\n", "clad_cell.fill = zircaloy\n", "clad_cell.region = +fuel_outer_radius & -clad_outer_radius\n", "fuel_pin_universe.add_cell(clad_cell)\n", "\n", "# Create a moderator Cell\n", - "moderator_cell = openmc.Cell(name='1.6% Moderator')\n", + "moderator_cell = openmc.Cell(name='1.6% Moderator', cell_id=3)\n", "moderator_cell.fill = water\n", "moderator_cell.region = +clad_outer_radius\n", "fuel_pin_universe.add_cell(moderator_cell)" @@ -207,22 +207,22 @@ "outputs": [], "source": [ "# Create a Universe to encapsulate a control rod guide tube\n", - "guide_tube_universe = openmc.Universe(name='Guide Tube')\n", + "guide_tube_universe = openmc.Universe(name='Guide Tube', universe_id=20)\n", "\n", "# Create guide tube Cell\n", - "guide_tube_cell = openmc.Cell(name='Guide Tube Water')\n", + "guide_tube_cell = openmc.Cell(name='Guide Tube Water', cell_id=4)\n", "guide_tube_cell.fill = water\n", "guide_tube_cell.region = -fuel_outer_radius\n", "guide_tube_universe.add_cell(guide_tube_cell)\n", "\n", "# Create a clad Cell\n", - "clad_cell = openmc.Cell(name='Guide Clad')\n", + "clad_cell = openmc.Cell(name='Guide Clad', cell_id=5)\n", "clad_cell.fill = zircaloy\n", "clad_cell.region = +fuel_outer_radius & -clad_outer_radius\n", "guide_tube_universe.add_cell(clad_cell)\n", "\n", "# Create a moderator Cell\n", - "moderator_cell = openmc.Cell(name='Guide Tube Moderator')\n", + "moderator_cell = openmc.Cell(name='Guide Tube Moderator', cell_id=6)\n", "moderator_cell.fill = water\n", "moderator_cell.region = +clad_outer_radius\n", "guide_tube_universe.add_cell(moderator_cell)" @@ -239,12 +239,12 @@ "cell_type": "code", "execution_count": 8, "metadata": { - "collapsed": true + "collapsed": false }, "outputs": [], "source": [ "# Create fuel assembly Lattice\n", - "assembly = openmc.RectLattice(name='1.6% Fuel Assembly')\n", + "assembly = openmc.RectLattice(name='1.6% Fuel Assembly', lattice_id=100)\n", "assembly.dimension = (17, 17)\n", "assembly.pitch = (1.26, 1.26)\n", "assembly.lower_left = [-1.26 * 17. / 2.0] * 2" @@ -298,7 +298,7 @@ "outputs": [], "source": [ "# Create root Cell\n", - "root_cell = openmc.Cell(name='root cell')\n", + "root_cell = openmc.Cell(name='root cell', cell_id=0)\n", "root_cell.fill = assembly\n", "\n", "# Add boundary planes\n", @@ -347,7 +347,7 @@ "outputs": [], "source": [ "# OpenMC simulation parameters\n", - "batches = 200\n", + "batches = 500\n", "inactive = 10\n", "particles = 5000\n", "\n", @@ -434,7 +434,7 @@ "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAPoAAAD6AgMAAAD1grKuAAAABGdBTUEAALGPC/xhBQAAACBjSFJN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\nVDE0OjIyOjAzLTA0OjAw01pE9wAAAABJRU5ErkJggg==\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAPoAAAD6AgMAAAD1grKuAAAABGdBTUEAALGPC/xhBQAAACBjSFJN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\nVDIxOjE1OjAxLTA0OjAwo0qoOwAAAABJRU5ErkJggg==\n", "text/plain": [ "" ] @@ -554,7 +554,7 @@ "cell_type": "code", "execution_count": 20, "metadata": { - "collapsed": true + "collapsed": false }, "outputs": [], "source": [ @@ -566,12 +566,31 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Lastly, we use the `Library` to construct the tallies needed to compute all of the requested multi-group cross sections in each domain and nuclide." + "Now that the `Library` has been setup, lets make sure it contains the types of cross sections which meet the needs of OpenMC's multi-group solver. Note that this step is done automatically when writing the Multi-Group Library file later in the process (as part of the `mgxs_lib.write_mg_library()`), but it is a good practice to also run this before spending all the time running OpenMC to generate the cross sections." ] }, { "cell_type": "code", "execution_count": 21, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "# Check the library - if no errors are raised, then the library is satisfactory.\n", + "mgxs_lib.check_library_for_openmc_mgxs()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Lastly, we use the `Library` to construct the tallies needed to compute all of the requested multi-group cross sections in each domain and nuclide." + ] + }, + { + "cell_type": "code", + "execution_count": 22, "metadata": { "collapsed": true }, @@ -592,7 +611,7 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 23, "metadata": { "collapsed": true }, @@ -612,7 +631,7 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 24, "metadata": { "collapsed": true }, @@ -640,7 +659,7 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 25, "metadata": { "collapsed": true }, @@ -652,7 +671,7 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 26, "metadata": { "collapsed": false }, @@ -677,8 +696,8 @@ " Copyright: 2011-2016 Massachusetts Institute of Technology\n", " License: http://openmc.readthedocs.org/en/latest/license.html\n", " Version: 0.7.1\n", - " Git SHA1: 179e9ab147e505563d118ed58096b3d225160ffa\n", - " Date/Time: 2016-05-07 14:22:04\n", + " Git SHA1: c779ca42c41a062a6a813e03f2add2d182ca9190\n", + " Date/Time: 2016-05-12 21:15:02\n", " OpenMP Threads: 4\n", "\n", " ===========================================================================\n", @@ -906,7 +925,307 @@ " 198/1 1.01366 1.02596 +/- 0.00130\n", " 199/1 1.04471 1.02605 +/- 0.00130\n", " 200/1 1.02416 1.02604 +/- 0.00129\n", - " Creating state point statepoint.200.h5...\n", + " 201/1 1.01172 1.02597 +/- 0.00129\n", + " 202/1 1.01683 1.02592 +/- 0.00128\n", + " 203/1 1.01341 1.02586 +/- 0.00128\n", + " 204/1 1.01507 1.02580 +/- 0.00127\n", + " 205/1 1.02540 1.02580 +/- 0.00127\n", + " 206/1 1.00310 1.02568 +/- 0.00127\n", + " 207/1 1.02822 1.02570 +/- 0.00126\n", + " 208/1 1.01023 1.02562 +/- 0.00126\n", + " 209/1 1.04603 1.02572 +/- 0.00125\n", + " 210/1 1.00775 1.02563 +/- 0.00125\n", + " 211/1 1.01706 1.02559 +/- 0.00125\n", + " 212/1 0.99434 1.02543 +/- 0.00125\n", + " 213/1 1.03346 1.02547 +/- 0.00124\n", + " 214/1 1.05322 1.02561 +/- 0.00124\n", + " 215/1 1.03057 1.02563 +/- 0.00124\n", + " 216/1 1.00976 1.02556 +/- 0.00123\n", + " 217/1 1.02760 1.02557 +/- 0.00123\n", + " 218/1 1.01259 1.02550 +/- 0.00122\n", + " 219/1 1.02829 1.02552 +/- 0.00122\n", + " 220/1 1.02228 1.02550 +/- 0.00121\n", + " 221/1 1.06679 1.02570 +/- 0.00122\n", + " 222/1 1.03417 1.02574 +/- 0.00122\n", + " 223/1 1.04239 1.02582 +/- 0.00121\n", + " 224/1 1.02062 1.02579 +/- 0.00121\n", + " 225/1 1.00331 1.02569 +/- 0.00121\n", + " 226/1 1.00131 1.02557 +/- 0.00121\n", + " 227/1 1.01768 1.02554 +/- 0.00120\n", + " 228/1 1.00813 1.02546 +/- 0.00120\n", + " 229/1 1.05320 1.02558 +/- 0.00120\n", + " 230/1 1.03472 1.02563 +/- 0.00120\n", + " 231/1 1.01426 1.02557 +/- 0.00119\n", + " 232/1 1.00782 1.02549 +/- 0.00119\n", + " 233/1 1.02813 1.02551 +/- 0.00118\n", + " 234/1 1.01184 1.02545 +/- 0.00118\n", + " 235/1 1.02156 1.02543 +/- 0.00118\n", + " 236/1 0.99029 1.02527 +/- 0.00118\n", + " 237/1 1.04196 1.02535 +/- 0.00118\n", + " 238/1 1.01594 1.02531 +/- 0.00117\n", + " 239/1 1.02732 1.02531 +/- 0.00117\n", + " 240/1 0.98987 1.02516 +/- 0.00117\n", + " 241/1 1.03388 1.02520 +/- 0.00117\n", + " 242/1 1.01319 1.02515 +/- 0.00116\n", + " 243/1 1.02870 1.02516 +/- 0.00116\n", + " 244/1 1.01943 1.02514 +/- 0.00115\n", + " 245/1 1.04463 1.02522 +/- 0.00115\n", + " 246/1 1.03551 1.02526 +/- 0.00115\n", + " 247/1 1.00436 1.02517 +/- 0.00115\n", + " 248/1 1.03326 1.02521 +/- 0.00114\n", + " 249/1 1.05769 1.02534 +/- 0.00115\n", + " 250/1 1.01372 1.02530 +/- 0.00114\n", + " 251/1 1.02971 1.02531 +/- 0.00114\n", + " 252/1 1.01166 1.02526 +/- 0.00113\n", + " 253/1 1.03992 1.02532 +/- 0.00113\n", + " 254/1 1.01507 1.02528 +/- 0.00113\n", + " 255/1 1.03222 1.02530 +/- 0.00112\n", + " 256/1 1.03096 1.02533 +/- 0.00112\n", + " 257/1 1.01153 1.02527 +/- 0.00112\n", + " 258/1 1.03668 1.02532 +/- 0.00111\n", + " 259/1 1.03070 1.02534 +/- 0.00111\n", + " 260/1 1.01189 1.02529 +/- 0.00111\n", + " 261/1 1.00082 1.02519 +/- 0.00111\n", + " 262/1 1.03653 1.02523 +/- 0.00110\n", + " 263/1 1.02908 1.02525 +/- 0.00110\n", + " 264/1 1.00072 1.02515 +/- 0.00110\n", + " 265/1 1.00832 1.02509 +/- 0.00109\n", + " 266/1 1.04385 1.02516 +/- 0.00109\n", + " 267/1 1.00117 1.02507 +/- 0.00109\n", + " 268/1 1.02682 1.02507 +/- 0.00109\n", + " 269/1 1.03202 1.02510 +/- 0.00108\n", + " 270/1 1.01275 1.02505 +/- 0.00108\n", + " 271/1 1.02633 1.02506 +/- 0.00108\n", + " 272/1 1.04811 1.02514 +/- 0.00108\n", + " 273/1 1.02851 1.02516 +/- 0.00107\n", + " 274/1 1.01270 1.02511 +/- 0.00107\n", + " 275/1 1.06222 1.02525 +/- 0.00107\n", + " 276/1 1.02778 1.02526 +/- 0.00107\n", + " 277/1 1.02601 1.02526 +/- 0.00107\n", + " 278/1 1.02356 1.02526 +/- 0.00106\n", + " 279/1 1.00792 1.02519 +/- 0.00106\n", + " 280/1 1.02331 1.02518 +/- 0.00106\n", + " 281/1 1.00985 1.02513 +/- 0.00105\n", + " 282/1 1.02035 1.02511 +/- 0.00105\n", + " 283/1 0.98181 1.02495 +/- 0.00106\n", + " 284/1 1.01829 1.02493 +/- 0.00106\n", + " 285/1 1.02929 1.02494 +/- 0.00105\n", + " 286/1 1.03524 1.02498 +/- 0.00105\n", + " 287/1 1.01212 1.02493 +/- 0.00105\n", + " 288/1 1.03584 1.02497 +/- 0.00104\n", + " 289/1 1.02961 1.02499 +/- 0.00104\n", + " 290/1 0.99692 1.02489 +/- 0.00104\n", + " 291/1 1.03966 1.02494 +/- 0.00104\n", + " 292/1 1.00965 1.02489 +/- 0.00104\n", + " 293/1 1.02601 1.02489 +/- 0.00103\n", + " 294/1 1.03224 1.02492 +/- 0.00103\n", + " 295/1 1.01596 1.02489 +/- 0.00103\n", + " 296/1 1.06964 1.02504 +/- 0.00103\n", + " 297/1 1.03982 1.02509 +/- 0.00103\n", + " 298/1 0.99758 1.02500 +/- 0.00103\n", + " 299/1 1.01479 1.02496 +/- 0.00103\n", + " 300/1 1.04517 1.02503 +/- 0.00103\n", + " 301/1 0.99128 1.02492 +/- 0.00103\n", + " 302/1 1.01493 1.02488 +/- 0.00103\n", + " 303/1 1.00623 1.02482 +/- 0.00103\n", + " 304/1 1.02560 1.02482 +/- 0.00102\n", + " 305/1 1.00806 1.02477 +/- 0.00102\n", + " 306/1 1.03524 1.02480 +/- 0.00102\n", + " 307/1 0.99244 1.02469 +/- 0.00102\n", + " 308/1 0.98013 1.02454 +/- 0.00103\n", + " 309/1 1.00853 1.02449 +/- 0.00103\n", + " 310/1 1.00116 1.02441 +/- 0.00103\n", + " 311/1 1.01730 1.02439 +/- 0.00102\n", + " 312/1 1.01198 1.02435 +/- 0.00102\n", + " 313/1 1.02405 1.02435 +/- 0.00102\n", + " 314/1 1.01734 1.02432 +/- 0.00101\n", + " 315/1 1.02320 1.02432 +/- 0.00101\n", + " 316/1 1.03438 1.02435 +/- 0.00101\n", + " 317/1 1.00106 1.02428 +/- 0.00101\n", + " 318/1 1.03114 1.02430 +/- 0.00100\n", + " 319/1 1.04955 1.02438 +/- 0.00100\n", + " 320/1 1.03259 1.02441 +/- 0.00100\n", + " 321/1 1.00687 1.02435 +/- 0.00100\n", + " 322/1 1.05753 1.02446 +/- 0.00100\n", + " 323/1 1.03676 1.02450 +/- 0.00100\n", + " 324/1 0.99796 1.02441 +/- 0.00100\n", + " 325/1 1.03783 1.02445 +/- 0.00100\n", + " 326/1 1.02315 1.02445 +/- 0.00099\n", + " 327/1 1.04205 1.02451 +/- 0.00099\n", + " 328/1 1.01971 1.02449 +/- 0.00099\n", + " 329/1 1.02394 1.02449 +/- 0.00099\n", + " 330/1 1.03318 1.02452 +/- 0.00098\n", + " 331/1 1.01503 1.02449 +/- 0.00098\n", + " 332/1 1.07143 1.02463 +/- 0.00099\n", + " 333/1 1.00991 1.02459 +/- 0.00099\n", + " 334/1 1.03115 1.02461 +/- 0.00098\n", + " 335/1 1.04400 1.02467 +/- 0.00098\n", + " 336/1 1.03516 1.02470 +/- 0.00098\n", + " 337/1 1.02025 1.02468 +/- 0.00098\n", + " 338/1 1.03269 1.02471 +/- 0.00098\n", + " 339/1 1.03745 1.02475 +/- 0.00097\n", + " 340/1 1.03685 1.02478 +/- 0.00097\n", + " 341/1 1.01831 1.02476 +/- 0.00097\n", + " 342/1 1.01425 1.02473 +/- 0.00097\n", + " 343/1 1.02990 1.02475 +/- 0.00096\n", + " 344/1 1.02958 1.02476 +/- 0.00096\n", + " 345/1 1.03133 1.02478 +/- 0.00096\n", + " 346/1 1.02441 1.02478 +/- 0.00095\n", + " 347/1 1.07010 1.02492 +/- 0.00096\n", + " 348/1 1.02327 1.02491 +/- 0.00096\n", + " 349/1 1.03123 1.02493 +/- 0.00096\n", + " 350/1 1.03158 1.02495 +/- 0.00095\n", + " 351/1 1.03473 1.02498 +/- 0.00095\n", + " 352/1 1.04000 1.02502 +/- 0.00095\n", + " 353/1 1.01651 1.02500 +/- 0.00095\n", + " 354/1 1.03647 1.02503 +/- 0.00094\n", + " 355/1 1.04650 1.02509 +/- 0.00094\n", + " 356/1 1.04703 1.02516 +/- 0.00094\n", + " 357/1 1.00260 1.02509 +/- 0.00094\n", + " 358/1 1.00075 1.02502 +/- 0.00094\n", + " 359/1 1.04874 1.02509 +/- 0.00094\n", + " 360/1 1.03211 1.02511 +/- 0.00094\n", + " 361/1 1.02136 1.02510 +/- 0.00094\n", + " 362/1 1.00803 1.02505 +/- 0.00094\n", + " 363/1 1.00319 1.02499 +/- 0.00094\n", + " 364/1 1.01443 1.02496 +/- 0.00093\n", + " 365/1 1.02685 1.02496 +/- 0.00093\n", + " 366/1 1.02373 1.02496 +/- 0.00093\n", + " 367/1 1.02026 1.02495 +/- 0.00093\n", + " 368/1 1.01579 1.02492 +/- 0.00092\n", + " 369/1 1.08004 1.02508 +/- 0.00093\n", + " 370/1 1.01715 1.02505 +/- 0.00093\n", + " 371/1 0.98578 1.02494 +/- 0.00093\n", + " 372/1 1.03033 1.02496 +/- 0.00093\n", + " 373/1 1.03269 1.02498 +/- 0.00093\n", + " 374/1 1.04050 1.02502 +/- 0.00093\n", + " 375/1 1.00760 1.02498 +/- 0.00093\n", + " 376/1 1.04492 1.02503 +/- 0.00093\n", + " 377/1 1.04983 1.02510 +/- 0.00093\n", + " 378/1 1.06022 1.02519 +/- 0.00093\n", + " 379/1 1.02516 1.02519 +/- 0.00093\n", + " 380/1 1.01740 1.02517 +/- 0.00092\n", + " 381/1 1.02520 1.02517 +/- 0.00092\n", + " 382/1 1.02820 1.02518 +/- 0.00092\n", + " 383/1 1.00697 1.02513 +/- 0.00092\n", + " 384/1 1.03497 1.02516 +/- 0.00092\n", + " 385/1 0.98404 1.02505 +/- 0.00092\n", + " 386/1 1.05206 1.02512 +/- 0.00092\n", + " 387/1 1.01502 1.02509 +/- 0.00092\n", + " 388/1 1.02196 1.02508 +/- 0.00092\n", + " 389/1 1.02856 1.02509 +/- 0.00091\n", + " 390/1 1.01376 1.02506 +/- 0.00091\n", + " 391/1 1.01696 1.02504 +/- 0.00091\n", + " 392/1 1.03283 1.02506 +/- 0.00091\n", + " 393/1 1.00787 1.02502 +/- 0.00091\n", + " 394/1 1.02184 1.02501 +/- 0.00090\n", + " 395/1 1.03170 1.02503 +/- 0.00090\n", + " 396/1 1.04406 1.02508 +/- 0.00090\n", + " 397/1 1.03939 1.02511 +/- 0.00090\n", + " 398/1 1.00329 1.02506 +/- 0.00090\n", + " 399/1 1.04518 1.02511 +/- 0.00090\n", + " 400/1 1.03435 1.02513 +/- 0.00090\n", + " 401/1 1.00525 1.02508 +/- 0.00089\n", + " 402/1 1.03112 1.02510 +/- 0.00089\n", + " 403/1 1.00188 1.02504 +/- 0.00089\n", + " 404/1 1.01241 1.02501 +/- 0.00089\n", + " 405/1 1.01796 1.02499 +/- 0.00089\n", + " 406/1 1.02686 1.02499 +/- 0.00089\n", + " 407/1 1.01003 1.02496 +/- 0.00088\n", + " 408/1 1.02359 1.02495 +/- 0.00088\n", + " 409/1 1.01258 1.02492 +/- 0.00088\n", + " 410/1 1.04361 1.02497 +/- 0.00088\n", + " 411/1 1.00885 1.02493 +/- 0.00088\n", + " 412/1 1.00999 1.02489 +/- 0.00088\n", + " 413/1 0.97832 1.02477 +/- 0.00088\n", + " 414/1 1.04183 1.02482 +/- 0.00088\n", + " 415/1 1.02279 1.02481 +/- 0.00088\n", + " 416/1 1.04197 1.02485 +/- 0.00088\n", + " 417/1 1.04617 1.02491 +/- 0.00088\n", + " 418/1 1.01311 1.02488 +/- 0.00088\n", + " 419/1 1.03904 1.02491 +/- 0.00087\n", + " 420/1 1.00458 1.02486 +/- 0.00087\n", + " 421/1 0.98580 1.02477 +/- 0.00088\n", + " 422/1 1.01850 1.02475 +/- 0.00087\n", + " 423/1 1.03739 1.02478 +/- 0.00087\n", + " 424/1 1.02716 1.02479 +/- 0.00087\n", + " 425/1 1.00711 1.02475 +/- 0.00087\n", + " 426/1 1.01008 1.02471 +/- 0.00087\n", + " 427/1 1.03332 1.02473 +/- 0.00087\n", + " 428/1 1.00501 1.02468 +/- 0.00087\n", + " 429/1 1.04549 1.02473 +/- 0.00086\n", + " 430/1 1.00582 1.02469 +/- 0.00086\n", + " 431/1 1.00586 1.02464 +/- 0.00086\n", + " 432/1 1.00082 1.02459 +/- 0.00086\n", + " 433/1 1.00835 1.02455 +/- 0.00086\n", + " 434/1 1.03965 1.02458 +/- 0.00086\n", + " 435/1 1.02385 1.02458 +/- 0.00086\n", + " 436/1 1.01440 1.02456 +/- 0.00086\n", + " 437/1 1.03127 1.02458 +/- 0.00085\n", + " 438/1 1.02961 1.02459 +/- 0.00085\n", + " 439/1 0.99584 1.02452 +/- 0.00085\n", + " 440/1 1.04964 1.02458 +/- 0.00085\n", + " 441/1 0.99792 1.02452 +/- 0.00085\n", + " 442/1 1.04971 1.02457 +/- 0.00085\n", + " 443/1 1.01504 1.02455 +/- 0.00085\n", + " 444/1 1.04359 1.02460 +/- 0.00085\n", + " 445/1 1.01148 1.02457 +/- 0.00085\n", + " 446/1 1.01203 1.02454 +/- 0.00085\n", + " 447/1 1.02353 1.02454 +/- 0.00085\n", + " 448/1 1.06299 1.02462 +/- 0.00085\n", + " 449/1 1.00017 1.02457 +/- 0.00085\n", + " 450/1 1.01193 1.02454 +/- 0.00085\n", + " 451/1 1.00179 1.02449 +/- 0.00085\n", + " 452/1 1.02425 1.02449 +/- 0.00085\n", + " 453/1 1.03629 1.02451 +/- 0.00084\n", + " 454/1 1.01955 1.02450 +/- 0.00084\n", + " 455/1 1.00870 1.02447 +/- 0.00084\n", + " 456/1 1.04230 1.02451 +/- 0.00084\n", + " 457/1 1.05081 1.02457 +/- 0.00084\n", + " 458/1 1.00271 1.02452 +/- 0.00084\n", + " 459/1 1.01010 1.02448 +/- 0.00084\n", + " 460/1 1.04656 1.02453 +/- 0.00084\n", + " 461/1 1.00790 1.02450 +/- 0.00084\n", + " 462/1 1.02214 1.02449 +/- 0.00084\n", + " 463/1 1.04401 1.02453 +/- 0.00083\n", + " 464/1 1.02863 1.02454 +/- 0.00083\n", + " 465/1 0.99971 1.02449 +/- 0.00083\n", + " 466/1 1.00344 1.02444 +/- 0.00083\n", + " 467/1 1.02810 1.02445 +/- 0.00083\n", + " 468/1 1.02091 1.02444 +/- 0.00083\n", + " 469/1 1.00545 1.02440 +/- 0.00083\n", + " 470/1 1.01590 1.02438 +/- 0.00083\n", + " 471/1 1.04465 1.02443 +/- 0.00083\n", + " 472/1 1.02028 1.02442 +/- 0.00082\n", + " 473/1 1.01951 1.02441 +/- 0.00082\n", + " 474/1 1.03280 1.02443 +/- 0.00082\n", + " 475/1 1.04722 1.02447 +/- 0.00082\n", + " 476/1 1.03587 1.02450 +/- 0.00082\n", + " 477/1 1.02234 1.02449 +/- 0.00082\n", + " 478/1 1.07848 1.02461 +/- 0.00082\n", + " 479/1 1.04759 1.02466 +/- 0.00082\n", + " 480/1 1.07189 1.02476 +/- 0.00083\n", + " 481/1 1.05811 1.02483 +/- 0.00083\n", + " 482/1 1.04554 1.02487 +/- 0.00083\n", + " 483/1 1.01956 1.02486 +/- 0.00083\n", + " 484/1 1.01055 1.02483 +/- 0.00083\n", + " 485/1 1.00845 1.02480 +/- 0.00082\n", + " 486/1 1.04607 1.02484 +/- 0.00082\n", + " 487/1 1.05955 1.02492 +/- 0.00083\n", + " 488/1 1.02245 1.02491 +/- 0.00082\n", + " 489/1 0.98206 1.02482 +/- 0.00083\n", + " 490/1 1.03786 1.02485 +/- 0.00083\n", + " 491/1 1.02973 1.02486 +/- 0.00082\n", + " 492/1 1.02890 1.02487 +/- 0.00082\n", + " 493/1 1.02086 1.02486 +/- 0.00082\n", + " 494/1 1.01194 1.02483 +/- 0.00082\n", + " 495/1 1.01902 1.02482 +/- 0.00082\n", + " 496/1 1.01783 1.02481 +/- 0.00082\n", + " 497/1 1.02129 1.02480 +/- 0.00081\n", + " 498/1 1.02407 1.02480 +/- 0.00081\n", + " 499/1 1.02873 1.02480 +/- 0.00081\n", + " 500/1 1.00998 1.02477 +/- 0.00081\n", + " Creating state point statepoint.500.h5...\n", "\n", " ===========================================================================\n", " ======================> SIMULATION FINISHED <======================\n", @@ -915,27 +1234,27 @@ "\n", " =======================> TIMING STATISTICS <=======================\n", "\n", - " Total time for initialization = 1.4810E+00 seconds\n", - " Reading cross sections = 1.1600E+00 seconds\n", - " Total time in simulation = 9.8823E+01 seconds\n", - " Time in transport only = 9.8622E+01 seconds\n", - " Time in inactive batches = 2.1290E+00 seconds\n", - " Time in active batches = 9.6694E+01 seconds\n", - " Time synchronizing fission bank = 1.4000E-02 seconds\n", - " Sampling source sites = 1.1000E-02 seconds\n", - " SEND/RECV source sites = 3.0000E-03 seconds\n", + " Total time for initialization = 1.5880E+00 seconds\n", + " Reading cross sections = 1.2650E+00 seconds\n", + " Total time in simulation = 2.6051E+02 seconds\n", + " Time in transport only = 2.6013E+02 seconds\n", + " Time in inactive batches = 2.0990E+00 seconds\n", + " Time in active batches = 2.5841E+02 seconds\n", + " Time synchronizing fission bank = 6.5000E-02 seconds\n", + " Sampling source sites = 4.4000E-02 seconds\n", + " SEND/RECV source sites = 2.1000E-02 seconds\n", " Time accumulating tallies = 2.0000E-03 seconds\n", " Total time for finalization = 0.0000E+00 seconds\n", - " Total time elapsed = 1.0031E+02 seconds\n", - " Calculation Rate (inactive) = 23485.2 neutrons/second\n", - " Calculation Rate (active) = 9824.81 neutrons/second\n", + " Total time elapsed = 2.6211E+02 seconds\n", + " Calculation Rate (inactive) = 23820.9 neutrons/second\n", + " Calculation Rate (active) = 9480.98 neutrons/second\n", "\n", " ============================> RESULTS <============================\n", "\n", - " k-effective (Collision) = 1.02505 +/- 0.00122\n", - " k-effective (Track-length) = 1.02604 +/- 0.00129\n", - " k-effective (Absorption) = 1.02501 +/- 0.00111\n", - " Combined k-effective = 1.02544 +/- 0.00091\n", + " k-effective (Collision) = 1.02480 +/- 0.00073\n", + " k-effective (Track-length) = 1.02477 +/- 0.00081\n", + " k-effective (Absorption) = 1.02552 +/- 0.00068\n", + " Combined k-effective = 1.02519 +/- 0.00055\n", " Leakage Fraction = 0.00000 +/- 0.00000\n", "\n" ] @@ -946,7 +1265,7 @@ "0" ] }, - "execution_count": 25, + "execution_count": 26, "metadata": {}, "output_type": "execute_result" } @@ -965,14 +1284,14 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 27, "metadata": { - "collapsed": true + "collapsed": false }, "outputs": [], "source": [ "# Move the StatePoint File\n", - "ce_spfile = './ce.h5'\n", + "ce_spfile = './ce_statepoint.h5'\n", "os.rename('statepoint.' + str(batches) + '.h5', ce_spfile)\n", "# Move the Summary file\n", "ce_sumfile = './ce_summary.h5'\n", @@ -985,44 +1304,26 @@ "source": [ "# Tally Data Processing\n", "\n", - "Our simulation ran successfully and created statepoint and summary output files. We begin our analysis by instantiating a `StatePoint` object." - ] - }, - { - "cell_type": "code", - "execution_count": 27, - "metadata": { - "collapsed": true - }, - "outputs": [], - "source": [ - "# Load the statepoint file\n", - "sp = openmc.StatePoint(ce_spfile)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Next we will save the value of keff from the continuous-energy calculation for later comparison" + "Our simulation ran successfully and created statepoint and summary output files. Let's begin by loading the StatePoint file, but not automatically linking the summary file." ] }, { "cell_type": "code", "execution_count": 28, "metadata": { - "collapsed": true + "collapsed": false }, "outputs": [], "source": [ - "ce_keff = sp.k_combined" + "# Load the statepoint file, but not the summary file, as it is a different filename than expected.\n", + "sp = openmc.StatePoint(ce_spfile, autolink=False)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "In addition to the statepoint file, our simulation also created a summary file which encapsulates information about the materials and geometry. This is necessary for the `openmc.mgxs` module to properly process the tally data. We first create a `Summary` object and link it with the statepoint." + "In addition to the statepoint file, our simulation also created a summary file which encapsulates information about the materials and geometry. This is necessary for the `openmc.mgxs` module to properly process the tally data. We first create a `Summary` object and link it with the statepoint. Normally this would not need to be performed, but since we have renamed our summary file to avoid conflicts with the Multi-Group calculation's summary file, we will load this in explicitly." ] }, { @@ -1037,32 +1338,6 @@ "sp.link_with_summary(su)" ] }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Next we will extract our fission distribution results from the statepoint for later comparison." - ] - }, - { - "cell_type": "code", - "execution_count": 30, - "metadata": { - "collapsed": false - }, - "outputs": [], - "source": [ - "# Get the OpenMC fission rate mesh tally data\n", - "mesh_tally = sp.get_tally(name='mesh tally')\n", - "openmc_fission_rates = mesh_tally.get_values(scores=['fission'])\n", - "\n", - "# Reshape array to 2D for plotting\n", - "openmc_fission_rates.shape = (17,17)\n", - "\n", - "# Normalize to the average pin power\n", - "openmc_fission_rates /= np.mean(openmc_fission_rates)" - ] - }, { "cell_type": "markdown", "metadata": {}, @@ -1072,7 +1347,7 @@ }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 30, "metadata": { "collapsed": false }, @@ -1105,7 +1380,7 @@ }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 31, "metadata": { "collapsed": false }, @@ -1114,53 +1389,38 @@ "name": "stderr", "output_type": "stream", "text": [ - "/home/nelsonag/git/openmc/openmc/tallies.py:1996: RuntimeWarning: invalid value encountered in true_divide\n", + "/home/nelsonag/git/openmc/openmc/tallies.py:1988: RuntimeWarning: invalid value encountered in true_divide\n", " self_rel_err = data['self']['std. dev.'] / data['self']['mean']\n", - "/home/nelsonag/git/openmc/openmc/tallies.py:1997: RuntimeWarning: invalid value encountered in true_divide\n", + "/home/nelsonag/git/openmc/openmc/tallies.py:1989: RuntimeWarning: invalid value encountered in true_divide\n", " other_rel_err = data['other']['std. dev.'] / data['other']['mean']\n", - "/home/nelsonag/git/openmc/openmc/tallies.py:1998: RuntimeWarning: invalid value encountered in true_divide\n", + "/home/nelsonag/git/openmc/openmc/tallies.py:1990: RuntimeWarning: invalid value encountered in true_divide\n", " new_tally._mean = data['self']['mean'] / data['other']['mean']\n" ] - }, - { - "data": { - "text/plain": [ - "{10000: 'fuel.2g',\n", - " 10001: 'fuel_clad.2g',\n", - " 10002: 'fuel_mod.2g',\n", - " 10003: 'gt_inmod.2g',\n", - " 10004: 'gt_clad.2g',\n", - " 10005: 'gt_outmod.2g'}" - ] - }, - "execution_count": 32, - "metadata": {}, - "output_type": "execute_result" } ], "source": [ "mgxs_lib.write_mg_library(filename='mgxs', xs_type='macro',\n", " domain_names=['fuel', 'fuel_clad', 'fuel_mod',\n", " 'gt_inmod', 'gt_clad', 'gt_outmod'],\n", - " xs_ids='2g')" + " xs_ids='2m')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "Now we will need to recreate similar xml files from above, beginning with materials.xml" + "Now we will need to recreate similar xml files from above, beginning with materials.xml. Similar to how continuous-energy cross section libraries are named, the `openmc.Macroscopic` quantities below can either have their `xs_id` included (i.e., `'.2m'`), or this can be left off but the `default_xs` parameter of the materials file be used instead to be set to the `'xs_id'` of interest (which is `'.2m'` in this case as defined in the previous cell)." ] }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 32, "metadata": { "collapsed": false }, "outputs": [], "source": [ - "# Instantiate our Macroscopic Data\n", + "# Instantiate our Macroscopic Data using mat_names for the name\n", "fuel_macro = openmc.Macroscopic('fuel')\n", "fuel_clad_macro = openmc.Macroscopic('fuel_clad')\n", "fuel_mod_macro = openmc.Macroscopic('fuel_mod')\n", @@ -1171,39 +1431,39 @@ "# Now define the materials\n", "\n", "# 1.6 enriched fuel UO2\n", - "fuel = openmc.Material(name='1.6% Fuel UO2')\n", + "fuel = openmc.Material(name='1.6% Fuel UO2', material_id=1)\n", "fuel.set_density('macro', 1.0)\n", "fuel.add_macroscopic(fuel_macro)\n", "\n", "# 1.6 enriched fuel cladding\n", - "fuel_clad = openmc.Material(name='1.6% Fuel Clad')\n", + "fuel_clad = openmc.Material(name='1.6% Fuel Clad', material_id=2)\n", "fuel_clad.set_density('macro', 1.0)\n", "fuel_clad.add_macroscopic(fuel_clad_macro)\n", "\n", "# 1.6 enriched fuel moderator\n", - "fuel_mod = openmc.Material(name='1.6% Fuel Water')\n", + "fuel_mod = openmc.Material(name='1.6% Fuel Water', material_id=3)\n", "fuel_mod.set_density('macro', 1.0)\n", "fuel_mod.add_macroscopic(fuel_mod_macro)\n", "\n", "# Guide Tube Inner Moderator\n", - "gt_inmod = openmc.Material(name='GT Inner Water')\n", + "gt_inmod = openmc.Material(name='GT Inner Water', material_id=4)\n", "gt_inmod.set_density('macro', 1.0)\n", "gt_inmod.add_macroscopic(gt_inmod_macro)\n", "\n", "# Guide Tube Cladding\n", - "gt_clad = openmc.Material(name='GT Clad')\n", + "gt_clad = openmc.Material(name='GT Clad', material_id=5)\n", "gt_clad.set_density('macro', 1.0)\n", "gt_clad.add_macroscopic(gt_clad_macro)\n", "\n", "# Guide Tube Outer Moderator\n", - "gt_outmod = openmc.Material(name='GT Outer Water')\n", + "gt_outmod = openmc.Material(name='GT Outer Water', material_id=6)\n", "gt_outmod.set_density('macro', 1.0)\n", "gt_outmod.add_macroscopic(gt_outmod_macro)\n", "\n", "# Finally, instantiate our Materials object\n", "materials_file = openmc.Materials((fuel, fuel_clad, fuel_mod,\n", " gt_inmod, gt_clad, gt_outmod))\n", - "materials_file.default_xs = '2g'\n", + "materials_file.default_xs = '2m'\n", "\n", "# Export to \"materials.xml\"\n", "materials_file.export_to_xml()\n" @@ -1213,61 +1473,62 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "For our geometry files we will simply repeat what as done for continuous-energy mode, except change the cell fill (i.e., the material) to use our newly defined materials." + "\n", + "For our geometry files we will do the same as before but now we will be pointing at our newly created materials instead." ] }, { "cell_type": "code", - "execution_count": 34, + "execution_count": 33, "metadata": { "collapsed": false }, "outputs": [], "source": [ "# Create a Universe to encapsulate a fuel pin\n", - "fuel_pin_universe = openmc.Universe(name='1.6% Fuel Pin')\n", + "fuel_pin_universe = openmc.Universe(name='1.6% Fuel Pin', universe_id=10)\n", "\n", "# Create fuel Cell\n", - "fuel_cell = openmc.Cell(name='1.6% Fuel')\n", + "fuel_cell = openmc.Cell(name='1.6% Fuel', cell_id=1)\n", "fuel_cell.fill = fuel\n", "fuel_cell.region = -fuel_outer_radius\n", "fuel_pin_universe.add_cell(fuel_cell)\n", "\n", "# Create a clad Cell\n", - "clad_cell = openmc.Cell(name='1.6% Clad')\n", + "clad_cell = openmc.Cell(name='1.6% Clad', cell_id=2)\n", "clad_cell.fill = fuel_clad\n", "clad_cell.region = +fuel_outer_radius & -clad_outer_radius\n", "fuel_pin_universe.add_cell(clad_cell)\n", "\n", "# Create a moderator Cell\n", - "moderator_cell = openmc.Cell(name='1.6% Moderator')\n", + "moderator_cell = openmc.Cell(name='1.6% Moderator', cell_id=3)\n", "moderator_cell.fill = fuel_mod\n", "moderator_cell.region = +clad_outer_radius\n", "fuel_pin_universe.add_cell(moderator_cell)\n", "\n", "# Create a Universe to encapsulate a control rod guide tube\n", - "guide_tube_universe = openmc.Universe(name='Guide Tube')\n", + "guide_tube_universe = openmc.Universe(name='Guide Tube', universe_id=20)\n", "\n", "# Create guide tube Cell\n", - "guide_tube_cell = openmc.Cell(name='Guide Tube Water')\n", + "guide_tube_cell = openmc.Cell(name='Guide Tube Water', cell_id=4)\n", "guide_tube_cell.fill = gt_inmod\n", "guide_tube_cell.region = -fuel_outer_radius\n", "guide_tube_universe.add_cell(guide_tube_cell)\n", "\n", "# Create a clad Cell\n", - "clad_cell = openmc.Cell(name='Guide Clad')\n", + "clad_cell = openmc.Cell(name='Guide Clad', cell_id=5)\n", "clad_cell.fill = gt_clad\n", "clad_cell.region = +fuel_outer_radius & -clad_outer_radius\n", "guide_tube_universe.add_cell(clad_cell)\n", "\n", "# Create a moderator Cell\n", - "moderator_cell = openmc.Cell(name='Guide Tube Moderator')\n", + "moderator_cell = openmc.Cell(name='Guide Tube Moderator', cell_id=6)\n", "moderator_cell.fill = gt_outmod\n", "moderator_cell.region = +clad_outer_radius\n", "guide_tube_universe.add_cell(moderator_cell)\n", "\n", "# Create fuel assembly Lattice\n", - "assembly = openmc.RectLattice(name='1.6% Fuel Assembly')\n", + "assembly = openmc.RectLattice(name='1.6% Fuel Assembly', lattice_id=100)\n", "assembly.dimension = (17, 17)\n", "assembly.pitch = (1.26, 1.26)\n", "assembly.lower_left = [-1.26 * 17. / 2.0] * 2\n", @@ -1289,7 +1550,7 @@ "assembly.universes = universes\n", "\n", "# Create root Cell\n", - "root_cell = openmc.Cell(name='root cell')\n", + "root_cell = openmc.Cell(name='root cell', cell_id=0)\n", "root_cell.fill = assembly\n", "\n", "# Add boundary planes\n", @@ -1316,7 +1577,7 @@ }, { "cell_type": "code", - "execution_count": 35, + "execution_count": 34, "metadata": { "collapsed": true }, @@ -1334,50 +1595,14 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Finally, lets tell OpenMC we want to tally fissions over a mesh for comparison. " + "Finally, since we want similar tally data in the end, we will leave our pre-existing `tallies.xml` file for this calculation.\n", + "\n", + "At this point, the problem is set up and we can run the multi-group calculation." ] }, { "cell_type": "code", - "execution_count": 36, - "metadata": { - "collapsed": true - }, - "outputs": [], - "source": [ - "# Instantiate a tally Mesh\n", - "mesh = openmc.Mesh(mesh_id=1)\n", - "mesh.type = 'regular'\n", - "mesh.dimension = [17, 17]\n", - "mesh.lower_left = [-10.71, -10.71]\n", - "mesh.upper_right = [+10.71, +10.71]\n", - "\n", - "# Instantiate tally Filter\n", - "mesh_filter = openmc.Filter()\n", - "mesh_filter.mesh = mesh\n", - "\n", - "# Instantiate the Tally\n", - "tally = openmc.Tally(name='mesh tally')\n", - "tally.filters = [mesh_filter]\n", - "tally.scores = ['fission']\n", - "\n", - "# Add tally to collection\n", - "tallies_file.append(tally)\n", - "\n", - "# Export all tallies to a \"tallies.xml\" file\n", - "tallies_file.export_to_xml()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Before we run the calculation we will close the StatePoint file (as we are about to over-write it), and then we can run the multi-group calculation." - ] - }, - { - "cell_type": "code", - "execution_count": 37, + "execution_count": 35, "metadata": { "collapsed": false }, @@ -1402,8 +1627,8 @@ " Copyright: 2011-2016 Massachusetts Institute of Technology\n", " License: http://openmc.readthedocs.org/en/latest/license.html\n", " Version: 0.7.1\n", - " Git SHA1: 179e9ab147e505563d118ed58096b3d225160ffa\n", - " Date/Time: 2016-05-07 14:23:45\n", + " Git SHA1: c779ca42c41a062a6a813e03f2add2d182ca9190\n", + " Date/Time: 2016-05-12 21:19:25\n", " OpenMP Threads: 4\n", "\n", " ===========================================================================\n", @@ -1417,12 +1642,12 @@ " Reading tallies XML file...\n", " Building neighboring cells lists for each surface...\n", " Loading Cross Section Data...\n", - " Loading fuel.2g Data...\n", - " Loading fuel_clad.2g Data...\n", - " Loading fuel_mod.2g Data...\n", - " Loading gt_inmod.2g Data...\n", - " Loading gt_clad.2g Data...\n", - " Loading gt_outmod.2g Data...\n", + " Loading fuel.2m Data...\n", + " Loading fuel_clad.2m Data...\n", + " Loading fuel_mod.2m Data...\n", + " Loading gt_inmod.2m Data...\n", + " Loading gt_clad.2m Data...\n", + " Loading gt_outmod.2m Data...\n", " Initializing source particles...\n", "\n", " ===========================================================================\n", @@ -1431,207 +1656,507 @@ "\n", " Bat./Gen. k Average k \n", " ========= ======== ==================== \n", - " 1/1 1.01863 \n", - " 2/1 1.02630 \n", - " 3/1 1.03077 \n", - " 4/1 0.99715 \n", - " 5/1 1.02328 \n", - " 6/1 1.02283 \n", - " 7/1 1.00540 \n", - " 8/1 1.02232 \n", - " 9/1 0.99782 \n", - " 10/1 1.00838 \n", - " 11/1 1.01803 \n", - " 12/1 1.02530 1.02167 +/- 0.00363\n", - " 13/1 1.00514 1.01616 +/- 0.00589\n", - " 14/1 0.98994 1.00960 +/- 0.00777\n", - " 15/1 1.01028 1.00974 +/- 0.00602\n", - " 16/1 1.04607 1.01580 +/- 0.00780\n", - " 17/1 1.03300 1.01825 +/- 0.00703\n", - " 18/1 1.03149 1.01991 +/- 0.00631\n", - " 19/1 0.98692 1.01624 +/- 0.00667\n", - " 20/1 1.05205 1.01982 +/- 0.00695\n", - " 21/1 1.01572 1.01945 +/- 0.00630\n", - " 22/1 1.02517 1.01993 +/- 0.00577\n", - " 23/1 1.00274 1.01861 +/- 0.00547\n", - " 24/1 1.04739 1.02066 +/- 0.00547\n", - " 25/1 1.01883 1.02054 +/- 0.00509\n", - " 26/1 1.02021 1.02052 +/- 0.00476\n", - " 27/1 1.04696 1.02207 +/- 0.00474\n", - " 28/1 1.02751 1.02238 +/- 0.00448\n", - " 29/1 1.09537 1.02622 +/- 0.00572\n", - " 30/1 1.03685 1.02675 +/- 0.00545\n", - " 31/1 0.99812 1.02539 +/- 0.00536\n", - " 32/1 1.02526 1.02538 +/- 0.00511\n", - " 33/1 1.05466 1.02665 +/- 0.00505\n", - " 34/1 1.04816 1.02755 +/- 0.00491\n", - " 35/1 1.00148 1.02651 +/- 0.00483\n", - " 36/1 1.02315 1.02638 +/- 0.00464\n", - " 37/1 1.05771 1.02754 +/- 0.00461\n", - " 38/1 1.01675 1.02715 +/- 0.00446\n", - " 39/1 1.03707 1.02749 +/- 0.00432\n", - " 40/1 1.01903 1.02721 +/- 0.00418\n", - " 41/1 1.00332 1.02644 +/- 0.00412\n", - " 42/1 1.02533 1.02641 +/- 0.00399\n", - " 43/1 0.98531 1.02516 +/- 0.00406\n", - " 44/1 1.00406 1.02454 +/- 0.00399\n", - " 45/1 1.01057 1.02414 +/- 0.00389\n", - " 46/1 1.02755 1.02424 +/- 0.00378\n", - " 47/1 1.02783 1.02433 +/- 0.00368\n", - " 48/1 1.00003 1.02369 +/- 0.00364\n", - " 49/1 1.00442 1.02320 +/- 0.00358\n", - " 50/1 1.03215 1.02342 +/- 0.00350\n", - " 51/1 1.01672 1.02326 +/- 0.00341\n", - " 52/1 1.03702 1.02359 +/- 0.00335\n", - " 53/1 1.02063 1.02352 +/- 0.00327\n", - " 54/1 1.04596 1.02403 +/- 0.00323\n", - " 55/1 1.01926 1.02392 +/- 0.00316\n", - " 56/1 1.03058 1.02407 +/- 0.00310\n", - " 57/1 1.06126 1.02486 +/- 0.00313\n", - " 58/1 1.06411 1.02568 +/- 0.00317\n", - " 59/1 1.03278 1.02582 +/- 0.00311\n", - " 60/1 1.04472 1.02620 +/- 0.00307\n", - " 61/1 1.00186 1.02572 +/- 0.00305\n", - " 62/1 1.01133 1.02545 +/- 0.00300\n", - " 63/1 1.03713 1.02567 +/- 0.00295\n", - " 64/1 1.01363 1.02544 +/- 0.00291\n", - " 65/1 0.98126 1.02464 +/- 0.00296\n", - " 66/1 1.01500 1.02447 +/- 0.00292\n", - " 67/1 1.02437 1.02447 +/- 0.00286\n", - " 68/1 1.05057 1.02492 +/- 0.00285\n", - " 69/1 1.04903 1.02533 +/- 0.00283\n", - " 70/1 1.02199 1.02527 +/- 0.00278\n", - " 71/1 1.00536 1.02494 +/- 0.00276\n", - " 72/1 1.01658 1.02481 +/- 0.00272\n", - " 73/1 1.00866 1.02455 +/- 0.00268\n", - " 74/1 1.01800 1.02445 +/- 0.00264\n", - " 75/1 0.99176 1.02395 +/- 0.00265\n", - " 76/1 1.03336 1.02409 +/- 0.00262\n", - " 77/1 1.02699 1.02413 +/- 0.00258\n", - " 78/1 1.01596 1.02401 +/- 0.00254\n", - " 79/1 1.02292 1.02400 +/- 0.00250\n", - " 80/1 1.04804 1.02434 +/- 0.00249\n", - " 81/1 0.99494 1.02393 +/- 0.00249\n", - " 82/1 1.02646 1.02396 +/- 0.00246\n", - " 83/1 1.01223 1.02380 +/- 0.00243\n", - " 84/1 1.02572 1.02383 +/- 0.00239\n", - " 85/1 1.02709 1.02387 +/- 0.00236\n", - " 86/1 1.00315 1.02360 +/- 0.00235\n", - " 87/1 1.01809 1.02353 +/- 0.00232\n", - " 88/1 1.01566 1.02342 +/- 0.00229\n", - " 89/1 1.01093 1.02327 +/- 0.00227\n", - " 90/1 1.02812 1.02333 +/- 0.00224\n", - " 91/1 1.02288 1.02332 +/- 0.00221\n", - " 92/1 1.04070 1.02353 +/- 0.00219\n", - " 93/1 1.03697 1.02370 +/- 0.00217\n", - " 94/1 1.03486 1.02383 +/- 0.00215\n", - " 95/1 1.06359 1.02430 +/- 0.00218\n", - " 96/1 1.04811 1.02457 +/- 0.00217\n", - " 97/1 1.01303 1.02444 +/- 0.00215\n", - " 98/1 1.01243 1.02430 +/- 0.00213\n", - " 99/1 1.03238 1.02439 +/- 0.00211\n", - " 100/1 1.02054 1.02435 +/- 0.00208\n", - " 101/1 1.00402 1.02413 +/- 0.00207\n", - " 102/1 1.03800 1.02428 +/- 0.00206\n", - " 103/1 1.02541 1.02429 +/- 0.00203\n", - " 104/1 1.06867 1.02476 +/- 0.00207\n", - " 105/1 1.03192 1.02484 +/- 0.00205\n", - " 106/1 1.00100 1.02459 +/- 0.00204\n", - " 107/1 1.01098 1.02445 +/- 0.00202\n", - " 108/1 1.02930 1.02450 +/- 0.00200\n", - " 109/1 1.02173 1.02447 +/- 0.00198\n", - " 110/1 1.01411 1.02437 +/- 0.00197\n", - " 111/1 1.03920 1.02452 +/- 0.00195\n", - " 112/1 1.01984 1.02447 +/- 0.00193\n", - " 113/1 1.03912 1.02461 +/- 0.00192\n", - " 114/1 1.04124 1.02477 +/- 0.00191\n", - " 115/1 1.04802 1.02499 +/- 0.00190\n", - " 116/1 1.04129 1.02515 +/- 0.00189\n", - " 117/1 1.03072 1.02520 +/- 0.00187\n", - " 118/1 1.05167 1.02544 +/- 0.00187\n", - " 119/1 0.99954 1.02521 +/- 0.00187\n", - " 120/1 1.00093 1.02499 +/- 0.00187\n", - " 121/1 1.04929 1.02520 +/- 0.00186\n", - " 122/1 1.04556 1.02539 +/- 0.00185\n", - " 123/1 1.03298 1.02545 +/- 0.00184\n", - " 124/1 1.01603 1.02537 +/- 0.00182\n", - " 125/1 1.03522 1.02546 +/- 0.00181\n", - " 126/1 1.05644 1.02572 +/- 0.00181\n", - " 127/1 1.03754 1.02582 +/- 0.00180\n", - " 128/1 1.01524 1.02573 +/- 0.00179\n", - " 129/1 1.01263 1.02562 +/- 0.00178\n", - " 130/1 0.99835 1.02540 +/- 0.00178\n", - " 131/1 1.01268 1.02529 +/- 0.00177\n", - " 132/1 1.03975 1.02541 +/- 0.00175\n", - " 133/1 1.00702 1.02526 +/- 0.00175\n", - " 134/1 1.02335 1.02525 +/- 0.00173\n", - " 135/1 1.04378 1.02539 +/- 0.00173\n", - " 136/1 1.04610 1.02556 +/- 0.00172\n", - " 137/1 1.02284 1.02554 +/- 0.00171\n", - " 138/1 1.05720 1.02578 +/- 0.00171\n", - " 139/1 1.00965 1.02566 +/- 0.00170\n", - " 140/1 1.03719 1.02575 +/- 0.00169\n", - " 141/1 1.02413 1.02574 +/- 0.00168\n", - " 142/1 1.03125 1.02578 +/- 0.00167\n", - " 143/1 1.03641 1.02586 +/- 0.00166\n", - " 144/1 1.02137 1.02582 +/- 0.00164\n", - " 145/1 1.01522 1.02575 +/- 0.00163\n", - " 146/1 1.05163 1.02594 +/- 0.00163\n", - " 147/1 1.03612 1.02601 +/- 0.00162\n", - " 148/1 1.03346 1.02606 +/- 0.00161\n", - " 149/1 1.02306 1.02604 +/- 0.00160\n", - " 150/1 1.01764 1.02598 +/- 0.00159\n", - " 151/1 1.01787 1.02592 +/- 0.00158\n", - " 152/1 1.03263 1.02597 +/- 0.00157\n", - " 153/1 1.01877 1.02592 +/- 0.00156\n", - " 154/1 1.02870 1.02594 +/- 0.00155\n", - " 155/1 1.03071 1.02597 +/- 0.00154\n", - " 156/1 1.04229 1.02609 +/- 0.00153\n", - " 157/1 1.03973 1.02618 +/- 0.00152\n", - " 158/1 1.02180 1.02615 +/- 0.00151\n", - " 159/1 1.01067 1.02604 +/- 0.00151\n", - " 160/1 1.02888 1.02606 +/- 0.00150\n", - " 161/1 1.01711 1.02600 +/- 0.00149\n", - " 162/1 1.01087 1.02590 +/- 0.00148\n", - " 163/1 1.01886 1.02586 +/- 0.00147\n", - " 164/1 1.02210 1.02583 +/- 0.00146\n", - " 165/1 1.04020 1.02593 +/- 0.00146\n", - " 166/1 1.03658 1.02600 +/- 0.00145\n", - " 167/1 1.03222 1.02603 +/- 0.00144\n", - " 168/1 1.03247 1.02608 +/- 0.00143\n", - " 169/1 0.99739 1.02590 +/- 0.00143\n", - " 170/1 1.02464 1.02589 +/- 0.00142\n", - " 171/1 1.04623 1.02601 +/- 0.00142\n", - " 172/1 1.04328 1.02612 +/- 0.00142\n", - " 173/1 1.00812 1.02601 +/- 0.00141\n", - " 174/1 1.01224 1.02593 +/- 0.00141\n", - " 175/1 1.00882 1.02582 +/- 0.00140\n", - " 176/1 1.01286 1.02574 +/- 0.00140\n", - " 177/1 1.02048 1.02571 +/- 0.00139\n", - " 178/1 1.04269 1.02581 +/- 0.00138\n", - " 179/1 1.05862 1.02601 +/- 0.00139\n", - " 180/1 1.02924 1.02603 +/- 0.00138\n", - " 181/1 1.01491 1.02596 +/- 0.00137\n", - " 182/1 1.04255 1.02606 +/- 0.00137\n", - " 183/1 0.99191 1.02586 +/- 0.00137\n", - " 184/1 1.00392 1.02573 +/- 0.00137\n", - " 185/1 1.02982 1.02576 +/- 0.00137\n", - " 186/1 1.02682 1.02576 +/- 0.00136\n", - " 187/1 1.01484 1.02570 +/- 0.00135\n", - " 188/1 1.02825 1.02572 +/- 0.00134\n", - " 189/1 0.98954 1.02551 +/- 0.00135\n", - " 190/1 1.00522 1.02540 +/- 0.00135\n", - " 191/1 1.03762 1.02547 +/- 0.00134\n", - " 192/1 1.02091 1.02544 +/- 0.00134\n", - " 193/1 1.04549 1.02555 +/- 0.00133\n", - " 194/1 1.05531 1.02572 +/- 0.00134\n", - " 195/1 1.01479 1.02566 +/- 0.00133\n", - " 196/1 1.01337 1.02559 +/- 0.00132\n", - " 197/1 0.99187 1.02541 +/- 0.00133\n", - " 198/1 1.01280 1.02534 +/- 0.00132\n", - " 199/1 1.00049 1.02521 +/- 0.00132\n", - " 200/1 1.01879 1.02518 +/- 0.00132\n", - " Creating state point statepoint.200.h5...\n", + " 1/1 1.01702 \n", + " 2/1 0.99463 \n", + " 3/1 1.02321 \n", + " 4/1 0.98628 \n", + " 5/1 1.03122 \n", + " 6/1 1.00774 \n", + " 7/1 1.05616 \n", + " 8/1 1.03051 \n", + " 9/1 1.02321 \n", + " 10/1 1.04380 \n", + " 11/1 1.05837 \n", + " 12/1 1.01514 1.03676 +/- 0.02161\n", + " 13/1 1.06720 1.04690 +/- 0.01608\n", + " 14/1 1.01696 1.03942 +/- 0.01361\n", + " 15/1 1.03549 1.03863 +/- 0.01057\n", + " 16/1 1.01599 1.03486 +/- 0.00942\n", + " 17/1 1.03070 1.03427 +/- 0.00799\n", + " 18/1 1.03778 1.03470 +/- 0.00693\n", + " 19/1 1.03042 1.03423 +/- 0.00613\n", + " 20/1 1.01047 1.03185 +/- 0.00598\n", + " 21/1 1.03251 1.03191 +/- 0.00541\n", + " 22/1 1.02047 1.03096 +/- 0.00503\n", + " 23/1 1.01729 1.02991 +/- 0.00474\n", + " 24/1 1.02948 1.02988 +/- 0.00439\n", + " 25/1 1.01963 1.02919 +/- 0.00414\n", + " 26/1 1.00626 1.02776 +/- 0.00413\n", + " 27/1 1.04531 1.02879 +/- 0.00402\n", + " 28/1 0.99936 1.02716 +/- 0.00412\n", + " 29/1 1.04497 1.02809 +/- 0.00401\n", + " 30/1 1.02429 1.02790 +/- 0.00381\n", + " 31/1 1.05112 1.02901 +/- 0.00379\n", + " 32/1 1.01843 1.02853 +/- 0.00365\n", + " 33/1 1.04478 1.02924 +/- 0.00355\n", + " 34/1 1.01719 1.02873 +/- 0.00344\n", + " 35/1 0.99873 1.02753 +/- 0.00351\n", + " 36/1 1.00054 1.02649 +/- 0.00353\n", + " 37/1 1.03986 1.02699 +/- 0.00343\n", + " 38/1 1.02243 1.02683 +/- 0.00331\n", + " 39/1 1.02744 1.02685 +/- 0.00319\n", + " 40/1 1.01174 1.02634 +/- 0.00313\n", + " 41/1 1.04973 1.02710 +/- 0.00312\n", + " 42/1 0.99564 1.02612 +/- 0.00317\n", + " 43/1 1.03022 1.02624 +/- 0.00308\n", + " 44/1 1.03526 1.02650 +/- 0.00300\n", + " 45/1 1.02143 1.02636 +/- 0.00292\n", + " 46/1 1.03264 1.02653 +/- 0.00284\n", + " 47/1 1.03868 1.02686 +/- 0.00278\n", + " 48/1 1.02385 1.02678 +/- 0.00271\n", + " 49/1 1.03897 1.02710 +/- 0.00266\n", + " 50/1 1.01267 1.02674 +/- 0.00261\n", + " 51/1 0.99683 1.02601 +/- 0.00265\n", + " 52/1 1.04189 1.02638 +/- 0.00261\n", + " 53/1 1.02871 1.02644 +/- 0.00255\n", + " 54/1 1.02564 1.02642 +/- 0.00250\n", + " 55/1 1.02955 1.02649 +/- 0.00244\n", + " 56/1 1.02390 1.02643 +/- 0.00239\n", + " 57/1 1.03342 1.02658 +/- 0.00234\n", + " 58/1 1.01430 1.02633 +/- 0.00231\n", + " 59/1 0.99242 1.02563 +/- 0.00236\n", + " 60/1 1.00442 1.02521 +/- 0.00235\n", + " 61/1 1.03870 1.02547 +/- 0.00232\n", + " 62/1 1.02146 1.02540 +/- 0.00228\n", + " 63/1 1.04782 1.02582 +/- 0.00227\n", + " 64/1 1.02872 1.02587 +/- 0.00223\n", + " 65/1 1.02420 1.02584 +/- 0.00219\n", + " 66/1 1.01974 1.02573 +/- 0.00215\n", + " 67/1 1.00774 1.02542 +/- 0.00214\n", + " 68/1 1.01323 1.02521 +/- 0.00211\n", + " 69/1 1.01468 1.02503 +/- 0.00208\n", + " 70/1 1.02869 1.02509 +/- 0.00205\n", + " 71/1 1.02284 1.02505 +/- 0.00202\n", + " 72/1 1.04815 1.02543 +/- 0.00202\n", + " 73/1 1.01119 1.02520 +/- 0.00200\n", + " 74/1 1.03314 1.02533 +/- 0.00197\n", + " 75/1 1.02333 1.02529 +/- 0.00194\n", + " 76/1 1.04030 1.02552 +/- 0.00193\n", + " 77/1 1.02537 1.02552 +/- 0.00190\n", + " 78/1 1.02875 1.02557 +/- 0.00187\n", + " 79/1 1.03588 1.02572 +/- 0.00185\n", + " 80/1 1.05250 1.02610 +/- 0.00186\n", + " 81/1 1.00477 1.02580 +/- 0.00186\n", + " 82/1 1.03903 1.02598 +/- 0.00184\n", + " 83/1 1.02378 1.02595 +/- 0.00182\n", + " 84/1 1.01107 1.02575 +/- 0.00180\n", + " 85/1 1.01550 1.02561 +/- 0.00178\n", + " 86/1 1.00540 1.02535 +/- 0.00178\n", + " 87/1 1.03056 1.02542 +/- 0.00176\n", + " 88/1 1.01742 1.02531 +/- 0.00174\n", + " 89/1 0.99730 1.02496 +/- 0.00175\n", + " 90/1 1.03569 1.02509 +/- 0.00174\n", + " 91/1 1.04514 1.02534 +/- 0.00173\n", + " 92/1 1.02757 1.02537 +/- 0.00171\n", + " 93/1 1.00610 1.02514 +/- 0.00171\n", + " 94/1 1.03576 1.02526 +/- 0.00169\n", + " 95/1 1.03732 1.02540 +/- 0.00168\n", + " 96/1 1.04784 1.02567 +/- 0.00168\n", + " 97/1 1.06507 1.02612 +/- 0.00172\n", + " 98/1 1.03673 1.02624 +/- 0.00170\n", + " 99/1 1.01270 1.02609 +/- 0.00169\n", + " 100/1 1.01980 1.02602 +/- 0.00167\n", + " 101/1 1.01357 1.02588 +/- 0.00166\n", + " 102/1 1.03125 1.02594 +/- 0.00164\n", + " 103/1 1.01527 1.02582 +/- 0.00163\n", + " 104/1 1.02403 1.02580 +/- 0.00161\n", + " 105/1 1.03435 1.02589 +/- 0.00160\n", + " 106/1 1.04113 1.02605 +/- 0.00159\n", + " 107/1 1.03291 1.02612 +/- 0.00157\n", + " 108/1 1.02478 1.02611 +/- 0.00156\n", + " 109/1 1.05814 1.02643 +/- 0.00158\n", + " 110/1 1.02647 1.02643 +/- 0.00156\n", + " 111/1 0.98951 1.02607 +/- 0.00159\n", + " 112/1 1.00739 1.02589 +/- 0.00158\n", + " 113/1 1.04165 1.02604 +/- 0.00157\n", + " 114/1 1.00047 1.02579 +/- 0.00158\n", + " 115/1 1.02550 1.02579 +/- 0.00156\n", + " 116/1 1.02408 1.02577 +/- 0.00155\n", + " 117/1 1.03110 1.02582 +/- 0.00153\n", + " 118/1 1.02874 1.02585 +/- 0.00152\n", + " 119/1 1.02348 1.02583 +/- 0.00151\n", + " 120/1 1.01969 1.02577 +/- 0.00149\n", + " 121/1 1.02312 1.02575 +/- 0.00148\n", + " 122/1 1.03261 1.02581 +/- 0.00147\n", + " 123/1 0.98394 1.02544 +/- 0.00150\n", + " 124/1 1.03771 1.02555 +/- 0.00149\n", + " 125/1 1.01857 1.02549 +/- 0.00148\n", + " 126/1 1.00066 1.02527 +/- 0.00148\n", + " 127/1 1.02372 1.02526 +/- 0.00147\n", + " 128/1 1.03307 1.02533 +/- 0.00146\n", + " 129/1 1.00889 1.02519 +/- 0.00145\n", + " 130/1 1.02053 1.02515 +/- 0.00144\n", + " 131/1 1.00943 1.02502 +/- 0.00144\n", + " 132/1 1.07225 1.02541 +/- 0.00148\n", + " 133/1 1.04068 1.02553 +/- 0.00147\n", + " 134/1 1.03509 1.02561 +/- 0.00146\n", + " 135/1 1.01250 1.02550 +/- 0.00145\n", + " 136/1 1.02179 1.02547 +/- 0.00144\n", + " 137/1 1.05685 1.02572 +/- 0.00145\n", + " 138/1 1.04217 1.02585 +/- 0.00144\n", + " 139/1 1.02793 1.02586 +/- 0.00143\n", + " 140/1 1.01207 1.02576 +/- 0.00143\n", + " 141/1 1.03445 1.02582 +/- 0.00142\n", + " 142/1 1.03579 1.02590 +/- 0.00141\n", + " 143/1 1.00786 1.02576 +/- 0.00140\n", + " 144/1 0.99089 1.02550 +/- 0.00142\n", + " 145/1 1.02617 1.02551 +/- 0.00141\n", + " 146/1 1.01691 1.02545 +/- 0.00140\n", + " 147/1 1.00692 1.02531 +/- 0.00139\n", + " 148/1 0.97702 1.02496 +/- 0.00143\n", + " 149/1 1.04002 1.02507 +/- 0.00142\n", + " 150/1 1.01262 1.02498 +/- 0.00141\n", + " 151/1 1.03613 1.02506 +/- 0.00141\n", + " 152/1 1.02920 1.02509 +/- 0.00140\n", + " 153/1 1.02199 1.02507 +/- 0.00139\n", + " 154/1 1.03421 1.02513 +/- 0.00138\n", + " 155/1 1.05882 1.02536 +/- 0.00139\n", + " 156/1 1.02649 1.02537 +/- 0.00138\n", + " 157/1 1.01933 1.02533 +/- 0.00137\n", + " 158/1 1.04269 1.02545 +/- 0.00137\n", + " 159/1 0.99604 1.02525 +/- 0.00137\n", + " 160/1 1.04748 1.02540 +/- 0.00137\n", + " 161/1 1.00501 1.02526 +/- 0.00137\n", + " 162/1 1.00550 1.02513 +/- 0.00137\n", + " 163/1 1.00115 1.02498 +/- 0.00137\n", + " 164/1 1.02283 1.02496 +/- 0.00136\n", + " 165/1 1.01964 1.02493 +/- 0.00135\n", + " 166/1 1.02287 1.02491 +/- 0.00134\n", + " 167/1 1.05498 1.02511 +/- 0.00134\n", + " 168/1 1.05267 1.02528 +/- 0.00135\n", + " 169/1 1.00474 1.02515 +/- 0.00135\n", + " 170/1 1.03469 1.02521 +/- 0.00134\n", + " 171/1 1.02499 1.02521 +/- 0.00133\n", + " 172/1 1.03961 1.02530 +/- 0.00132\n", + " 173/1 1.01240 1.02522 +/- 0.00132\n", + " 174/1 1.00762 1.02511 +/- 0.00132\n", + " 175/1 1.00200 1.02497 +/- 0.00131\n", + " 176/1 1.01449 1.02491 +/- 0.00131\n", + " 177/1 1.01111 1.02483 +/- 0.00130\n", + " 178/1 1.01208 1.02475 +/- 0.00130\n", + " 179/1 1.03304 1.02480 +/- 0.00129\n", + " 180/1 1.04504 1.02492 +/- 0.00129\n", + " 181/1 1.03476 1.02498 +/- 0.00128\n", + " 182/1 1.02124 1.02495 +/- 0.00128\n", + " 183/1 0.98855 1.02474 +/- 0.00128\n", + " 184/1 1.04689 1.02487 +/- 0.00128\n", + " 185/1 1.00618 1.02476 +/- 0.00128\n", + " 186/1 1.02012 1.02474 +/- 0.00127\n", + " 187/1 1.00162 1.02461 +/- 0.00127\n", + " 188/1 1.03269 1.02465 +/- 0.00127\n", + " 189/1 1.04772 1.02478 +/- 0.00127\n", + " 190/1 1.01132 1.02471 +/- 0.00126\n", + " 191/1 1.02669 1.02472 +/- 0.00125\n", + " 192/1 1.01154 1.02464 +/- 0.00125\n", + " 193/1 1.05795 1.02483 +/- 0.00126\n", + " 194/1 1.01615 1.02478 +/- 0.00125\n", + " 195/1 1.03828 1.02485 +/- 0.00125\n", + " 196/1 1.00695 1.02476 +/- 0.00124\n", + " 197/1 1.04126 1.02484 +/- 0.00124\n", + " 198/1 1.02834 1.02486 +/- 0.00123\n", + " 199/1 1.01000 1.02478 +/- 0.00123\n", + " 200/1 0.99294 1.02462 +/- 0.00123\n", + " 201/1 1.00248 1.02450 +/- 0.00123\n", + " 202/1 1.03461 1.02455 +/- 0.00123\n", + " 203/1 1.06289 1.02475 +/- 0.00124\n", + " 204/1 1.03010 1.02478 +/- 0.00123\n", + " 205/1 1.04636 1.02489 +/- 0.00123\n", + " 206/1 1.05434 1.02504 +/- 0.00123\n", + " 207/1 1.03993 1.02512 +/- 0.00123\n", + " 208/1 1.02672 1.02512 +/- 0.00122\n", + " 209/1 1.04958 1.02525 +/- 0.00122\n", + " 210/1 0.99194 1.02508 +/- 0.00123\n", + " 211/1 1.01570 1.02503 +/- 0.00122\n", + " 212/1 1.04079 1.02511 +/- 0.00122\n", + " 213/1 1.02961 1.02513 +/- 0.00121\n", + " 214/1 1.03797 1.02520 +/- 0.00121\n", + " 215/1 1.03714 1.02526 +/- 0.00120\n", + " 216/1 1.03299 1.02529 +/- 0.00120\n", + " 217/1 1.00461 1.02519 +/- 0.00120\n", + " 218/1 1.02386 1.02519 +/- 0.00119\n", + " 219/1 1.01955 1.02516 +/- 0.00119\n", + " 220/1 1.04372 1.02525 +/- 0.00118\n", + " 221/1 1.01694 1.02521 +/- 0.00118\n", + " 222/1 0.99642 1.02507 +/- 0.00118\n", + " 223/1 1.00999 1.02500 +/- 0.00118\n", + " 224/1 1.02703 1.02501 +/- 0.00117\n", + " 225/1 1.00236 1.02491 +/- 0.00117\n", + " 226/1 1.02825 1.02492 +/- 0.00117\n", + " 227/1 1.04535 1.02502 +/- 0.00116\n", + " 228/1 1.01779 1.02498 +/- 0.00116\n", + " 229/1 1.01058 1.02492 +/- 0.00116\n", + " 230/1 1.00391 1.02482 +/- 0.00115\n", + " 231/1 1.05990 1.02498 +/- 0.00116\n", + " 232/1 1.01885 1.02495 +/- 0.00116\n", + " 233/1 1.03204 1.02498 +/- 0.00115\n", + " 234/1 0.99396 1.02485 +/- 0.00115\n", + " 235/1 1.01828 1.02482 +/- 0.00115\n", + " 236/1 1.08225 1.02507 +/- 0.00117\n", + " 237/1 1.00335 1.02498 +/- 0.00117\n", + " 238/1 1.03097 1.02500 +/- 0.00117\n", + " 239/1 1.01738 1.02497 +/- 0.00116\n", + " 240/1 1.02261 1.02496 +/- 0.00116\n", + " 241/1 1.02814 1.02497 +/- 0.00115\n", + " 242/1 1.01158 1.02491 +/- 0.00115\n", + " 243/1 1.03507 1.02496 +/- 0.00114\n", + " 244/1 1.01914 1.02493 +/- 0.00114\n", + " 245/1 1.04555 1.02502 +/- 0.00114\n", + " 246/1 1.02459 1.02502 +/- 0.00113\n", + " 247/1 1.05827 1.02516 +/- 0.00114\n", + " 248/1 1.02549 1.02516 +/- 0.00113\n", + " 249/1 1.03354 1.02520 +/- 0.00113\n", + " 250/1 1.04186 1.02526 +/- 0.00113\n", + " 251/1 1.00466 1.02518 +/- 0.00112\n", + " 252/1 0.99065 1.02504 +/- 0.00113\n", + " 253/1 1.03065 1.02506 +/- 0.00112\n", + " 254/1 1.02167 1.02505 +/- 0.00112\n", + " 255/1 1.01700 1.02501 +/- 0.00112\n", + " 256/1 1.03619 1.02506 +/- 0.00111\n", + " 257/1 1.01833 1.02503 +/- 0.00111\n", + " 258/1 1.02211 1.02502 +/- 0.00110\n", + " 259/1 1.04348 1.02509 +/- 0.00110\n", + " 260/1 1.03444 1.02513 +/- 0.00110\n", + " 261/1 1.05597 1.02525 +/- 0.00110\n", + " 262/1 1.02085 1.02524 +/- 0.00110\n", + " 263/1 1.00552 1.02516 +/- 0.00109\n", + " 264/1 1.03976 1.02522 +/- 0.00109\n", + " 265/1 1.02810 1.02523 +/- 0.00109\n", + " 266/1 1.00911 1.02516 +/- 0.00108\n", + " 267/1 1.01963 1.02514 +/- 0.00108\n", + " 268/1 1.03732 1.02519 +/- 0.00108\n", + " 269/1 1.02422 1.02519 +/- 0.00107\n", + " 270/1 1.01546 1.02515 +/- 0.00107\n", + " 271/1 1.05488 1.02526 +/- 0.00107\n", + " 272/1 1.01709 1.02523 +/- 0.00107\n", + " 273/1 1.05629 1.02535 +/- 0.00107\n", + " 274/1 1.03864 1.02540 +/- 0.00107\n", + " 275/1 1.01472 1.02536 +/- 0.00106\n", + " 276/1 1.03425 1.02539 +/- 0.00106\n", + " 277/1 1.00663 1.02532 +/- 0.00106\n", + " 278/1 1.03326 1.02535 +/- 0.00106\n", + " 279/1 1.02571 1.02535 +/- 0.00105\n", + " 280/1 1.00525 1.02528 +/- 0.00105\n", + " 281/1 1.00451 1.02520 +/- 0.00105\n", + " 282/1 1.04016 1.02526 +/- 0.00105\n", + " 283/1 0.98343 1.02510 +/- 0.00105\n", + " 284/1 1.04843 1.02519 +/- 0.00105\n", + " 285/1 1.01807 1.02516 +/- 0.00105\n", + " 286/1 1.02393 1.02516 +/- 0.00105\n", + " 287/1 1.01851 1.02514 +/- 0.00104\n", + " 288/1 1.03976 1.02519 +/- 0.00104\n", + " 289/1 1.03153 1.02521 +/- 0.00104\n", + " 290/1 1.00416 1.02514 +/- 0.00104\n", + " 291/1 1.01426 1.02510 +/- 0.00103\n", + " 292/1 1.02583 1.02510 +/- 0.00103\n", + " 293/1 1.01680 1.02507 +/- 0.00103\n", + " 294/1 1.04578 1.02514 +/- 0.00103\n", + " 295/1 1.03162 1.02517 +/- 0.00102\n", + " 296/1 1.01682 1.02514 +/- 0.00102\n", + " 297/1 1.00488 1.02507 +/- 0.00102\n", + " 298/1 1.03057 1.02508 +/- 0.00101\n", + " 299/1 1.01126 1.02504 +/- 0.00101\n", + " 300/1 1.03528 1.02507 +/- 0.00101\n", + " 301/1 1.05548 1.02518 +/- 0.00101\n", + " 302/1 1.02994 1.02519 +/- 0.00101\n", + " 303/1 1.03010 1.02521 +/- 0.00100\n", + " 304/1 1.04031 1.02526 +/- 0.00100\n", + " 305/1 1.05866 1.02537 +/- 0.00101\n", + " 306/1 1.03602 1.02541 +/- 0.00100\n", + " 307/1 1.01362 1.02537 +/- 0.00100\n", + " 308/1 1.01318 1.02533 +/- 0.00100\n", + " 309/1 1.04262 1.02539 +/- 0.00100\n", + " 310/1 1.01626 1.02536 +/- 0.00099\n", + " 311/1 1.00285 1.02528 +/- 0.00099\n", + " 312/1 0.98155 1.02514 +/- 0.00100\n", + " 313/1 1.05649 1.02524 +/- 0.00100\n", + " 314/1 1.00960 1.02519 +/- 0.00100\n", + " 315/1 1.05350 1.02528 +/- 0.00100\n", + " 316/1 1.03842 1.02533 +/- 0.00100\n", + " 317/1 1.01394 1.02529 +/- 0.00100\n", + " 318/1 1.01830 1.02527 +/- 0.00099\n", + " 319/1 1.02050 1.02525 +/- 0.00099\n", + " 320/1 1.03402 1.02528 +/- 0.00099\n", + " 321/1 1.04547 1.02534 +/- 0.00099\n", + " 322/1 1.02579 1.02534 +/- 0.00098\n", + " 323/1 1.01922 1.02533 +/- 0.00098\n", + " 324/1 1.01050 1.02528 +/- 0.00098\n", + " 325/1 1.01426 1.02524 +/- 0.00098\n", + " 326/1 1.03283 1.02527 +/- 0.00097\n", + " 327/1 1.03859 1.02531 +/- 0.00097\n", + " 328/1 1.01536 1.02528 +/- 0.00097\n", + " 329/1 1.03149 1.02530 +/- 0.00097\n", + " 330/1 1.04328 1.02535 +/- 0.00096\n", + " 331/1 1.01949 1.02534 +/- 0.00096\n", + " 332/1 1.02319 1.02533 +/- 0.00096\n", + " 333/1 1.01704 1.02530 +/- 0.00096\n", + " 334/1 1.02691 1.02531 +/- 0.00095\n", + " 335/1 1.03188 1.02533 +/- 0.00095\n", + " 336/1 1.03107 1.02535 +/- 0.00095\n", + " 337/1 1.02410 1.02534 +/- 0.00094\n", + " 338/1 0.99917 1.02526 +/- 0.00094\n", + " 339/1 1.03593 1.02529 +/- 0.00094\n", + " 340/1 1.02286 1.02529 +/- 0.00094\n", + " 341/1 1.04154 1.02534 +/- 0.00094\n", + " 342/1 1.01664 1.02531 +/- 0.00094\n", + " 343/1 1.01041 1.02527 +/- 0.00093\n", + " 344/1 1.02033 1.02525 +/- 0.00093\n", + " 345/1 1.03137 1.02527 +/- 0.00093\n", + " 346/1 1.02162 1.02526 +/- 0.00093\n", + " 347/1 1.00835 1.02521 +/- 0.00092\n", + " 348/1 1.01168 1.02517 +/- 0.00092\n", + " 349/1 1.01168 1.02513 +/- 0.00092\n", + " 350/1 1.03509 1.02516 +/- 0.00092\n", + " 351/1 1.01883 1.02514 +/- 0.00092\n", + " 352/1 1.04314 1.02519 +/- 0.00091\n", + " 353/1 0.99067 1.02509 +/- 0.00092\n", + " 354/1 1.03100 1.02511 +/- 0.00091\n", + " 355/1 1.01664 1.02508 +/- 0.00091\n", + " 356/1 1.02193 1.02507 +/- 0.00091\n", + " 357/1 1.03213 1.02509 +/- 0.00091\n", + " 358/1 1.00555 1.02504 +/- 0.00091\n", + " 359/1 1.04849 1.02511 +/- 0.00091\n", + " 360/1 1.02174 1.02510 +/- 0.00090\n", + " 361/1 1.05064 1.02517 +/- 0.00090\n", + " 362/1 1.05274 1.02525 +/- 0.00091\n", + " 363/1 1.00932 1.02520 +/- 0.00090\n", + " 364/1 1.03400 1.02523 +/- 0.00090\n", + " 365/1 1.00149 1.02516 +/- 0.00090\n", + " 366/1 1.01631 1.02514 +/- 0.00090\n", + " 367/1 1.03928 1.02517 +/- 0.00090\n", + " 368/1 1.01318 1.02514 +/- 0.00090\n", + " 369/1 1.04610 1.02520 +/- 0.00090\n", + " 370/1 1.04338 1.02525 +/- 0.00089\n", + " 371/1 1.01638 1.02523 +/- 0.00089\n", + " 372/1 1.04056 1.02527 +/- 0.00089\n", + " 373/1 1.00090 1.02520 +/- 0.00089\n", + " 374/1 1.01261 1.02517 +/- 0.00089\n", + " 375/1 1.03919 1.02520 +/- 0.00089\n", + " 376/1 0.99900 1.02513 +/- 0.00089\n", + " 377/1 1.00168 1.02507 +/- 0.00089\n", + " 378/1 0.99476 1.02499 +/- 0.00089\n", + " 379/1 1.04960 1.02505 +/- 0.00089\n", + " 380/1 0.99797 1.02498 +/- 0.00089\n", + " 381/1 1.04956 1.02505 +/- 0.00089\n", + " 382/1 1.02803 1.02505 +/- 0.00089\n", + " 383/1 0.99388 1.02497 +/- 0.00089\n", + " 384/1 1.00767 1.02492 +/- 0.00089\n", + " 385/1 1.00856 1.02488 +/- 0.00089\n", + " 386/1 1.02997 1.02489 +/- 0.00088\n", + " 387/1 0.97841 1.02477 +/- 0.00089\n", + " 388/1 0.99712 1.02470 +/- 0.00089\n", + " 389/1 0.99072 1.02461 +/- 0.00089\n", + " 390/1 1.02439 1.02461 +/- 0.00089\n", + " 391/1 1.02769 1.02462 +/- 0.00089\n", + " 392/1 1.02205 1.02461 +/- 0.00089\n", + " 393/1 1.03702 1.02464 +/- 0.00088\n", + " 394/1 1.00274 1.02458 +/- 0.00088\n", + " 395/1 1.00131 1.02452 +/- 0.00088\n", + " 396/1 1.00130 1.02446 +/- 0.00088\n", + " 397/1 1.00472 1.02441 +/- 0.00088\n", + " 398/1 1.00724 1.02437 +/- 0.00088\n", + " 399/1 1.03061 1.02438 +/- 0.00088\n", + " 400/1 0.99651 1.02431 +/- 0.00088\n", + " 401/1 0.99290 1.02423 +/- 0.00088\n", + " 402/1 1.02166 1.02423 +/- 0.00088\n", + " 403/1 1.01691 1.02421 +/- 0.00088\n", + " 404/1 1.00492 1.02416 +/- 0.00088\n", + " 405/1 1.00663 1.02411 +/- 0.00088\n", + " 406/1 1.01865 1.02410 +/- 0.00087\n", + " 407/1 1.02717 1.02411 +/- 0.00087\n", + " 408/1 1.01793 1.02409 +/- 0.00087\n", + " 409/1 1.02606 1.02410 +/- 0.00087\n", + " 410/1 1.03809 1.02413 +/- 0.00087\n", + " 411/1 1.03780 1.02417 +/- 0.00086\n", + " 412/1 1.02782 1.02418 +/- 0.00086\n", + " 413/1 1.03077 1.02419 +/- 0.00086\n", + " 414/1 1.00651 1.02415 +/- 0.00086\n", + " 415/1 1.05594 1.02423 +/- 0.00086\n", + " 416/1 0.99558 1.02416 +/- 0.00086\n", + " 417/1 1.00689 1.02411 +/- 0.00086\n", + " 418/1 1.02932 1.02413 +/- 0.00086\n", + " 419/1 1.03552 1.02415 +/- 0.00086\n", + " 420/1 1.03735 1.02419 +/- 0.00085\n", + " 421/1 1.02402 1.02419 +/- 0.00085\n", + " 422/1 1.04227 1.02423 +/- 0.00085\n", + " 423/1 1.03087 1.02425 +/- 0.00085\n", + " 424/1 1.04363 1.02429 +/- 0.00085\n", + " 425/1 1.02676 1.02430 +/- 0.00085\n", + " 426/1 1.03739 1.02433 +/- 0.00085\n", + " 427/1 1.02977 1.02434 +/- 0.00084\n", + " 428/1 1.02547 1.02435 +/- 0.00084\n", + " 429/1 1.03552 1.02437 +/- 0.00084\n", + " 430/1 1.04282 1.02442 +/- 0.00084\n", + " 431/1 1.03171 1.02443 +/- 0.00084\n", + " 432/1 1.01030 1.02440 +/- 0.00084\n", + " 433/1 1.04168 1.02444 +/- 0.00084\n", + " 434/1 0.98994 1.02436 +/- 0.00084\n", + " 435/1 0.98166 1.02426 +/- 0.00084\n", + " 436/1 1.00178 1.02421 +/- 0.00084\n", + " 437/1 1.03801 1.02424 +/- 0.00084\n", + " 438/1 1.02099 1.02423 +/- 0.00084\n", + " 439/1 1.01305 1.02421 +/- 0.00084\n", + " 440/1 1.02286 1.02420 +/- 0.00083\n", + " 441/1 1.03697 1.02423 +/- 0.00083\n", + " 442/1 0.99050 1.02415 +/- 0.00083\n", + " 443/1 1.02238 1.02415 +/- 0.00083\n", + " 444/1 1.05188 1.02421 +/- 0.00083\n", + " 445/1 1.03150 1.02423 +/- 0.00083\n", + " 446/1 1.01071 1.02420 +/- 0.00083\n", + " 447/1 1.03713 1.02423 +/- 0.00083\n", + " 448/1 1.03631 1.02426 +/- 0.00083\n", + " 449/1 1.02968 1.02427 +/- 0.00083\n", + " 450/1 1.03031 1.02428 +/- 0.00082\n", + " 451/1 1.02161 1.02428 +/- 0.00082\n", + " 452/1 0.99036 1.02420 +/- 0.00082\n", + " 453/1 1.02581 1.02420 +/- 0.00082\n", + " 454/1 1.03140 1.02422 +/- 0.00082\n", + " 455/1 1.01962 1.02421 +/- 0.00082\n", + " 456/1 1.00680 1.02417 +/- 0.00082\n", + " 457/1 1.00178 1.02412 +/- 0.00082\n", + " 458/1 1.02306 1.02412 +/- 0.00082\n", + " 459/1 1.02653 1.02412 +/- 0.00081\n", + " 460/1 1.02934 1.02413 +/- 0.00081\n", + " 461/1 1.00872 1.02410 +/- 0.00081\n", + " 462/1 1.00012 1.02405 +/- 0.00081\n", + " 463/1 0.99057 1.02397 +/- 0.00081\n", + " 464/1 1.02353 1.02397 +/- 0.00081\n", + " 465/1 1.01402 1.02395 +/- 0.00081\n", + " 466/1 1.01651 1.02393 +/- 0.00081\n", + " 467/1 1.01024 1.02390 +/- 0.00081\n", + " 468/1 1.02504 1.02391 +/- 0.00080\n", + " 469/1 1.00891 1.02387 +/- 0.00080\n", + " 470/1 1.04038 1.02391 +/- 0.00080\n", + " 471/1 1.04346 1.02395 +/- 0.00080\n", + " 472/1 1.02634 1.02396 +/- 0.00080\n", + " 473/1 1.01207 1.02393 +/- 0.00080\n", + " 474/1 1.00787 1.02390 +/- 0.00080\n", + " 475/1 1.03591 1.02392 +/- 0.00080\n", + " 476/1 1.04257 1.02396 +/- 0.00080\n", + " 477/1 1.00536 1.02392 +/- 0.00079\n", + " 478/1 1.07545 1.02403 +/- 0.00080\n", + " 479/1 1.02306 1.02403 +/- 0.00080\n", + " 480/1 1.02733 1.02404 +/- 0.00080\n", + " 481/1 1.00990 1.02401 +/- 0.00080\n", + " 482/1 0.99031 1.02394 +/- 0.00080\n", + " 483/1 0.98006 1.02384 +/- 0.00080\n", + " 484/1 1.05635 1.02391 +/- 0.00080\n", + " 485/1 1.02410 1.02391 +/- 0.00080\n", + " 486/1 1.01227 1.02389 +/- 0.00080\n", + " 487/1 1.00614 1.02385 +/- 0.00080\n", + " 488/1 1.01837 1.02384 +/- 0.00080\n", + " 489/1 1.02565 1.02384 +/- 0.00080\n", + " 490/1 1.00530 1.02381 +/- 0.00079\n", + " 491/1 1.01958 1.02380 +/- 0.00079\n", + " 492/1 1.04490 1.02384 +/- 0.00079\n", + " 493/1 1.02567 1.02384 +/- 0.00079\n", + " 494/1 1.03865 1.02387 +/- 0.00079\n", + " 495/1 1.03990 1.02391 +/- 0.00079\n", + " 496/1 0.98352 1.02382 +/- 0.00079\n", + " 497/1 1.00909 1.02379 +/- 0.00079\n", + " 498/1 1.03661 1.02382 +/- 0.00079\n", + " 499/1 1.04423 1.02386 +/- 0.00079\n", + " 500/1 1.06406 1.02394 +/- 0.00079\n", + " Creating state point statepoint.500.h5...\n", "\n", " ===========================================================================\n", " ======================> SIMULATION FINISHED <======================\n", @@ -1640,27 +2165,27 @@ "\n", " =======================> TIMING STATISTICS <=======================\n", "\n", - " Total time for initialization = 6.3000E-02 seconds\n", + " Total time for initialization = 5.3000E-02 seconds\n", " Reading cross sections = 5.0000E-03 seconds\n", - " Total time in simulation = 7.3280E+01 seconds\n", - " Time in transport only = 7.3104E+01 seconds\n", - " Time in inactive batches = 1.1200E+00 seconds\n", - " Time in active batches = 7.2160E+01 seconds\n", - " Time synchronizing fission bank = 2.5000E-02 seconds\n", - " Sampling source sites = 1.8000E-02 seconds\n", - " SEND/RECV source sites = 7.0000E-03 seconds\n", - " Time accumulating tallies = 0.0000E+00 seconds\n", + " Total time in simulation = 1.8631E+02 seconds\n", + " Time in transport only = 1.8590E+02 seconds\n", + " Time in inactive batches = 1.1710E+00 seconds\n", + " Time in active batches = 1.8514E+02 seconds\n", + " Time synchronizing fission bank = 7.3000E-02 seconds\n", + " Sampling source sites = 5.1000E-02 seconds\n", + " SEND/RECV source sites = 2.2000E-02 seconds\n", + " Time accumulating tallies = 4.0000E-03 seconds\n", " Total time for finalization = 0.0000E+00 seconds\n", - " Total time elapsed = 7.3353E+01 seconds\n", - " Calculation Rate (inactive) = 44642.9 neutrons/second\n", - " Calculation Rate (active) = 13165.2 neutrons/second\n", + " Total time elapsed = 1.8637E+02 seconds\n", + " Calculation Rate (inactive) = 42698.5 neutrons/second\n", + " Calculation Rate (active) = 13233.2 neutrons/second\n", "\n", " ============================> RESULTS <============================\n", "\n", - " k-effective (Collision) = 1.02597 +/- 0.00117\n", - " k-effective (Track-length) = 1.02518 +/- 0.00132\n", - " k-effective (Absorption) = 1.02581 +/- 0.00070\n", - " Combined k-effective = 1.02562 +/- 0.00068\n", + " k-effective (Collision) = 1.02403 +/- 0.00071\n", + " k-effective (Track-length) = 1.02394 +/- 0.00079\n", + " k-effective (Absorption) = 1.02539 +/- 0.00044\n", + " Combined k-effective = 1.02518 +/- 0.00042\n", " Leakage Fraction = 0.00000 +/- 0.00000\n", "\n" ] @@ -1671,15 +2196,12 @@ "0" ] }, - "execution_count": 37, + "execution_count": 35, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "# Close the StatePoint File\n", - "sp._f.close()\n", - "\n", "# Run the Multi-Group OpenMC Simulation\n", "openmc.run()" ] @@ -1691,12 +2213,13 @@ "# Results Comparison\n", "Now we can compare the multi-group and continuous-energy results.\n", "\n", - "We will begin by loading the multi-group statepoint file we just finished writing and extracting the calculated keff." + "We will begin by loading the multi-group statepoint file we just finished writing and extracting the calculated keff.\n", + "Since we did not rename the summary file, we do not need to load it separately this time." ] }, { "cell_type": "code", - "execution_count": 38, + "execution_count": 36, "metadata": { "collapsed": false }, @@ -1704,11 +2227,27 @@ "source": [ "# Load the last statepoint file and keff value\n", "mgsp = openmc.StatePoint('statepoint.' + str(batches) + '.h5')\n", - "mgsu = openmc.Summary('summary.h5')\n", - "mgsp.link_with_summary(mgsu)\n", "mg_keff = mgsp.k_combined" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Next, we can load the continuous-energy eigenvalue for comparison." + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "ce_keff = sp.k_combined" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -1718,7 +2257,7 @@ }, { "cell_type": "code", - "execution_count": 39, + "execution_count": 38, "metadata": { "collapsed": false }, @@ -1727,9 +2266,9 @@ "name": "stdout", "output_type": "stream", "text": [ - "Continuous-Energy keff = 1.025440\n", - "Multi-Group keff = 1.025621\n", - "bias [pcm]: -18.1\n" + "Continuous-Energy keff = 1.025194\n", + "Multi-Group keff = 1.025183\n", + "bias [pcm]: 1.1\n" ] } ], @@ -1745,7 +2284,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "We see quite good agreement with only an 18pcm difference between the two." + "We see quite good agreement with only an 1 pcm difference between the two. While these results are quite favorable, due to the high degree of approximations inherent in practical application of multi-group theory, one should not expect results of such fidelity always for multi-group Monte Carlo calculations." ] }, { @@ -1764,16 +2303,9 @@ "First, we extract volume-integrated fission rates from the Multi-Group calculation's mesh fission rate tally for each pin cell in the fuel assembly." ] }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Now we can do the same for the Multi-Group results." - ] - }, { "cell_type": "code", - "execution_count": 40, + "execution_count": 39, "metadata": { "collapsed": false }, @@ -1790,6 +2322,32 @@ "mgopenmc_fission_rates /= np.mean(mgopenmc_fission_rates)" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we can do the same for the Multi-Group results." + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# Get the OpenMC fission rate mesh tally data\n", + "mesh_tally = sp.get_tally(name='mesh tally')\n", + "openmc_fission_rates = mesh_tally.get_values(scores=['fission'])\n", + "\n", + "# Reshape array to 2D for plotting\n", + "openmc_fission_rates.shape = (17,17)\n", + "\n", + "# Normalize to the average pin power\n", + "openmc_fission_rates /= np.mean(openmc_fission_rates)" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -1807,7 +2365,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 41, @@ -1816,9 +2374,9 @@ }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAADDCAYAAACS2+oqAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nRKQklNBFREpCCV1EpCSU0EVESuL/ASY96jLsHTMbAAAAAElFTkSuQmCC\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAADDCAYAAACS2+oqAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\noYuIVIQSuohIRSihi4hUxP8DxMTTRn5AfRMAAAAASUVORK5CYII=\n", "text/plain": [ - "" + "" ] }, "metadata": {}, @@ -1845,6 +2403,15 @@ "source": [ "We also see very good agreement between the fission rate distributions." ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [] } ], "metadata": { diff --git a/openmc/mgxs/library.py b/openmc/mgxs/library.py index 82b7616735..334a0fa9cf 100644 --- a/openmc/mgxs/library.py +++ b/openmc/mgxs/library.py @@ -724,7 +724,7 @@ class Library(object): def write_mg_library(self, xs_type='macro', domain_names=None, xs_ids=None, filename='mg_cross_sections', directory='./', - return_names=True): + return_names=False): """Creates a cross-section data library file for the Multi-Group mode of OpenMC. @@ -749,7 +749,7 @@ class Library(object): return_names : bool Flag to indicate if the user would like the names of the materials generated by this function returned with completion. - Defaults to True. + Defaults to False, indicating that no names will be returned. Returns ------- From eb20de6a51b35d221c8ee8e1f0cc0d86478bba14 Mon Sep 17 00:00:00 2001 From: Adam Nelson Date: Fri, 13 May 2016 22:32:48 -0400 Subject: [PATCH 13/20] Updating per the latest round of comments. This includes simplifying the notebook significantly, and adding a get_xsdata method to Library. --- .../pythonapi/examples/mgxs-part-iv.ipynb | 1428 +++-------------- docs/source/usersguide/mgxs_library.rst | 6 +- openmc/material.py | 12 +- openmc/mgxs/library.py | 275 ++-- openmc/mgxs_library.py | 211 +-- src/input_xml.F90 | 12 +- 6 files changed, 393 insertions(+), 1551 deletions(-) diff --git a/docs/source/pythonapi/examples/mgxs-part-iv.ipynb b/docs/source/pythonapi/examples/mgxs-part-iv.ipynb index 823d67ae16..d03db2cce6 100644 --- a/docs/source/pythonapi/examples/mgxs-part-iv.ipynb +++ b/docs/source/pythonapi/examples/mgxs-part-iv.ipynb @@ -7,9 +7,8 @@ "This Notebook illustrates the use of the openmc.mgxs.Library class specifically for application in OpenMC's multi-group mode. This example notebook follows the same process as was done in MGXS Part III, but instead uses OpenMC as the multi-group solver. This Notebook illustrates the following features:\n", "\n", " - Calculation of multi-group cross sections for a fuel assembly\n", - " - Automated creation, manipulation and storage of MGXS with openmc.mgxs.Library\n", - " - Validation of multi-group cross sections with OpenMC\n", - " - Steady-state pin-by-pin fission rates comparison between Continuous-Energy mode and Multi-Group OpenMC.\n", + " - Automated creation and storage of MGXS with openmc.mgxs.Library\n", + " - Steady-state pin-by-pin fission rates comparison between continuous-energy and multi-group OpenMC.\n", "\n", "Note: This Notebook illustrates the use of Pandas DataFrames to containerize multi-group cross section data. We recommend using Pandas >v0.15.0 or later since OpenMC's Python API leverages the multi-indexing feature included in the most recent releases of Pandas.\n" ] @@ -84,23 +83,23 @@ "outputs": [], "source": [ "# 1.6 enriched fuel\n", - "fuel = openmc.Material(name='1.6% Fuel')\n", + "fuel = openmc.Material(name='1.6% Fuel', material_id=1)\n", "fuel.set_density('g/cm3', 10.31341)\n", "fuel.add_nuclide(u235, 3.7503e-4)\n", "fuel.add_nuclide(u238, 2.2625e-2)\n", "fuel.add_nuclide(o16, 4.6007e-2)\n", "\n", + "# zircaloy\n", + "zircaloy = openmc.Material(name='Zircaloy', material_id=2)\n", + "zircaloy.set_density('g/cm3', 6.55)\n", + "zircaloy.add_nuclide(zr90, 7.2758e-3)\n", + "\n", "# borated water\n", - "water = openmc.Material(name='Borated Water')\n", + "water = openmc.Material(name='Borated Water', material_id=3)\n", "water.set_density('g/cm3', 0.740582)\n", "water.add_nuclide(h1, 4.9457e-2)\n", "water.add_nuclide(o16, 2.4732e-2)\n", - "water.add_nuclide(b10, 8.0042e-6)\n", - "\n", - "# zircaloy\n", - "zircaloy = openmc.Material(name='Zircaloy')\n", - "zircaloy.set_density('g/cm3', 6.55)\n", - "zircaloy.add_nuclide(zr90, 7.2758e-3)" + "water.add_nuclide(b10, 8.0042e-6)\n" ] }, { @@ -119,7 +118,7 @@ "outputs": [], "source": [ "# Instantiate a Materials object\n", - "materials_file = openmc.Materials((fuel, water, zircaloy))\n", + "materials_file = openmc.Materials((fuel, zircaloy, water))\n", "materials_file.default_xs = '71c'\n", "\n", "# Export to \"materials.xml\"\n", @@ -347,7 +346,7 @@ "outputs": [], "source": [ "# OpenMC simulation parameters\n", - "batches = 500\n", + "batches = 50\n", "inactive = 10\n", "particles = 5000\n", "\n", @@ -434,7 +433,7 @@ "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAPoAAAD6AgMAAAD1grKuAAAABGdBTUEAALGPC/xhBQAAACBjSFJN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\nVDIxOjE1OjAxLTA0OjAwo0qoOwAAAABJRU5ErkJggg==\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAPoAAAD6AgMAAAD1grKuAAAABGdBTUEAALGPC/xhBQAAACBjSFJN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\nVDIyOjI5OjQxLTA0OjAwt3zdEQAAAABJRU5ErkJggg==\n", "text/plain": [ "" ] @@ -523,7 +522,7 @@ "source": [ "Now we must specify the type of domain over which we would like the `Library` to compute multi-group cross sections. The domain type corresponds to the type of tally filter to be used in the tallies created to compute multi-group cross sections. At the present time, the `Library` supports \"material,\" \"cell,\" and \"universe\" domain types. We will use a \"cell\" domain type here to compute cross sections in each of the cells in the fuel assembly geometry.\n", "\n", - "**Note:** By default, the `Library` class will instantiate `MGXS` objects for each and every domain (material, cell or universe) in the geometry of interest. However, one may specify a subset of these domains to the `Library.domains` property. In our case, we wish to compute multi-group cross sections in each and every cell since they will be needed in our downstream multi-group OpenMC calculation on the identical combinatorial geometry mesh." + "**Note:** By default, the `Library` class will instantiate `MGXS` objects for each and every domain (material, cell or universe) in the geometry of interest. However, one may specify a subset of these domains to the `Library.domains` property. In our this simple example, we wish to compute multi-group cross sections only for each material." ] }, { @@ -535,10 +534,10 @@ "outputs": [], "source": [ "# Specify a \"cell\" domain type for the cross section tally filters\n", - "mgxs_lib.domain_type = \"cell\"\n", + "mgxs_lib.domain_type = \"material\"\n", "\n", "# Specify the cell domains over which to compute multi-group cross sections\n", - "mgxs_lib.domains = geometry.get_all_material_cells()" + "mgxs_lib.domains = geometry.get_all_materials()" ] }, { @@ -697,7 +696,7 @@ " License: http://openmc.readthedocs.org/en/latest/license.html\n", " Version: 0.7.1\n", " Git SHA1: c779ca42c41a062a6a813e03f2add2d182ca9190\n", - " Date/Time: 2016-05-12 21:15:02\n", + " Date/Time: 2016-05-13 22:29:41\n", " OpenMP Threads: 4\n", "\n", " ===========================================================================\n", @@ -713,9 +712,9 @@ " Loading ACE cross section table: 92235.71c\n", " Loading ACE cross section table: 92238.71c\n", " Loading ACE cross section table: 8016.71c\n", + " Loading ACE cross section table: 40090.71c\n", " Loading ACE cross section table: 1001.71c\n", " Loading ACE cross section table: 5010.71c\n", - " Loading ACE cross section table: 40090.71c\n", " Maximum neutron transport energy: 20.0000 MeV for 92235.71c\n", " Initializing source particles...\n", "\n", @@ -725,507 +724,57 @@ "\n", " Bat./Gen. k Average k \n", " ========= ======== ==================== \n", - " 1/1 1.05162 \n", - " 2/1 1.05369 \n", - " 3/1 1.02989 \n", - " 4/1 1.00126 \n", - " 5/1 1.03151 \n", - " 6/1 1.00183 \n", - " 7/1 0.99379 \n", - " 8/1 1.04193 \n", - " 9/1 1.01578 \n", - " 10/1 1.03349 \n", - " 11/1 1.03354 \n", - " 12/1 1.03646 1.03500 +/- 0.00146\n", - " 13/1 1.00873 1.02624 +/- 0.00880\n", - " 14/1 1.04263 1.03034 +/- 0.00745\n", - " 15/1 1.01556 1.02738 +/- 0.00648\n", - " 16/1 1.04897 1.03098 +/- 0.00640\n", - " 17/1 1.01796 1.02912 +/- 0.00572\n", - " 18/1 1.02276 1.02833 +/- 0.00502\n", - " 19/1 1.04003 1.02963 +/- 0.00461\n", - " 20/1 1.00695 1.02736 +/- 0.00471\n", - " 21/1 1.00012 1.02488 +/- 0.00493\n", - " 22/1 1.03580 1.02579 +/- 0.00459\n", - " 23/1 1.03427 1.02644 +/- 0.00427\n", - " 24/1 1.06024 1.02886 +/- 0.00463\n", - " 25/1 1.00742 1.02743 +/- 0.00454\n", - " 26/1 1.02556 1.02731 +/- 0.00425\n", - " 27/1 1.02207 1.02700 +/- 0.00401\n", - " 28/1 1.05847 1.02875 +/- 0.00416\n", - " 29/1 1.01125 1.02783 +/- 0.00404\n", - " 30/1 1.03213 1.02804 +/- 0.00384\n", - " 31/1 1.02241 1.02778 +/- 0.00366\n", - " 32/1 1.02675 1.02773 +/- 0.00349\n", - " 33/1 1.05484 1.02891 +/- 0.00354\n", - " 34/1 1.01893 1.02849 +/- 0.00341\n", - " 35/1 0.99044 1.02697 +/- 0.00361\n", - " 36/1 1.02602 1.02693 +/- 0.00347\n", - " 37/1 1.04107 1.02746 +/- 0.00338\n", - " 38/1 1.03237 1.02763 +/- 0.00326\n", - " 39/1 1.01489 1.02719 +/- 0.00318\n", - " 40/1 1.01065 1.02664 +/- 0.00312\n", - " 41/1 1.03722 1.02698 +/- 0.00304\n", - " 42/1 1.04339 1.02750 +/- 0.00298\n", - " 43/1 1.00921 1.02694 +/- 0.00294\n", - " 44/1 1.04576 1.02750 +/- 0.00291\n", - " 45/1 1.02580 1.02745 +/- 0.00283\n", - " 46/1 1.03464 1.02765 +/- 0.00275\n", - " 47/1 1.01552 1.02732 +/- 0.00270\n", - " 48/1 1.03357 1.02748 +/- 0.00263\n", - " 49/1 1.03439 1.02766 +/- 0.00257\n", - " 50/1 1.04281 1.02804 +/- 0.00253\n", - " 51/1 1.02902 1.02806 +/- 0.00247\n", - " 52/1 1.02245 1.02793 +/- 0.00241\n", - " 53/1 1.05271 1.02851 +/- 0.00243\n", - " 54/1 0.98630 1.02755 +/- 0.00256\n", - " 55/1 1.02690 1.02753 +/- 0.00250\n", - " 56/1 1.04107 1.02783 +/- 0.00246\n", - " 57/1 1.03029 1.02788 +/- 0.00241\n", - " 58/1 1.01874 1.02769 +/- 0.00237\n", - " 59/1 1.04211 1.02798 +/- 0.00234\n", - " 60/1 0.99584 1.02734 +/- 0.00238\n", - " 61/1 1.05166 1.02782 +/- 0.00238\n", - " 62/1 1.05572 1.02835 +/- 0.00239\n", - " 63/1 1.02694 1.02833 +/- 0.00235\n", - " 64/1 1.03314 1.02842 +/- 0.00231\n", - " 65/1 1.05850 1.02896 +/- 0.00233\n", - " 66/1 1.01100 1.02864 +/- 0.00231\n", - " 67/1 1.03784 1.02880 +/- 0.00227\n", - " 68/1 1.04084 1.02901 +/- 0.00224\n", - " 69/1 1.03932 1.02919 +/- 0.00221\n", - " 70/1 1.02564 1.02913 +/- 0.00218\n", - " 71/1 1.00027 1.02865 +/- 0.00219\n", - " 72/1 1.02385 1.02858 +/- 0.00216\n", - " 73/1 1.04885 1.02890 +/- 0.00215\n", - " 74/1 1.00298 1.02849 +/- 0.00215\n", - " 75/1 1.02009 1.02836 +/- 0.00212\n", - " 76/1 1.04505 1.02862 +/- 0.00211\n", - " 77/1 1.02889 1.02862 +/- 0.00207\n", - " 78/1 1.01306 1.02839 +/- 0.00206\n", - " 79/1 1.01817 1.02824 +/- 0.00203\n", - " 80/1 1.00533 1.02792 +/- 0.00203\n", - " 81/1 1.04439 1.02815 +/- 0.00201\n", - " 82/1 1.02212 1.02806 +/- 0.00199\n", - " 83/1 0.99419 1.02760 +/- 0.00201\n", - " 84/1 1.07132 1.02819 +/- 0.00207\n", - " 85/1 1.02710 1.02818 +/- 0.00204\n", - " 86/1 1.01702 1.02803 +/- 0.00202\n", - " 87/1 1.02134 1.02794 +/- 0.00200\n", - " 88/1 1.05231 1.02826 +/- 0.00200\n", - " 89/1 1.05290 1.02857 +/- 0.00200\n", - " 90/1 1.05751 1.02893 +/- 0.00200\n", - " 91/1 1.03970 1.02906 +/- 0.00198\n", - " 92/1 0.99678 1.02867 +/- 0.00200\n", - " 93/1 1.04471 1.02886 +/- 0.00198\n", - " 94/1 1.00820 1.02862 +/- 0.00198\n", - " 95/1 1.05823 1.02896 +/- 0.00198\n", - " 96/1 1.05118 1.02922 +/- 0.00198\n", - " 97/1 1.03617 1.02930 +/- 0.00196\n", - " 98/1 1.00585 1.02904 +/- 0.00195\n", - " 99/1 1.06663 1.02946 +/- 0.00198\n", - " 100/1 1.01802 1.02933 +/- 0.00196\n", - " 101/1 1.02695 1.02931 +/- 0.00194\n", - " 102/1 1.01642 1.02917 +/- 0.00192\n", - " 103/1 1.02567 1.02913 +/- 0.00190\n", - " 104/1 1.03519 1.02919 +/- 0.00188\n", - " 105/1 1.02439 1.02914 +/- 0.00186\n", - " 106/1 1.03779 1.02923 +/- 0.00184\n", - " 107/1 1.01304 1.02906 +/- 0.00183\n", - " 108/1 1.02541 1.02903 +/- 0.00181\n", - " 109/1 1.04297 1.02917 +/- 0.00180\n", - " 110/1 1.00442 1.02892 +/- 0.00180\n", - " 111/1 1.03102 1.02894 +/- 0.00178\n", - " 112/1 1.00380 1.02870 +/- 0.00178\n", - " 113/1 1.04010 1.02881 +/- 0.00177\n", - " 114/1 1.01297 1.02865 +/- 0.00176\n", - " 115/1 1.00130 1.02839 +/- 0.00176\n", - " 116/1 1.02001 1.02831 +/- 0.00174\n", - " 117/1 1.03847 1.02841 +/- 0.00173\n", - " 118/1 1.00371 1.02818 +/- 0.00173\n", - " 119/1 1.02650 1.02817 +/- 0.00171\n", - " 120/1 1.00767 1.02798 +/- 0.00171\n", - " 121/1 1.00408 1.02776 +/- 0.00171\n", - " 122/1 1.00235 1.02754 +/- 0.00171\n", - " 123/1 1.01212 1.02740 +/- 0.00170\n", - " 124/1 1.03278 1.02745 +/- 0.00168\n", - " 125/1 1.00818 1.02728 +/- 0.00168\n", - " 126/1 1.02132 1.02723 +/- 0.00166\n", - " 127/1 1.03677 1.02731 +/- 0.00165\n", - " 128/1 1.04148 1.02743 +/- 0.00164\n", - " 129/1 1.01245 1.02730 +/- 0.00163\n", - " 130/1 1.04172 1.02742 +/- 0.00162\n", - " 131/1 1.04519 1.02757 +/- 0.00162\n", - " 132/1 1.02495 1.02755 +/- 0.00160\n", - " 133/1 0.99747 1.02731 +/- 0.00161\n", - " 134/1 1.02411 1.02728 +/- 0.00160\n", - " 135/1 1.05750 1.02752 +/- 0.00160\n", - " 136/1 1.02341 1.02749 +/- 0.00159\n", - " 137/1 1.02212 1.02745 +/- 0.00158\n", - " 138/1 1.03464 1.02750 +/- 0.00157\n", - " 139/1 1.05920 1.02775 +/- 0.00157\n", - " 140/1 1.01911 1.02768 +/- 0.00156\n", - " 141/1 1.03076 1.02771 +/- 0.00155\n", - " 142/1 1.03648 1.02777 +/- 0.00154\n", - " 143/1 1.00382 1.02759 +/- 0.00154\n", - " 144/1 1.00366 1.02741 +/- 0.00154\n", - " 145/1 1.01638 1.02733 +/- 0.00153\n", - " 146/1 1.02418 1.02731 +/- 0.00152\n", - " 147/1 0.99267 1.02706 +/- 0.00153\n", - " 148/1 1.02575 1.02705 +/- 0.00152\n", - " 149/1 0.98560 1.02675 +/- 0.00153\n", - " 150/1 1.02725 1.02675 +/- 0.00152\n", - " 151/1 1.03723 1.02683 +/- 0.00151\n", - " 152/1 1.00857 1.02670 +/- 0.00151\n", - " 153/1 1.00642 1.02656 +/- 0.00151\n", - " 154/1 1.03461 1.02661 +/- 0.00150\n", - " 155/1 1.00088 1.02643 +/- 0.00150\n", - " 156/1 1.02589 1.02643 +/- 0.00149\n", - " 157/1 1.02494 1.02642 +/- 0.00148\n", - " 158/1 1.03303 1.02646 +/- 0.00147\n", - " 159/1 1.02276 1.02644 +/- 0.00146\n", - " 160/1 1.03293 1.02648 +/- 0.00145\n", - " 161/1 1.04758 1.02662 +/- 0.00144\n", - " 162/1 1.01033 1.02652 +/- 0.00144\n", - " 163/1 1.03883 1.02660 +/- 0.00143\n", - " 164/1 1.00519 1.02646 +/- 0.00143\n", - " 165/1 1.05958 1.02667 +/- 0.00144\n", - " 166/1 1.03849 1.02675 +/- 0.00143\n", - " 167/1 1.02306 1.02672 +/- 0.00142\n", - " 168/1 1.02693 1.02672 +/- 0.00141\n", - " 169/1 1.02584 1.02672 +/- 0.00140\n", - " 170/1 0.99388 1.02651 +/- 0.00141\n", - " 171/1 0.99376 1.02631 +/- 0.00141\n", - " 172/1 1.00453 1.02618 +/- 0.00141\n", - " 173/1 1.04516 1.02629 +/- 0.00141\n", - " 174/1 1.02402 1.02628 +/- 0.00140\n", - " 175/1 0.99012 1.02606 +/- 0.00141\n", - " 176/1 1.02084 1.02603 +/- 0.00140\n", - " 177/1 1.03959 1.02611 +/- 0.00139\n", - " 178/1 1.01719 1.02606 +/- 0.00139\n", - " 179/1 1.01671 1.02600 +/- 0.00138\n", - " 180/1 1.03691 1.02606 +/- 0.00137\n", - " 181/1 1.04276 1.02616 +/- 0.00137\n", - " 182/1 1.02002 1.02613 +/- 0.00136\n", - " 183/1 1.03081 1.02615 +/- 0.00135\n", - " 184/1 1.02432 1.02614 +/- 0.00135\n", - " 185/1 1.02225 1.02612 +/- 0.00134\n", - " 186/1 1.04722 1.02624 +/- 0.00134\n", - " 187/1 0.98045 1.02598 +/- 0.00135\n", - " 188/1 1.02555 1.02598 +/- 0.00135\n", - " 189/1 1.03645 1.02604 +/- 0.00134\n", - " 190/1 1.00407 1.02592 +/- 0.00134\n", - " 191/1 1.03033 1.02594 +/- 0.00133\n", - " 192/1 1.04175 1.02603 +/- 0.00133\n", - " 193/1 1.00555 1.02592 +/- 0.00132\n", - " 194/1 1.00183 1.02578 +/- 0.00132\n", - " 195/1 1.04328 1.02588 +/- 0.00132\n", - " 196/1 1.03041 1.02590 +/- 0.00131\n", - " 197/1 1.04791 1.02602 +/- 0.00131\n", - " 198/1 1.01366 1.02596 +/- 0.00130\n", - " 199/1 1.04471 1.02605 +/- 0.00130\n", - " 200/1 1.02416 1.02604 +/- 0.00129\n", - " 201/1 1.01172 1.02597 +/- 0.00129\n", - " 202/1 1.01683 1.02592 +/- 0.00128\n", - " 203/1 1.01341 1.02586 +/- 0.00128\n", - " 204/1 1.01507 1.02580 +/- 0.00127\n", - " 205/1 1.02540 1.02580 +/- 0.00127\n", - " 206/1 1.00310 1.02568 +/- 0.00127\n", - " 207/1 1.02822 1.02570 +/- 0.00126\n", - " 208/1 1.01023 1.02562 +/- 0.00126\n", - " 209/1 1.04603 1.02572 +/- 0.00125\n", - " 210/1 1.00775 1.02563 +/- 0.00125\n", - " 211/1 1.01706 1.02559 +/- 0.00125\n", - " 212/1 0.99434 1.02543 +/- 0.00125\n", - " 213/1 1.03346 1.02547 +/- 0.00124\n", - " 214/1 1.05322 1.02561 +/- 0.00124\n", - " 215/1 1.03057 1.02563 +/- 0.00124\n", - " 216/1 1.00976 1.02556 +/- 0.00123\n", - " 217/1 1.02760 1.02557 +/- 0.00123\n", - " 218/1 1.01259 1.02550 +/- 0.00122\n", - " 219/1 1.02829 1.02552 +/- 0.00122\n", - " 220/1 1.02228 1.02550 +/- 0.00121\n", - " 221/1 1.06679 1.02570 +/- 0.00122\n", - " 222/1 1.03417 1.02574 +/- 0.00122\n", - " 223/1 1.04239 1.02582 +/- 0.00121\n", - " 224/1 1.02062 1.02579 +/- 0.00121\n", - " 225/1 1.00331 1.02569 +/- 0.00121\n", - " 226/1 1.00131 1.02557 +/- 0.00121\n", - " 227/1 1.01768 1.02554 +/- 0.00120\n", - " 228/1 1.00813 1.02546 +/- 0.00120\n", - " 229/1 1.05320 1.02558 +/- 0.00120\n", - " 230/1 1.03472 1.02563 +/- 0.00120\n", - " 231/1 1.01426 1.02557 +/- 0.00119\n", - " 232/1 1.00782 1.02549 +/- 0.00119\n", - " 233/1 1.02813 1.02551 +/- 0.00118\n", - " 234/1 1.01184 1.02545 +/- 0.00118\n", - " 235/1 1.02156 1.02543 +/- 0.00118\n", - " 236/1 0.99029 1.02527 +/- 0.00118\n", - " 237/1 1.04196 1.02535 +/- 0.00118\n", - " 238/1 1.01594 1.02531 +/- 0.00117\n", - " 239/1 1.02732 1.02531 +/- 0.00117\n", - " 240/1 0.98987 1.02516 +/- 0.00117\n", - " 241/1 1.03388 1.02520 +/- 0.00117\n", - " 242/1 1.01319 1.02515 +/- 0.00116\n", - " 243/1 1.02870 1.02516 +/- 0.00116\n", - " 244/1 1.01943 1.02514 +/- 0.00115\n", - " 245/1 1.04463 1.02522 +/- 0.00115\n", - " 246/1 1.03551 1.02526 +/- 0.00115\n", - " 247/1 1.00436 1.02517 +/- 0.00115\n", - " 248/1 1.03326 1.02521 +/- 0.00114\n", - " 249/1 1.05769 1.02534 +/- 0.00115\n", - " 250/1 1.01372 1.02530 +/- 0.00114\n", - " 251/1 1.02971 1.02531 +/- 0.00114\n", - " 252/1 1.01166 1.02526 +/- 0.00113\n", - " 253/1 1.03992 1.02532 +/- 0.00113\n", - " 254/1 1.01507 1.02528 +/- 0.00113\n", - " 255/1 1.03222 1.02530 +/- 0.00112\n", - " 256/1 1.03096 1.02533 +/- 0.00112\n", - " 257/1 1.01153 1.02527 +/- 0.00112\n", - " 258/1 1.03668 1.02532 +/- 0.00111\n", - " 259/1 1.03070 1.02534 +/- 0.00111\n", - " 260/1 1.01189 1.02529 +/- 0.00111\n", - " 261/1 1.00082 1.02519 +/- 0.00111\n", - " 262/1 1.03653 1.02523 +/- 0.00110\n", - " 263/1 1.02908 1.02525 +/- 0.00110\n", - " 264/1 1.00072 1.02515 +/- 0.00110\n", - " 265/1 1.00832 1.02509 +/- 0.00109\n", - " 266/1 1.04385 1.02516 +/- 0.00109\n", - " 267/1 1.00117 1.02507 +/- 0.00109\n", - " 268/1 1.02682 1.02507 +/- 0.00109\n", - " 269/1 1.03202 1.02510 +/- 0.00108\n", - " 270/1 1.01275 1.02505 +/- 0.00108\n", - " 271/1 1.02633 1.02506 +/- 0.00108\n", - " 272/1 1.04811 1.02514 +/- 0.00108\n", - " 273/1 1.02851 1.02516 +/- 0.00107\n", - " 274/1 1.01270 1.02511 +/- 0.00107\n", - " 275/1 1.06222 1.02525 +/- 0.00107\n", - " 276/1 1.02778 1.02526 +/- 0.00107\n", - " 277/1 1.02601 1.02526 +/- 0.00107\n", - " 278/1 1.02356 1.02526 +/- 0.00106\n", - " 279/1 1.00792 1.02519 +/- 0.00106\n", - " 280/1 1.02331 1.02518 +/- 0.00106\n", - " 281/1 1.00985 1.02513 +/- 0.00105\n", - " 282/1 1.02035 1.02511 +/- 0.00105\n", - " 283/1 0.98181 1.02495 +/- 0.00106\n", - " 284/1 1.01829 1.02493 +/- 0.00106\n", - " 285/1 1.02929 1.02494 +/- 0.00105\n", - " 286/1 1.03524 1.02498 +/- 0.00105\n", - " 287/1 1.01212 1.02493 +/- 0.00105\n", - " 288/1 1.03584 1.02497 +/- 0.00104\n", - " 289/1 1.02961 1.02499 +/- 0.00104\n", - " 290/1 0.99692 1.02489 +/- 0.00104\n", - " 291/1 1.03966 1.02494 +/- 0.00104\n", - " 292/1 1.00965 1.02489 +/- 0.00104\n", - " 293/1 1.02601 1.02489 +/- 0.00103\n", - " 294/1 1.03224 1.02492 +/- 0.00103\n", - " 295/1 1.01596 1.02489 +/- 0.00103\n", - " 296/1 1.06964 1.02504 +/- 0.00103\n", - " 297/1 1.03982 1.02509 +/- 0.00103\n", - " 298/1 0.99758 1.02500 +/- 0.00103\n", - " 299/1 1.01479 1.02496 +/- 0.00103\n", - " 300/1 1.04517 1.02503 +/- 0.00103\n", - " 301/1 0.99128 1.02492 +/- 0.00103\n", - " 302/1 1.01493 1.02488 +/- 0.00103\n", - " 303/1 1.00623 1.02482 +/- 0.00103\n", - " 304/1 1.02560 1.02482 +/- 0.00102\n", - " 305/1 1.00806 1.02477 +/- 0.00102\n", - " 306/1 1.03524 1.02480 +/- 0.00102\n", - " 307/1 0.99244 1.02469 +/- 0.00102\n", - " 308/1 0.98013 1.02454 +/- 0.00103\n", - " 309/1 1.00853 1.02449 +/- 0.00103\n", - " 310/1 1.00116 1.02441 +/- 0.00103\n", - " 311/1 1.01730 1.02439 +/- 0.00102\n", - " 312/1 1.01198 1.02435 +/- 0.00102\n", - " 313/1 1.02405 1.02435 +/- 0.00102\n", - " 314/1 1.01734 1.02432 +/- 0.00101\n", - " 315/1 1.02320 1.02432 +/- 0.00101\n", - " 316/1 1.03438 1.02435 +/- 0.00101\n", - " 317/1 1.00106 1.02428 +/- 0.00101\n", - " 318/1 1.03114 1.02430 +/- 0.00100\n", - " 319/1 1.04955 1.02438 +/- 0.00100\n", - " 320/1 1.03259 1.02441 +/- 0.00100\n", - " 321/1 1.00687 1.02435 +/- 0.00100\n", - " 322/1 1.05753 1.02446 +/- 0.00100\n", - " 323/1 1.03676 1.02450 +/- 0.00100\n", - " 324/1 0.99796 1.02441 +/- 0.00100\n", - " 325/1 1.03783 1.02445 +/- 0.00100\n", - " 326/1 1.02315 1.02445 +/- 0.00099\n", - " 327/1 1.04205 1.02451 +/- 0.00099\n", - " 328/1 1.01971 1.02449 +/- 0.00099\n", - " 329/1 1.02394 1.02449 +/- 0.00099\n", - " 330/1 1.03318 1.02452 +/- 0.00098\n", - " 331/1 1.01503 1.02449 +/- 0.00098\n", - " 332/1 1.07143 1.02463 +/- 0.00099\n", - " 333/1 1.00991 1.02459 +/- 0.00099\n", - " 334/1 1.03115 1.02461 +/- 0.00098\n", - " 335/1 1.04400 1.02467 +/- 0.00098\n", - " 336/1 1.03516 1.02470 +/- 0.00098\n", - " 337/1 1.02025 1.02468 +/- 0.00098\n", - " 338/1 1.03269 1.02471 +/- 0.00098\n", - " 339/1 1.03745 1.02475 +/- 0.00097\n", - " 340/1 1.03685 1.02478 +/- 0.00097\n", - " 341/1 1.01831 1.02476 +/- 0.00097\n", - " 342/1 1.01425 1.02473 +/- 0.00097\n", - " 343/1 1.02990 1.02475 +/- 0.00096\n", - " 344/1 1.02958 1.02476 +/- 0.00096\n", - " 345/1 1.03133 1.02478 +/- 0.00096\n", - " 346/1 1.02441 1.02478 +/- 0.00095\n", - " 347/1 1.07010 1.02492 +/- 0.00096\n", - " 348/1 1.02327 1.02491 +/- 0.00096\n", - " 349/1 1.03123 1.02493 +/- 0.00096\n", - " 350/1 1.03158 1.02495 +/- 0.00095\n", - " 351/1 1.03473 1.02498 +/- 0.00095\n", - " 352/1 1.04000 1.02502 +/- 0.00095\n", - " 353/1 1.01651 1.02500 +/- 0.00095\n", - " 354/1 1.03647 1.02503 +/- 0.00094\n", - " 355/1 1.04650 1.02509 +/- 0.00094\n", - " 356/1 1.04703 1.02516 +/- 0.00094\n", - " 357/1 1.00260 1.02509 +/- 0.00094\n", - " 358/1 1.00075 1.02502 +/- 0.00094\n", - " 359/1 1.04874 1.02509 +/- 0.00094\n", - " 360/1 1.03211 1.02511 +/- 0.00094\n", - " 361/1 1.02136 1.02510 +/- 0.00094\n", - " 362/1 1.00803 1.02505 +/- 0.00094\n", - " 363/1 1.00319 1.02499 +/- 0.00094\n", - " 364/1 1.01443 1.02496 +/- 0.00093\n", - " 365/1 1.02685 1.02496 +/- 0.00093\n", - " 366/1 1.02373 1.02496 +/- 0.00093\n", - " 367/1 1.02026 1.02495 +/- 0.00093\n", - " 368/1 1.01579 1.02492 +/- 0.00092\n", - " 369/1 1.08004 1.02508 +/- 0.00093\n", - " 370/1 1.01715 1.02505 +/- 0.00093\n", - " 371/1 0.98578 1.02494 +/- 0.00093\n", - " 372/1 1.03033 1.02496 +/- 0.00093\n", - " 373/1 1.03269 1.02498 +/- 0.00093\n", - " 374/1 1.04050 1.02502 +/- 0.00093\n", - " 375/1 1.00760 1.02498 +/- 0.00093\n", - " 376/1 1.04492 1.02503 +/- 0.00093\n", - " 377/1 1.04983 1.02510 +/- 0.00093\n", - " 378/1 1.06022 1.02519 +/- 0.00093\n", - " 379/1 1.02516 1.02519 +/- 0.00093\n", - " 380/1 1.01740 1.02517 +/- 0.00092\n", - " 381/1 1.02520 1.02517 +/- 0.00092\n", - " 382/1 1.02820 1.02518 +/- 0.00092\n", - " 383/1 1.00697 1.02513 +/- 0.00092\n", - " 384/1 1.03497 1.02516 +/- 0.00092\n", - " 385/1 0.98404 1.02505 +/- 0.00092\n", - " 386/1 1.05206 1.02512 +/- 0.00092\n", - " 387/1 1.01502 1.02509 +/- 0.00092\n", - " 388/1 1.02196 1.02508 +/- 0.00092\n", - " 389/1 1.02856 1.02509 +/- 0.00091\n", - " 390/1 1.01376 1.02506 +/- 0.00091\n", - " 391/1 1.01696 1.02504 +/- 0.00091\n", - " 392/1 1.03283 1.02506 +/- 0.00091\n", - " 393/1 1.00787 1.02502 +/- 0.00091\n", - " 394/1 1.02184 1.02501 +/- 0.00090\n", - " 395/1 1.03170 1.02503 +/- 0.00090\n", - " 396/1 1.04406 1.02508 +/- 0.00090\n", - " 397/1 1.03939 1.02511 +/- 0.00090\n", - " 398/1 1.00329 1.02506 +/- 0.00090\n", - " 399/1 1.04518 1.02511 +/- 0.00090\n", - " 400/1 1.03435 1.02513 +/- 0.00090\n", - " 401/1 1.00525 1.02508 +/- 0.00089\n", - " 402/1 1.03112 1.02510 +/- 0.00089\n", - " 403/1 1.00188 1.02504 +/- 0.00089\n", - " 404/1 1.01241 1.02501 +/- 0.00089\n", - " 405/1 1.01796 1.02499 +/- 0.00089\n", - " 406/1 1.02686 1.02499 +/- 0.00089\n", - " 407/1 1.01003 1.02496 +/- 0.00088\n", - " 408/1 1.02359 1.02495 +/- 0.00088\n", - " 409/1 1.01258 1.02492 +/- 0.00088\n", - " 410/1 1.04361 1.02497 +/- 0.00088\n", - " 411/1 1.00885 1.02493 +/- 0.00088\n", - " 412/1 1.00999 1.02489 +/- 0.00088\n", - " 413/1 0.97832 1.02477 +/- 0.00088\n", - " 414/1 1.04183 1.02482 +/- 0.00088\n", - " 415/1 1.02279 1.02481 +/- 0.00088\n", - " 416/1 1.04197 1.02485 +/- 0.00088\n", - " 417/1 1.04617 1.02491 +/- 0.00088\n", - " 418/1 1.01311 1.02488 +/- 0.00088\n", - " 419/1 1.03904 1.02491 +/- 0.00087\n", - " 420/1 1.00458 1.02486 +/- 0.00087\n", - " 421/1 0.98580 1.02477 +/- 0.00088\n", - " 422/1 1.01850 1.02475 +/- 0.00087\n", - " 423/1 1.03739 1.02478 +/- 0.00087\n", - " 424/1 1.02716 1.02479 +/- 0.00087\n", - " 425/1 1.00711 1.02475 +/- 0.00087\n", - " 426/1 1.01008 1.02471 +/- 0.00087\n", - " 427/1 1.03332 1.02473 +/- 0.00087\n", - " 428/1 1.00501 1.02468 +/- 0.00087\n", - " 429/1 1.04549 1.02473 +/- 0.00086\n", - " 430/1 1.00582 1.02469 +/- 0.00086\n", - " 431/1 1.00586 1.02464 +/- 0.00086\n", - " 432/1 1.00082 1.02459 +/- 0.00086\n", - " 433/1 1.00835 1.02455 +/- 0.00086\n", - " 434/1 1.03965 1.02458 +/- 0.00086\n", - " 435/1 1.02385 1.02458 +/- 0.00086\n", - " 436/1 1.01440 1.02456 +/- 0.00086\n", - " 437/1 1.03127 1.02458 +/- 0.00085\n", - " 438/1 1.02961 1.02459 +/- 0.00085\n", - " 439/1 0.99584 1.02452 +/- 0.00085\n", - " 440/1 1.04964 1.02458 +/- 0.00085\n", - " 441/1 0.99792 1.02452 +/- 0.00085\n", - " 442/1 1.04971 1.02457 +/- 0.00085\n", - " 443/1 1.01504 1.02455 +/- 0.00085\n", - " 444/1 1.04359 1.02460 +/- 0.00085\n", - " 445/1 1.01148 1.02457 +/- 0.00085\n", - " 446/1 1.01203 1.02454 +/- 0.00085\n", - " 447/1 1.02353 1.02454 +/- 0.00085\n", - " 448/1 1.06299 1.02462 +/- 0.00085\n", - " 449/1 1.00017 1.02457 +/- 0.00085\n", - " 450/1 1.01193 1.02454 +/- 0.00085\n", - " 451/1 1.00179 1.02449 +/- 0.00085\n", - " 452/1 1.02425 1.02449 +/- 0.00085\n", - " 453/1 1.03629 1.02451 +/- 0.00084\n", - " 454/1 1.01955 1.02450 +/- 0.00084\n", - " 455/1 1.00870 1.02447 +/- 0.00084\n", - " 456/1 1.04230 1.02451 +/- 0.00084\n", - " 457/1 1.05081 1.02457 +/- 0.00084\n", - " 458/1 1.00271 1.02452 +/- 0.00084\n", - " 459/1 1.01010 1.02448 +/- 0.00084\n", - " 460/1 1.04656 1.02453 +/- 0.00084\n", - " 461/1 1.00790 1.02450 +/- 0.00084\n", - " 462/1 1.02214 1.02449 +/- 0.00084\n", - " 463/1 1.04401 1.02453 +/- 0.00083\n", - " 464/1 1.02863 1.02454 +/- 0.00083\n", - " 465/1 0.99971 1.02449 +/- 0.00083\n", - " 466/1 1.00344 1.02444 +/- 0.00083\n", - " 467/1 1.02810 1.02445 +/- 0.00083\n", - " 468/1 1.02091 1.02444 +/- 0.00083\n", - " 469/1 1.00545 1.02440 +/- 0.00083\n", - " 470/1 1.01590 1.02438 +/- 0.00083\n", - " 471/1 1.04465 1.02443 +/- 0.00083\n", - " 472/1 1.02028 1.02442 +/- 0.00082\n", - " 473/1 1.01951 1.02441 +/- 0.00082\n", - " 474/1 1.03280 1.02443 +/- 0.00082\n", - " 475/1 1.04722 1.02447 +/- 0.00082\n", - " 476/1 1.03587 1.02450 +/- 0.00082\n", - " 477/1 1.02234 1.02449 +/- 0.00082\n", - " 478/1 1.07848 1.02461 +/- 0.00082\n", - " 479/1 1.04759 1.02466 +/- 0.00082\n", - " 480/1 1.07189 1.02476 +/- 0.00083\n", - " 481/1 1.05811 1.02483 +/- 0.00083\n", - " 482/1 1.04554 1.02487 +/- 0.00083\n", - " 483/1 1.01956 1.02486 +/- 0.00083\n", - " 484/1 1.01055 1.02483 +/- 0.00083\n", - " 485/1 1.00845 1.02480 +/- 0.00082\n", - " 486/1 1.04607 1.02484 +/- 0.00082\n", - " 487/1 1.05955 1.02492 +/- 0.00083\n", - " 488/1 1.02245 1.02491 +/- 0.00082\n", - " 489/1 0.98206 1.02482 +/- 0.00083\n", - " 490/1 1.03786 1.02485 +/- 0.00083\n", - " 491/1 1.02973 1.02486 +/- 0.00082\n", - " 492/1 1.02890 1.02487 +/- 0.00082\n", - " 493/1 1.02086 1.02486 +/- 0.00082\n", - " 494/1 1.01194 1.02483 +/- 0.00082\n", - " 495/1 1.01902 1.02482 +/- 0.00082\n", - " 496/1 1.01783 1.02481 +/- 0.00082\n", - " 497/1 1.02129 1.02480 +/- 0.00081\n", - " 498/1 1.02407 1.02480 +/- 0.00081\n", - " 499/1 1.02873 1.02480 +/- 0.00081\n", - " 500/1 1.00998 1.02477 +/- 0.00081\n", - " Creating state point statepoint.500.h5...\n", + " 1/1 1.05201 \n", + " 2/1 1.02017 \n", + " 3/1 1.02398 \n", + " 4/1 1.02677 \n", + " 5/1 1.01070 \n", + " 6/1 1.02964 \n", + " 7/1 1.02163 \n", + " 8/1 1.04524 \n", + " 9/1 1.00773 \n", + " 10/1 1.01536 \n", + " 11/1 1.02992 \n", + " 12/1 1.03248 1.03120 +/- 0.00128\n", + " 13/1 0.99044 1.01761 +/- 0.01361\n", + " 14/1 1.01484 1.01692 +/- 0.00965\n", + " 15/1 1.01491 1.01652 +/- 0.00748\n", + " 16/1 1.03809 1.02011 +/- 0.00709\n", + " 17/1 1.02536 1.02086 +/- 0.00604\n", + " 18/1 1.03663 1.02283 +/- 0.00559\n", + " 19/1 1.03902 1.02463 +/- 0.00525\n", + " 20/1 1.01557 1.02373 +/- 0.00478\n", + " 21/1 1.01286 1.02274 +/- 0.00443\n", + " 22/1 1.01392 1.02200 +/- 0.00411\n", + " 23/1 1.04439 1.02372 +/- 0.00416\n", + " 24/1 1.04034 1.02491 +/- 0.00403\n", + " 25/1 0.99433 1.02287 +/- 0.00427\n", + " 26/1 1.02720 1.02314 +/- 0.00400\n", + " 27/1 1.03545 1.02387 +/- 0.00383\n", + " 28/1 1.03853 1.02468 +/- 0.00370\n", + " 29/1 1.02735 1.02482 +/- 0.00350\n", + " 30/1 1.02429 1.02480 +/- 0.00332\n", + " 31/1 1.02901 1.02500 +/- 0.00317\n", + " 32/1 1.03296 1.02536 +/- 0.00304\n", + " 33/1 1.03605 1.02582 +/- 0.00294\n", + " 34/1 1.04247 1.02652 +/- 0.00290\n", + " 35/1 1.02088 1.02629 +/- 0.00279\n", + " 36/1 1.03017 1.02644 +/- 0.00269\n", + " 37/1 1.03216 1.02665 +/- 0.00259\n", + " 38/1 1.01459 1.02622 +/- 0.00254\n", + " 39/1 1.03706 1.02659 +/- 0.00248\n", + " 40/1 1.01383 1.02617 +/- 0.00243\n", + " 41/1 0.99043 1.02502 +/- 0.00262\n", + " 42/1 1.02891 1.02514 +/- 0.00254\n", + " 43/1 1.02100 1.02501 +/- 0.00246\n", + " 44/1 0.99546 1.02414 +/- 0.00254\n", + " 45/1 1.01562 1.02390 +/- 0.00248\n", + " 46/1 1.03025 1.02408 +/- 0.00242\n", + " 47/1 0.99409 1.02327 +/- 0.00249\n", + " 48/1 1.04355 1.02380 +/- 0.00248\n", + " 49/1 1.02763 1.02390 +/- 0.00242\n", + " 50/1 0.99426 1.02316 +/- 0.00247\n", + " Creating state point statepoint.50.h5...\n", "\n", " ===========================================================================\n", " ======================> SIMULATION FINISHED <======================\n", @@ -1234,27 +783,27 @@ "\n", " =======================> TIMING STATISTICS <=======================\n", "\n", - " Total time for initialization = 1.5880E+00 seconds\n", - " Reading cross sections = 1.2650E+00 seconds\n", - " Total time in simulation = 2.6051E+02 seconds\n", - " Time in transport only = 2.6013E+02 seconds\n", - " Time in inactive batches = 2.0990E+00 seconds\n", - " Time in active batches = 2.5841E+02 seconds\n", - " Time synchronizing fission bank = 6.5000E-02 seconds\n", - " Sampling source sites = 4.4000E-02 seconds\n", - " SEND/RECV source sites = 2.1000E-02 seconds\n", - " Time accumulating tallies = 2.0000E-03 seconds\n", + " Total time for initialization = 1.4550E+00 seconds\n", + " Reading cross sections = 1.1400E+00 seconds\n", + " Total time in simulation = 1.9150E+01 seconds\n", + " Time in transport only = 1.9021E+01 seconds\n", + " Time in inactive batches = 2.1570E+00 seconds\n", + " Time in active batches = 1.6993E+01 seconds\n", + " Time synchronizing fission bank = 7.0000E-03 seconds\n", + " Sampling source sites = 5.0000E-03 seconds\n", + " SEND/RECV source sites = 2.0000E-03 seconds\n", + " Time accumulating tallies = 0.0000E+00 seconds\n", " Total time for finalization = 0.0000E+00 seconds\n", - " Total time elapsed = 2.6211E+02 seconds\n", - " Calculation Rate (inactive) = 23820.9 neutrons/second\n", - " Calculation Rate (active) = 9480.98 neutrons/second\n", + " Total time elapsed = 2.0614E+01 seconds\n", + " Calculation Rate (inactive) = 23180.3 neutrons/second\n", + " Calculation Rate (active) = 11769.6 neutrons/second\n", "\n", " ============================> RESULTS <============================\n", "\n", - " k-effective (Collision) = 1.02480 +/- 0.00073\n", - " k-effective (Track-length) = 1.02477 +/- 0.00081\n", - " k-effective (Absorption) = 1.02552 +/- 0.00068\n", - " Combined k-effective = 1.02519 +/- 0.00055\n", + " k-effective (Collision) = 1.02389 +/- 0.00235\n", + " k-effective (Track-length) = 1.02316 +/- 0.00247\n", + " k-effective (Absorption) = 1.02494 +/- 0.00180\n", + " Combined k-effective = 1.02429 +/- 0.00140\n", " Leakage Fraction = 0.00000 +/- 0.00000\n", "\n" ] @@ -1399,10 +948,12 @@ } ], "source": [ - "mgxs_lib.write_mg_library(filename='mgxs', xs_type='macro',\n", - " domain_names=['fuel', 'fuel_clad', 'fuel_mod',\n", - " 'gt_inmod', 'gt_clad', 'gt_outmod'],\n", - " xs_ids='2m')" + "# Create a MGXS File which can then be written to disk\n", + "mgxs_file = mgxs_lib.create_mg_library(xs_type='macro', domain_names=['fuel', 'zircaloy', 'water'],\n", + " xs_ids='2m')\n", + "\n", + "# Write the file to disk using the default filename of `mgxs.xml`\n", + "mgxs_file.export_to_xml()" ] }, { @@ -1420,49 +971,27 @@ }, "outputs": [], "source": [ - "# Instantiate our Macroscopic Data using mat_names for the name\n", + "# Instantiate our Macroscopic Data\n", "fuel_macro = openmc.Macroscopic('fuel')\n", - "fuel_clad_macro = openmc.Macroscopic('fuel_clad')\n", - "fuel_mod_macro = openmc.Macroscopic('fuel_mod')\n", - "gt_inmod_macro = openmc.Macroscopic('gt_inmod')\n", - "gt_clad_macro = openmc.Macroscopic('gt_clad')\n", - "gt_outmod_macro = openmc.Macroscopic('gt_outmod')\n", - "\n", - "# Now define the materials\n", + "zircaloy_macro = openmc.Macroscopic('zircaloy')\n", + "water_macro = openmc.Macroscopic('water')\n", "\n", + "# Now re-define our materials to use the Multi-Group macroscopic data\n", + "# instead of the continuous-energy data.\n", "# 1.6 enriched fuel UO2\n", - "fuel = openmc.Material(name='1.6% Fuel UO2', material_id=1)\n", - "fuel.set_density('macro', 1.0)\n", + "fuel = openmc.Material(name='UO2', material_id=1)\n", "fuel.add_macroscopic(fuel_macro)\n", "\n", - "# 1.6 enriched fuel cladding\n", - "fuel_clad = openmc.Material(name='1.6% Fuel Clad', material_id=2)\n", - "fuel_clad.set_density('macro', 1.0)\n", - "fuel_clad.add_macroscopic(fuel_clad_macro)\n", + "# cladding\n", + "zircaloy = openmc.Material(name='Clad', material_id=2)\n", + "zircaloy.add_macroscopic(zircaloy_macro)\n", "\n", - "# 1.6 enriched fuel moderator\n", - "fuel_mod = openmc.Material(name='1.6% Fuel Water', material_id=3)\n", - "fuel_mod.set_density('macro', 1.0)\n", - "fuel_mod.add_macroscopic(fuel_mod_macro)\n", - "\n", - "# Guide Tube Inner Moderator\n", - "gt_inmod = openmc.Material(name='GT Inner Water', material_id=4)\n", - "gt_inmod.set_density('macro', 1.0)\n", - "gt_inmod.add_macroscopic(gt_inmod_macro)\n", - "\n", - "# Guide Tube Cladding\n", - "gt_clad = openmc.Material(name='GT Clad', material_id=5)\n", - "gt_clad.set_density('macro', 1.0)\n", - "gt_clad.add_macroscopic(gt_clad_macro)\n", - "\n", - "# Guide Tube Outer Moderator\n", - "gt_outmod = openmc.Material(name='GT Outer Water', material_id=6)\n", - "gt_outmod.set_density('macro', 1.0)\n", - "gt_outmod.add_macroscopic(gt_outmod_macro)\n", + "# moderator\n", + "water = openmc.Material(name='Water', material_id=3)\n", + "water.add_macroscopic(water_macro)\n", "\n", "# Finally, instantiate our Materials object\n", - "materials_file = openmc.Materials((fuel, fuel_clad, fuel_mod,\n", - " gt_inmod, gt_clad, gt_outmod))\n", + "materials_file = openmc.Materials((fuel, zircaloy, water))\n", "materials_file.default_xs = '2m'\n", "\n", "# Export to \"materials.xml\"\n", @@ -1473,98 +1002,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "\n", - "For our geometry files we will do the same as before but now we will be pointing at our newly created materials instead." - ] - }, - { - "cell_type": "code", - "execution_count": 33, - "metadata": { - "collapsed": false - }, - "outputs": [], - "source": [ - "# Create a Universe to encapsulate a fuel pin\n", - "fuel_pin_universe = openmc.Universe(name='1.6% Fuel Pin', universe_id=10)\n", - "\n", - "# Create fuel Cell\n", - "fuel_cell = openmc.Cell(name='1.6% Fuel', cell_id=1)\n", - "fuel_cell.fill = fuel\n", - "fuel_cell.region = -fuel_outer_radius\n", - "fuel_pin_universe.add_cell(fuel_cell)\n", - "\n", - "# Create a clad Cell\n", - "clad_cell = openmc.Cell(name='1.6% Clad', cell_id=2)\n", - "clad_cell.fill = fuel_clad\n", - "clad_cell.region = +fuel_outer_radius & -clad_outer_radius\n", - "fuel_pin_universe.add_cell(clad_cell)\n", - "\n", - "# Create a moderator Cell\n", - "moderator_cell = openmc.Cell(name='1.6% Moderator', cell_id=3)\n", - "moderator_cell.fill = fuel_mod\n", - "moderator_cell.region = +clad_outer_radius\n", - "fuel_pin_universe.add_cell(moderator_cell)\n", - "\n", - "# Create a Universe to encapsulate a control rod guide tube\n", - "guide_tube_universe = openmc.Universe(name='Guide Tube', universe_id=20)\n", - "\n", - "# Create guide tube Cell\n", - "guide_tube_cell = openmc.Cell(name='Guide Tube Water', cell_id=4)\n", - "guide_tube_cell.fill = gt_inmod\n", - "guide_tube_cell.region = -fuel_outer_radius\n", - "guide_tube_universe.add_cell(guide_tube_cell)\n", - "\n", - "# Create a clad Cell\n", - "clad_cell = openmc.Cell(name='Guide Clad', cell_id=5)\n", - "clad_cell.fill = gt_clad\n", - "clad_cell.region = +fuel_outer_radius & -clad_outer_radius\n", - "guide_tube_universe.add_cell(clad_cell)\n", - "\n", - "# Create a moderator Cell\n", - "moderator_cell = openmc.Cell(name='Guide Tube Moderator', cell_id=6)\n", - "moderator_cell.fill = gt_outmod\n", - "moderator_cell.region = +clad_outer_radius\n", - "guide_tube_universe.add_cell(moderator_cell)\n", - "\n", - "# Create fuel assembly Lattice\n", - "assembly = openmc.RectLattice(name='1.6% Fuel Assembly', lattice_id=100)\n", - "assembly.dimension = (17, 17)\n", - "assembly.pitch = (1.26, 1.26)\n", - "assembly.lower_left = [-1.26 * 17. / 2.0] * 2\n", - "\n", - "# Create array indices for guide tube locations in lattice\n", - "template_x = np.array([5, 8, 11, 3, 13, 2, 5, 8, 11, 14, 2, 5, 8,\n", - " 11, 14, 2, 5, 8, 11, 14, 3, 13, 5, 8, 11])\n", - "template_y = np.array([2, 2, 2, 3, 3, 5, 5, 5, 5, 5, 8, 8, 8, 8,\n", - " 8, 11, 11, 11, 11, 11, 13, 13, 14, 14, 14])\n", - "\n", - "# Initialize an empty 17x17 array of the lattice universes\n", - "universes = np.empty((17, 17), dtype=openmc.Universe)\n", - "\n", - "# Fill the array with the fuel pin and guide tube universes\n", - "universes[:,:] = fuel_pin_universe\n", - "universes[template_x, template_y] = guide_tube_universe\n", - "\n", - "# Store the array of universes in the lattice\n", - "assembly.universes = universes\n", - "\n", - "# Create root Cell\n", - "root_cell = openmc.Cell(name='root cell', cell_id=0)\n", - "root_cell.fill = assembly\n", - "\n", - "# Add boundary planes\n", - "root_cell.region = +min_x & -max_x & +min_y & -max_y & +min_z & -max_z\n", - "\n", - "# Create root Universe\n", - "root_universe = openmc.Universe(universe_id=0, name='root universe')\n", - "root_universe.add_cell(root_cell)\n", - "\n", - "# Create Geometry and set root Universe\n", - "geometry = openmc.Geometry()\n", - "geometry.root_universe = root_universe\n", - "# Export to \"geometry.xml\"\n", - "geometry.export_to_xml()" + "No geometry file neeeds to be written as the continuous-energy file is correctly defined for the multi-group case as well." ] }, { @@ -1577,7 +1015,7 @@ }, { "cell_type": "code", - "execution_count": 34, + "execution_count": 33, "metadata": { "collapsed": true }, @@ -1602,9 +1040,10 @@ }, { "cell_type": "code", - "execution_count": 35, + "execution_count": 34, "metadata": { - "collapsed": false + "collapsed": false, + "scrolled": true }, "outputs": [ { @@ -1628,7 +1067,7 @@ " License: http://openmc.readthedocs.org/en/latest/license.html\n", " Version: 0.7.1\n", " Git SHA1: c779ca42c41a062a6a813e03f2add2d182ca9190\n", - " Date/Time: 2016-05-12 21:19:25\n", + " Date/Time: 2016-05-13 22:30:02\n", " OpenMP Threads: 4\n", "\n", " ===========================================================================\n", @@ -1643,11 +1082,8 @@ " Building neighboring cells lists for each surface...\n", " Loading Cross Section Data...\n", " Loading fuel.2m Data...\n", - " Loading fuel_clad.2m Data...\n", - " Loading fuel_mod.2m Data...\n", - " Loading gt_inmod.2m Data...\n", - " Loading gt_clad.2m Data...\n", - " Loading gt_outmod.2m Data...\n", + " Loading zircaloy.2m Data...\n", + " Loading water.2m Data...\n", " Initializing source particles...\n", "\n", " ===========================================================================\n", @@ -1656,507 +1092,57 @@ "\n", " Bat./Gen. k Average k \n", " ========= ======== ==================== \n", - " 1/1 1.01702 \n", - " 2/1 0.99463 \n", - " 3/1 1.02321 \n", - " 4/1 0.98628 \n", - " 5/1 1.03122 \n", - " 6/1 1.00774 \n", - " 7/1 1.05616 \n", - " 8/1 1.03051 \n", - " 9/1 1.02321 \n", - " 10/1 1.04380 \n", - " 11/1 1.05837 \n", - " 12/1 1.01514 1.03676 +/- 0.02161\n", - " 13/1 1.06720 1.04690 +/- 0.01608\n", - " 14/1 1.01696 1.03942 +/- 0.01361\n", - " 15/1 1.03549 1.03863 +/- 0.01057\n", - " 16/1 1.01599 1.03486 +/- 0.00942\n", - " 17/1 1.03070 1.03427 +/- 0.00799\n", - " 18/1 1.03778 1.03470 +/- 0.00693\n", - " 19/1 1.03042 1.03423 +/- 0.00613\n", - " 20/1 1.01047 1.03185 +/- 0.00598\n", - " 21/1 1.03251 1.03191 +/- 0.00541\n", - " 22/1 1.02047 1.03096 +/- 0.00503\n", - " 23/1 1.01729 1.02991 +/- 0.00474\n", - " 24/1 1.02948 1.02988 +/- 0.00439\n", - " 25/1 1.01963 1.02919 +/- 0.00414\n", - " 26/1 1.00626 1.02776 +/- 0.00413\n", - " 27/1 1.04531 1.02879 +/- 0.00402\n", - " 28/1 0.99936 1.02716 +/- 0.00412\n", - " 29/1 1.04497 1.02809 +/- 0.00401\n", - " 30/1 1.02429 1.02790 +/- 0.00381\n", - " 31/1 1.05112 1.02901 +/- 0.00379\n", - " 32/1 1.01843 1.02853 +/- 0.00365\n", - " 33/1 1.04478 1.02924 +/- 0.00355\n", - " 34/1 1.01719 1.02873 +/- 0.00344\n", - " 35/1 0.99873 1.02753 +/- 0.00351\n", - " 36/1 1.00054 1.02649 +/- 0.00353\n", - " 37/1 1.03986 1.02699 +/- 0.00343\n", - " 38/1 1.02243 1.02683 +/- 0.00331\n", - " 39/1 1.02744 1.02685 +/- 0.00319\n", - " 40/1 1.01174 1.02634 +/- 0.00313\n", - " 41/1 1.04973 1.02710 +/- 0.00312\n", - " 42/1 0.99564 1.02612 +/- 0.00317\n", - " 43/1 1.03022 1.02624 +/- 0.00308\n", - " 44/1 1.03526 1.02650 +/- 0.00300\n", - " 45/1 1.02143 1.02636 +/- 0.00292\n", - " 46/1 1.03264 1.02653 +/- 0.00284\n", - " 47/1 1.03868 1.02686 +/- 0.00278\n", - " 48/1 1.02385 1.02678 +/- 0.00271\n", - " 49/1 1.03897 1.02710 +/- 0.00266\n", - " 50/1 1.01267 1.02674 +/- 0.00261\n", - " 51/1 0.99683 1.02601 +/- 0.00265\n", - " 52/1 1.04189 1.02638 +/- 0.00261\n", - " 53/1 1.02871 1.02644 +/- 0.00255\n", - " 54/1 1.02564 1.02642 +/- 0.00250\n", - " 55/1 1.02955 1.02649 +/- 0.00244\n", - " 56/1 1.02390 1.02643 +/- 0.00239\n", - " 57/1 1.03342 1.02658 +/- 0.00234\n", - " 58/1 1.01430 1.02633 +/- 0.00231\n", - " 59/1 0.99242 1.02563 +/- 0.00236\n", - " 60/1 1.00442 1.02521 +/- 0.00235\n", - " 61/1 1.03870 1.02547 +/- 0.00232\n", - " 62/1 1.02146 1.02540 +/- 0.00228\n", - " 63/1 1.04782 1.02582 +/- 0.00227\n", - " 64/1 1.02872 1.02587 +/- 0.00223\n", - " 65/1 1.02420 1.02584 +/- 0.00219\n", - " 66/1 1.01974 1.02573 +/- 0.00215\n", - " 67/1 1.00774 1.02542 +/- 0.00214\n", - " 68/1 1.01323 1.02521 +/- 0.00211\n", - " 69/1 1.01468 1.02503 +/- 0.00208\n", - " 70/1 1.02869 1.02509 +/- 0.00205\n", - " 71/1 1.02284 1.02505 +/- 0.00202\n", - " 72/1 1.04815 1.02543 +/- 0.00202\n", - " 73/1 1.01119 1.02520 +/- 0.00200\n", - " 74/1 1.03314 1.02533 +/- 0.00197\n", - " 75/1 1.02333 1.02529 +/- 0.00194\n", - " 76/1 1.04030 1.02552 +/- 0.00193\n", - " 77/1 1.02537 1.02552 +/- 0.00190\n", - " 78/1 1.02875 1.02557 +/- 0.00187\n", - " 79/1 1.03588 1.02572 +/- 0.00185\n", - " 80/1 1.05250 1.02610 +/- 0.00186\n", - " 81/1 1.00477 1.02580 +/- 0.00186\n", - " 82/1 1.03903 1.02598 +/- 0.00184\n", - " 83/1 1.02378 1.02595 +/- 0.00182\n", - " 84/1 1.01107 1.02575 +/- 0.00180\n", - " 85/1 1.01550 1.02561 +/- 0.00178\n", - " 86/1 1.00540 1.02535 +/- 0.00178\n", - " 87/1 1.03056 1.02542 +/- 0.00176\n", - " 88/1 1.01742 1.02531 +/- 0.00174\n", - " 89/1 0.99730 1.02496 +/- 0.00175\n", - " 90/1 1.03569 1.02509 +/- 0.00174\n", - " 91/1 1.04514 1.02534 +/- 0.00173\n", - " 92/1 1.02757 1.02537 +/- 0.00171\n", - " 93/1 1.00610 1.02514 +/- 0.00171\n", - " 94/1 1.03576 1.02526 +/- 0.00169\n", - " 95/1 1.03732 1.02540 +/- 0.00168\n", - " 96/1 1.04784 1.02567 +/- 0.00168\n", - " 97/1 1.06507 1.02612 +/- 0.00172\n", - " 98/1 1.03673 1.02624 +/- 0.00170\n", - " 99/1 1.01270 1.02609 +/- 0.00169\n", - " 100/1 1.01980 1.02602 +/- 0.00167\n", - " 101/1 1.01357 1.02588 +/- 0.00166\n", - " 102/1 1.03125 1.02594 +/- 0.00164\n", - " 103/1 1.01527 1.02582 +/- 0.00163\n", - " 104/1 1.02403 1.02580 +/- 0.00161\n", - " 105/1 1.03435 1.02589 +/- 0.00160\n", - " 106/1 1.04113 1.02605 +/- 0.00159\n", - " 107/1 1.03291 1.02612 +/- 0.00157\n", - " 108/1 1.02478 1.02611 +/- 0.00156\n", - " 109/1 1.05814 1.02643 +/- 0.00158\n", - " 110/1 1.02647 1.02643 +/- 0.00156\n", - " 111/1 0.98951 1.02607 +/- 0.00159\n", - " 112/1 1.00739 1.02589 +/- 0.00158\n", - " 113/1 1.04165 1.02604 +/- 0.00157\n", - " 114/1 1.00047 1.02579 +/- 0.00158\n", - " 115/1 1.02550 1.02579 +/- 0.00156\n", - " 116/1 1.02408 1.02577 +/- 0.00155\n", - " 117/1 1.03110 1.02582 +/- 0.00153\n", - " 118/1 1.02874 1.02585 +/- 0.00152\n", - " 119/1 1.02348 1.02583 +/- 0.00151\n", - " 120/1 1.01969 1.02577 +/- 0.00149\n", - " 121/1 1.02312 1.02575 +/- 0.00148\n", - " 122/1 1.03261 1.02581 +/- 0.00147\n", - " 123/1 0.98394 1.02544 +/- 0.00150\n", - " 124/1 1.03771 1.02555 +/- 0.00149\n", - " 125/1 1.01857 1.02549 +/- 0.00148\n", - " 126/1 1.00066 1.02527 +/- 0.00148\n", - " 127/1 1.02372 1.02526 +/- 0.00147\n", - " 128/1 1.03307 1.02533 +/- 0.00146\n", - " 129/1 1.00889 1.02519 +/- 0.00145\n", - " 130/1 1.02053 1.02515 +/- 0.00144\n", - " 131/1 1.00943 1.02502 +/- 0.00144\n", - " 132/1 1.07225 1.02541 +/- 0.00148\n", - " 133/1 1.04068 1.02553 +/- 0.00147\n", - " 134/1 1.03509 1.02561 +/- 0.00146\n", - " 135/1 1.01250 1.02550 +/- 0.00145\n", - " 136/1 1.02179 1.02547 +/- 0.00144\n", - " 137/1 1.05685 1.02572 +/- 0.00145\n", - " 138/1 1.04217 1.02585 +/- 0.00144\n", - " 139/1 1.02793 1.02586 +/- 0.00143\n", - " 140/1 1.01207 1.02576 +/- 0.00143\n", - " 141/1 1.03445 1.02582 +/- 0.00142\n", - " 142/1 1.03579 1.02590 +/- 0.00141\n", - " 143/1 1.00786 1.02576 +/- 0.00140\n", - " 144/1 0.99089 1.02550 +/- 0.00142\n", - " 145/1 1.02617 1.02551 +/- 0.00141\n", - " 146/1 1.01691 1.02545 +/- 0.00140\n", - " 147/1 1.00692 1.02531 +/- 0.00139\n", - " 148/1 0.97702 1.02496 +/- 0.00143\n", - " 149/1 1.04002 1.02507 +/- 0.00142\n", - " 150/1 1.01262 1.02498 +/- 0.00141\n", - " 151/1 1.03613 1.02506 +/- 0.00141\n", - " 152/1 1.02920 1.02509 +/- 0.00140\n", - " 153/1 1.02199 1.02507 +/- 0.00139\n", - " 154/1 1.03421 1.02513 +/- 0.00138\n", - " 155/1 1.05882 1.02536 +/- 0.00139\n", - " 156/1 1.02649 1.02537 +/- 0.00138\n", - " 157/1 1.01933 1.02533 +/- 0.00137\n", - " 158/1 1.04269 1.02545 +/- 0.00137\n", - " 159/1 0.99604 1.02525 +/- 0.00137\n", - " 160/1 1.04748 1.02540 +/- 0.00137\n", - " 161/1 1.00501 1.02526 +/- 0.00137\n", - " 162/1 1.00550 1.02513 +/- 0.00137\n", - " 163/1 1.00115 1.02498 +/- 0.00137\n", - " 164/1 1.02283 1.02496 +/- 0.00136\n", - " 165/1 1.01964 1.02493 +/- 0.00135\n", - " 166/1 1.02287 1.02491 +/- 0.00134\n", - " 167/1 1.05498 1.02511 +/- 0.00134\n", - " 168/1 1.05267 1.02528 +/- 0.00135\n", - " 169/1 1.00474 1.02515 +/- 0.00135\n", - " 170/1 1.03469 1.02521 +/- 0.00134\n", - " 171/1 1.02499 1.02521 +/- 0.00133\n", - " 172/1 1.03961 1.02530 +/- 0.00132\n", - " 173/1 1.01240 1.02522 +/- 0.00132\n", - " 174/1 1.00762 1.02511 +/- 0.00132\n", - " 175/1 1.00200 1.02497 +/- 0.00131\n", - " 176/1 1.01449 1.02491 +/- 0.00131\n", - " 177/1 1.01111 1.02483 +/- 0.00130\n", - " 178/1 1.01208 1.02475 +/- 0.00130\n", - " 179/1 1.03304 1.02480 +/- 0.00129\n", - " 180/1 1.04504 1.02492 +/- 0.00129\n", - " 181/1 1.03476 1.02498 +/- 0.00128\n", - " 182/1 1.02124 1.02495 +/- 0.00128\n", - " 183/1 0.98855 1.02474 +/- 0.00128\n", - " 184/1 1.04689 1.02487 +/- 0.00128\n", - " 185/1 1.00618 1.02476 +/- 0.00128\n", - " 186/1 1.02012 1.02474 +/- 0.00127\n", - " 187/1 1.00162 1.02461 +/- 0.00127\n", - " 188/1 1.03269 1.02465 +/- 0.00127\n", - " 189/1 1.04772 1.02478 +/- 0.00127\n", - " 190/1 1.01132 1.02471 +/- 0.00126\n", - " 191/1 1.02669 1.02472 +/- 0.00125\n", - " 192/1 1.01154 1.02464 +/- 0.00125\n", - " 193/1 1.05795 1.02483 +/- 0.00126\n", - " 194/1 1.01615 1.02478 +/- 0.00125\n", - " 195/1 1.03828 1.02485 +/- 0.00125\n", - " 196/1 1.00695 1.02476 +/- 0.00124\n", - " 197/1 1.04126 1.02484 +/- 0.00124\n", - " 198/1 1.02834 1.02486 +/- 0.00123\n", - " 199/1 1.01000 1.02478 +/- 0.00123\n", - " 200/1 0.99294 1.02462 +/- 0.00123\n", - " 201/1 1.00248 1.02450 +/- 0.00123\n", - " 202/1 1.03461 1.02455 +/- 0.00123\n", - " 203/1 1.06289 1.02475 +/- 0.00124\n", - " 204/1 1.03010 1.02478 +/- 0.00123\n", - " 205/1 1.04636 1.02489 +/- 0.00123\n", - " 206/1 1.05434 1.02504 +/- 0.00123\n", - " 207/1 1.03993 1.02512 +/- 0.00123\n", - " 208/1 1.02672 1.02512 +/- 0.00122\n", - " 209/1 1.04958 1.02525 +/- 0.00122\n", - " 210/1 0.99194 1.02508 +/- 0.00123\n", - " 211/1 1.01570 1.02503 +/- 0.00122\n", - " 212/1 1.04079 1.02511 +/- 0.00122\n", - " 213/1 1.02961 1.02513 +/- 0.00121\n", - " 214/1 1.03797 1.02520 +/- 0.00121\n", - " 215/1 1.03714 1.02526 +/- 0.00120\n", - " 216/1 1.03299 1.02529 +/- 0.00120\n", - " 217/1 1.00461 1.02519 +/- 0.00120\n", - " 218/1 1.02386 1.02519 +/- 0.00119\n", - " 219/1 1.01955 1.02516 +/- 0.00119\n", - " 220/1 1.04372 1.02525 +/- 0.00118\n", - " 221/1 1.01694 1.02521 +/- 0.00118\n", - " 222/1 0.99642 1.02507 +/- 0.00118\n", - " 223/1 1.00999 1.02500 +/- 0.00118\n", - " 224/1 1.02703 1.02501 +/- 0.00117\n", - " 225/1 1.00236 1.02491 +/- 0.00117\n", - " 226/1 1.02825 1.02492 +/- 0.00117\n", - " 227/1 1.04535 1.02502 +/- 0.00116\n", - " 228/1 1.01779 1.02498 +/- 0.00116\n", - " 229/1 1.01058 1.02492 +/- 0.00116\n", - " 230/1 1.00391 1.02482 +/- 0.00115\n", - " 231/1 1.05990 1.02498 +/- 0.00116\n", - " 232/1 1.01885 1.02495 +/- 0.00116\n", - " 233/1 1.03204 1.02498 +/- 0.00115\n", - " 234/1 0.99396 1.02485 +/- 0.00115\n", - " 235/1 1.01828 1.02482 +/- 0.00115\n", - " 236/1 1.08225 1.02507 +/- 0.00117\n", - " 237/1 1.00335 1.02498 +/- 0.00117\n", - " 238/1 1.03097 1.02500 +/- 0.00117\n", - " 239/1 1.01738 1.02497 +/- 0.00116\n", - " 240/1 1.02261 1.02496 +/- 0.00116\n", - " 241/1 1.02814 1.02497 +/- 0.00115\n", - " 242/1 1.01158 1.02491 +/- 0.00115\n", - " 243/1 1.03507 1.02496 +/- 0.00114\n", - " 244/1 1.01914 1.02493 +/- 0.00114\n", - " 245/1 1.04555 1.02502 +/- 0.00114\n", - " 246/1 1.02459 1.02502 +/- 0.00113\n", - " 247/1 1.05827 1.02516 +/- 0.00114\n", - " 248/1 1.02549 1.02516 +/- 0.00113\n", - " 249/1 1.03354 1.02520 +/- 0.00113\n", - " 250/1 1.04186 1.02526 +/- 0.00113\n", - " 251/1 1.00466 1.02518 +/- 0.00112\n", - " 252/1 0.99065 1.02504 +/- 0.00113\n", - " 253/1 1.03065 1.02506 +/- 0.00112\n", - " 254/1 1.02167 1.02505 +/- 0.00112\n", - " 255/1 1.01700 1.02501 +/- 0.00112\n", - " 256/1 1.03619 1.02506 +/- 0.00111\n", - " 257/1 1.01833 1.02503 +/- 0.00111\n", - " 258/1 1.02211 1.02502 +/- 0.00110\n", - " 259/1 1.04348 1.02509 +/- 0.00110\n", - " 260/1 1.03444 1.02513 +/- 0.00110\n", - " 261/1 1.05597 1.02525 +/- 0.00110\n", - " 262/1 1.02085 1.02524 +/- 0.00110\n", - " 263/1 1.00552 1.02516 +/- 0.00109\n", - " 264/1 1.03976 1.02522 +/- 0.00109\n", - " 265/1 1.02810 1.02523 +/- 0.00109\n", - " 266/1 1.00911 1.02516 +/- 0.00108\n", - " 267/1 1.01963 1.02514 +/- 0.00108\n", - " 268/1 1.03732 1.02519 +/- 0.00108\n", - " 269/1 1.02422 1.02519 +/- 0.00107\n", - " 270/1 1.01546 1.02515 +/- 0.00107\n", - " 271/1 1.05488 1.02526 +/- 0.00107\n", - " 272/1 1.01709 1.02523 +/- 0.00107\n", - " 273/1 1.05629 1.02535 +/- 0.00107\n", - " 274/1 1.03864 1.02540 +/- 0.00107\n", - " 275/1 1.01472 1.02536 +/- 0.00106\n", - " 276/1 1.03425 1.02539 +/- 0.00106\n", - " 277/1 1.00663 1.02532 +/- 0.00106\n", - " 278/1 1.03326 1.02535 +/- 0.00106\n", - " 279/1 1.02571 1.02535 +/- 0.00105\n", - " 280/1 1.00525 1.02528 +/- 0.00105\n", - " 281/1 1.00451 1.02520 +/- 0.00105\n", - " 282/1 1.04016 1.02526 +/- 0.00105\n", - " 283/1 0.98343 1.02510 +/- 0.00105\n", - " 284/1 1.04843 1.02519 +/- 0.00105\n", - " 285/1 1.01807 1.02516 +/- 0.00105\n", - " 286/1 1.02393 1.02516 +/- 0.00105\n", - " 287/1 1.01851 1.02514 +/- 0.00104\n", - " 288/1 1.03976 1.02519 +/- 0.00104\n", - " 289/1 1.03153 1.02521 +/- 0.00104\n", - " 290/1 1.00416 1.02514 +/- 0.00104\n", - " 291/1 1.01426 1.02510 +/- 0.00103\n", - " 292/1 1.02583 1.02510 +/- 0.00103\n", - " 293/1 1.01680 1.02507 +/- 0.00103\n", - " 294/1 1.04578 1.02514 +/- 0.00103\n", - " 295/1 1.03162 1.02517 +/- 0.00102\n", - " 296/1 1.01682 1.02514 +/- 0.00102\n", - " 297/1 1.00488 1.02507 +/- 0.00102\n", - " 298/1 1.03057 1.02508 +/- 0.00101\n", - " 299/1 1.01126 1.02504 +/- 0.00101\n", - " 300/1 1.03528 1.02507 +/- 0.00101\n", - " 301/1 1.05548 1.02518 +/- 0.00101\n", - " 302/1 1.02994 1.02519 +/- 0.00101\n", - " 303/1 1.03010 1.02521 +/- 0.00100\n", - " 304/1 1.04031 1.02526 +/- 0.00100\n", - " 305/1 1.05866 1.02537 +/- 0.00101\n", - " 306/1 1.03602 1.02541 +/- 0.00100\n", - " 307/1 1.01362 1.02537 +/- 0.00100\n", - " 308/1 1.01318 1.02533 +/- 0.00100\n", - " 309/1 1.04262 1.02539 +/- 0.00100\n", - " 310/1 1.01626 1.02536 +/- 0.00099\n", - " 311/1 1.00285 1.02528 +/- 0.00099\n", - " 312/1 0.98155 1.02514 +/- 0.00100\n", - " 313/1 1.05649 1.02524 +/- 0.00100\n", - " 314/1 1.00960 1.02519 +/- 0.00100\n", - " 315/1 1.05350 1.02528 +/- 0.00100\n", - " 316/1 1.03842 1.02533 +/- 0.00100\n", - " 317/1 1.01394 1.02529 +/- 0.00100\n", - " 318/1 1.01830 1.02527 +/- 0.00099\n", - " 319/1 1.02050 1.02525 +/- 0.00099\n", - " 320/1 1.03402 1.02528 +/- 0.00099\n", - " 321/1 1.04547 1.02534 +/- 0.00099\n", - " 322/1 1.02579 1.02534 +/- 0.00098\n", - " 323/1 1.01922 1.02533 +/- 0.00098\n", - " 324/1 1.01050 1.02528 +/- 0.00098\n", - " 325/1 1.01426 1.02524 +/- 0.00098\n", - " 326/1 1.03283 1.02527 +/- 0.00097\n", - " 327/1 1.03859 1.02531 +/- 0.00097\n", - " 328/1 1.01536 1.02528 +/- 0.00097\n", - " 329/1 1.03149 1.02530 +/- 0.00097\n", - " 330/1 1.04328 1.02535 +/- 0.00096\n", - " 331/1 1.01949 1.02534 +/- 0.00096\n", - " 332/1 1.02319 1.02533 +/- 0.00096\n", - " 333/1 1.01704 1.02530 +/- 0.00096\n", - " 334/1 1.02691 1.02531 +/- 0.00095\n", - " 335/1 1.03188 1.02533 +/- 0.00095\n", - " 336/1 1.03107 1.02535 +/- 0.00095\n", - " 337/1 1.02410 1.02534 +/- 0.00094\n", - " 338/1 0.99917 1.02526 +/- 0.00094\n", - " 339/1 1.03593 1.02529 +/- 0.00094\n", - " 340/1 1.02286 1.02529 +/- 0.00094\n", - " 341/1 1.04154 1.02534 +/- 0.00094\n", - " 342/1 1.01664 1.02531 +/- 0.00094\n", - " 343/1 1.01041 1.02527 +/- 0.00093\n", - " 344/1 1.02033 1.02525 +/- 0.00093\n", - " 345/1 1.03137 1.02527 +/- 0.00093\n", - " 346/1 1.02162 1.02526 +/- 0.00093\n", - " 347/1 1.00835 1.02521 +/- 0.00092\n", - " 348/1 1.01168 1.02517 +/- 0.00092\n", - " 349/1 1.01168 1.02513 +/- 0.00092\n", - " 350/1 1.03509 1.02516 +/- 0.00092\n", - " 351/1 1.01883 1.02514 +/- 0.00092\n", - " 352/1 1.04314 1.02519 +/- 0.00091\n", - " 353/1 0.99067 1.02509 +/- 0.00092\n", - " 354/1 1.03100 1.02511 +/- 0.00091\n", - " 355/1 1.01664 1.02508 +/- 0.00091\n", - " 356/1 1.02193 1.02507 +/- 0.00091\n", - " 357/1 1.03213 1.02509 +/- 0.00091\n", - " 358/1 1.00555 1.02504 +/- 0.00091\n", - " 359/1 1.04849 1.02511 +/- 0.00091\n", - " 360/1 1.02174 1.02510 +/- 0.00090\n", - " 361/1 1.05064 1.02517 +/- 0.00090\n", - " 362/1 1.05274 1.02525 +/- 0.00091\n", - " 363/1 1.00932 1.02520 +/- 0.00090\n", - " 364/1 1.03400 1.02523 +/- 0.00090\n", - " 365/1 1.00149 1.02516 +/- 0.00090\n", - " 366/1 1.01631 1.02514 +/- 0.00090\n", - " 367/1 1.03928 1.02517 +/- 0.00090\n", - " 368/1 1.01318 1.02514 +/- 0.00090\n", - " 369/1 1.04610 1.02520 +/- 0.00090\n", - " 370/1 1.04338 1.02525 +/- 0.00089\n", - " 371/1 1.01638 1.02523 +/- 0.00089\n", - " 372/1 1.04056 1.02527 +/- 0.00089\n", - " 373/1 1.00090 1.02520 +/- 0.00089\n", - " 374/1 1.01261 1.02517 +/- 0.00089\n", - " 375/1 1.03919 1.02520 +/- 0.00089\n", - " 376/1 0.99900 1.02513 +/- 0.00089\n", - " 377/1 1.00168 1.02507 +/- 0.00089\n", - " 378/1 0.99476 1.02499 +/- 0.00089\n", - " 379/1 1.04960 1.02505 +/- 0.00089\n", - " 380/1 0.99797 1.02498 +/- 0.00089\n", - " 381/1 1.04956 1.02505 +/- 0.00089\n", - " 382/1 1.02803 1.02505 +/- 0.00089\n", - " 383/1 0.99388 1.02497 +/- 0.00089\n", - " 384/1 1.00767 1.02492 +/- 0.00089\n", - " 385/1 1.00856 1.02488 +/- 0.00089\n", - " 386/1 1.02997 1.02489 +/- 0.00088\n", - " 387/1 0.97841 1.02477 +/- 0.00089\n", - " 388/1 0.99712 1.02470 +/- 0.00089\n", - " 389/1 0.99072 1.02461 +/- 0.00089\n", - " 390/1 1.02439 1.02461 +/- 0.00089\n", - " 391/1 1.02769 1.02462 +/- 0.00089\n", - " 392/1 1.02205 1.02461 +/- 0.00089\n", - " 393/1 1.03702 1.02464 +/- 0.00088\n", - " 394/1 1.00274 1.02458 +/- 0.00088\n", - " 395/1 1.00131 1.02452 +/- 0.00088\n", - " 396/1 1.00130 1.02446 +/- 0.00088\n", - " 397/1 1.00472 1.02441 +/- 0.00088\n", - " 398/1 1.00724 1.02437 +/- 0.00088\n", - " 399/1 1.03061 1.02438 +/- 0.00088\n", - " 400/1 0.99651 1.02431 +/- 0.00088\n", - " 401/1 0.99290 1.02423 +/- 0.00088\n", - " 402/1 1.02166 1.02423 +/- 0.00088\n", - " 403/1 1.01691 1.02421 +/- 0.00088\n", - " 404/1 1.00492 1.02416 +/- 0.00088\n", - " 405/1 1.00663 1.02411 +/- 0.00088\n", - " 406/1 1.01865 1.02410 +/- 0.00087\n", - " 407/1 1.02717 1.02411 +/- 0.00087\n", - " 408/1 1.01793 1.02409 +/- 0.00087\n", - " 409/1 1.02606 1.02410 +/- 0.00087\n", - " 410/1 1.03809 1.02413 +/- 0.00087\n", - " 411/1 1.03780 1.02417 +/- 0.00086\n", - " 412/1 1.02782 1.02418 +/- 0.00086\n", - " 413/1 1.03077 1.02419 +/- 0.00086\n", - " 414/1 1.00651 1.02415 +/- 0.00086\n", - " 415/1 1.05594 1.02423 +/- 0.00086\n", - " 416/1 0.99558 1.02416 +/- 0.00086\n", - " 417/1 1.00689 1.02411 +/- 0.00086\n", - " 418/1 1.02932 1.02413 +/- 0.00086\n", - " 419/1 1.03552 1.02415 +/- 0.00086\n", - " 420/1 1.03735 1.02419 +/- 0.00085\n", - " 421/1 1.02402 1.02419 +/- 0.00085\n", - " 422/1 1.04227 1.02423 +/- 0.00085\n", - " 423/1 1.03087 1.02425 +/- 0.00085\n", - " 424/1 1.04363 1.02429 +/- 0.00085\n", - " 425/1 1.02676 1.02430 +/- 0.00085\n", - " 426/1 1.03739 1.02433 +/- 0.00085\n", - " 427/1 1.02977 1.02434 +/- 0.00084\n", - " 428/1 1.02547 1.02435 +/- 0.00084\n", - " 429/1 1.03552 1.02437 +/- 0.00084\n", - " 430/1 1.04282 1.02442 +/- 0.00084\n", - " 431/1 1.03171 1.02443 +/- 0.00084\n", - " 432/1 1.01030 1.02440 +/- 0.00084\n", - " 433/1 1.04168 1.02444 +/- 0.00084\n", - " 434/1 0.98994 1.02436 +/- 0.00084\n", - " 435/1 0.98166 1.02426 +/- 0.00084\n", - " 436/1 1.00178 1.02421 +/- 0.00084\n", - " 437/1 1.03801 1.02424 +/- 0.00084\n", - " 438/1 1.02099 1.02423 +/- 0.00084\n", - " 439/1 1.01305 1.02421 +/- 0.00084\n", - " 440/1 1.02286 1.02420 +/- 0.00083\n", - " 441/1 1.03697 1.02423 +/- 0.00083\n", - " 442/1 0.99050 1.02415 +/- 0.00083\n", - " 443/1 1.02238 1.02415 +/- 0.00083\n", - " 444/1 1.05188 1.02421 +/- 0.00083\n", - " 445/1 1.03150 1.02423 +/- 0.00083\n", - " 446/1 1.01071 1.02420 +/- 0.00083\n", - " 447/1 1.03713 1.02423 +/- 0.00083\n", - " 448/1 1.03631 1.02426 +/- 0.00083\n", - " 449/1 1.02968 1.02427 +/- 0.00083\n", - " 450/1 1.03031 1.02428 +/- 0.00082\n", - " 451/1 1.02161 1.02428 +/- 0.00082\n", - " 452/1 0.99036 1.02420 +/- 0.00082\n", - " 453/1 1.02581 1.02420 +/- 0.00082\n", - " 454/1 1.03140 1.02422 +/- 0.00082\n", - " 455/1 1.01962 1.02421 +/- 0.00082\n", - " 456/1 1.00680 1.02417 +/- 0.00082\n", - " 457/1 1.00178 1.02412 +/- 0.00082\n", - " 458/1 1.02306 1.02412 +/- 0.00082\n", - " 459/1 1.02653 1.02412 +/- 0.00081\n", - " 460/1 1.02934 1.02413 +/- 0.00081\n", - " 461/1 1.00872 1.02410 +/- 0.00081\n", - " 462/1 1.00012 1.02405 +/- 0.00081\n", - " 463/1 0.99057 1.02397 +/- 0.00081\n", - " 464/1 1.02353 1.02397 +/- 0.00081\n", - " 465/1 1.01402 1.02395 +/- 0.00081\n", - " 466/1 1.01651 1.02393 +/- 0.00081\n", - " 467/1 1.01024 1.02390 +/- 0.00081\n", - " 468/1 1.02504 1.02391 +/- 0.00080\n", - " 469/1 1.00891 1.02387 +/- 0.00080\n", - " 470/1 1.04038 1.02391 +/- 0.00080\n", - " 471/1 1.04346 1.02395 +/- 0.00080\n", - " 472/1 1.02634 1.02396 +/- 0.00080\n", - " 473/1 1.01207 1.02393 +/- 0.00080\n", - " 474/1 1.00787 1.02390 +/- 0.00080\n", - " 475/1 1.03591 1.02392 +/- 0.00080\n", - " 476/1 1.04257 1.02396 +/- 0.00080\n", - " 477/1 1.00536 1.02392 +/- 0.00079\n", - " 478/1 1.07545 1.02403 +/- 0.00080\n", - " 479/1 1.02306 1.02403 +/- 0.00080\n", - " 480/1 1.02733 1.02404 +/- 0.00080\n", - " 481/1 1.00990 1.02401 +/- 0.00080\n", - " 482/1 0.99031 1.02394 +/- 0.00080\n", - " 483/1 0.98006 1.02384 +/- 0.00080\n", - " 484/1 1.05635 1.02391 +/- 0.00080\n", - " 485/1 1.02410 1.02391 +/- 0.00080\n", - " 486/1 1.01227 1.02389 +/- 0.00080\n", - " 487/1 1.00614 1.02385 +/- 0.00080\n", - " 488/1 1.01837 1.02384 +/- 0.00080\n", - " 489/1 1.02565 1.02384 +/- 0.00080\n", - " 490/1 1.00530 1.02381 +/- 0.00079\n", - " 491/1 1.01958 1.02380 +/- 0.00079\n", - " 492/1 1.04490 1.02384 +/- 0.00079\n", - " 493/1 1.02567 1.02384 +/- 0.00079\n", - " 494/1 1.03865 1.02387 +/- 0.00079\n", - " 495/1 1.03990 1.02391 +/- 0.00079\n", - " 496/1 0.98352 1.02382 +/- 0.00079\n", - " 497/1 1.00909 1.02379 +/- 0.00079\n", - " 498/1 1.03661 1.02382 +/- 0.00079\n", - " 499/1 1.04423 1.02386 +/- 0.00079\n", - " 500/1 1.06406 1.02394 +/- 0.00079\n", - " Creating state point statepoint.500.h5...\n", + " 1/1 1.02073 \n", + " 2/1 1.04004 \n", + " 3/1 1.02324 \n", + " 4/1 1.01690 \n", + " 5/1 1.03702 \n", + " 6/1 1.01796 \n", + " 7/1 1.01779 \n", + " 8/1 1.02764 \n", + " 9/1 1.03324 \n", + " 10/1 1.01465 \n", + " 11/1 1.02268 \n", + " 12/1 1.01598 1.01933 +/- 0.00335\n", + " 13/1 1.01993 1.01953 +/- 0.00194\n", + " 14/1 1.01779 1.01910 +/- 0.00144\n", + " 15/1 1.01014 1.01731 +/- 0.00211\n", + " 16/1 1.04059 1.02119 +/- 0.00425\n", + " 17/1 1.04877 1.02513 +/- 0.00533\n", + " 18/1 1.05504 1.02887 +/- 0.00594\n", + " 19/1 1.02601 1.02855 +/- 0.00525\n", + " 20/1 1.04347 1.03004 +/- 0.00493\n", + " 21/1 1.01703 1.02886 +/- 0.00461\n", + " 22/1 1.02628 1.02864 +/- 0.00421\n", + " 23/1 1.02598 1.02844 +/- 0.00388\n", + " 24/1 1.05341 1.03022 +/- 0.00401\n", + " 25/1 1.02201 1.02967 +/- 0.00377\n", + " 26/1 1.00758 1.02829 +/- 0.00379\n", + " 27/1 1.00720 1.02705 +/- 0.00377\n", + " 28/1 1.03098 1.02727 +/- 0.00356\n", + " 29/1 1.03022 1.02743 +/- 0.00337\n", + " 30/1 1.01694 1.02690 +/- 0.00324\n", + " 31/1 0.99064 1.02518 +/- 0.00353\n", + " 32/1 0.99495 1.02380 +/- 0.00364\n", + " 33/1 1.03220 1.02417 +/- 0.00350\n", + " 34/1 1.02399 1.02416 +/- 0.00335\n", + " 35/1 1.03048 1.02441 +/- 0.00322\n", + " 36/1 1.05360 1.02553 +/- 0.00329\n", + " 37/1 1.05030 1.02645 +/- 0.00330\n", + " 38/1 1.04167 1.02699 +/- 0.00322\n", + " 39/1 1.04406 1.02758 +/- 0.00317\n", + " 40/1 1.01169 1.02705 +/- 0.00310\n", + " 41/1 1.00191 1.02624 +/- 0.00311\n", + " 42/1 1.02729 1.02628 +/- 0.00301\n", + " 43/1 1.02263 1.02616 +/- 0.00292\n", + " 44/1 1.05344 1.02697 +/- 0.00295\n", + " 45/1 1.03607 1.02723 +/- 0.00287\n", + " 46/1 1.00357 1.02657 +/- 0.00287\n", + " 47/1 1.03353 1.02676 +/- 0.00279\n", + " 48/1 1.03817 1.02706 +/- 0.00274\n", + " 49/1 1.01454 1.02674 +/- 0.00269\n", + " 50/1 0.99860 1.02603 +/- 0.00271\n", + " Creating state point statepoint.50.h5...\n", "\n", " ===========================================================================\n", " ======================> SIMULATION FINISHED <======================\n", @@ -2165,27 +1151,27 @@ "\n", " =======================> TIMING STATISTICS <=======================\n", "\n", - " Total time for initialization = 5.3000E-02 seconds\n", - " Reading cross sections = 5.0000E-03 seconds\n", - " Total time in simulation = 1.8631E+02 seconds\n", - " Time in transport only = 1.8590E+02 seconds\n", - " Time in inactive batches = 1.1710E+00 seconds\n", - " Time in active batches = 1.8514E+02 seconds\n", - " Time synchronizing fission bank = 7.3000E-02 seconds\n", - " Sampling source sites = 5.1000E-02 seconds\n", - " SEND/RECV source sites = 2.2000E-02 seconds\n", - " Time accumulating tallies = 4.0000E-03 seconds\n", + " Total time for initialization = 3.7000E-02 seconds\n", + " Reading cross sections = 4.0000E-03 seconds\n", + " Total time in simulation = 1.2661E+01 seconds\n", + " Time in transport only = 1.2600E+01 seconds\n", + " Time in inactive batches = 1.1370E+00 seconds\n", + " Time in active batches = 1.1524E+01 seconds\n", + " Time synchronizing fission bank = 7.0000E-03 seconds\n", + " Sampling source sites = 5.0000E-03 seconds\n", + " SEND/RECV source sites = 2.0000E-03 seconds\n", + " Time accumulating tallies = 0.0000E+00 seconds\n", " Total time for finalization = 0.0000E+00 seconds\n", - " Total time elapsed = 1.8637E+02 seconds\n", - " Calculation Rate (inactive) = 42698.5 neutrons/second\n", - " Calculation Rate (active) = 13233.2 neutrons/second\n", + " Total time elapsed = 1.2707E+01 seconds\n", + " Calculation Rate (inactive) = 43975.4 neutrons/second\n", + " Calculation Rate (active) = 17355.1 neutrons/second\n", "\n", " ============================> RESULTS <============================\n", "\n", - " k-effective (Collision) = 1.02403 +/- 0.00071\n", - " k-effective (Track-length) = 1.02394 +/- 0.00079\n", - " k-effective (Absorption) = 1.02539 +/- 0.00044\n", - " Combined k-effective = 1.02518 +/- 0.00042\n", + " k-effective (Collision) = 1.02471 +/- 0.00243\n", + " k-effective (Track-length) = 1.02603 +/- 0.00271\n", + " k-effective (Absorption) = 1.02312 +/- 0.00182\n", + " Combined k-effective = 1.02387 +/- 0.00172\n", " Leakage Fraction = 0.00000 +/- 0.00000\n", "\n" ] @@ -2196,7 +1182,7 @@ "0" ] }, - "execution_count": 35, + "execution_count": 34, "metadata": {}, "output_type": "execute_result" } @@ -2219,7 +1205,7 @@ }, { "cell_type": "code", - "execution_count": 36, + "execution_count": 35, "metadata": { "collapsed": false }, @@ -2239,7 +1225,7 @@ }, { "cell_type": "code", - "execution_count": 37, + "execution_count": 36, "metadata": { "collapsed": true }, @@ -2257,7 +1243,7 @@ }, { "cell_type": "code", - "execution_count": 38, + "execution_count": 37, "metadata": { "collapsed": false }, @@ -2266,9 +1252,9 @@ "name": "stdout", "output_type": "stream", "text": [ - "Continuous-Energy keff = 1.025194\n", - "Multi-Group keff = 1.025183\n", - "bias [pcm]: 1.1\n" + "Continuous-Energy keff = 1.024295\n", + "Multi-Group keff = 1.023875\n", + "bias [pcm]: 42.0\n" ] } ], @@ -2284,7 +1270,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "We see quite good agreement with only an 1 pcm difference between the two. While these results are quite favorable, due to the high degree of approximations inherent in practical application of multi-group theory, one should not expect results of such fidelity always for multi-group Monte Carlo calculations." + "We see quite good agreement with only a 42 pcm difference between the two methods. Due to the high degree of approximations inherent in practical application of multi-group theory, one should not expect results of such high fidelity always for multi-group Monte Carlo calculations." ] }, { @@ -2305,7 +1291,7 @@ }, { "cell_type": "code", - "execution_count": 39, + "execution_count": 38, "metadata": { "collapsed": false }, @@ -2313,39 +1299,39 @@ "source": [ "# Get the OpenMC fission rate mesh tally data\n", "mg_mesh_tally = mgsp.get_tally(name='mesh tally')\n", - "mgopenmc_fission_rates = mg_mesh_tally.get_values(scores=['fission'])\n", + "mg_fission_rates = mg_mesh_tally.get_values(scores=['fission'])\n", "\n", "# Reshape array to 2D for plotting\n", - "mgopenmc_fission_rates.shape = (17,17)\n", + "mg_fission_rates.shape = (17,17)\n", "\n", "# Normalize to the average pin power\n", - "mgopenmc_fission_rates /= np.mean(mgopenmc_fission_rates)" + "mg_fission_rates /= np.mean(mg_fission_rates)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "Now we can do the same for the Multi-Group results." + "Now we can do the same for the Continuous-Energy results." ] }, { "cell_type": "code", - "execution_count": 40, + "execution_count": 39, "metadata": { - "collapsed": true + "collapsed": false }, "outputs": [], "source": [ "# Get the OpenMC fission rate mesh tally data\n", - "mesh_tally = sp.get_tally(name='mesh tally')\n", - "openmc_fission_rates = mesh_tally.get_values(scores=['fission'])\n", + "ce_mesh_tally = sp.get_tally(name='mesh tally')\n", + "ce_fission_rates = ce_mesh_tally.get_values(scores=['fission'])\n", "\n", "# Reshape array to 2D for plotting\n", - "openmc_fission_rates.shape = (17,17)\n", + "ce_fission_rates.shape = (17,17)\n", "\n", "# Normalize to the average pin power\n", - "openmc_fission_rates /= np.mean(openmc_fission_rates)" + "ce_fission_rates /= np.mean(ce_fission_rates)" ] }, { @@ -2357,7 +1343,7 @@ }, { "cell_type": "code", - "execution_count": 41, + "execution_count": 40, "metadata": { "collapsed": false }, @@ -2365,18 +1351,18 @@ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 41, + "execution_count": 40, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAADDCAYAAACS2+oqAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\noYuIVIQSuohIRSihi4hUxP8DxMTTRn5AfRMAAAAASUVORK5CYII=\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAADDCAYAAACS2+oqAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nMIunubFhPwAAAABJRU5ErkJggg==\n", "text/plain": [ - "" + "" ] }, "metadata": {}, @@ -2386,12 +1372,12 @@ "source": [ "# Plot the CE fission rates in the left subplot\n", "fig = plt.subplot(121)\n", - "plt.imshow(openmc_fission_rates, interpolation='none', cmap='jet')\n", + "plt.imshow(ce_fission_rates, interpolation='none', cmap='jet')\n", "plt.title('Continuous-Energy Fission Rates')\n", "\n", "# Plot the MG fission rates in the right subplot\n", "fig2 = plt.subplot(122)\n", - "plt.imshow(mgopenmc_fission_rates, interpolation='none', cmap='jet')\n", + "plt.imshow(mg_fission_rates, interpolation='none', cmap='jet')\n", "plt.title('Multi-Group Fission Rates')\n" ] }, diff --git a/docs/source/usersguide/mgxs_library.rst b/docs/source/usersguide/mgxs_library.rst index a5d2ec0d06..8628bef4e0 100644 --- a/docs/source/usersguide/mgxs_library.rst +++ b/docs/source/usersguide/mgxs_library.rst @@ -8,10 +8,10 @@ OpenMC can be run in continuous-energy mode or multi-group mode, provided the nuclear data is available. In continuous-energy mode, the ``cross_sections.xml`` file contains necessary meta-data for each data set, including the name and a file system location where the complete library -can be found. In multi-group mode, this ``cross_sections.xml`` file contains +can be found. In multi-group mode, this ``mgxs.xml`` file contains this same meta-data describing the nuclide or material, but also contains the group-wise nuclear data. This portion of the manual describes the format of -the multi-group data library required to be used in the ``cross_sections.xml`` +the multi-group data library required to be used in the ``mgxs.xml`` file. Similar to the other input file types, the multi-group library is provided in @@ -23,7 +23,7 @@ materials. .. _XML: http://www.w3.org/XML/ ------------------------------------------------ -MGXS Library Specification -- cross_sections.xml +MGXS Library Specification -- mgxs.xml ------------------------------------------------ The multi-group library meta-data is contained within the groups_, diff --git a/openmc/material.py b/openmc/material.py index e9a74f1e75..02cbc117d0 100644 --- a/openmc/material.py +++ b/openmc/material.py @@ -348,7 +348,9 @@ class Material(object): del self._nuclides[nuclide._name] def add_macroscopic(self, macroscopic): - """Add a macroscopic to the material + """Add a macroscopic to the material. This will also set the + density of the material to 1.0, unless it has been otherwise set, + as a default for Macroscopic cross sections. Parameters ---------- @@ -386,6 +388,14 @@ class Material(object): 'Material!'.format(self._id, macroscopic) raise ValueError(msg) + # Generally speaking, the density for a macroscopic object will + # be 1.0. Therefore, lets set density to 1.0 so that the user + # doesnt need to set it unless its needed. + # Of course, if the user has already set a value of density, + # then we will not override it. + if self._density is None: + self.set_density('macro', 1.0) + def remove_macroscopic(self, macroscopic): """Remove a macroscopic from the material diff --git a/openmc/mgxs/library.py b/openmc/mgxs/library.py index 334a0fa9cf..44746e209d 100644 --- a/openmc/mgxs/library.py +++ b/openmc/mgxs/library.py @@ -722,11 +722,140 @@ class Library(object): # Load and return pickled Library object return pickle.load(open(full_filename, 'rb')) - def write_mg_library(self, xs_type='macro', domain_names=None, xs_ids=None, - filename='mg_cross_sections', directory='./', - return_names=False): - """Creates a cross-section data library file for the Multi-Group - mode of OpenMC. + def get_xsdata(self, domain, domain_name, nuclide='total', xs_type='macro', + xs_id='1m', order=-1): + """Generates an openmc.XSdata object describing a multi-group cross section + data set for eventual combination in to an openmc.MGXSLibrary object + (i.e., the library). + + Parameters + ---------- + domain : openmc.Material or openmc.Cell or openmc.Universe + The domain for spatial homogenization + domain_name : str + Name to apply to the "xsdata" entry produced by this method + nuclide : str + A nuclide name string (e.g., 'U-235'). Defaults to 'total' to + obtain a material-wise macroscopic cross section. + xs_type: {'macro', 'micro'} + Provide the macro or micro cross section in units of cm^-1 or + barns. Defaults to 'macro'. If the Library object is not tallied by + nuclide this will be set to 'macro' regardless. + xs_ids : str + Cross section set identifier. Defaults to '1m'. + order : Scattering order for this dataset entry. Default is -1, + which will force the XSdata object to use whatever the maximum + order available. + + Returns + ------- + xsdata : openmc.XSdata + Multi-Group Cross Section data set object. + + Raises + ------ + ValueError + When the Library object is initialized with insufficient types of + cross sections for the Library. + + See also + -------- + Library.create_mg_library(...) + + """ + + cv.check_type('domain', domain, (openmc.Material, openmc.Cell, + openmc.Cell)) + cv.check_type('domain_name', domain_name, basestring) + cv.check_type('nuclide', nuclide, basestring) + cv.check_value('xs_type', xs_type, ['macro', 'micro']) + cv.check_type('xs_id', xs_id, basestring) + cv.check_type('order', order, Integral) + cv.check_greater_than('order', order, -1, equality=True) + + # Make sure statepoint has been loaded + if self._sp_filename is None: + msg = 'A StatePoint must be loaded before calling ' \ + 'the create_mg_library() function' + raise ValueError(msg) + + # If gathering material-specific data, set the xs_type to macro + if not self.by_nuclide: + xs_type = 'macro' + + # Build & add metadata to XSdata object + name = domain_name + if nuclide is not 'total': + name += '_' + nuclide + name += '.' + xs_id + xsdata = openmc.XSdata(name, self.energy_groups) + xsdata.order = order + if nuclide is not 'total': + xsdata.zaid = self._nuclides[nuclide][0] + xsdata.awr = self._nuclides[nuclide][1] + + # Now get xs data itself + if 'transport' in self.mgxs_types: + mymgxs = self.get_mgxs(domain, 'transport') + xsdata.set_total_mgxs(mymgxs, xs_type=xs_type, nuclide=[nuclide]) + elif 'total' in self.mgxs_types: + mymgxs = self.get_mgxs(domain, 'total') + xsdata.set_total_mgxs(mymgxs, xs_type=xs_type, nuclide=[nuclide]) + if 'absorption' in self.mgxs_types: + mymgxs = self.get_mgxs(domain, 'absorption') + xsdata.set_absorption_mgxs(mymgxs, xs_type=xs_type, + nuclide=[nuclide]) + if 'fission' in self.mgxs_types: + mymgxs = self.get_mgxs(domain, 'fission') + xsdata.set_fission_mgxs(mymgxs, xs_type=xs_type, + nuclide=[nuclide]) + if 'kappa-fission' in self.mgxs_types: + mymgxs = self.get_mgxs(domain, 'kappa-fission') + xsdata.set_kappa_fission_mgxs(mymgxs, xs_type=xs_type, + nuclide=[nuclide]) + if 'chi' in self.mgxs_types: + mymgxs = self.get_mgxs(domain, 'chi') + xsdata.set_chi_mgxs(mymgxs, xs_type=xs_type, nuclide=[nuclide]) + if 'nu-fission' in self.mgxs_types: + mymgxs = self.get_mgxs(domain, 'nu-fission') + xsdata.set_nu_fission_mgxs(mymgxs, xs_type=xs_type, + nuclide=[nuclide]) + # multiplicity requires scatter and nu-scatter + if ((('scatter matrix' in self.mgxs_types) and + ('nu-scatter matrix' in self.mgxs_types))): + scatt_mgxs = self.get_mgxs(domain, 'scatter matrix') + nuscatt_mgxs = self.get_mgxs(domain, 'nu-scatter matrix') + xsdata.set_multiplicity_mgxs(nuscatt_mgxs, scatt_mgxs, + xs_type=xs_type, nuclide=[nuclide]) + using_multiplicity = True + else: + using_multiplicity = False + + if using_multiplicity: + nuscatt_mgxs = self.get_mgxs(domain, 'nu-scatter matrix') + xsdata.set_scatter_mgxs(nuscatt_mgxs, xs_type=xs_type, + nuclide=[nuclide]) + else: + if 'nu-scatter matrix' in self.mgxs_types: + nuscatt_mgxs = self.get_mgxs(domain, 'nu-scatter matrix') + xsdata.set_scatter_mgxs(nuscatt_mgxs, xs_type=xs_type, + nuclide=[nuclide]) + + # Since we are not using multiplicity, then + # scattering multiplication (nu-scatter) must be + # accounted for approximately by using an adjusted + # absorption cross section. + if 'total' in self.mgxs_types: + xsdata._absorption = \ + np.subtract(xsdata.total, + np.sum(xsdata.scatter[0, :, :], axis=1)) + + return xsdata + + def create_mg_library(self, xs_type='macro', domain_names=None, + xs_ids=None): + """Creates an openmc.MGXSLibrary object to contain the MGXS data for the + Multi-Group mode of OpenMC. Parameters ---------- @@ -735,28 +864,18 @@ class Library(object): barns. Defaults to 'macro'. If the Library object is not tallied by nuclide this will be set to 'macro' regardless. domain_names : Iterable of str - List of names to apply to the xsdata entries in the + List of names to apply to the "xsdata" entries in the resultant mgxs data file. Defaults to 'set1', 'set2', ... xs_ids : str or Iterable of str Cross section set identifier (i.e., '71c') for all data sets (if only str) or for each individual one (if iterable of str). Defaults to '1m'. - filename : str - Filename for the pickle file. Defaults to 'mg_cross_sections'. - directory : str - Directory for the pickle file. Defaults to './' (the - current working directory). - return_names : bool - Flag to indicate if the user would like the names of the - materials generated by this function returned with completion. - Defaults to False, indicating that no names will be returned. Returns ------- - mat_names : Iterable of str - Iterable of material names generated during this routine and - applies to the cross section library. Note this is returned if - the return_names parameter is provided. + mgxs_file : openmc.MGXSLibrary + Multi-Group Cross Section File that is ready to be printed to the + file of choice by the user. Raises ------ @@ -774,10 +893,9 @@ class Library(object): # multi-group cross section types self.check_library_for_openmc_mgxs() - # Check the provided parameters cv.check_value('xs_type', xs_type, ['macro', 'micro']) if domain_names is not None: - cv.check_iterable_type('domain_names', filename, basestring) + cv.check_iterable_type('domain_names', domain_names, basestring) if xs_ids is not None: if isinstance(xs_ids, basestring): # If we only have a string lets convert it now to a list @@ -787,25 +905,11 @@ class Library(object): cv.check_iterable_type('xs_ids', xs_ids, basestring) else: xs_ids = ['1m' for i in range(len(self.domains))] - cv.check_type('filename', filename, basestring) - cv.check_type('directory', directory, basestring) - # Make sure statepoint has been loaded - if self._sp_filename is None: - msg = 'A StatePoint must be loaded before calling ' \ - 'the write_mg_library() function' - raise ValueError(msg) - - # Construct the collection of the nuclides to report + # If gathering material-specific data, set the xs_type to macro if not self.by_nuclide: xs_type = 'macro' - # Make directory if it does not exist and build our filename - if not os.path.exists(directory): - os.makedirs(directory) - full_filename = os.path.join(directory, filename + '.xml') - full_filename = full_filename.replace(' ', '-') - # Initialize file mgxs_file = openmc.MGXSLibrary(self.energy_groups) @@ -813,13 +917,10 @@ class Library(object): # support for higher orders are included in openmc.mgxs order = 0 - # Build XSdata objects + # Build storage for our XSdata objects xsdatas = [] - mat_names = {} for i, domain in enumerate(self.domains): - - mat_names[domain.id] = {} if self.by_nuclide: nuclides = list(domain.get_all_nuclides().keys()) else: @@ -832,99 +933,23 @@ class Library(object): name = domain_names[i] if nuclide is not 'total': name += '_' + nuclide - name += '.' + xs_ids[i] - # Store the name - mat_names[domain.id][nuclide] = name - - xsdata = openmc.XSdata(name, self.energy_groups) - xsdata.order = order - if nuclide is not 'total': - xsdata.zaid = self._nuclides[nuclide][0] - xsdata.awr = self._nuclides[nuclide][1] - - nuclide = [nuclide] - # Now get xs data itself - if 'transport' in self.mgxs_types: - mymgxs = self.get_mgxs(domain, 'transport') - xsdata.set_total_mgxs(mymgxs, xs_type=xs_type, - nuclide=nuclide) - elif 'total' in self.mgxs_types: - mymgxs = self.get_mgxs(domain, 'total') - xsdata.set_total_mgxs(mymgxs, xs_type=xs_type, - nuclide=nuclide) - if 'absorption' in self.mgxs_types: - mymgxs = self.get_mgxs(domain, 'absorption') - xsdata.set_absorption_mgxs(mymgxs, xs_type=xs_type, - nuclide=nuclide) - if 'fission' in self.mgxs_types: - mymgxs = self.get_mgxs(domain, 'fission') - xsdata.set_fission_mgxs(mymgxs, xs_type=xs_type, - nuclide=nuclide) - if 'kappa-fission' in self.mgxs_types: - mymgxs = self.get_mgxs(domain, 'kappa-fission') - xsdata.set_kappa_fission_mgxs(mymgxs, xs_type=xs_type, - nuclide=nuclide) - if 'chi' in self.mgxs_types: - mymgxs = self.get_mgxs(domain, 'chi') - xsdata.set_chi_mgxs(mymgxs, xs_type=xs_type, - nuclide=nuclide) - if 'nu-fission' in self.mgxs_types: - mymgxs = self.get_mgxs(domain, 'nu-fission') - xsdata.set_nu_fission_mgxs(mymgxs, xs_type=xs_type, - nuclide=nuclide) - # multiplicity requires scatter and nu-scatter - if ((('scatter matrix' in self.mgxs_types) and - ('nu-scatter matrix' in self.mgxs_types))): - scatt_mgxs = self.get_mgxs(domain, - 'scatter matrix') - nuscatt_mgxs = self.get_mgxs(domain, - 'nu-scatter matrix') - xsdata.set_multiplicity_mgxs(nuscatt_mgxs, scatt_mgxs, - xs_type=xs_type, - nuclide=nuclide) - using_multiplicity = True - else: - using_multiplicity = False - - if using_multiplicity: - nuscatt_mgxs = self.get_mgxs(domain, - 'nu-scatter matrix') - xsdata.set_scatter_mgxs(nuscatt_mgxs, xs_type=xs_type, - nuclide=nuclide) - else: - if 'nu-scatter matrix' in self.mgxs_types: - nuscatt_mgxs = self.get_mgxs(domain, - 'nu-scatter matrix') - xsdata.set_scatter_mgxs(nuscatt_mgxs, xs_type=xs_type, - nuclide=nuclide) - - # Since we are not using multiplicity, then - # scattering multiplication (nu-scatter) must be - # accounted for approximately by using an adjusted - # absorption cross section. - if 'total' in self.mgxs_types: - xsdata._absorption = \ - np.subtract(xsdata.total, - np.sum(xsdata.scatter[0, :, :], - axis=1)) + xsdata = self.get_xsdata(domain, name, nuclide=nuclide, + xs_type=xs_type, xs_id=xs_ids[i], + order=order) xsdatas.append(xsdata) # Add XSdatas to file mgxs_file.add_xsdatas(xsdatas) - # Finally, write the file - mgxs_file.export_to_xml(full_filename) - - if return_names: - return mat_names + return mgxs_file def check_library_for_openmc_mgxs(self): - """This routine will check the MGXS Types within the provided - Library to ensure the data types provided can be used to create - a MGXS Library for OpenMC's Multi-Group mode via the - `Library.write_mg_library` method. + """This routine will check the MGXS Types within a Library + to ensure the MGXS types provided can be used to create + a MGXS Library for OpenMC's Multi-Group mode. + The rules to check include: - Either total or transport should be present. - Both can be available if one wants, but we should @@ -943,7 +968,7 @@ class Library(object): See also -------- - Library.write_mg_library(...) + Library.create_mg_library(...) """ diff --git a/openmc/mgxs_library.py b/openmc/mgxs_library.py index 29d0bfdd7d..e59ef2d61d 100644 --- a/openmc/mgxs_library.py +++ b/openmc/mgxs_library.py @@ -420,7 +420,8 @@ class XSdata(object): enable = tabular_legendre['enable'] check_type('enable', enable, bool) else: - msg = 'enable must be provided in tabular_legendre' + msg = 'The tabular_legendre dict must include a value keyed by ' \ + '"enable"' raise ValueError(msg) if 'num_points' in tabular_legendre: num_points = tabular_legendre['num_points'] @@ -448,217 +449,77 @@ class XSdata(object): @total.setter def total(self, total): - """This method sets the total cross section by performing a - deep-copy of the provided ndarray. If the angular - representation is "isotropic" the shape of the input array - must be the number of energy groups. If the angular - representation is "angle" then the shape of the input - array must be the number of polar angles, number azimuthal - angles and energy groups. - - Parameters - ---------- - total: ndarray - Array of group-wise cross sections to apply - - """ - - # check we have a numpy list check_type('total', total, np.ndarray, expected_iter_type=Real) - # Check the dimensions of the data check_value('total shape', total.shape, self.vector_shape) - self._total = np.copy(total) + self._total = total @absorption.setter def absorption(self, absorption): - """This method sets the absorption cross section by performing a - deep-copy of the provided ndarray. If the angular - representation is "isotropic" the shape of the input array - must be the number of energy groups. If the angular - representation is "angle" then the shape of the input - array must be the number of polar angles, number azimuthal - angles and energy groups. - - Parameters - ---------- - absorption: ndarray - Array of group-wise cross sections to apply - - """ - - # check we have a numpy list check_type('absorption', absorption, np.ndarray, expected_iter_type=Real) - # Check the dimensions of the data check_value('absorption shape', absorption.shape, self.vector_shape) - self._absorption = np.copy(absorption) + self._absorption = absorption @fission.setter def fission(self, fission): - """This method sets the fission cross section by performing a - deep-copy of the provided ndarray. If the angular - representation is "isotropic" the shape of the input array - must be the number of energy groups. If the angular - representation is "angle" then the shape of the input - array must be the number of polar angles, number azimuthal - angles and energy groups. - - Parameters - ---------- - fission: ndarray - Array of group-wise cross sections to apply - - """ - - # check we have a numpy list check_type('fission', fission, np.ndarray, expected_iter_type=Real) - # Check the dimensions of the data check_value('fission shape', fission.shape, self.vector_shape) - self._fission = np.copy(fission) + self._fission = fission if np.sum(self._fission) > 0.0: self._fissionable = True @kappa_fission.setter def kappa_fission(self, kappa_fission): - """This method sets the kappa_fission cross section by performing a - deep-copy of the provided ndarray. If the angular - representation is "isotropic" the shape of the input array - must be the number of energy groups. If the angular - representation is "angle" then the shape of the input - array must be the number of polar angles, number azimuthal - angles and energy groups. - - Parameters - ---------- - kappa_fission: ndarray - Array of group-wise cross sections to apply - - """ - - # check we have a numpy list - check_type('kappa_fission', fission, np.ndarray, + check_type('kappa_fission', kappa_fission, np.ndarray, expected_iter_type=Real) - # Check the dimensions of the data check_value('kappa fission shape', kappa_fission.shape, self.vector_shape) - self._kappa_fission = np.copy(fission) + self._kappa_fission = kappa_fission if np.sum(self._kappa_fission) > 0.0: self._fissionable = True @chi.setter def chi(self, chi): - """This method sets the chi cross section by performing a - deep-copy of the provided ndarray. If the angular - representation is "isotropic" the shape of the input array - must be the number of energy groups. If the angular - representation is "angle" then the shape of the input - array must be the number of polar angles, number azimuthal - angles and energy groups. - - Parameters - ---------- - chi: ndarray - Array of group-wise chi values to apply - - """ - if self._use_chi is not None: if not self._use_chi: msg = 'Providing chi when nu_fission already provided as a' \ 'matrix' raise ValueError(msg) - # check we have a numpy list check_type('chi', chi, np.ndarray, expected_iter_type=Real) - # Check the dimensions of the data check_value('chi shape', chi.shape, self.vector_shape) - self._chi = np.copy(chi) + self._chi = chi if self._use_chi is not None: self._use_chi = True @scatter.setter def scatter(self, scatter): - """This method sets the scattering matrix cross sections - by performing a deep-copy of the provided ndarray. - If the angular representation is "isotropic" the shape of - the input array must be the number of scattering orders, the - number of energy groups, and the number of energy groups. If - the angular representation is "angle" then the shape of the input - array must be the number of polar angles, number azimuthal - angles, number of scattering orders, energy groups, and energy groups. - - Parameters - ---------- - scatter : ndarrays - Array of cross sections to apply - - """ - - # check we have a numpy list check_type('scatter', scatter, np.ndarray, expected_iter_type=Real, max_depth=len(scatter.shape)) - # Check the dimensions of the data check_value('scatter shape', scatter.shape, self.pn_matrix_shape) - self._scatter = np.copy(scatter) + self._scatter = scatter @multiplicity.setter def multiplicity(self, multiplicity): - """This method sets the scattering multiplicity matrix cross sections - by performing a deep-copy of the provided ndarray. Multiplicity, - in OpenMC parlance, is a factor used to account for the production - of neutrons introduced by scattering multiplication reactions, i.e., - (n,xn) events. In this sense, the multiplication matrix is simply - defined as the ratio of the nu-scatter and scatter matrices. - If the angular representation is "isotropic" the shape of - the input array must be the number of energy groups and the number - of energy groups. If the angular representation is "angle" then the - shape of the input array must be the number of polar angles, - number azimuthal angles, number of scattering orders, energy groups, - and energy groups. - - Parameters - ---------- - multiplicity : ndarrays - Array of scattering multiplications to apply - - """ - - # check we have a numpy list check_type('multiplicity', multiplicity, np.ndarray, expected_iter_type=Real, max_depth=len(multiplicity.shape)) - # Check the dimensions of the data check_value('multiplicity shape', multiplicity.shape, self.matrix_shape) - self._multiplicity = np.copy(multiplicity) + self._multiplicity = multiplicity @nu_fission.setter def nu_fission(self, nu_fission): - """This method sets the nu_fission cross section by performing a - deep-copy of the provided ndarray. If the angular - representation is "isotropic" the shape of the input array - must be the number of energy groups. If the angular - representation is "angle" then the shape of the input - array must be the number of polar angles, number azimuthal - angles and energy groups. - - Parameters - ---------- - nu_fission: ndarray - Array of group-wise cross sections to apply - - """ - # The NuFissionXS class does not have the capability to produce # a fission matrix and therefore if this path is pursued, we know # chi must be used. @@ -669,12 +530,10 @@ class XSdata(object): # chi already has been set. If not, we just check that this is OK # and set the use_chi flag accordingly - # First, check we have a numpy list check_type('nu_fission', nu_fission, np.ndarray, expected_iter_type=Real, max_depth=len(nu_fission.shape)) if self._use_chi is not None: - # Check the dimensions of the data if self._use_chi: check_value('nu_fission shape', nu_fission.shape, self.vector_shape) @@ -682,16 +541,16 @@ class XSdata(object): check_value('nu_fission shape', nu_fission.shape, self.matrix_shape) else: - # Make sure the dimensions are at least right check_value('nu_fission shape', nu_fission.shape, (self.vector_shape, self.matrix_shape)) - # Then find out which one we have so we can set use_chi + # Find out if we have a nu-fission matrix or vector + # and set a flag to allow other methods to check this later. if nu_fission.shape == self.vector_shape: self._use_chi = True else: self._use_chi = False - self._nu_fission = np.copy(nu_fission) + self._nu_fission = nu_fission if np.sum(self._nu_fission) > 0.0: self._fissionable = True @@ -716,11 +575,7 @@ class XSdata(object): check_type('total', total, (openmc.mgxs.TotalXS, openmc.mgxs.TransportXS)) - - # Make sure passed MGXS object contains correct group structure check_value('energy_groups', total.energy_groups, [self.energy_groups]) - - # Make sure passed MGXS object has correct domain type check_value('domain_type', total.domain_type, ['universe', 'cell', 'material']) @@ -750,12 +605,8 @@ class XSdata(object): """ check_type('absorption', absorption, openmc.mgxs.AbsorptionXS) - - # Make sure passed MGXS object contains correct group structure check_value('energy_groups', absorption.energy_groups, [self.energy_groups]) - - # Make sure passed MGXS object has correct domain type check_value('domain_type', absorption.domain_type, ['universe', 'cell', 'material']) @@ -785,12 +636,8 @@ class XSdata(object): """ check_type('fission', fission, openmc.mgxs.FissionXS) - - # Make sure passed MGXS object contains correct group structure check_value('energy_groups', fission.energy_groups, [self.energy_groups]) - - # Make sure passed MGXS object has correct domain type check_value('domain_type', fission.domain_type, ['universe', 'cell', 'material']) @@ -824,12 +671,8 @@ class XSdata(object): # a fission matrix and therefore if this path is pursued, we know # chi must be used. check_type('nu_fission', nu_fission, openmc.mgxs.NuFissionXS) - - # Make sure passed MGXS object contains correct group structure check_value('energy_groups', nu_fission.energy_groups, [self.energy_groups]) - - # Make sure passed MGXS object has correct domain type check_value('domain_type', nu_fission.domain_type, ['universe', 'cell', 'material']) @@ -866,12 +709,8 @@ class XSdata(object): """ check_type('k_fission', k_fission, openmc.mgxs.KappaFissionXS) - - # Make sure passed MGXS object contains correct group structure check_value('energy_groups', k_fission.energy_groups, [self.energy_groups]) - - # Make sure passed MGXS object has correct domain type check_value('domain_type', k_fission.domain_type, ['universe', 'cell', 'material']) @@ -906,11 +745,7 @@ class XSdata(object): raise ValueError(msg) check_type('chi', chi, openmc.mgxs.Chi) - - # Make sure passed MGXS object contains correct group structure check_value('energy_groups', chi.energy_groups, [self.energy_groups]) - - # Make sure passed MGXS object has correct domain type check_value('domain_type', chi.domain_type, ['universe', 'cell', 'material']) @@ -944,12 +779,8 @@ class XSdata(object): """ check_type('scatter', scatter, openmc.mgxs.ScatterMatrixXS) - - # Make sure passed MGXS object contains correct group structure check_value('energy_groups', scatter.energy_groups, [self.energy_groups]) - - # Make sure passed MGXS object has correct domain type check_value('domain_type', scatter.domain_type, ['universe', 'cell', 'material']) @@ -990,14 +821,10 @@ class XSdata(object): check_type('nuscatter', nuscatter, openmc.mgxs.NuScatterMatrixXS) check_type('scatter', scatter, openmc.mgxs.ScatterMatrixXS) - - # Make sure passed MGXS object contains correct group structure check_value('energy_groups', nuscatter.energy_groups, [self.energy_groups]) check_value('energy_groups', scatter.energy_groups, [self.energy_groups]) - - # Make sure passed MGXS object has correct domain type check_value('domain_type', nuscatter.domain_type, ['universe', 'cell', 'material']) check_value('domain_type', scatter.domain_type, @@ -1153,14 +980,10 @@ class MGXSLibrary(object): MGXS information to add """ - - # Check the type if not isinstance(xsdata, XSdata): msg = 'Unable to add a non-XSdata "{0}" to the ' \ 'MGXSLibrary instance'.format(xsdata) raise ValueError(msg) - - # Make sure energy groups match. if xsdata.energy_groups != self._energy_groups: msg = 'Energy groups of XSdata do not match that of MGXSLibrary.' raise ValueError(msg) @@ -1176,8 +999,6 @@ class MGXSLibrary(object): XSdatas to add """ - - # Check we have an iterable of XSdatas check_iterable_type('xsdatas', xsdatas, XSdata) for xsdata in xsdatas: @@ -1222,14 +1043,14 @@ class MGXSLibrary(object): xml_element = xsdata._get_xsdata_xml() self._cross_sections_file.append(xml_element) - def export_to_xml(self, filename='mg_cross_sections.xml'): - """Create an mg_cross_sections.xml file that can be used for a + def export_to_xml(self, filename='mgxs.xml'): + """Create an mgxs.xml file that can be used for a simulation. Parameters ---------- filename : str, optional - filename of file, default is mg_cross_sections.xml + filename of file, default is mgxs.xml """ diff --git a/src/input_xml.F90 b/src/input_xml.F90 index 22eff595cd..24986be876 100644 --- a/src/input_xml.F90 +++ b/src/input_xml.F90 @@ -153,7 +153,7 @@ contains else call get_environment_variable("OPENMC_MG_CROSS_SECTIONS", env_variable) if (len_trim(env_variable) == 0) then - call fatal_error("No cross_sections.xml file was specified in & + call fatal_error("No mgxs.xml file was specified in & &settings.xml or in the OPENMC_MG_CROSS_SECTIONS environment & &variable. OpenMC needs such a file to identify where to & &find the cross section libraries. Please consult the user's & @@ -4537,24 +4537,24 @@ contains subroutine read_mg_cross_sections_xml() integer :: i ! loop index - logical :: file_exists ! does cross_sections.xml exist? + logical :: file_exists ! does mgxs.xml exist? type(XsListing), pointer :: listing => null() type(Node), pointer :: doc => null() type(Node), pointer :: node_xsdata => null() type(NodeList), pointer :: node_xsdata_list => null() real(8), allocatable :: rev_energy_bins(:) - ! Check if cross_sections.xml exists + ! Check if mgxs.xml exists inquire(FILE=path_cross_sections, EXIST=file_exists) if (.not. file_exists) then - ! Could not find cross_sections.xml file + ! Could not find mgxs.xml file call fatal_error("Cross sections XML file '" & // trim(path_cross_sections) // "' does not exist!") end if call write_message("Reading cross sections XML file...", 5) - ! Parse cross_sections.xml file + ! Parse mgxs.xml file call open_xmldoc(doc, path_cross_sections) if (check_for_node(doc, "groups")) then @@ -4602,7 +4602,7 @@ contains ! Allocate xs_listings array if (n_listings == 0) then call fatal_error("At least one element must be present in & - &cross_sections.xml file!") + &mgxs.xml file!") else allocate(xs_listings(n_listings)) end if From 86cf42d7a63ab65db19986787510fe670a88e955 Mon Sep 17 00:00:00 2001 From: Adam Nelson Date: Sat, 14 May 2016 07:58:10 -0400 Subject: [PATCH 14/20] Clarifications in example notebook --- .../pythonapi/examples/mgxs-part-iv.ipynb | 69 +++++++++++-------- 1 file changed, 39 insertions(+), 30 deletions(-) diff --git a/docs/source/pythonapi/examples/mgxs-part-iv.ipynb b/docs/source/pythonapi/examples/mgxs-part-iv.ipynb index d03db2cce6..b81e8f06b2 100644 --- a/docs/source/pythonapi/examples/mgxs-part-iv.ipynb +++ b/docs/source/pythonapi/examples/mgxs-part-iv.ipynb @@ -433,7 +433,7 @@ "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAPoAAAD6AgMAAAD1grKuAAAABGdBTUEAALGPC/xhBQAAACBjSFJN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\nVDIyOjI5OjQxLTA0OjAwt3zdEQAAAABJRU5ErkJggg==\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAPoAAAD6AgMAAAD1grKuAAAABGdBTUEAALGPC/xhBQAAACBjSFJN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\nVDA3OjU2OjMwLTA0OjAwwkYeeQAAAABJRU5ErkJggg==\n", "text/plain": [ "" ] @@ -520,9 +520,9 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Now we must specify the type of domain over which we would like the `Library` to compute multi-group cross sections. The domain type corresponds to the type of tally filter to be used in the tallies created to compute multi-group cross sections. At the present time, the `Library` supports \"material,\" \"cell,\" and \"universe\" domain types. We will use a \"cell\" domain type here to compute cross sections in each of the cells in the fuel assembly geometry.\n", + "Now we must specify the type of domain over which we would like the `Library` to compute multi-group cross sections. The domain type corresponds to the type of tally filter to be used in the tallies created to compute multi-group cross sections. At the present time, the `Library` supports \"material,\" \"cell,\" and \"universe\" domain types. In this simple example, we wish to compute multi-group cross sections only for each material andtherefore will use a \"material\" domain type.\n", "\n", - "**Note:** By default, the `Library` class will instantiate `MGXS` objects for each and every domain (material, cell or universe) in the geometry of interest. However, one may specify a subset of these domains to the `Library.domains` property. In our this simple example, we wish to compute multi-group cross sections only for each material." + "**Note:** By default, the `Library` class will instantiate `MGXS` objects for each and every domain (material, cell or universe) in the geometry of interest. However, one may specify a subset of these domains to the `Library.domains` property." ] }, { @@ -696,7 +696,7 @@ " License: http://openmc.readthedocs.org/en/latest/license.html\n", " Version: 0.7.1\n", " Git SHA1: c779ca42c41a062a6a813e03f2add2d182ca9190\n", - " Date/Time: 2016-05-13 22:29:41\n", + " Date/Time: 2016-05-14 07:56:31\n", " OpenMP Threads: 4\n", "\n", " ===========================================================================\n", @@ -783,20 +783,20 @@ "\n", " =======================> TIMING STATISTICS <=======================\n", "\n", - " Total time for initialization = 1.4550E+00 seconds\n", - " Reading cross sections = 1.1400E+00 seconds\n", - " Total time in simulation = 1.9150E+01 seconds\n", - " Time in transport only = 1.9021E+01 seconds\n", - " Time in inactive batches = 2.1570E+00 seconds\n", - " Time in active batches = 1.6993E+01 seconds\n", - " Time synchronizing fission bank = 7.0000E-03 seconds\n", + " Total time for initialization = 1.4930E+00 seconds\n", + " Reading cross sections = 1.1850E+00 seconds\n", + " Total time in simulation = 1.9053E+01 seconds\n", + " Time in transport only = 1.9002E+01 seconds\n", + " Time in inactive batches = 2.0890E+00 seconds\n", + " Time in active batches = 1.6964E+01 seconds\n", + " Time synchronizing fission bank = 6.0000E-03 seconds\n", " Sampling source sites = 5.0000E-03 seconds\n", - " SEND/RECV source sites = 2.0000E-03 seconds\n", + " SEND/RECV source sites = 1.0000E-03 seconds\n", " Time accumulating tallies = 0.0000E+00 seconds\n", " Total time for finalization = 0.0000E+00 seconds\n", - " Total time elapsed = 2.0614E+01 seconds\n", - " Calculation Rate (inactive) = 23180.3 neutrons/second\n", - " Calculation Rate (active) = 11769.6 neutrons/second\n", + " Total time elapsed = 2.0556E+01 seconds\n", + " Calculation Rate (inactive) = 23934.9 neutrons/second\n", + " Calculation Rate (active) = 11789.7 neutrons/second\n", "\n", " ============================> RESULTS <============================\n", "\n", @@ -960,7 +960,11 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Now we will need to recreate similar xml files from above, beginning with materials.xml. Similar to how continuous-energy cross section libraries are named, the `openmc.Macroscopic` quantities below can either have their `xs_id` included (i.e., `'.2m'`), or this can be left off but the `default_xs` parameter of the materials file be used instead to be set to the `'xs_id'` of interest (which is `'.2m'` in this case as defined in the previous cell)." + "OpenMC's multi-group mode uses the same input files as does the continuous-energy mode (materials, geometry, settings, plots ,and tallies file). Differences would include the use of a flag to tell the code to use multi-group transport, a location of the multi-group library file, and any changes needed in the materials.xml and geometry.xml files to re-define materials as necessary (for example, if using a macroscopic cross section library instead of individual microscopic nuclide cross sections as is done in continuous-energy, or if multiple cross sections exist for the same material due to the material existing in varied spectral regions).\n", + "\n", + "Since this example is using material-wise macroscopic cross sections without considering that the neutron energy spectra and thus cross sections may be changing in space, we only need to modify the materials.xml and settings.xml files. If the material names and ids are not otherwise changed, then the geometry.xml file does not need to be modified from its continuous-energy form. The tallies.xml file will be left untouched as it currently contains the tally types that we will need to perform our comparison. \n", + "\n", + "First we will create the new materials.xml file. Continuous-energy cross section nuclidic data sets are named with the nuclide name followed by a cross section identifier. For example, the data for hydrogen is accessed in OpenMC by the name `H-1.71c`. The cross-section identifier (in this case, `71c`) can be used to distinguish between different variants of `H-1` data, such as for different evaluations or temperatures. OpenMC multi-group libraries use the same convention of a name followed by a xs identifier. We will use a cross section identifier here of `2m`. Similar to how continuous-energy cross section libraries are named, the `openmc.Macroscopic` quantities below can either have their `xs_id` included (i.e., `'fuel.2m'`). An alternative is to leave this extension off and simply change the `default_xs` parameter to `.2m`." ] }, { @@ -1067,7 +1071,7 @@ " License: http://openmc.readthedocs.org/en/latest/license.html\n", " Version: 0.7.1\n", " Git SHA1: c779ca42c41a062a6a813e03f2add2d182ca9190\n", - " Date/Time: 2016-05-13 22:30:02\n", + " Date/Time: 2016-05-14 07:56:52\n", " OpenMP Threads: 4\n", "\n", " ===========================================================================\n", @@ -1151,20 +1155,20 @@ "\n", " =======================> TIMING STATISTICS <=======================\n", "\n", - " Total time for initialization = 3.7000E-02 seconds\n", - " Reading cross sections = 4.0000E-03 seconds\n", - " Total time in simulation = 1.2661E+01 seconds\n", - " Time in transport only = 1.2600E+01 seconds\n", - " Time in inactive batches = 1.1370E+00 seconds\n", - " Time in active batches = 1.1524E+01 seconds\n", + " Total time for initialization = 4.0000E-02 seconds\n", + " Reading cross sections = 6.0000E-03 seconds\n", + " Total time in simulation = 1.2540E+01 seconds\n", + " Time in transport only = 1.2496E+01 seconds\n", + " Time in inactive batches = 1.1110E+00 seconds\n", + " Time in active batches = 1.1429E+01 seconds\n", " Time synchronizing fission bank = 7.0000E-03 seconds\n", " Sampling source sites = 5.0000E-03 seconds\n", " SEND/RECV source sites = 2.0000E-03 seconds\n", " Time accumulating tallies = 0.0000E+00 seconds\n", " Total time for finalization = 0.0000E+00 seconds\n", - " Total time elapsed = 1.2707E+01 seconds\n", - " Calculation Rate (inactive) = 43975.4 neutrons/second\n", - " Calculation Rate (active) = 17355.1 neutrons/second\n", + " Total time elapsed = 1.2589E+01 seconds\n", + " Calculation Rate (inactive) = 45004.5 neutrons/second\n", + " Calculation Rate (active) = 17499.3 neutrons/second\n", "\n", " ============================> RESULTS <============================\n", "\n", @@ -1351,7 +1355,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 40, @@ -1360,9 +1364,9 @@ }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAADDCAYAAACS2+oqAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nMIunubFhPwAAAABJRU5ErkJggg==\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAADDCAYAAACS2+oqAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nhMgJCuhCCJETFNCFECInKKALIURO+H/MOIwTGD7mCAAAAABJRU5ErkJggg==\n", "text/plain": [ - "" + "" ] }, "metadata": {}, @@ -1370,6 +1374,11 @@ } ], "source": [ + "# Force zeros to be NaNs so their values are not included when matplotlib calculates\n", + "# the color scale\n", + "ce_fission_rates[ce_fission_rates == 0.] = np.nan\n", + "mg_fission_rates[mg_fission_rates == 0.] = np.nan\n", + "\n", "# Plot the CE fission rates in the left subplot\n", "fig = plt.subplot(121)\n", "plt.imshow(ce_fission_rates, interpolation='none', cmap='jet')\n", @@ -1387,7 +1396,7 @@ "collapsed": true }, "source": [ - "We also see very good agreement between the fission rate distributions." + "We also see very good agreement between the fission rate distributions, though these should converge closer together with an increasing number of particle histories in both the continuous-energy run to generate the multi-group cross sections, and in the multi-group calculation itself." ] }, { From 4bec584ddb7d07be7d92ad9d037e8363b2f25614 Mon Sep 17 00:00:00 2001 From: Adam Nelson Date: Sat, 14 May 2016 13:04:27 -0400 Subject: [PATCH 15/20] Removed *_id setting in example notebook IV, since they are not needed, just as @wbinventor said. I owe this man a beer. --- .../pythonapi/examples/mgxs-part-iv.ipynb | 94 +++++++++---------- 1 file changed, 47 insertions(+), 47 deletions(-) diff --git a/docs/source/pythonapi/examples/mgxs-part-iv.ipynb b/docs/source/pythonapi/examples/mgxs-part-iv.ipynb index b81e8f06b2..d15f265d4c 100644 --- a/docs/source/pythonapi/examples/mgxs-part-iv.ipynb +++ b/docs/source/pythonapi/examples/mgxs-part-iv.ipynb @@ -83,19 +83,19 @@ "outputs": [], "source": [ "# 1.6 enriched fuel\n", - "fuel = openmc.Material(name='1.6% Fuel', material_id=1)\n", + "fuel = openmc.Material(name='1.6% Fuel')\n", "fuel.set_density('g/cm3', 10.31341)\n", "fuel.add_nuclide(u235, 3.7503e-4)\n", "fuel.add_nuclide(u238, 2.2625e-2)\n", "fuel.add_nuclide(o16, 4.6007e-2)\n", "\n", "# zircaloy\n", - "zircaloy = openmc.Material(name='Zircaloy', material_id=2)\n", + "zircaloy = openmc.Material(name='Zircaloy')\n", "zircaloy.set_density('g/cm3', 6.55)\n", "zircaloy.add_nuclide(zr90, 7.2758e-3)\n", "\n", "# borated water\n", - "water = openmc.Material(name='Borated Water', material_id=3)\n", + "water = openmc.Material(name='Borated Water')\n", "water.set_density('g/cm3', 0.740582)\n", "water.add_nuclide(h1, 4.9457e-2)\n", "water.add_nuclide(o16, 2.4732e-2)\n", @@ -169,22 +169,22 @@ "outputs": [], "source": [ "# Create a Universe to encapsulate a fuel pin\n", - "fuel_pin_universe = openmc.Universe(name='1.6% Fuel Pin', universe_id=10)\n", + "fuel_pin_universe = openmc.Universe(name='1.6% Fuel Pin')\n", "\n", "# Create fuel Cell\n", - "fuel_cell = openmc.Cell(name='1.6% Fuel', cell_id=1)\n", + "fuel_cell = openmc.Cell(name='1.6% Fuel')\n", "fuel_cell.fill = fuel\n", "fuel_cell.region = -fuel_outer_radius\n", "fuel_pin_universe.add_cell(fuel_cell)\n", "\n", "# Create a clad Cell\n", - "clad_cell = openmc.Cell(name='1.6% Clad', cell_id=2)\n", + "clad_cell = openmc.Cell(name='1.6% Clad')\n", "clad_cell.fill = zircaloy\n", "clad_cell.region = +fuel_outer_radius & -clad_outer_radius\n", "fuel_pin_universe.add_cell(clad_cell)\n", "\n", "# Create a moderator Cell\n", - "moderator_cell = openmc.Cell(name='1.6% Moderator', cell_id=3)\n", + "moderator_cell = openmc.Cell(name='1.6% Moderator')\n", "moderator_cell.fill = water\n", "moderator_cell.region = +clad_outer_radius\n", "fuel_pin_universe.add_cell(moderator_cell)" @@ -206,22 +206,22 @@ "outputs": [], "source": [ "# Create a Universe to encapsulate a control rod guide tube\n", - "guide_tube_universe = openmc.Universe(name='Guide Tube', universe_id=20)\n", + "guide_tube_universe = openmc.Universe(name='Guide Tube')\n", "\n", "# Create guide tube Cell\n", - "guide_tube_cell = openmc.Cell(name='Guide Tube Water', cell_id=4)\n", + "guide_tube_cell = openmc.Cell(name='Guide Tube Water')\n", "guide_tube_cell.fill = water\n", "guide_tube_cell.region = -fuel_outer_radius\n", "guide_tube_universe.add_cell(guide_tube_cell)\n", "\n", "# Create a clad Cell\n", - "clad_cell = openmc.Cell(name='Guide Clad', cell_id=5)\n", + "clad_cell = openmc.Cell(name='Guide Clad')\n", "clad_cell.fill = zircaloy\n", "clad_cell.region = +fuel_outer_radius & -clad_outer_radius\n", "guide_tube_universe.add_cell(clad_cell)\n", "\n", "# Create a moderator Cell\n", - "moderator_cell = openmc.Cell(name='Guide Tube Moderator', cell_id=6)\n", + "moderator_cell = openmc.Cell(name='Guide Tube Moderator')\n", "moderator_cell.fill = water\n", "moderator_cell.region = +clad_outer_radius\n", "guide_tube_universe.add_cell(moderator_cell)" @@ -243,7 +243,7 @@ "outputs": [], "source": [ "# Create fuel assembly Lattice\n", - "assembly = openmc.RectLattice(name='1.6% Fuel Assembly', lattice_id=100)\n", + "assembly = openmc.RectLattice(name='1.6% Fuel Assembly')\n", "assembly.dimension = (17, 17)\n", "assembly.pitch = (1.26, 1.26)\n", "assembly.lower_left = [-1.26 * 17. / 2.0] * 2" @@ -297,14 +297,14 @@ "outputs": [], "source": [ "# Create root Cell\n", - "root_cell = openmc.Cell(name='root cell', cell_id=0)\n", + "root_cell = openmc.Cell(name='root cell')\n", "root_cell.fill = assembly\n", "\n", "# Add boundary planes\n", "root_cell.region = +min_x & -max_x & +min_y & -max_y & +min_z & -max_z\n", "\n", "# Create root Universe\n", - "root_universe = openmc.Universe(universe_id=0, name='root universe')\n", + "root_universe = openmc.Universe(name='root universe')\n", "root_universe.add_cell(root_cell)" ] }, @@ -382,7 +382,7 @@ "outputs": [], "source": [ "# Instantiate a Plot\n", - "plot = openmc.Plot(plot_id=1)\n", + "plot = openmc.Plot()\n", "plot.filename = 'materials-xy'\n", "plot.origin = [0, 0, 0]\n", "plot.pixels = [250, 250]\n", @@ -433,7 +433,7 @@ "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAPoAAAD6AgMAAAD1grKuAAAABGdBTUEAALGPC/xhBQAAACBjSFJN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\nVDA3OjU2OjMwLTA0OjAwwkYeeQAAAABJRU5ErkJggg==\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAPoAAAD6AgMAAAD1grKuAAAABGdBTUEAALGPC/xhBQAAACBjSFJN\nAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAAADFBMVEX////pgJFyEhJNv8RV\nUZDeAAAAAWJLR0QAiAUdSAAAAAd0SU1FB+AFDgw7IYtuT2MAAAWFSURBVGje7Zs7cttADIZ9CSvX\ncrP0iCxUqbBc8Ag6xR6BhV2EvYvwFD4CCx1ABT1jMdgndpegRQnOrCbjpPlGESISC4A/gd27e8H5\n83CX3b4+iKJrRHkS4vkghMPBonRYWGwtfgD2YN+dRDUOoh6lACw0Noi9w2fESuEoAR/uVuMolX03\n9oXGT7F3eFL2iEfhUX1f4cPdL/ishs+68ai+udE4xPhexbjX2FfjGNoPj/DPNX4Tsd+EODr8FvsV\ndf1Hd9P2VvCi4+s/aXvrf+upAD+1/9GV1mkOH5X9vV6THtfvACslcaUCbESL61drBPtdI8SrFMWr\nELsXCkuFDYW75gbiP7d9Cf7bAYI/aCwUShrBvh30+lWQkzVgZ/HD4OixNCgcQpJ3BxU/Ln91elKo\nM5VEE38QtJ+Yv6cQ9xjKNYayyl8TypP8DfJnQ2H/b/N3ye9P83cT33SQv/sQh9gV7zZ/0dNj5HQa\nC5vVzv9+/WFN2w8KVaZ2BwL1+pv4g0x1QRfjq0dB4Q3kT277oP6VNL6gKxNU9a8zK+WLbi/Wwpdi\nhbboKqyxFOulHMj6v4W/AXbmUeAxrv9J/CqEBXaRKsXaodD4nsYvkT/G6H1D4SR/iPy1Roj9JsQ5\ne18/7EUHv1+Fvx/Xj5V9Ugb5K8TW4TZEEdcvoz/up0VTe9qsVIppKVX6a7D6y9ZvwEKjrtQxPtv6\nfXII9vCxKOGaIeAIfEF8IvAG8ie3vRK9rRQl+PPpSctbhfpTUCpviH+kxsZgpT91+snoX1l49KK3\niUQvICRy5aUw6l8leoVwoo3Uv1rKreF/UFLY6d9QP4L9Wf2r7EP9GOSfcsjZ56f60kz+XmVPXv+R\nuP49ff0T/53Rv6n/7m2lvXT9Wqd/VUz8hvh5M/ED6ILmt4mfHYZSaePnTWpsf/SvqV9O6dLYYClL\nEetnoH/LBLFoBvrX189uTv8++kot5vTvQD4/9jP690g9P/4z/bvo/XVG/xYoZZx+8fr3MxAtsf7t\nUOkG2JqsTtCIpgCt/qX1226KqZS7gfzJbe+c9jLrtIZ8lXD+s4umlW6AKIVrlML2/cXjgPFjlJqI\nRC+Fj0bVJe+vSh56pSdR6YkQ1ygF10Wqf0FeLta/iKn9Mv1L24ti2e+7W4n1b3T/W+L+t9H9T/Sv\nVboUmqJJon1/hZq8LnzRDlDrX1u0xRT1+6vEpomMmyYkqi95vIH8yW1PN+122KkLcNLKi/WTF01z\n/cNASrWE/l3ev6T17zX909z9X27/euK/Rf3zWP+Waf9eEv37KkWJ+rfDl6ZglNDa+cEBhwYDvkoN\nP/rX69814NaI3imq0l7OYDy/qSdDGwr7r+Y3VbzoKZr6XX2lfxfOb87qXzr+b1j/Xlp/nP6dn98M\ncdH7cn7zjPObKsYWS3Eb9w8n85smHtqQuPuZ30T2dlIT6F9xFl+n8xslegL9a4c2KRr9W4rp/GYq\numiM9Nec/j2v/yj9u1h//hv9e93vc++f63/u+rPjL3f+5Lbn1j9m/eXWf+7zh/v8+2b9e/Hzn6s/\nuPqHrb8g71n6L3f+5Lbnvn8w33+4718/+5d47//c/gO7/5E7/nPbc/tv3P4fs//I7X9y+6/fqH+v\n6j9z+9/c/ju3/8+eP+TOn9z23PkXc/7Gnf9x5483q38Xzn+582fu/Js9fy8kb/6fO39y23P3n3S8\n/S/c/Tfc/T83uX/pgv1XE/9duP+Lu/+Mvf8td/znti8kb/8ld/9nx9t/Sjw/Ltr/yt1/+337f6/b\nf0zoB3nJ/ucVc/81d/83e/957vzJbc89/8A8f8E9/5HE78XnT/4H/cs5f8Q9/8Q9f8U+/5U7f3Lb\nc88fdrzzjyvm+cuf/Uu887/c88fs88954/8vO4SjPC+2QRIAAAAldEVYdGRhdGU6Y3JlYXRlADIw\nMTYtMDUtMTRUMTI6NTk6MzMtMDQ6MDDz2LWwAAAAJXRFWHRkYXRlOm1vZGlmeQAyMDE2LTA1LTE0\nVDEyOjU5OjMzLTA0OjAwgoUNDAAAAABJRU5ErkJggg==\n", "text/plain": [ "" ] @@ -637,7 +637,7 @@ "outputs": [], "source": [ "# Instantiate a tally Mesh\n", - "mesh = openmc.Mesh(mesh_id=1)\n", + "mesh = openmc.Mesh()\n", "mesh.type = 'regular'\n", "mesh.dimension = [17, 17]\n", "mesh.lower_left = [-10.71, -10.71]\n", @@ -696,7 +696,7 @@ " License: http://openmc.readthedocs.org/en/latest/license.html\n", " Version: 0.7.1\n", " Git SHA1: c779ca42c41a062a6a813e03f2add2d182ca9190\n", - " Date/Time: 2016-05-14 07:56:31\n", + " Date/Time: 2016-05-14 12:59:34\n", " OpenMP Threads: 4\n", "\n", " ===========================================================================\n", @@ -783,20 +783,20 @@ "\n", " =======================> TIMING STATISTICS <=======================\n", "\n", - " Total time for initialization = 1.4930E+00 seconds\n", - " Reading cross sections = 1.1850E+00 seconds\n", - " Total time in simulation = 1.9053E+01 seconds\n", - " Time in transport only = 1.9002E+01 seconds\n", - " Time in inactive batches = 2.0890E+00 seconds\n", - " Time in active batches = 1.6964E+01 seconds\n", - " Time synchronizing fission bank = 6.0000E-03 seconds\n", - " Sampling source sites = 5.0000E-03 seconds\n", + " Total time for initialization = 1.4720E+00 seconds\n", + " Reading cross sections = 1.1730E+00 seconds\n", + " Total time in simulation = 1.9211E+01 seconds\n", + " Time in transport only = 1.9108E+01 seconds\n", + " Time in inactive batches = 2.1390E+00 seconds\n", + " Time in active batches = 1.7072E+01 seconds\n", + " Time synchronizing fission bank = 1.0000E-02 seconds\n", + " Sampling source sites = 9.0000E-03 seconds\n", " SEND/RECV source sites = 1.0000E-03 seconds\n", " Time accumulating tallies = 0.0000E+00 seconds\n", " Total time for finalization = 0.0000E+00 seconds\n", - " Total time elapsed = 2.0556E+01 seconds\n", - " Calculation Rate (inactive) = 23934.9 neutrons/second\n", - " Calculation Rate (active) = 11789.7 neutrons/second\n", + " Total time elapsed = 2.0692E+01 seconds\n", + " Calculation Rate (inactive) = 23375.4 neutrons/second\n", + " Calculation Rate (active) = 11715.1 neutrons/second\n", "\n", " ============================> RESULTS <============================\n", "\n", @@ -950,7 +950,7 @@ "source": [ "# Create a MGXS File which can then be written to disk\n", "mgxs_file = mgxs_lib.create_mg_library(xs_type='macro', domain_names=['fuel', 'zircaloy', 'water'],\n", - " xs_ids='2m')\n", + " xs_ids='2m')\n", "\n", "# Write the file to disk using the default filename of `mgxs.xml`\n", "mgxs_file.export_to_xml()" @@ -983,15 +983,15 @@ "# Now re-define our materials to use the Multi-Group macroscopic data\n", "# instead of the continuous-energy data.\n", "# 1.6 enriched fuel UO2\n", - "fuel = openmc.Material(name='UO2', material_id=1)\n", + "fuel = openmc.Material(name='UO2')\n", "fuel.add_macroscopic(fuel_macro)\n", "\n", "# cladding\n", - "zircaloy = openmc.Material(name='Clad', material_id=2)\n", + "zircaloy = openmc.Material(name='Clad')\n", "zircaloy.add_macroscopic(zircaloy_macro)\n", "\n", "# moderator\n", - "water = openmc.Material(name='Water', material_id=3)\n", + "water = openmc.Material(name='Water')\n", "water.add_macroscopic(water_macro)\n", "\n", "# Finally, instantiate our Materials object\n", @@ -1071,7 +1071,7 @@ " License: http://openmc.readthedocs.org/en/latest/license.html\n", " Version: 0.7.1\n", " Git SHA1: c779ca42c41a062a6a813e03f2add2d182ca9190\n", - " Date/Time: 2016-05-14 07:56:52\n", + " Date/Time: 2016-05-14 12:59:55\n", " OpenMP Threads: 4\n", "\n", " ===========================================================================\n", @@ -1156,19 +1156,19 @@ " =======================> TIMING STATISTICS <=======================\n", "\n", " Total time for initialization = 4.0000E-02 seconds\n", - " Reading cross sections = 6.0000E-03 seconds\n", - " Total time in simulation = 1.2540E+01 seconds\n", - " Time in transport only = 1.2496E+01 seconds\n", - " Time in inactive batches = 1.1110E+00 seconds\n", - " Time in active batches = 1.1429E+01 seconds\n", - " Time synchronizing fission bank = 7.0000E-03 seconds\n", - " Sampling source sites = 5.0000E-03 seconds\n", - " SEND/RECV source sites = 2.0000E-03 seconds\n", + " Reading cross sections = 3.0000E-03 seconds\n", + " Total time in simulation = 1.3223E+01 seconds\n", + " Time in transport only = 1.3175E+01 seconds\n", + " Time in inactive batches = 1.1160E+00 seconds\n", + " Time in active batches = 1.2107E+01 seconds\n", + " Time synchronizing fission bank = 9.0000E-03 seconds\n", + " Sampling source sites = 8.0000E-03 seconds\n", + " SEND/RECV source sites = 1.0000E-03 seconds\n", " Time accumulating tallies = 0.0000E+00 seconds\n", " Total time for finalization = 0.0000E+00 seconds\n", - " Total time elapsed = 1.2589E+01 seconds\n", - " Calculation Rate (inactive) = 45004.5 neutrons/second\n", - " Calculation Rate (active) = 17499.3 neutrons/second\n", + " Total time elapsed = 1.3272E+01 seconds\n", + " Calculation Rate (inactive) = 44802.9 neutrons/second\n", + " Calculation Rate (active) = 16519.4 neutrons/second\n", "\n", " ============================> RESULTS <============================\n", "\n", @@ -1355,7 +1355,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 40, @@ -1366,7 +1366,7 @@ "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAADDCAYAAACS2+oqAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nhMgJCuhCCJETFNCFECInKKALIURO+H/MOIwTGD7mCAAAAABJRU5ErkJggg==\n", "text/plain": [ - "" + "" ] }, "metadata": {}, From 071e8d3e305532b9e53f747af6ac533ed01fc17d Mon Sep 17 00:00:00 2001 From: Adam Nelson Date: Sun, 15 May 2016 14:26:54 -0400 Subject: [PATCH 16/20] Forgot universe_id=0 for root in example nb (fixed), resolved comments from @paulromano, and made sure the example problem worked still (it did, but I simplified it a bit since data doesnt need to be numpy arrays anymore. --- .../pythonapi/examples/mgxs-part-iv.ipynb | 72 ++++++------ docs/source/usersguide/mgxs_library.rst | 6 +- .../python/pincell_multigroup/build-xml.py | 71 ++++++------ openmc/mgxs/library.py | 46 +++++--- openmc/mgxs/mgxs.py | 2 +- openmc/mgxs_library.py | 108 ++++++++++++------ 6 files changed, 172 insertions(+), 133 deletions(-) diff --git a/docs/source/pythonapi/examples/mgxs-part-iv.ipynb b/docs/source/pythonapi/examples/mgxs-part-iv.ipynb index d15f265d4c..4509f0fc83 100644 --- a/docs/source/pythonapi/examples/mgxs-part-iv.ipynb +++ b/docs/source/pythonapi/examples/mgxs-part-iv.ipynb @@ -304,7 +304,7 @@ "root_cell.region = +min_x & -max_x & +min_y & -max_y & +min_z & -max_z\n", "\n", "# Create root Universe\n", - "root_universe = openmc.Universe(name='root universe')\n", + "root_universe = openmc.Universe(name='root universe', universe_id=0)\n", "root_universe.add_cell(root_cell)" ] }, @@ -319,7 +319,7 @@ "cell_type": "code", "execution_count": 11, "metadata": { - "collapsed": true + "collapsed": false }, "outputs": [], "source": [ @@ -433,7 +433,7 @@ "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAPoAAAD6AgMAAAD1grKuAAAABGdBTUEAALGPC/xhBQAAACBjSFJN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\nVDEyOjU5OjMzLTA0OjAwgoUNDAAAAABJRU5ErkJggg==\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAPoAAAD6AgMAAAD1grKuAAAABGdBTUEAALGPC/xhBQAAACBjSFJN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\nVDE0OjIyOjM0LTA0OjAwmHSTugAAAABJRU5ErkJggg==\n", "text/plain": [ "" ] @@ -693,10 +693,10 @@ " 888\n", "\n", " Copyright: 2011-2016 Massachusetts Institute of Technology\n", - " License: http://openmc.readthedocs.org/en/latest/license.html\n", + " License: http://openmc.readthedocs.io/en/latest/license.html\n", " Version: 0.7.1\n", - " Git SHA1: c779ca42c41a062a6a813e03f2add2d182ca9190\n", - " Date/Time: 2016-05-14 12:59:34\n", + " Git SHA1: 4bec584ddb7d07be7d92ad9d037e8363b2f25614\n", + " Date/Time: 2016-05-15 14:22:34\n", " OpenMP Threads: 4\n", "\n", " ===========================================================================\n", @@ -783,20 +783,20 @@ "\n", " =======================> TIMING STATISTICS <=======================\n", "\n", - " Total time for initialization = 1.4720E+00 seconds\n", - " Reading cross sections = 1.1730E+00 seconds\n", - " Total time in simulation = 1.9211E+01 seconds\n", - " Time in transport only = 1.9108E+01 seconds\n", - " Time in inactive batches = 2.1390E+00 seconds\n", - " Time in active batches = 1.7072E+01 seconds\n", - " Time synchronizing fission bank = 1.0000E-02 seconds\n", - " Sampling source sites = 9.0000E-03 seconds\n", - " SEND/RECV source sites = 1.0000E-03 seconds\n", + " Total time for initialization = 1.4620E+00 seconds\n", + " Reading cross sections = 1.1520E+00 seconds\n", + " Total time in simulation = 2.1015E+01 seconds\n", + " Time in transport only = 2.0844E+01 seconds\n", + " Time in inactive batches = 2.2260E+00 seconds\n", + " Time in active batches = 1.8789E+01 seconds\n", + " Time synchronizing fission bank = 9.0000E-03 seconds\n", + " Sampling source sites = 5.0000E-03 seconds\n", + " SEND/RECV source sites = 4.0000E-03 seconds\n", " Time accumulating tallies = 0.0000E+00 seconds\n", " Total time for finalization = 0.0000E+00 seconds\n", - " Total time elapsed = 2.0692E+01 seconds\n", - " Calculation Rate (inactive) = 23375.4 neutrons/second\n", - " Calculation Rate (active) = 11715.1 neutrons/second\n", + " Total time elapsed = 2.2491E+01 seconds\n", + " Calculation Rate (inactive) = 22461.8 neutrons/second\n", + " Calculation Rate (active) = 10644.5 neutrons/second\n", "\n", " ============================> RESULTS <============================\n", "\n", @@ -949,7 +949,7 @@ ], "source": [ "# Create a MGXS File which can then be written to disk\n", - "mgxs_file = mgxs_lib.create_mg_library(xs_type='macro', domain_names=['fuel', 'zircaloy', 'water'],\n", + "mgxs_file = mgxs_lib.create_mg_library(xs_type='macro', xsdata_names=['fuel', 'zircaloy', 'water'],\n", " xs_ids='2m')\n", "\n", "# Write the file to disk using the default filename of `mgxs.xml`\n", @@ -1068,10 +1068,10 @@ " 888\n", "\n", " Copyright: 2011-2016 Massachusetts Institute of Technology\n", - " License: http://openmc.readthedocs.org/en/latest/license.html\n", + " License: http://openmc.readthedocs.io/en/latest/license.html\n", " Version: 0.7.1\n", - " Git SHA1: c779ca42c41a062a6a813e03f2add2d182ca9190\n", - " Date/Time: 2016-05-14 12:59:55\n", + " Git SHA1: 4bec584ddb7d07be7d92ad9d037e8363b2f25614\n", + " Date/Time: 2016-05-15 14:22:57\n", " OpenMP Threads: 4\n", "\n", " ===========================================================================\n", @@ -1155,20 +1155,20 @@ "\n", " =======================> TIMING STATISTICS <=======================\n", "\n", - " Total time for initialization = 4.0000E-02 seconds\n", + " Total time for initialization = 3.5000E-02 seconds\n", " Reading cross sections = 3.0000E-03 seconds\n", - " Total time in simulation = 1.3223E+01 seconds\n", - " Time in transport only = 1.3175E+01 seconds\n", - " Time in inactive batches = 1.1160E+00 seconds\n", - " Time in active batches = 1.2107E+01 seconds\n", - " Time synchronizing fission bank = 9.0000E-03 seconds\n", - " Sampling source sites = 8.0000E-03 seconds\n", + " Total time in simulation = 1.2599E+01 seconds\n", + " Time in transport only = 1.2565E+01 seconds\n", + " Time in inactive batches = 1.1220E+00 seconds\n", + " Time in active batches = 1.1477E+01 seconds\n", + " Time synchronizing fission bank = 6.0000E-03 seconds\n", + " Sampling source sites = 5.0000E-03 seconds\n", " SEND/RECV source sites = 1.0000E-03 seconds\n", - " Time accumulating tallies = 0.0000E+00 seconds\n", - " Total time for finalization = 0.0000E+00 seconds\n", - " Total time elapsed = 1.3272E+01 seconds\n", - " Calculation Rate (inactive) = 44802.9 neutrons/second\n", - " Calculation Rate (active) = 16519.4 neutrons/second\n", + " Time accumulating tallies = 1.0000E-03 seconds\n", + " Total time for finalization = 1.0000E-03 seconds\n", + " Total time elapsed = 1.2644E+01 seconds\n", + " Calculation Rate (inactive) = 44563.3 neutrons/second\n", + " Calculation Rate (active) = 17426.2 neutrons/second\n", "\n", " ============================> RESULTS <============================\n", "\n", @@ -1355,7 +1355,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 40, @@ -1366,7 +1366,7 @@ "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAADDCAYAAACS2+oqAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nhMgJCuhCCJETFNCFECInKKALIURO+H/MOIwTGD7mCAAAAABJRU5ErkJggg==\n", "text/plain": [ - "" + "" ] }, "metadata": {}, diff --git a/docs/source/usersguide/mgxs_library.rst b/docs/source/usersguide/mgxs_library.rst index 8628bef4e0..98a9e84859 100644 --- a/docs/source/usersguide/mgxs_library.rst +++ b/docs/source/usersguide/mgxs_library.rst @@ -22,9 +22,9 @@ materials. .. _XML: http://www.w3.org/XML/ ------------------------------------------------- +-------------------------------------- MGXS Library Specification -- mgxs.xml ------------------------------------------------- +-------------------------------------- The multi-group library meta-data is contained within the groups_, group_structure_, and inverse_velocities_ elements. @@ -33,7 +33,7 @@ The actual multi-group data itself is contained within the xsdata_ element. .. _groups: ```` Element ----------------------------------- +-------------------- The ```` element has no attributes and simply provides the number of energy groups contained within the library. diff --git a/examples/python/pincell_multigroup/build-xml.py b/examples/python/pincell_multigroup/build-xml.py index c7d6dfc8be..5ac5b376a3 100644 --- a/examples/python/pincell_multigroup/build-xml.py +++ b/examples/python/pincell_multigroup/build-xml.py @@ -1,4 +1,3 @@ -import numpy as np import openmc import openmc.mgxs @@ -12,7 +11,7 @@ inactive = 10 particles = 1000 ############################################################################### -# Exporting to OpenMC mg_cross_sections.xml file +# Exporting to OpenMC mgxs.xml file ############################################################################### # Instantiate the energy group data @@ -22,45 +21,43 @@ groups = openmc.mgxs.EnergyGroups(group_edges=[1E-11, 0.0635E-6, 10.0E-6, # Instantiate the 7-group (C5G7) cross section data uo2_xsdata = openmc.XSdata('UO2.300K', groups) uo2_xsdata.order = 0 -uo2_xsdata.total = np.array([0.1779492, 0.3298048, 0.4803882, 0.5543674, - 0.3118013, 0.3951678, 0.5644058]) -uo2_xsdata.absorption = np.array([8.0248E-03, 3.7174E-03, 2.6769E-02, 9.6236E-02, - 3.0020E-02, 1.1126E-01, 2.8278E-01]) -scatter = [[[0.1275370, 0.0423780, 0.0000094, 0.0000000, 0.0000000, 0.0000000, 0.0000000], - [0.0000000, 0.3244560, 0.0016314, 0.0000000, 0.0000000, 0.0000000, 0.0000000], - [0.0000000, 0.0000000, 0.4509400, 0.0026792, 0.0000000, 0.0000000, 0.0000000], - [0.0000000, 0.0000000, 0.0000000, 0.4525650, 0.0055664, 0.0000000, 0.0000000], - [0.0000000, 0.0000000, 0.0000000, 0.0001253, 0.2714010, 0.0102550, 0.0000000], - [0.0000000, 0.0000000, 0.0000000, 0.0000000, 0.0012968, 0.2658020, 0.0168090], - [0.0000000, 0.0000000, 0.0000000, 0.0000000, 0.0000000, 0.0085458, 0.2730800]]] -uo2_xsdata.scatter = np.array(scatter[:][:]) -uo2_xsdata.fission = np.array([7.21206E-03, 8.19301E-04, 6.45320E-03, - 1.85648E-02, 1.78084E-02, 8.30348E-02, - 2.16004E-01]) -uo2_xsdata.nu_fission = np.array([2.005998E-02, 2.027303E-03, 1.570599E-02, - 4.518301E-02, 4.334208E-02, 2.020901E-01, - 5.257105E-01]) -uo2_xsdata.chi = np.array([5.8791E-01, 4.1176E-01, 3.3906E-04, 1.1761E-07, - 0.0000E+00, 0.0000E+00, 0.0000E+00]) +uo2_xsdata.total = [0.1779492, 0.3298048, 0.4803882, 0.5543674, + 0.3118013, 0.3951678, 0.5644058] +uo2_xsdata.absorption = [8.0248E-03, 3.7174E-03, 2.6769E-02, 9.6236E-02, + 3.0020E-02, 1.1126E-01, 2.8278E-01] +uo2_xsdata.scatter = [[[0.1275370, 0.0423780, 0.0000094, 0.0000000, 0.0000000, 0.0000000, 0.0000000], + [0.0000000, 0.3244560, 0.0016314, 0.0000000, 0.0000000, 0.0000000, 0.0000000], + [0.0000000, 0.0000000, 0.4509400, 0.0026792, 0.0000000, 0.0000000, 0.0000000], + [0.0000000, 0.0000000, 0.0000000, 0.4525650, 0.0055664, 0.0000000, 0.0000000], + [0.0000000, 0.0000000, 0.0000000, 0.0001253, 0.2714010, 0.0102550, 0.0000000], + [0.0000000, 0.0000000, 0.0000000, 0.0000000, 0.0012968, 0.2658020, 0.0168090], + [0.0000000, 0.0000000, 0.0000000, 0.0000000, 0.0000000, 0.0085458, 0.2730800]]] +uo2_xsdata.fission = [7.21206E-03, 8.19301E-04, 6.45320E-03, + 1.85648E-02, 1.78084E-02, 8.30348E-02, + 2.16004E-01] +uo2_xsdata.nu_fission = [2.005998E-02, 2.027303E-03, 1.570599E-02, + 4.518301E-02, 4.334208E-02, 2.020901E-01, + 5.257105E-01] +uo2_xsdata.chi = [5.8791E-01, 4.1176E-01, 3.3906E-04, 1.1761E-07, + 0.0000E+00, 0.0000E+00, 0.0000E+00] h2o_xsdata = openmc.XSdata('LWTR.300K', groups) h2o_xsdata.order = 0 -h2o_xsdata.total = np.array([0.15920605, 0.412969593, 0.59030986, 0.58435, - 0.718, 1.2544497, 2.650379]) -h2o_xsdata.absorption = np.array([6.0105E-04, 1.5793E-05, 3.3716E-04, - 1.9406E-03, 5.7416E-03, 1.5001E-02, - 3.7239E-02]) -scatter = [[[0.0444777, 0.1134000, 0.0007235, 0.0000037, 0.0000001, 0.0000000, 0.0000000], - [0.0000000, 0.2823340, 0.1299400, 0.0006234, 0.0000480, 0.0000074, 0.0000010], - [0.0000000, 0.0000000, 0.3452560, 0.2245700, 0.0169990, 0.0026443, 0.0005034], - [0.0000000, 0.0000000, 0.0000000, 0.0910284, 0.4155100, 0.0637320, 0.0121390], - [0.0000000, 0.0000000, 0.0000000, 0.0000714, 0.1391380, 0.5118200, 0.0612290], - [0.0000000, 0.0000000, 0.0000000, 0.0000000, 0.0022157, 0.6999130, 0.5373200], - [0.0000000, 0.0000000, 0.0000000, 0.0000000, 0.0000000, 0.1324400, 2.4807000]]] -h2o_xsdata.scatter = np.array(scatter) +h2o_xsdata.total = [0.15920605, 0.412969593, 0.59030986, 0.58435, + 0.718, 1.2544497, 2.650379] +h2o_xsdata.absorption = [6.0105E-04, 1.5793E-05, 3.3716E-04, + 1.9406E-03, 5.7416E-03, 1.5001E-02, + 3.7239E-02] +h2o_xsdata.scatter = [[[0.0444777, 0.1134000, 0.0007235, 0.0000037, 0.0000001, 0.0000000, 0.0000000], + [0.0000000, 0.2823340, 0.1299400, 0.0006234, 0.0000480, 0.0000074, 0.0000010], + [0.0000000, 0.0000000, 0.3452560, 0.2245700, 0.0169990, 0.0026443, 0.0005034], + [0.0000000, 0.0000000, 0.0000000, 0.0910284, 0.4155100, 0.0637320, 0.0121390], + [0.0000000, 0.0000000, 0.0000000, 0.0000714, 0.1391380, 0.5118200, 0.0612290], + [0.0000000, 0.0000000, 0.0000000, 0.0000000, 0.0022157, 0.6999130, 0.5373200], + [0.0000000, 0.0000000, 0.0000000, 0.0000000, 0.0000000, 0.1324400, 2.4807000]]] mg_cross_sections_file = openmc.MGXSLibrary(groups) -mg_cross_sections_file.add_xsdatas([uo2_xsdata,h2o_xsdata]) +mg_cross_sections_file.add_xsdatas([uo2_xsdata, h2o_xsdata]) mg_cross_sections_file.export_to_xml() @@ -134,7 +131,7 @@ geometry.export_to_xml() # Instantiate a Settings object, set all runtime parameters, and export to XML settings_file = openmc.Settings() settings_file.energy_mode = "multi-group" -settings_file.cross_sections = "./mg_cross_sections.xml" +settings_file.cross_sections = "./mgxs.xml" settings_file.batches = batches settings_file.inactive = inactive settings_file.particles = particles diff --git a/openmc/mgxs/library.py b/openmc/mgxs/library.py index 44746e209d..586302a4b5 100644 --- a/openmc/mgxs/library.py +++ b/openmc/mgxs/library.py @@ -247,8 +247,7 @@ class Library(object): @domain_type.setter def domain_type(self, domain_type): - cv.check_value('domain type', domain_type, - tuple(openmc.mgxs.DOMAIN_TYPES)) + cv.check_value('domain type', domain_type, openmc.mgxs.DOMAIN_TYPES) self._domain_type = domain_type @domains.setter @@ -722,8 +721,8 @@ class Library(object): # Load and return pickled Library object return pickle.load(open(full_filename, 'rb')) - def get_xsdata(self, domain, domain_name, nuclide='total', xs_type='macro', - xs_id='1m', order=-1): + def get_xsdata(self, domain, xsdata_name, nuclide='total', xs_type='macro', + xs_id='1m', order=None): """Generates an openmc.XSdata object describing a multi-group cross section data set for eventual combination in to an openmc.MGXSLibrary object (i.e., the library). @@ -732,7 +731,7 @@ class Library(object): ---------- domain : openmc.Material or openmc.Cell or openmc.Universe The domain for spatial homogenization - domain_name : str + xsdata_name : str Name to apply to the "xsdata" entry produced by this method nuclide : str A nuclide name string (e.g., 'U-235'). Defaults to 'total' to @@ -743,7 +742,7 @@ class Library(object): nuclide this will be set to 'macro' regardless. xs_ids : str Cross section set identifier. Defaults to '1m'. - order : Scattering order for this dataset entry. Default is -1, + order : Scattering order for this dataset entry. Default is None, which will force the XSdata object to use whatever the maximum order available. @@ -766,11 +765,11 @@ class Library(object): cv.check_type('domain', domain, (openmc.Material, openmc.Cell, openmc.Cell)) - cv.check_type('domain_name', domain_name, basestring) + cv.check_type('xsdata_name', xsdata_name, basestring) cv.check_type('nuclide', nuclide, basestring) cv.check_value('xs_type', xs_type, ['macro', 'micro']) cv.check_type('xs_id', xs_id, basestring) - cv.check_type('order', order, Integral) + cv.check_type('order', order, (type(None), Integral)) cv.check_greater_than('order', order, -1, equality=True) # Make sure statepoint has been loaded @@ -784,12 +783,18 @@ class Library(object): xs_type = 'macro' # Build & add metadata to XSdata object - name = domain_name + name = xsdata_name if nuclide is not 'total': name += '_' + nuclide name += '.' + xs_id xsdata = openmc.XSdata(name, self.energy_groups) - xsdata.order = order + if order is 0: + xsdata.order = order + else: + msg = 'Generating anisotropic scattering from openmc.Library' \ + 'objects has not yet been implemented.' + raise NotImplementedError(msg) + if nuclide is not 'total': xsdata.zaid = self._nuclides[nuclide][0] xsdata.awr = self._nuclides[nuclide][1] @@ -852,7 +857,7 @@ class Library(object): return xsdata - def create_mg_library(self, xs_type='macro', domain_names=None, + def create_mg_library(self, xs_type='macro', xsdata_names=None, xs_ids=None): """Creates an openmc.MGXSLibrary object to contain the MGXS data for the Multi-Group mode of OpenMC. @@ -863,7 +868,7 @@ class Library(object): Provide the macro or micro cross section in units of cm^-1 or barns. Defaults to 'macro'. If the Library object is not tallied by nuclide this will be set to 'macro' regardless. - domain_names : Iterable of str + xsdata_names : Iterable of str List of names to apply to the "xsdata" entries in the resultant mgxs data file. Defaults to 'set1', 'set2', ... xs_ids : str or Iterable of str @@ -894,8 +899,8 @@ class Library(object): self.check_library_for_openmc_mgxs() cv.check_value('xs_type', xs_type, ['macro', 'micro']) - if domain_names is not None: - cv.check_iterable_type('domain_names', domain_names, basestring) + if xsdata_names is not None: + cv.check_iterable_type('xsdata_names', xsdata_names, basestring) if xs_ids is not None: if isinstance(xs_ids, basestring): # If we only have a string lets convert it now to a list @@ -927,14 +932,14 @@ class Library(object): nuclides = ['total'] for nuclide in nuclides: # Build & add metadata to XSdata object - if domain_names is None: - name = 'set' + str(i + 1) + if xsdata_names is None: + xsdata_name = 'set' + str(i + 1) else: - name = domain_names[i] + xsdata_name = xsdata_names[i] if nuclide is not 'total': - name += '_' + nuclide + xsdata_name += '_' + nuclide - xsdata = self.get_xsdata(domain, name, nuclide=nuclide, + xsdata = self.get_xsdata(domain, xsdata_name, nuclide=nuclide, xs_type=xs_type, xs_id=xs_ids[i], order=order) @@ -952,14 +957,17 @@ class Library(object): The rules to check include: - Either total or transport should be present. + - Both can be available if one wants, but we should use whatever corresponds to Library.correction (if P0: transport) + - Absorption and total (or transport) are required. - A nu-fission cross section and chi values are not required as a fixed source problem could be the target. - Fission and kappa-fission are not required as they are only needed to support tallies the user may wish to request. - A nu-scatter matrix is required. + - Having both nu-scatter (of any order) and scatter (at least isotropic) matrices is preferred - If only nu-scatter, need total (not transport), to diff --git a/openmc/mgxs/mgxs.py b/openmc/mgxs/mgxs.py index f8a712f683..7cfec2f54c 100644 --- a/openmc/mgxs/mgxs.py +++ b/openmc/mgxs/mgxs.py @@ -283,7 +283,7 @@ class MGXS(object): @domain_type.setter def domain_type(self, domain_type): - cv.check_value('domain type', domain_type, tuple(DOMAIN_TYPES)) + cv.check_value('domain type', domain_type, DOMAIN_TYPES) self._domain_type = domain_type @energy_groups.setter diff --git a/openmc/mgxs_library.py b/openmc/mgxs_library.py index e59ef2d61d..b7c61595ff 100644 --- a/openmc/mgxs_library.py +++ b/openmc/mgxs_library.py @@ -346,6 +346,16 @@ class XSdata(object): self.energy_groups.num_groups, self.energy_groups.num_groups) + @property + def pn_matrix_shape(self): + if self.representation is 'isotropic': + return (self.num_orders, self.energy_groups.num_groups, + self.energy_groups.num_groups) + elif self.representation is 'angle': + return (self.num_polar, self.num_azimuthal, self.num_orders, + self.energy_groups.num_groups, + self.energy_groups.num_groups) + @name.setter def name(self, name): check_type('name for XSdata', name, basestring) @@ -449,38 +459,49 @@ class XSdata(object): @total.setter def total(self, total): - check_type('total', total, np.ndarray, expected_iter_type=Real) - check_value('total shape', total.shape, self.vector_shape) + check_type('total', total, Iterable, expected_iter_type=Real) + # Convert to a numpy array so we can easily get the shape for + # checking + nptotal = np.array(total) + check_value('total shape', nptotal.shape, [self.vector_shape]) - self._total = total + self._total = nptotal @absorption.setter def absorption(self, absorption): - check_type('absorption', absorption, np.ndarray, - expected_iter_type=Real) - check_value('absorption shape', absorption.shape, self.vector_shape) + check_type('absorption', absorption, Iterable, expected_iter_type=Real) + # Convert to a numpy array so we can easily get the shape for + # checking + npabsorption = np.array(absorption) + check_value('absorption shape', npabsorption.shape, + [self.vector_shape]) - self._absorption = absorption + self._absorption = npabsorption @fission.setter def fission(self, fission): - check_type('fission', fission, np.ndarray, - expected_iter_type=Real) - check_value('fission shape', fission.shape, self.vector_shape) + check_type('fission', fission, Iterable, expected_iter_type=Real) + # Convert to a numpy array so we can easily get the shape for + # checking + npfission = np.array(fission) + check_value('fission shape', npfission.shape, [self.vector_shape]) - self._fission = fission + self._fission = npfission if np.sum(self._fission) > 0.0: self._fissionable = True @kappa_fission.setter def kappa_fission(self, kappa_fission): - check_type('kappa_fission', kappa_fission, np.ndarray, + check_type('kappa_fission', kappa_fission, Iterable, expected_iter_type=Real) - check_value('kappa fission shape', kappa_fission.shape, - self.vector_shape) + # Convert to a numpy array so we can easily get the shape for + # checking + npkappa_fission = np.array(kappa_fission) + check_value('kappa fission shape', npkappa_fission.shape, + [self.vector_shape]) - self._kappa_fission = kappa_fission + self._kappa_fission = npkappa_fission if np.sum(self._kappa_fission) > 0.0: self._fissionable = True @@ -493,30 +514,39 @@ class XSdata(object): 'matrix' raise ValueError(msg) - check_type('chi', chi, np.ndarray, expected_iter_type=Real) - check_value('chi shape', chi.shape, self.vector_shape) + check_type('chi', chi, Iterable, expected_iter_type=Real) + # Convert to a numpy array so we can easily get the shape for + # checking + npchi = np.array(chi) + check_value('chi shape', npchi.shape, [self.vector_shape]) - self._chi = chi + self._chi = npchi if self._use_chi is not None: self._use_chi = True @scatter.setter def scatter(self, scatter): - check_type('scatter', scatter, np.ndarray, expected_iter_type=Real, - max_depth=len(scatter.shape)) - check_value('scatter shape', scatter.shape, self.pn_matrix_shape) + # Convert to a numpy array so we can easily get the shape for + # checking + npscatter = np.array(scatter) + check_iterable_type('scatter', npscatter, Real, + max_depth=len(npscatter.shape)) + check_value('scatter shape', npscatter.shape, [self.pn_matrix_shape]) - self._scatter = scatter + self._scatter = npscatter @multiplicity.setter def multiplicity(self, multiplicity): - check_type('multiplicity', multiplicity, np.ndarray, - expected_iter_type=Real, max_depth=len(multiplicity.shape)) - check_value('multiplicity shape', multiplicity.shape, - self.matrix_shape) + # Convert to a numpy array so we can easily get the shape for + # checking + npmultiplicity = np.array(multiplicity) + check_iterable_type('multiplicity', npmultiplicity, Real, + max_depth=len(npmultiplicity.shape)) + check_value('multiplicity shape', npmultiplicity.shape, + [self.matrix_shape]) - self._multiplicity = multiplicity + self._multiplicity = npmultiplicity @nu_fission.setter def nu_fission(self, nu_fission): @@ -530,27 +560,31 @@ class XSdata(object): # chi already has been set. If not, we just check that this is OK # and set the use_chi flag accordingly - check_type('nu_fission', nu_fission, np.ndarray, - expected_iter_type=Real, max_depth=len(nu_fission.shape)) + # Convert to a numpy array so we can easily get the shape for + # checking + npnu_fission = np.array(nu_fission) + + check_iterable_type('nu_fission', npnu_fission, Real, + max_depth=len(npnu_fission.shape)) if self._use_chi is not None: if self._use_chi: - check_value('nu_fission shape', nu_fission.shape, - self.vector_shape) + check_value('nu_fission shape', npnu_fission.shape, + [self.vector_shape]) else: - check_value('nu_fission shape', nu_fission.shape, - self.matrix_shape) + check_value('nu_fission shape', npnu_fission.shape, + [self.matrix_shape]) else: - check_value('nu_fission shape', nu_fission.shape, - (self.vector_shape, self.matrix_shape)) + check_value('nu_fission shape', npnu_fission.shape, + [self.vector_shape, self.matrix_shape]) # Find out if we have a nu-fission matrix or vector # and set a flag to allow other methods to check this later. - if nu_fission.shape == self.vector_shape: + if npnu_fission.shape == self.vector_shape: self._use_chi = True else: self._use_chi = False - self._nu_fission = nu_fission + self._nu_fission = npnu_fission if np.sum(self._nu_fission) > 0.0: self._fissionable = True From 142033c2607f400fbd365bd79a8b2f1a07177b22 Mon Sep 17 00:00:00 2001 From: Adam Nelson Date: Sun, 15 May 2016 14:56:00 -0400 Subject: [PATCH 17/20] minor edits per @paulromano comments --- openmc/mgxs/library.py | 1 + openmc/mgxs_library.py | 24 ++++++++++++------------ 2 files changed, 13 insertions(+), 12 deletions(-) diff --git a/openmc/mgxs/library.py b/openmc/mgxs/library.py index 586302a4b5..45b502be48 100644 --- a/openmc/mgxs/library.py +++ b/openmc/mgxs/library.py @@ -956,6 +956,7 @@ class Library(object): a MGXS Library for OpenMC's Multi-Group mode. The rules to check include: + - Either total or transport should be present. - Both can be available if one wants, but we should diff --git a/openmc/mgxs_library.py b/openmc/mgxs_library.py index b7c61595ff..7a2c0e7b74 100644 --- a/openmc/mgxs_library.py +++ b/openmc/mgxs_library.py @@ -103,7 +103,7 @@ class XSdata(object): 1000*(atomic number) + mass number. As an example, the zaid of U-235 would be 92235. awr : float - Atomic-weight-ratio of an isotope. That is, the ratio of the mass + Atomic weight ratio of an isotope. That is, the ratio of the mass of the isotope to the mass of a single neutron. kT : float Temperature (in units of MeV). @@ -390,14 +390,14 @@ class XSdata(object): def zaid(self, zaid): # Check type and value check_type('zaid', zaid, Integral) - check_greater_than('zaid', zaid, 0, equality=False) + check_greater_than('zaid', zaid, 0) self._zaid = zaid @awr.setter def awr(self, awr): # Check validity of type and that the awr value is > 0 check_type('awr', awr, Real) - check_greater_than('awr', awr, 0.0, equality=False) + check_greater_than('awr', awr, 0.0) self._awr = awr @kT.setter @@ -462,7 +462,7 @@ class XSdata(object): check_type('total', total, Iterable, expected_iter_type=Real) # Convert to a numpy array so we can easily get the shape for # checking - nptotal = np.array(total) + nptotal = np.asarray(total) check_value('total shape', nptotal.shape, [self.vector_shape]) self._total = nptotal @@ -472,7 +472,7 @@ class XSdata(object): check_type('absorption', absorption, Iterable, expected_iter_type=Real) # Convert to a numpy array so we can easily get the shape for # checking - npabsorption = np.array(absorption) + npabsorption = np.asarray(absorption) check_value('absorption shape', npabsorption.shape, [self.vector_shape]) @@ -483,7 +483,7 @@ class XSdata(object): check_type('fission', fission, Iterable, expected_iter_type=Real) # Convert to a numpy array so we can easily get the shape for # checking - npfission = np.array(fission) + npfission = np.asarray(fission) check_value('fission shape', npfission.shape, [self.vector_shape]) self._fission = npfission @@ -497,7 +497,7 @@ class XSdata(object): expected_iter_type=Real) # Convert to a numpy array so we can easily get the shape for # checking - npkappa_fission = np.array(kappa_fission) + npkappa_fission = np.asarray(kappa_fission) check_value('kappa fission shape', npkappa_fission.shape, [self.vector_shape]) @@ -517,7 +517,7 @@ class XSdata(object): check_type('chi', chi, Iterable, expected_iter_type=Real) # Convert to a numpy array so we can easily get the shape for # checking - npchi = np.array(chi) + npchi = np.asarray(chi) check_value('chi shape', npchi.shape, [self.vector_shape]) self._chi = npchi @@ -529,7 +529,7 @@ class XSdata(object): def scatter(self, scatter): # Convert to a numpy array so we can easily get the shape for # checking - npscatter = np.array(scatter) + npscatter = np.asarray(scatter) check_iterable_type('scatter', npscatter, Real, max_depth=len(npscatter.shape)) check_value('scatter shape', npscatter.shape, [self.pn_matrix_shape]) @@ -540,7 +540,7 @@ class XSdata(object): def multiplicity(self, multiplicity): # Convert to a numpy array so we can easily get the shape for # checking - npmultiplicity = np.array(multiplicity) + npmultiplicity = np.asarray(multiplicity) check_iterable_type('multiplicity', npmultiplicity, Real, max_depth=len(npmultiplicity.shape)) check_value('multiplicity shape', npmultiplicity.shape, @@ -562,7 +562,7 @@ class XSdata(object): # Convert to a numpy array so we can easily get the shape for # checking - npnu_fission = np.array(nu_fission) + npnu_fission = np.asarray(nu_fission) check_iterable_type('nu_fission', npnu_fission, Real, max_depth=len(npnu_fission.shape)) @@ -595,7 +595,7 @@ class XSdata(object): Parameters ---------- - total: {openmc.mgxs.TotalXS, openmc.mgxs.TransportXS} + total: openmc.mgxs.TotalXS or openmc.mgxs.TransportXS MGXS Object containing the total or transport cross section for the domain of interest. nuclide : str From e13bd5c853b4251ef5ef8f46f0c1221fdde0442f Mon Sep 17 00:00:00 2001 From: Adam Nelson Date: Sun, 15 May 2016 19:13:22 -0400 Subject: [PATCH 18/20] Fixed per @paulromano comments --- openmc/mgxs/library.py | 18 +++++++--------- openmc/mgxs_library.py | 47 ++++++++++++++++++++++++++++++++++++++++-- src/summary.F90 | 2 +- 3 files changed, 53 insertions(+), 14 deletions(-) diff --git a/openmc/mgxs/library.py b/openmc/mgxs/library.py index 45b502be48..baa4d63047 100644 --- a/openmc/mgxs/library.py +++ b/openmc/mgxs/library.py @@ -4,9 +4,10 @@ import copy import pickle from numbers import Integral from collections import OrderedDict -import numpy as np from warnings import warn +import numpy as np + import openmc import openmc.mgxs import openmc.checkvalue as cv @@ -759,7 +760,7 @@ class Library(object): See also -------- - Library.create_mg_library(...) + Library.create_mg_library() """ @@ -890,7 +891,7 @@ class Library(object): See also -------- - Library.dump_to_file(mgxs_lib, filename, directory) + Library.dump_to_file() """ @@ -922,9 +923,7 @@ class Library(object): # support for higher orders are included in openmc.mgxs order = 0 - # Build storage for our XSdata objects - xsdatas = [] - + # Create the xsdata object and add it to the mgxs_file for i, domain in enumerate(self.domains): if self.by_nuclide: nuclides = list(domain.get_all_nuclides().keys()) @@ -943,10 +942,7 @@ class Library(object): xs_type=xs_type, xs_id=xs_ids[i], order=order) - xsdatas.append(xsdata) - - # Add XSdatas to file - mgxs_file.add_xsdatas(xsdatas) + mgxs_file.add_xsdata(xsdata) return mgxs_file @@ -977,7 +973,7 @@ class Library(object): See also -------- - Library.create_mg_library(...) + Library.create_mg_library() """ diff --git a/openmc/mgxs_library.py b/openmc/mgxs_library.py index 7a2c0e7b74..408175f43b 100644 --- a/openmc/mgxs_library.py +++ b/openmc/mgxs_library.py @@ -367,7 +367,7 @@ class XSdata(object): check_type('energy_groups', energy_groups, openmc.mgxs.EnergyGroups) if energy_group.group_edges is None: - msg = 'Unable to assign an EnergyGroups object ' + \ + msg = 'Unable to assign an EnergyGroups object ' \ 'with uninitialized group edges' raise ValueError(msg) self._energy_groups = energy_groups @@ -518,7 +518,10 @@ class XSdata(object): # Convert to a numpy array so we can easily get the shape for # checking npchi = np.asarray(chi) - check_value('chi shape', npchi.shape, [self.vector_shape]) + # Check the shape + if npchi.shape != self.vector_shape: + msg = 'Provided chi iterable does not have the expected shape.' + raise ValueError(msg) self._chi = npchi @@ -605,6 +608,11 @@ class XSdata(object): Provide the macro or micro cross section in units of cm^-1 or barns. Defaults to 'macro'. + See also + -------- + openmc.mgxs.Library.create_mg_library() + openmc.mgxs.Library.get_xsdata + """ check_type('total', total, (openmc.mgxs.TotalXS, @@ -636,6 +644,11 @@ class XSdata(object): Provide the macro or micro cross section in units of cm^-1 or barns. Defaults to 'macro'. + See also + -------- + openmc.mgxs.Library.create_mg_library() + openmc.mgxs.Library.get_xsdata + """ check_type('absorption', absorption, openmc.mgxs.AbsorptionXS) @@ -667,6 +680,11 @@ class XSdata(object): Provide the macro or micro cross section in units of cm^-1 or barns. Defaults to 'macro'. + See also + -------- + openmc.mgxs.Library.create_mg_library() + openmc.mgxs.Library.get_xsdata + """ check_type('fission', fission, openmc.mgxs.FissionXS) @@ -699,6 +717,11 @@ class XSdata(object): Provide the macro or micro cross section in units of cm^-1 or barns. Defaults to 'macro'. + See also + -------- + openmc.mgxs.Library.create_mg_library() + openmc.mgxs.Library.get_xsdata + """ # The NuFissionXS class does not have the capability to produce @@ -740,6 +763,11 @@ class XSdata(object): Provide the macro or micro cross section in units of cm^-1 or barns. Defaults to 'macro'. + See also + -------- + openmc.mgxs.Library.create_mg_library() + openmc.mgxs.Library.get_xsdata + """ check_type('k_fission', k_fission, openmc.mgxs.KappaFissionXS) @@ -770,6 +798,11 @@ class XSdata(object): Provide the macro or micro cross section in units of cm^-1 or barns. Defaults to 'macro'. + See also + -------- + openmc.mgxs.Library.create_mg_library() + openmc.mgxs.Library.get_xsdata + """ if self._use_chi is not None: @@ -810,6 +843,11 @@ class XSdata(object): Provide the macro or micro cross section in units of cm^-1 or barns. Defaults to 'macro'. + See also + -------- + openmc.mgxs.Library.create_mg_library() + openmc.mgxs.Library.get_xsdata + """ check_type('scatter', scatter, openmc.mgxs.ScatterMatrixXS) @@ -851,6 +889,11 @@ class XSdata(object): Provide the macro or micro cross section in units of cm^-1 or barns. Defaults to 'macro'. + See also + -------- + openmc.mgxs.Library.create_mg_library() + openmc.mgxs.Library.get_xsdata + """ check_type('nuscatter', nuscatter, openmc.mgxs.NuScatterMatrixXS) diff --git a/src/summary.F90 b/src/summary.F90 index 9defcc92fd..aabf6c22b2 100644 --- a/src/summary.F90 +++ b/src/summary.F90 @@ -118,7 +118,7 @@ contains real(8), allocatable :: awrs(:) integer, allocatable :: zaids(:) - ! Use H5LT interface to write useful data from nuclide objects + ! Write useful data from nuclide objects nuclide_group = create_group(file_id, "nuclides") call write_dataset(nuclide_group, "n_nuclides_total", n_nuclides_total) From 16886a41d95de450cbc0474833058601f17abc61 Mon Sep 17 00:00:00 2001 From: Adam Nelson Date: Tue, 17 May 2016 05:35:55 -0400 Subject: [PATCH 19/20] Incorporating Legendre scattering to Library and Mgxs_library modules (and example nbook). --- .../pythonapi/examples/mgxs-part-iv.ipynb | 258 ++++++++++-------- openmc/mgxs/library.py | 40 ++- openmc/mgxs_library.py | 42 ++- 3 files changed, 198 insertions(+), 142 deletions(-) diff --git a/docs/source/pythonapi/examples/mgxs-part-iv.ipynb b/docs/source/pythonapi/examples/mgxs-part-iv.ipynb index 4509f0fc83..e1d61cedcc 100644 --- a/docs/source/pythonapi/examples/mgxs-part-iv.ipynb +++ b/docs/source/pythonapi/examples/mgxs-part-iv.ipynb @@ -433,7 +433,7 @@ "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAPoAAAD6AgMAAAD1grKuAAAABGdBTUEAALGPC/xhBQAAACBjSFJN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\nVDE0OjIyOjM0LTA0OjAwmHSTugAAAABJRU5ErkJggg==\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAPoAAAD6AgMAAAD1grKuAAAABGdBTUEAALGPC/xhBQAAACBjSFJN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\nVDA1OjMyOjMzLTA0OjAwW2RvZAAAAABJRU5ErkJggg==\n", "text/plain": [ "" ] @@ -512,7 +512,7 @@ "outputs": [], "source": [ "# Specify multi-group cross section types to compute\n", - "mgxs_lib.mgxs_types = ['transport', 'absorption', 'nu-fission', 'fission',\n", + "mgxs_lib.mgxs_types = ['total', 'absorption', 'nu-fission', 'fission',\n", " 'nu-scatter matrix', 'scatter matrix', 'chi']" ] }, @@ -565,7 +565,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Now that the `Library` has been setup, lets make sure it contains the types of cross sections which meet the needs of OpenMC's multi-group solver. Note that this step is done automatically when writing the Multi-Group Library file later in the process (as part of the `mgxs_lib.write_mg_library()`), but it is a good practice to also run this before spending all the time running OpenMC to generate the cross sections." + "Now we will set the scattering order that we wish to use. For this problem we will use P3 scattering." ] }, { @@ -574,6 +574,34 @@ "metadata": { "collapsed": false }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/nelsonag/git/openmc/openmc/mgxs/library.py:320: RuntimeWarning: The P0 correction will be ignored since the scattering order 0 is greater than zero\n", + " warnings.warn(msg, RuntimeWarning)\n" + ] + } + ], + "source": [ + "# Set the Legendre order to 3 for P3 scattering\n", + "mgxs_lib.legendre_order = 3" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now that the `Library` has been setup, lets make sure it contains the types of cross sections which meet the needs of OpenMC's multi-group solver. Note that this step is done automatically when writing the Multi-Group Library file later in the process (as part of the `mgxs_lib.write_mg_library()`), but it is a good practice to also run this before spending all the time running OpenMC to generate the cross sections." + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": { + "collapsed": false + }, "outputs": [], "source": [ "# Check the library - if no errors are raised, then the library is satisfactory.\n", @@ -589,9 +617,9 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 23, "metadata": { - "collapsed": true + "collapsed": false }, "outputs": [], "source": [ @@ -610,7 +638,7 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 24, "metadata": { "collapsed": true }, @@ -630,7 +658,7 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 25, "metadata": { "collapsed": true }, @@ -658,7 +686,7 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 26, "metadata": { "collapsed": true }, @@ -670,7 +698,7 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 27, "metadata": { "collapsed": false }, @@ -695,8 +723,8 @@ " Copyright: 2011-2016 Massachusetts Institute of Technology\n", " License: http://openmc.readthedocs.io/en/latest/license.html\n", " Version: 0.7.1\n", - " Git SHA1: 4bec584ddb7d07be7d92ad9d037e8363b2f25614\n", - " Date/Time: 2016-05-15 14:22:34\n", + " Git SHA1: 058ba68895a2f880402fda3d58cfb14b162931d9\n", + " Date/Time: 2016-05-17 05:32:34\n", " OpenMP Threads: 4\n", "\n", " ===========================================================================\n", @@ -783,20 +811,20 @@ "\n", " =======================> TIMING STATISTICS <=======================\n", "\n", - " Total time for initialization = 1.4620E+00 seconds\n", - " Reading cross sections = 1.1520E+00 seconds\n", - " Total time in simulation = 2.1015E+01 seconds\n", - " Time in transport only = 2.0844E+01 seconds\n", - " Time in inactive batches = 2.2260E+00 seconds\n", - " Time in active batches = 1.8789E+01 seconds\n", - " Time synchronizing fission bank = 9.0000E-03 seconds\n", - " Sampling source sites = 5.0000E-03 seconds\n", - " SEND/RECV source sites = 4.0000E-03 seconds\n", - " Time accumulating tallies = 0.0000E+00 seconds\n", + " Total time for initialization = 1.4400E+00 seconds\n", + " Reading cross sections = 1.1340E+00 seconds\n", + " Total time in simulation = 1.8207E+01 seconds\n", + " Time in transport only = 1.8125E+01 seconds\n", + " Time in inactive batches = 2.1170E+00 seconds\n", + " Time in active batches = 1.6090E+01 seconds\n", + " Time synchronizing fission bank = 3.0000E-03 seconds\n", + " Sampling source sites = 2.0000E-03 seconds\n", + " SEND/RECV source sites = 1.0000E-03 seconds\n", + " Time accumulating tallies = 1.0000E-03 seconds\n", " Total time for finalization = 0.0000E+00 seconds\n", - " Total time elapsed = 2.2491E+01 seconds\n", - " Calculation Rate (inactive) = 22461.8 neutrons/second\n", - " Calculation Rate (active) = 10644.5 neutrons/second\n", + " Total time elapsed = 1.9657E+01 seconds\n", + " Calculation Rate (inactive) = 23618.3 neutrons/second\n", + " Calculation Rate (active) = 12430.1 neutrons/second\n", "\n", " ============================> RESULTS <============================\n", "\n", @@ -814,7 +842,7 @@ "0" ] }, - "execution_count": 26, + "execution_count": 27, "metadata": {}, "output_type": "execute_result" } @@ -833,7 +861,7 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 28, "metadata": { "collapsed": false }, @@ -858,7 +886,7 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 29, "metadata": { "collapsed": false }, @@ -877,7 +905,7 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 30, "metadata": { "collapsed": false }, @@ -896,7 +924,7 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 31, "metadata": { "collapsed": false }, @@ -929,7 +957,7 @@ }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 32, "metadata": { "collapsed": false }, @@ -969,7 +997,7 @@ }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 33, "metadata": { "collapsed": false }, @@ -1019,7 +1047,7 @@ }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 34, "metadata": { "collapsed": true }, @@ -1044,7 +1072,7 @@ }, { "cell_type": "code", - "execution_count": 34, + "execution_count": 35, "metadata": { "collapsed": false, "scrolled": true @@ -1070,8 +1098,8 @@ " Copyright: 2011-2016 Massachusetts Institute of Technology\n", " License: http://openmc.readthedocs.io/en/latest/license.html\n", " Version: 0.7.1\n", - " Git SHA1: 4bec584ddb7d07be7d92ad9d037e8363b2f25614\n", - " Date/Time: 2016-05-15 14:22:57\n", + " Git SHA1: 058ba68895a2f880402fda3d58cfb14b162931d9\n", + " Date/Time: 2016-05-17 05:32:54\n", " OpenMP Threads: 4\n", "\n", " ===========================================================================\n", @@ -1096,56 +1124,56 @@ "\n", " Bat./Gen. k Average k \n", " ========= ======== ==================== \n", - " 1/1 1.02073 \n", - " 2/1 1.04004 \n", - " 3/1 1.02324 \n", - " 4/1 1.01690 \n", - " 5/1 1.03702 \n", - " 6/1 1.01796 \n", - " 7/1 1.01779 \n", - " 8/1 1.02764 \n", - " 9/1 1.03324 \n", - " 10/1 1.01465 \n", - " 11/1 1.02268 \n", - " 12/1 1.01598 1.01933 +/- 0.00335\n", - " 13/1 1.01993 1.01953 +/- 0.00194\n", - " 14/1 1.01779 1.01910 +/- 0.00144\n", - " 15/1 1.01014 1.01731 +/- 0.00211\n", - " 16/1 1.04059 1.02119 +/- 0.00425\n", - " 17/1 1.04877 1.02513 +/- 0.00533\n", - " 18/1 1.05504 1.02887 +/- 0.00594\n", - " 19/1 1.02601 1.02855 +/- 0.00525\n", - " 20/1 1.04347 1.03004 +/- 0.00493\n", - " 21/1 1.01703 1.02886 +/- 0.00461\n", - " 22/1 1.02628 1.02864 +/- 0.00421\n", - " 23/1 1.02598 1.02844 +/- 0.00388\n", - " 24/1 1.05341 1.03022 +/- 0.00401\n", - " 25/1 1.02201 1.02967 +/- 0.00377\n", - " 26/1 1.00758 1.02829 +/- 0.00379\n", - " 27/1 1.00720 1.02705 +/- 0.00377\n", - " 28/1 1.03098 1.02727 +/- 0.00356\n", - " 29/1 1.03022 1.02743 +/- 0.00337\n", - " 30/1 1.01694 1.02690 +/- 0.00324\n", - " 31/1 0.99064 1.02518 +/- 0.00353\n", - " 32/1 0.99495 1.02380 +/- 0.00364\n", - " 33/1 1.03220 1.02417 +/- 0.00350\n", - " 34/1 1.02399 1.02416 +/- 0.00335\n", - " 35/1 1.03048 1.02441 +/- 0.00322\n", - " 36/1 1.05360 1.02553 +/- 0.00329\n", - " 37/1 1.05030 1.02645 +/- 0.00330\n", - " 38/1 1.04167 1.02699 +/- 0.00322\n", - " 39/1 1.04406 1.02758 +/- 0.00317\n", - " 40/1 1.01169 1.02705 +/- 0.00310\n", - " 41/1 1.00191 1.02624 +/- 0.00311\n", - " 42/1 1.02729 1.02628 +/- 0.00301\n", - " 43/1 1.02263 1.02616 +/- 0.00292\n", - " 44/1 1.05344 1.02697 +/- 0.00295\n", - " 45/1 1.03607 1.02723 +/- 0.00287\n", - " 46/1 1.00357 1.02657 +/- 0.00287\n", - " 47/1 1.03353 1.02676 +/- 0.00279\n", - " 48/1 1.03817 1.02706 +/- 0.00274\n", - " 49/1 1.01454 1.02674 +/- 0.00269\n", - " 50/1 0.99860 1.02603 +/- 0.00271\n", + " 1/1 1.02235 \n", + " 2/1 1.01108 \n", + " 3/1 1.02801 \n", + " 4/1 1.01404 \n", + " 5/1 1.03423 \n", + " 6/1 1.03282 \n", + " 7/1 1.04060 \n", + " 8/1 1.01152 \n", + " 9/1 1.02063 \n", + " 10/1 1.02604 \n", + " 11/1 1.02137 \n", + " 12/1 1.01416 1.01776 +/- 0.00360\n", + " 13/1 1.00239 1.01264 +/- 0.00553\n", + " 14/1 1.04293 1.02021 +/- 0.00852\n", + " 15/1 1.02029 1.02023 +/- 0.00660\n", + " 16/1 1.01512 1.01938 +/- 0.00546\n", + " 17/1 1.02098 1.01960 +/- 0.00462\n", + " 18/1 1.05954 1.02460 +/- 0.00640\n", + " 19/1 1.02347 1.02447 +/- 0.00564\n", + " 20/1 1.03063 1.02509 +/- 0.00508\n", + " 21/1 1.04679 1.02706 +/- 0.00500\n", + " 22/1 1.01301 1.02589 +/- 0.00472\n", + " 23/1 1.00936 1.02462 +/- 0.00452\n", + " 24/1 1.01030 1.02360 +/- 0.00431\n", + " 25/1 1.03799 1.02456 +/- 0.00412\n", + " 26/1 1.00404 1.02327 +/- 0.00406\n", + " 27/1 1.02987 1.02366 +/- 0.00384\n", + " 28/1 1.00107 1.02241 +/- 0.00383\n", + " 29/1 1.01460 1.02200 +/- 0.00365\n", + " 30/1 1.01433 1.02161 +/- 0.00348\n", + " 31/1 1.01566 1.02133 +/- 0.00332\n", + " 32/1 1.03339 1.02188 +/- 0.00321\n", + " 33/1 1.03974 1.02265 +/- 0.00317\n", + " 34/1 1.03136 1.02302 +/- 0.00306\n", + " 35/1 1.05175 1.02417 +/- 0.00315\n", + " 36/1 1.05444 1.02533 +/- 0.00324\n", + " 37/1 1.02432 1.02529 +/- 0.00312\n", + " 38/1 1.01464 1.02491 +/- 0.00303\n", + " 39/1 1.01086 1.02443 +/- 0.00296\n", + " 40/1 1.02492 1.02444 +/- 0.00286\n", + " 41/1 1.02882 1.02459 +/- 0.00277\n", + " 42/1 1.00377 1.02394 +/- 0.00276\n", + " 43/1 0.97480 1.02245 +/- 0.00306\n", + " 44/1 1.03623 1.02285 +/- 0.00300\n", + " 45/1 1.02606 1.02294 +/- 0.00291\n", + " 46/1 1.01771 1.02280 +/- 0.00284\n", + " 47/1 1.05400 1.02364 +/- 0.00288\n", + " 48/1 1.01844 1.02350 +/- 0.00281\n", + " 49/1 1.00754 1.02309 +/- 0.00277\n", + " 50/1 1.02902 1.02324 +/- 0.00270\n", " Creating state point statepoint.50.h5...\n", "\n", " ===========================================================================\n", @@ -1155,27 +1183,27 @@ "\n", " =======================> TIMING STATISTICS <=======================\n", "\n", - " Total time for initialization = 3.5000E-02 seconds\n", - " Reading cross sections = 3.0000E-03 seconds\n", - " Total time in simulation = 1.2599E+01 seconds\n", - " Time in transport only = 1.2565E+01 seconds\n", - " Time in inactive batches = 1.1220E+00 seconds\n", - " Time in active batches = 1.1477E+01 seconds\n", - " Time synchronizing fission bank = 6.0000E-03 seconds\n", - " Sampling source sites = 5.0000E-03 seconds\n", + " Total time for initialization = 4.7000E-02 seconds\n", + " Reading cross sections = 6.0000E-03 seconds\n", + " Total time in simulation = 1.4145E+01 seconds\n", + " Time in transport only = 1.4098E+01 seconds\n", + " Time in inactive batches = 1.2400E+00 seconds\n", + " Time in active batches = 1.2905E+01 seconds\n", + " Time synchronizing fission bank = 4.0000E-03 seconds\n", + " Sampling source sites = 3.0000E-03 seconds\n", " SEND/RECV source sites = 1.0000E-03 seconds\n", " Time accumulating tallies = 1.0000E-03 seconds\n", - " Total time for finalization = 1.0000E-03 seconds\n", - " Total time elapsed = 1.2644E+01 seconds\n", - " Calculation Rate (inactive) = 44563.3 neutrons/second\n", - " Calculation Rate (active) = 17426.2 neutrons/second\n", + " Total time for finalization = 0.0000E+00 seconds\n", + " Total time elapsed = 1.4201E+01 seconds\n", + " Calculation Rate (inactive) = 40322.6 neutrons/second\n", + " Calculation Rate (active) = 15497.9 neutrons/second\n", "\n", " ============================> RESULTS <============================\n", "\n", - " k-effective (Collision) = 1.02471 +/- 0.00243\n", - " k-effective (Track-length) = 1.02603 +/- 0.00271\n", - " k-effective (Absorption) = 1.02312 +/- 0.00182\n", - " Combined k-effective = 1.02387 +/- 0.00172\n", + " k-effective (Collision) = 1.02379 +/- 0.00230\n", + " k-effective (Track-length) = 1.02324 +/- 0.00270\n", + " k-effective (Absorption) = 1.02813 +/- 0.00172\n", + " Combined k-effective = 1.02680 +/- 0.00165\n", " Leakage Fraction = 0.00000 +/- 0.00000\n", "\n" ] @@ -1186,7 +1214,7 @@ "0" ] }, - "execution_count": 34, + "execution_count": 35, "metadata": {}, "output_type": "execute_result" } @@ -1209,7 +1237,7 @@ }, { "cell_type": "code", - "execution_count": 35, + "execution_count": 36, "metadata": { "collapsed": false }, @@ -1229,7 +1257,7 @@ }, { "cell_type": "code", - "execution_count": 36, + "execution_count": 37, "metadata": { "collapsed": true }, @@ -1247,7 +1275,7 @@ }, { "cell_type": "code", - "execution_count": 37, + "execution_count": 38, "metadata": { "collapsed": false }, @@ -1257,8 +1285,8 @@ "output_type": "stream", "text": [ "Continuous-Energy keff = 1.024295\n", - "Multi-Group keff = 1.023875\n", - "bias [pcm]: 42.0\n" + "Multi-Group keff = 1.026805\n", + "bias [pcm]: -251.0\n" ] } ], @@ -1274,7 +1302,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "We see quite good agreement with only a 42 pcm difference between the two methods. Due to the high degree of approximations inherent in practical application of multi-group theory, one should not expect results of such high fidelity always for multi-group Monte Carlo calculations." + "This shows a 251 pcm bias between the two methods. Some degree of mismatch is expected simply to the very few histories being used in these example problems. An additional mismatch is always inherent in the practical application of multi-group theory due to the high degree of approximations inherent in that method." ] }, { @@ -1295,7 +1323,7 @@ }, { "cell_type": "code", - "execution_count": 38, + "execution_count": 39, "metadata": { "collapsed": false }, @@ -1321,7 +1349,7 @@ }, { "cell_type": "code", - "execution_count": 39, + "execution_count": 40, "metadata": { "collapsed": false }, @@ -1347,7 +1375,7 @@ }, { "cell_type": "code", - "execution_count": 40, + "execution_count": 41, "metadata": { "collapsed": false }, @@ -1355,18 +1383,18 @@ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 40, + "execution_count": 41, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAADDCAYAAACS2+oqAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nhMgJCuhCCJETFNCFECInKKALIURO+H/MOIwTGD7mCAAAAABJRU5ErkJggg==\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAADDCAYAAACS2+oqAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", "text/plain": [ - "" + "" ] }, "metadata": {}, diff --git a/openmc/mgxs/library.py b/openmc/mgxs/library.py index bc643ed3e7..e5728a812e 100644 --- a/openmc/mgxs/library.py +++ b/openmc/mgxs/library.py @@ -460,7 +460,7 @@ class Library(object): ---------- domain : Material or Cell or Universe or Integral The material, cell, or universe object of interest (or its ID) - mgxs_type : {'total', 'transport', 'absorption', 'capture', 'fission', 'nu-fission', 'kappa-fission', 'scatter', 'nu-scatter', 'scatter matrix', 'nu-scatter matrix', 'chi'} + mgxs_type : {'total', 'transport', 'nu-transport', 'absorption', 'capture', 'fission', 'nu-fission', 'kappa-fission', 'scatter', 'nu-scatter', 'scatter matrix', 'nu-scatter matrix', 'chi'} The type of multi-group cross section object to return Returns @@ -773,9 +773,9 @@ class Library(object): nuclide this will be set to 'macro' regardless. xs_ids : str Cross section set identifier. Defaults to '1m'. - order : Scattering order for this dataset entry. Default is None, - which will force the XSdata object to use whatever the maximum - order available. + order : Scattering order for this data entry. Default is None, + which will force the XSdata object to use whatever the order of the + Library object is. Returns ------- @@ -801,7 +801,8 @@ class Library(object): cv.check_value('xs_type', xs_type, ['macro', 'micro']) cv.check_type('xs_id', xs_id, basestring) cv.check_type('order', order, (type(None), Integral)) - cv.check_greater_than('order', order, -1, equality=True) + if order is not None: + cv.check_greater_than('order', order, 0, equality=True) # Make sure statepoint has been loaded if self._sp_filename is None: @@ -819,20 +820,22 @@ class Library(object): name += '_' + nuclide name += '.' + xs_id xsdata = openmc.XSdata(name, self.energy_groups) - if order is 0: - xsdata.order = order + + if order is None: + # Set the order to the Library's order (the defualt behavior) + xsdata.order = self.legendre_order else: - msg = 'Generating anisotropic scattering from openmc.Library' \ - 'objects has not yet been implemented.' - raise NotImplementedError(msg) + # Set the order of the xsdata object to the minimum of + # the provided order or the Library's order. + xsdata.order = min(order, self.legendre_order) if nuclide is not 'total': xsdata.zaid = self._nuclides[nuclide][0] xsdata.awr = self._nuclides[nuclide][1] # Now get xs data itself - if 'transport' in self.mgxs_types: - mymgxs = self.get_mgxs(domain, 'transport') + if ('nu-transport' in self.mgxs_types) and (self.correction == 'P0'): + mymgxs = self.get_mgxs(domain, 'nu-transport') xsdata.set_total_mgxs(mymgxs, xs_type=xs_type, nuclide=[nuclide]) elif 'total' in self.mgxs_types: mymgxs = self.get_mgxs(domain, 'total') @@ -949,10 +952,6 @@ class Library(object): # Initialize file mgxs_file = openmc.MGXSLibrary(self.energy_groups) - # Set the scattering order as isotropic until - # support for higher orders are included in openmc.mgxs - order = 0 - # Create the xsdata object and add it to the mgxs_file for i, domain in enumerate(self.domains): if self.by_nuclide: @@ -969,8 +968,7 @@ class Library(object): xsdata_name += '_' + nuclide xsdata = self.get_xsdata(domain, xsdata_name, nuclide=nuclide, - xs_type=xs_type, xs_id=xs_ids[i], - order=order) + xs_type=xs_type, xs_id=xs_ids[i]) mgxs_file.add_xsdata(xsdata) @@ -1031,10 +1029,10 @@ class Library(object): # Total or transport can be present, but if using # self.correction=="P0", then we should use transport. if (((self.correction is "P0") and - ('transport' not in self.mgxs_types))): + ('nu-transport' not in self.mgxs_types))): error_flag = True - msg = 'Transport MGXS type is required since a "P0" correction ' \ - 'is applied, but a Transport MGXS is not provided.' + msg = 'NuTransport MGXS type is required since a "P0" correction' \ + ' is applied, but a Transport MGXS is not provided.' warn(msg) elif (((self.correction is None) and ('total' not in self.mgxs_types))): diff --git a/openmc/mgxs_library.py b/openmc/mgxs_library.py index 408175f43b..99942361b9 100644 --- a/openmc/mgxs_library.py +++ b/openmc/mgxs_library.py @@ -829,7 +829,8 @@ class XSdata(object): def set_scatter_mgxs(self, scatter, nuclide='total', xs_type='macro'): """This method allows for an openmc.mgxs.ScatterMatrixXS to be used to set the scatter matrix cross section for this XSdata - object. + object. If the XsData.order attribute has not yet been set, then + it will be set based on the properties of scatter. Parameters ---------- @@ -856,9 +857,35 @@ class XSdata(object): check_value('domain_type', scatter.domain_type, ['universe', 'cell', 'material']) + # Methods of representing anisotropic scattering besides + # Legendre expansions have not been implemented yet in openmc.mgxs. + # Therefore check to make sure the XsData has been set to + # legendre scattering. + if (self.scatt_type != 'legendre'): + msg = 'Anisotrpic scattering representations other than ' \ + 'Legendre expansions have not yet been implemented in ' \ + 'openmc.mgxs.' + raise ValueError(msg) + + # If the user has not defined XsData.order, then we will set + # the order based on the data within scatter. + # Otherwise, we will check to see that XsData.order to match + # the order of scatter + if self.order is None: + self.order = scatter.legendre_order + else: + check_value('legendre_order', scatter.legendre_order, + [self.order]) + if self._representation is 'isotropic': - self._scatter = np.array([scatter.get_xs(nuclides=nuclide, - xs_type=xs_type)]) + # Get the scattering orders in the outermost dimension + self._scatter = np.zeros((self.num_orders, + self.energy_groups.num_groups, + self.energy_groups.num_groups)) + for moment in range(self.num_orders): + self._scatter[moment, :, :] = scatter.get_xs(nuclides=nuclide, + xs_type=xs_type, + moment=moment) elif self._representation is 'angle': msg = 'Angular-Dependent MGXS have not yet been implemented' @@ -908,10 +935,12 @@ class XSdata(object): ['universe', 'cell', 'material']) if self._representation is 'isotropic': + # import pdb; pdb.set_trace() + nuscatt = nuscatter.get_xs(nuclides=nuclide, - xs_type=xs_type) + xs_type=xs_type, moment=0) scatt = scatter.get_xs(nuclides=nuclide, - xs_type=xs_type) + xs_type=xs_type, moment=0) self._multiplicity = np.divide(nuscatt, scatt) elif self._representation is 'angle': msg = 'Angular-Dependent MGXS have not yet been implemented' @@ -969,7 +998,8 @@ class XSdata(object): if self._tabular_legendre is not None: subelement = ET.SubElement(element, 'tabular_legendre') subelement.set('enable', str(self._tabular_legendre['enable'])) - subelement.set('num_points', str(self._tabular_legendre['num_points'])) + subelement.set('num_points', + str(self._tabular_legendre['num_points'])) if self._total is not None: subelement = ET.SubElement(element, 'total') From b1516c91849989f40ac011e77af659409d34de94 Mon Sep 17 00:00:00 2001 From: Adam Nelson Date: Tue, 17 May 2016 21:24:03 -0400 Subject: [PATCH 20/20] Updated per minor edits from @wbinventor and added a routine to calculate the mgxs_library and Materials objects --- .../pythonapi/examples/mgxs-part-iv.ipynb | 178 +++++++++--------- openmc/mgxs/library.py | 118 +++++++++++- openmc/mgxs_library.py | 50 +++-- 3 files changed, 222 insertions(+), 124 deletions(-) diff --git a/docs/source/pythonapi/examples/mgxs-part-iv.ipynb b/docs/source/pythonapi/examples/mgxs-part-iv.ipynb index e1d61cedcc..4b73cf3caa 100644 --- a/docs/source/pythonapi/examples/mgxs-part-iv.ipynb +++ b/docs/source/pythonapi/examples/mgxs-part-iv.ipynb @@ -433,7 +433,7 @@ "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAPoAAAD6AgMAAAD1grKuAAAABGdBTUEAALGPC/xhBQAAACBjSFJN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\nVDA1OjMyOjMzLTA0OjAwW2RvZAAAAABJRU5ErkJggg==\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAPoAAAD6AgMAAAD1grKuAAAABGdBTUEAALGPC/xhBQAAACBjSFJN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\nVDIxOjE0OjA1LTA0OjAwwp46AAAAAABJRU5ErkJggg==\n", "text/plain": [ "" ] @@ -724,7 +724,7 @@ " License: http://openmc.readthedocs.io/en/latest/license.html\n", " Version: 0.7.1\n", " Git SHA1: 058ba68895a2f880402fda3d58cfb14b162931d9\n", - " Date/Time: 2016-05-17 05:32:34\n", + " Date/Time: 2016-05-17 21:14:05\n", " OpenMP Threads: 4\n", "\n", " ===========================================================================\n", @@ -811,20 +811,20 @@ "\n", " =======================> TIMING STATISTICS <=======================\n", "\n", - " Total time for initialization = 1.4400E+00 seconds\n", - " Reading cross sections = 1.1340E+00 seconds\n", - " Total time in simulation = 1.8207E+01 seconds\n", - " Time in transport only = 1.8125E+01 seconds\n", - " Time in inactive batches = 2.1170E+00 seconds\n", - " Time in active batches = 1.6090E+01 seconds\n", - " Time synchronizing fission bank = 3.0000E-03 seconds\n", - " Sampling source sites = 2.0000E-03 seconds\n", - " SEND/RECV source sites = 1.0000E-03 seconds\n", - " Time accumulating tallies = 1.0000E-03 seconds\n", + " Total time for initialization = 1.4530E+00 seconds\n", + " Reading cross sections = 1.1470E+00 seconds\n", + " Total time in simulation = 1.8747E+01 seconds\n", + " Time in transport only = 1.8639E+01 seconds\n", + " Time in inactive batches = 2.1690E+00 seconds\n", + " Time in active batches = 1.6578E+01 seconds\n", + " Time synchronizing fission bank = 6.0000E-03 seconds\n", + " Sampling source sites = 4.0000E-03 seconds\n", + " SEND/RECV source sites = 2.0000E-03 seconds\n", + " Time accumulating tallies = 0.0000E+00 seconds\n", " Total time for finalization = 0.0000E+00 seconds\n", - " Total time elapsed = 1.9657E+01 seconds\n", - " Calculation Rate (inactive) = 23618.3 neutrons/second\n", - " Calculation Rate (active) = 12430.1 neutrons/second\n", + " Total time elapsed = 2.0209E+01 seconds\n", + " Calculation Rate (inactive) = 23052.1 neutrons/second\n", + " Calculation Rate (active) = 12064.2 neutrons/second\n", "\n", " ============================> RESULTS <============================\n", "\n", @@ -1099,7 +1099,7 @@ " License: http://openmc.readthedocs.io/en/latest/license.html\n", " Version: 0.7.1\n", " Git SHA1: 058ba68895a2f880402fda3d58cfb14b162931d9\n", - " Date/Time: 2016-05-17 05:32:54\n", + " Date/Time: 2016-05-17 21:14:26\n", " OpenMP Threads: 4\n", "\n", " ===========================================================================\n", @@ -1124,56 +1124,56 @@ "\n", " Bat./Gen. k Average k \n", " ========= ======== ==================== \n", - " 1/1 1.02235 \n", - " 2/1 1.01108 \n", - " 3/1 1.02801 \n", - " 4/1 1.01404 \n", - " 5/1 1.03423 \n", - " 6/1 1.03282 \n", - " 7/1 1.04060 \n", - " 8/1 1.01152 \n", - " 9/1 1.02063 \n", - " 10/1 1.02604 \n", - " 11/1 1.02137 \n", - " 12/1 1.01416 1.01776 +/- 0.00360\n", - " 13/1 1.00239 1.01264 +/- 0.00553\n", - " 14/1 1.04293 1.02021 +/- 0.00852\n", - " 15/1 1.02029 1.02023 +/- 0.00660\n", - " 16/1 1.01512 1.01938 +/- 0.00546\n", - " 17/1 1.02098 1.01960 +/- 0.00462\n", - " 18/1 1.05954 1.02460 +/- 0.00640\n", - " 19/1 1.02347 1.02447 +/- 0.00564\n", - " 20/1 1.03063 1.02509 +/- 0.00508\n", - " 21/1 1.04679 1.02706 +/- 0.00500\n", - " 22/1 1.01301 1.02589 +/- 0.00472\n", - " 23/1 1.00936 1.02462 +/- 0.00452\n", - " 24/1 1.01030 1.02360 +/- 0.00431\n", - " 25/1 1.03799 1.02456 +/- 0.00412\n", - " 26/1 1.00404 1.02327 +/- 0.00406\n", - " 27/1 1.02987 1.02366 +/- 0.00384\n", - " 28/1 1.00107 1.02241 +/- 0.00383\n", - " 29/1 1.01460 1.02200 +/- 0.00365\n", - " 30/1 1.01433 1.02161 +/- 0.00348\n", - " 31/1 1.01566 1.02133 +/- 0.00332\n", - " 32/1 1.03339 1.02188 +/- 0.00321\n", - " 33/1 1.03974 1.02265 +/- 0.00317\n", - " 34/1 1.03136 1.02302 +/- 0.00306\n", - " 35/1 1.05175 1.02417 +/- 0.00315\n", - " 36/1 1.05444 1.02533 +/- 0.00324\n", - " 37/1 1.02432 1.02529 +/- 0.00312\n", - " 38/1 1.01464 1.02491 +/- 0.00303\n", - " 39/1 1.01086 1.02443 +/- 0.00296\n", - " 40/1 1.02492 1.02444 +/- 0.00286\n", - " 41/1 1.02882 1.02459 +/- 0.00277\n", - " 42/1 1.00377 1.02394 +/- 0.00276\n", - " 43/1 0.97480 1.02245 +/- 0.00306\n", - " 44/1 1.03623 1.02285 +/- 0.00300\n", - " 45/1 1.02606 1.02294 +/- 0.00291\n", - " 46/1 1.01771 1.02280 +/- 0.00284\n", - " 47/1 1.05400 1.02364 +/- 0.00288\n", - " 48/1 1.01844 1.02350 +/- 0.00281\n", - " 49/1 1.00754 1.02309 +/- 0.00277\n", - " 50/1 1.02902 1.02324 +/- 0.00270\n", + " 1/1 1.06913 \n", + " 2/1 1.04067 \n", + " 3/1 1.01854 \n", + " 4/1 1.00203 \n", + " 5/1 1.03243 \n", + " 6/1 1.02688 \n", + " 7/1 1.06855 \n", + " 8/1 1.03420 \n", + " 9/1 1.01657 \n", + " 10/1 1.02795 \n", + " 11/1 1.01796 \n", + " 12/1 1.03372 1.02584 +/- 0.00788\n", + " 13/1 1.02433 1.02534 +/- 0.00458\n", + " 14/1 1.01147 1.02187 +/- 0.00474\n", + " 15/1 1.01215 1.01993 +/- 0.00416\n", + " 16/1 1.04088 1.02342 +/- 0.00487\n", + " 17/1 1.04033 1.02583 +/- 0.00477\n", + " 18/1 1.04483 1.02821 +/- 0.00477\n", + " 19/1 1.02870 1.02826 +/- 0.00420\n", + " 20/1 1.01339 1.02678 +/- 0.00404\n", + " 21/1 1.03389 1.02742 +/- 0.00371\n", + " 22/1 1.02535 1.02725 +/- 0.00340\n", + " 23/1 1.00225 1.02533 +/- 0.00367\n", + " 24/1 0.99938 1.02347 +/- 0.00387\n", + " 25/1 1.01620 1.02299 +/- 0.00363\n", + " 26/1 1.03393 1.02367 +/- 0.00347\n", + " 27/1 1.01875 1.02338 +/- 0.00327\n", + " 28/1 1.00305 1.02225 +/- 0.00328\n", + " 29/1 1.01453 1.02185 +/- 0.00313\n", + " 30/1 1.02891 1.02220 +/- 0.00299\n", + " 31/1 0.99612 1.02096 +/- 0.00311\n", + " 32/1 1.04911 1.02224 +/- 0.00323\n", + " 33/1 1.01410 1.02188 +/- 0.00310\n", + " 34/1 0.98979 1.02055 +/- 0.00326\n", + " 35/1 1.00938 1.02010 +/- 0.00316\n", + " 36/1 1.02857 1.02043 +/- 0.00305\n", + " 37/1 1.04095 1.02119 +/- 0.00303\n", + " 38/1 1.02033 1.02115 +/- 0.00292\n", + " 39/1 1.02104 1.02115 +/- 0.00282\n", + " 40/1 1.00854 1.02073 +/- 0.00276\n", + " 41/1 1.00932 1.02036 +/- 0.00269\n", + " 42/1 1.00284 1.01982 +/- 0.00266\n", + " 43/1 1.02489 1.01997 +/- 0.00258\n", + " 44/1 1.03981 1.02055 +/- 0.00257\n", + " 45/1 1.02630 1.02072 +/- 0.00251\n", + " 46/1 1.00133 1.02018 +/- 0.00249\n", + " 47/1 1.02409 1.02028 +/- 0.00243\n", + " 48/1 1.03928 1.02078 +/- 0.00241\n", + " 49/1 1.01226 1.02057 +/- 0.00236\n", + " 50/1 1.03536 1.02094 +/- 0.00233\n", " Creating state point statepoint.50.h5...\n", "\n", " ===========================================================================\n", @@ -1183,27 +1183,27 @@ "\n", " =======================> TIMING STATISTICS <=======================\n", "\n", - " Total time for initialization = 4.7000E-02 seconds\n", - " Reading cross sections = 6.0000E-03 seconds\n", - " Total time in simulation = 1.4145E+01 seconds\n", - " Time in transport only = 1.4098E+01 seconds\n", - " Time in inactive batches = 1.2400E+00 seconds\n", - " Time in active batches = 1.2905E+01 seconds\n", - " Time synchronizing fission bank = 4.0000E-03 seconds\n", - " Sampling source sites = 3.0000E-03 seconds\n", - " SEND/RECV source sites = 1.0000E-03 seconds\n", - " Time accumulating tallies = 1.0000E-03 seconds\n", + " Total time for initialization = 4.6000E-02 seconds\n", + " Reading cross sections = 8.0000E-03 seconds\n", + " Total time in simulation = 1.4524E+01 seconds\n", + " Time in transport only = 1.4457E+01 seconds\n", + " Time in inactive batches = 1.3350E+00 seconds\n", + " Time in active batches = 1.3189E+01 seconds\n", + " Time synchronizing fission bank = 7.0000E-03 seconds\n", + " Sampling source sites = 5.0000E-03 seconds\n", + " SEND/RECV source sites = 2.0000E-03 seconds\n", + " Time accumulating tallies = 0.0000E+00 seconds\n", " Total time for finalization = 0.0000E+00 seconds\n", - " Total time elapsed = 1.4201E+01 seconds\n", - " Calculation Rate (inactive) = 40322.6 neutrons/second\n", - " Calculation Rate (active) = 15497.9 neutrons/second\n", + " Total time elapsed = 1.4579E+01 seconds\n", + " Calculation Rate (inactive) = 37453.2 neutrons/second\n", + " Calculation Rate (active) = 15164.2 neutrons/second\n", "\n", " ============================> RESULTS <============================\n", "\n", - " k-effective (Collision) = 1.02379 +/- 0.00230\n", - " k-effective (Track-length) = 1.02324 +/- 0.00270\n", - " k-effective (Absorption) = 1.02813 +/- 0.00172\n", - " Combined k-effective = 1.02680 +/- 0.00165\n", + " k-effective (Collision) = 1.02358 +/- 0.00231\n", + " k-effective (Track-length) = 1.02094 +/- 0.00233\n", + " k-effective (Absorption) = 1.02682 +/- 0.00152\n", + " Combined k-effective = 1.02527 +/- 0.00153\n", " Leakage Fraction = 0.00000 +/- 0.00000\n", "\n" ] @@ -1285,8 +1285,8 @@ "output_type": "stream", "text": [ "Continuous-Energy keff = 1.024295\n", - "Multi-Group keff = 1.026805\n", - "bias [pcm]: -251.0\n" + "Multi-Group keff = 1.025274\n", + "bias [pcm]: -97.9\n" ] } ], @@ -1302,7 +1302,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "This shows a 251 pcm bias between the two methods. Some degree of mismatch is expected simply to the very few histories being used in these example problems. An additional mismatch is always inherent in the practical application of multi-group theory due to the high degree of approximations inherent in that method." + "This shows a nontrivial pcm bias between the two methods. Some degree of mismatch is expected simply to the very few histories being used in these example problems. An additional mismatch is always inherent in the practical application of multi-group theory due to the high degree of approximations inherent in that method." ] }, { @@ -1383,7 +1383,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 41, @@ -1392,9 +1392,9 @@ }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAADDCAYAAACS2+oqAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAADDCAYAAACS2+oqAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nnKCALoQQOUEBXQghcsL/A1cunn39vbPfAAAAAElFTkSuQmCC\n", "text/plain": [ - "" + "" ] }, "metadata": {}, diff --git a/openmc/mgxs/library.py b/openmc/mgxs/library.py index e5728a812e..20302b6246 100644 --- a/openmc/mgxs/library.py +++ b/openmc/mgxs/library.py @@ -774,8 +774,8 @@ class Library(object): xs_ids : str Cross section set identifier. Defaults to '1m'. order : Scattering order for this data entry. Default is None, - which will force the XSdata object to use whatever the order of the - Library object is. + which will set the XSdata object to use the order of the + Library. Returns ------- @@ -803,6 +803,7 @@ class Library(object): cv.check_type('order', order, (type(None), Integral)) if order is not None: cv.check_greater_than('order', order, 0, equality=True) + cv.check_less_than('order', order, 10, equality=True) # Make sure statepoint has been loaded if self._sp_filename is None: @@ -834,7 +835,7 @@ class Library(object): xsdata.awr = self._nuclides[nuclide][1] # Now get xs data itself - if ('nu-transport' in self.mgxs_types) and (self.correction == 'P0'): + if 'nu-transport' in self.mgxs_types and self.correction == 'P0': mymgxs = self.get_mgxs(domain, 'nu-transport') xsdata.set_total_mgxs(mymgxs, xs_type=xs_type, nuclide=[nuclide]) elif 'total' in self.mgxs_types: @@ -974,6 +975,104 @@ class Library(object): return mgxs_file + def create_mg_library_and_materials(self, xsdata_names=None, xs_ids=None, + material_ids=None): + """Creates an openmc.MGXSLibrary object to contain the MGXS data for the + Multi-Group mode of OpenMC as well as the associated openmc.Materials + objects. This method cannot be used for Library objects with + `Library.by_nuclide == True` since the materials to output would be + problem dependent and thus any Materials object produced by this method + would not be useful. + + Parameters + ---------- + xsdata_names : Iterable of str + List of names to apply to the "xsdata" entries in the + resultant mgxs data file. Defaults to 'set1', 'set2', ... + xs_ids : str or Iterable of str + Cross section set identifier (i.e., '71c') for all + data sets (if only str) or for each individual one + (if iterable of str). Defaults to '1m'. + material_ids : None or Iterable of Integral + An optional list of material IDs to pass to the materials in + materials_file. Defaults to `None` implying the materials will be + given an ID number which matches the index of the domain in + `self.domains` + + Returns + ------- + mgxs_file : openmc.MGXSLibrary + Multi-Group Cross Section File that is ready to be printed to the + file of choice by the user. + materials_file : openmc.Materials + Materials file ready to be printed with all the macroscopic data + present within this Library. + + Raises + ------ + ValueError + When the Library object is initialized with insufficient types of + cross sections for the Library. + + See also + -------- + Library.create_mg_library() + Library.dump_to_file() + + """ + + # Check to ensure the Library contains the correct + # multi-group cross section types + self.check_library_for_openmc_mgxs() + + if xsdata_names is not None: + cv.check_iterable_type('xsdata_names', xsdata_names, basestring) + if xs_ids is not None: + if isinstance(xs_ids, basestring): + # If we only have a string lets convert it now to a list + # of strings. + xs_ids = [xs_ids for i in range(len(self.domains))] + else: + cv.check_iterable_type('xs_ids', xs_ids, basestring) + else: + xs_ids = ['1m' for i in range(len(self.domains))] + if material_ids is not None: + cv.check_iterable_type('material_ids', material_ids, Integral) + xs_type = 'macro' + + # Initialize files + mgxs_file = openmc.MGXSLibrary(self.energy_groups) + + materials = [] + macroscopics = [] + nuclide = 'total' + # Create the xsdata object and add it to the mgxs_file + for i, domain in enumerate(self.domains): + # Build & add metadata to XSdata object + if xsdata_names is None: + xsdata_name = 'set' + str(i + 1) + else: + xsdata_name = xsdata_names[i] + + xsdata = self.get_xsdata(domain, xsdata_name, nuclide=nuclide, + xs_type=xs_type, xs_id=xs_ids[i]) + + mgxs_file.add_xsdata(xsdata) + + macroscopics.append(openmc.Macroscopic(name=xsdata_name, + xs=xs_ids[i])) + if material_ids is not None: + mat_id = material_ids[i] + else: + mat_id = i + materials.append(openmc.Material(name=xsdata_name + '.' + + xs_ids[i], material_id=mat_id)) + materials[-1].add_macroscopic(macroscopics[-1]) + + materials_file = openmc.Materials(materials) + + return (mgxs_file, materials_file) + def check_library_for_openmc_mgxs(self): """This routine will check the MGXS Types within a Library to ensure the MGXS types provided can be used to create @@ -1009,12 +1108,12 @@ class Library(object): # Ensure absorption is present if 'absorption' not in self.mgxs_types: error_flag = True - msg = 'Absorption MGXS type is required but not provided.' + msg = '"absorption" MGXS type is required but not provided.' warn(msg) # Ensure nu-scattering matrix is required if 'nu-scatter matrix' not in self.mgxs_types: error_flag = True - msg = 'Nu-Scatter Matrix MGXS type is required but not provided.' + msg = '"nu-scatter matrix" MGXS type is required but not provided.' warn(msg) else: # Ok, now see the status of scatter @@ -1023,7 +1122,7 @@ class Library(object): # we need total, and not transport. if 'total' not in self.mgxs_types: error_flag = True - msg = 'Total MGXS type is required if a ' \ + msg = '"total" MGXS type is required if a ' \ 'scattering matrix is not provided.' warn(msg) # Total or transport can be present, but if using @@ -1031,13 +1130,14 @@ class Library(object): if (((self.correction is "P0") and ('nu-transport' not in self.mgxs_types))): error_flag = True - msg = 'NuTransport MGXS type is required since a "P0" correction' \ - ' is applied, but a Transport MGXS is not provided.' + msg = 'A "nu-transport" MGXS type is required since a "P0" ' \ + 'correction is applied, but a "nu-transport" MGXS is ' \ + 'not provided.' warn(msg) elif (((self.correction is None) and ('total' not in self.mgxs_types))): error_flag = True - msg = 'Total MGXS type is required, but not provided.' + msg = '"total" MGXS type is required, but not provided.' warn(msg) if error_flag: diff --git a/openmc/mgxs_library.py b/openmc/mgxs_library.py index 99942361b9..88ae05808a 100644 --- a/openmc/mgxs_library.py +++ b/openmc/mgxs_library.py @@ -137,6 +137,10 @@ class XSdata(object): ``representation``. matrix_shape : iterable of int Dimensionality of matrix multi-group cross sections (e.g., the + fission matrix cross section). The return result depends on the + value of ``representation``. + pn_matrix_shape : iterable of int + Dimensionality of scattering matrix data (e.g., the scattering matrix cross section). The return result depends on the value of ``representation``. total : numpy.ndarray @@ -621,9 +625,9 @@ class XSdata(object): check_value('domain_type', total.domain_type, ['universe', 'cell', 'material']) - if self._representation is 'isotropic': + if self.representation is 'isotropic': self._total = total.get_xs(nuclides=nuclide, xs_type=xs_type) - elif self._representation is 'angle': + elif self.representation is 'angle': msg = 'Angular-Dependent MGXS have not yet been implemented' raise ValueError(msg) @@ -657,10 +661,10 @@ class XSdata(object): check_value('domain_type', absorption.domain_type, ['universe', 'cell', 'material']) - if self._representation is 'isotropic': + if self.representation is 'isotropic': self._absorption = absorption.get_xs(nuclides=nuclide, xs_type=xs_type) - elif self._representation is 'angle': + elif self.representation is 'angle': msg = 'Angular-Dependent MGXS have not yet been implemented' raise ValueError(msg) @@ -693,10 +697,10 @@ class XSdata(object): check_value('domain_type', fission.domain_type, ['universe', 'cell', 'material']) - if self._representation is 'isotropic': + if self.representation is 'isotropic': self._fission = fission.get_xs(nuclides=nuclide, xs_type=xs_type) - elif self._representation is 'angle': + elif self.representation is 'angle': msg = 'Angular-Dependent MGXS have not yet been implemented' raise ValueError(msg) @@ -733,10 +737,10 @@ class XSdata(object): check_value('domain_type', nu_fission.domain_type, ['universe', 'cell', 'material']) - if self._representation is 'isotropic': + if self.representation is 'isotropic': self._nu_fission = nu_fission.get_xs(nuclides=nuclide, xs_type=xs_type) - elif self._representation is 'angle': + elif self.representation is 'angle': msg = 'Angular-Dependent MGXS have not yet been implemented' raise ValueError(msg) @@ -776,10 +780,10 @@ class XSdata(object): check_value('domain_type', k_fission.domain_type, ['universe', 'cell', 'material']) - if self._representation is 'isotropic': + if self.representation is 'isotropic': self._kappa_fission = k_fission.get_xs(nuclides=nuclide, xs_type=xs_type) - elif self._representation is 'angle': + elif self.representation is 'angle': msg = 'Angular-Dependent MGXS have not yet been implemented' raise ValueError(msg) @@ -816,10 +820,10 @@ class XSdata(object): check_value('domain_type', chi.domain_type, ['universe', 'cell', 'material']) - if self._representation is 'isotropic': + if self.representation is 'isotropic': self._chi = chi.get_xs(nuclides=nuclide, xs_type=xs_type) - elif self._representation is 'angle': + elif self.representation is 'angle': msg = 'Angular-Dependent MGXS have not yet been implemented' raise ValueError(msg) @@ -829,7 +833,7 @@ class XSdata(object): def set_scatter_mgxs(self, scatter, nuclide='total', xs_type='macro'): """This method allows for an openmc.mgxs.ScatterMatrixXS to be used to set the scatter matrix cross section for this XSdata - object. If the XsData.order attribute has not yet been set, then + object. If the XSdata.order attribute has not yet been set, then it will be set based on the properties of scatter. Parameters @@ -857,19 +861,15 @@ class XSdata(object): check_value('domain_type', scatter.domain_type, ['universe', 'cell', 'material']) - # Methods of representing anisotropic scattering besides - # Legendre expansions have not been implemented yet in openmc.mgxs. - # Therefore check to make sure the XsData has been set to - # legendre scattering. if (self.scatt_type != 'legendre'): - msg = 'Anisotrpic scattering representations other than ' \ + msg = 'Anisotropic scattering representations other than ' \ 'Legendre expansions have not yet been implemented in ' \ 'openmc.mgxs.' raise ValueError(msg) - # If the user has not defined XsData.order, then we will set + # If the user has not defined XSdata.order, then we will set # the order based on the data within scatter. - # Otherwise, we will check to see that XsData.order to match + # Otherwise, we will check to see that XSdata.order to match # the order of scatter if self.order is None: self.order = scatter.legendre_order @@ -877,7 +877,7 @@ class XSdata(object): check_value('legendre_order', scatter.legendre_order, [self.order]) - if self._representation is 'isotropic': + if self.representation is 'isotropic': # Get the scattering orders in the outermost dimension self._scatter = np.zeros((self.num_orders, self.energy_groups.num_groups, @@ -887,7 +887,7 @@ class XSdata(object): xs_type=xs_type, moment=moment) - elif self._representation is 'angle': + elif self.representation is 'angle': msg = 'Angular-Dependent MGXS have not yet been implemented' raise ValueError(msg) @@ -934,15 +934,13 @@ class XSdata(object): check_value('domain_type', scatter.domain_type, ['universe', 'cell', 'material']) - if self._representation is 'isotropic': - # import pdb; pdb.set_trace() - + if self.representation is 'isotropic': nuscatt = nuscatter.get_xs(nuclides=nuclide, xs_type=xs_type, moment=0) scatt = scatter.get_xs(nuclides=nuclide, xs_type=xs_type, moment=0) self._multiplicity = np.divide(nuscatt, scatt) - elif self._representation is 'angle': + elif self.representation is 'angle': msg = 'Angular-Dependent MGXS have not yet been implemented' raise ValueError(msg) self._multiplicity = np.nan_to_num(self._multiplicity)