From 6478849b44945a71603be105c36d7abc8949f4d9 Mon Sep 17 00:00:00 2001 From: Sterling Harper Date: Sun, 11 Sep 2016 17:29:24 -0400 Subject: [PATCH] Fix most MGXS tests --- openmc/filter.py | 4 +- openmc/mgxs/mdgxs.py | 34 +++--- openmc/mgxs/mgxs.py | 105 +++++++++++------- openmc/tallies.py | 4 +- .../test_tally_aggregation.py | 9 +- 5 files changed, 90 insertions(+), 66 deletions(-) diff --git a/openmc/filter.py b/openmc/filter.py index a4d97f94c7..5af92fc1ef 100644 --- a/openmc/filter.py +++ b/openmc/filter.py @@ -626,7 +626,9 @@ class EnergyFilter(Filter): return type(self)(sorted(merged_bins)) def is_subset(self, other): - if len(self.bins) != len(other.bins): + if type(self) != type(other): + return False + elif len(self.bins) != len(other.bins): return False else: return np.allclose(self.bins, other.bins) diff --git a/openmc/mgxs/mdgxs.py b/openmc/mgxs/mdgxs.py index 8941d4c6f9..1c3b0f401a 100644 --- a/openmc/mgxs/mdgxs.py +++ b/openmc/mgxs/mdgxs.py @@ -193,10 +193,10 @@ class MDGXS(MGXS): # Create the non-domain specific Filters for the Tallies group_edges = self.energy_groups.group_edges - energy_filter = openmc.Filter('energy', group_edges) + energy_filter = openmc.EnergyFilter(group_edges) if self.delayed_groups != None: - delayed_filter = openmc.Filter('delayedgroup', self.delayed_groups) + delayed_filter = openmc.DelayedGroupFilter(self.delayed_groups) return [[energy_filter], [delayed_filter, energy_filter]] else: return [[energy_filter], [energy_filter]] @@ -329,7 +329,7 @@ class MDGXS(MGXS): if not isinstance(groups, basestring): cv.check_iterable_type('groups', groups, Integral) for group in groups: - filters.append('energy') + filters.append(openmc.EnergyFilter) filter_bins.append( (self.energy_groups.get_group_bounds(group),)) @@ -337,7 +337,7 @@ class MDGXS(MGXS): if not isinstance(delayed_groups, basestring): cv.check_type('delayed groups', delayed_groups, list, int) for delayed_group in delayed_groups: - filters.append('delayedgroup') + filters.append(openmc.DelayedGroupFilter) filter_bins.append((delayed_group,)) # Construct a collection of the nuclides to retrieve from the xs tally @@ -444,11 +444,11 @@ class MDGXS(MGXS): group_bounds = self.energy_groups.get_group_bounds(group) energy_bins.append(group_bounds) filter_bins.append(tuple(energy_bins)) - filters.append('energy') + filters.append(openmc.EnergyFilter) if len(delayed_groups) != 0: filter_bins.append(tuple(delayed_groups)) - filters.append('delayedgroup') + filters.append(openmc.DelayedGroupFilter) # Clone this MGXS to initialize the sliced version slice_xs = copy.deepcopy(self) @@ -971,10 +971,10 @@ class ChiDelayed(MDGXS): def filters(self): # Create the non-domain specific Filters for the Tallies group_edges = self.energy_groups.group_edges - energyout = openmc.Filter('energyout', group_edges) - energyin = openmc.Filter('energy', [group_edges[0], group_edges[-1]]) + energyout = openmc.EnergyoutFilter(group_edges) + energyin = openmc.EnergyFilter([group_edges[0], group_edges[-1]]) if self.delayed_groups != None: - delayed_filter = openmc.Filter('delayedgroup', self.delayed_groups) + delayed_filter = openmc.DelayedGroupFilter(self.delayed_groups) return [[delayed_filter, energyin], [delayed_filter, energyout]] else: return [[energyin], [energyout]] @@ -1001,7 +1001,8 @@ class ChiDelayed(MDGXS): delayed_nu_fission_in = self.tallies['delayed-nu-fission-in'] # Remove coarse energy filter to keep it out of tally arithmetic - energy_filter = delayed_nu_fission_in.find_filter('energy') + energy_filter = delayed_nu_fission_in.find_filter( + openmc.EnergyFilter) delayed_nu_fission_in.remove_filter(energy_filter) # Compute chi @@ -1046,7 +1047,7 @@ class ChiDelayed(MDGXS): # Temporarily remove energy filter from delayed-nu-fission-in since its # group structure will work in super MGXS.get_slice(...) method delayed_nu_fission_in = self.tallies['delayed-nu-fission-in'] - energy_filter = delayed_nu_fission_in.find_filter('energy') + energy_filter = delayed_nu_fission_in.find_filter(openmc.EnergyFilter) delayed_nu_fission_in.remove_filter(energy_filter) # Call super class method and null out derived tallies @@ -1065,11 +1066,11 @@ class ChiDelayed(MDGXS): group_bounds = self.energy_groups.get_group_bounds(group) energy_bins.append(group_bounds) filter_bins.append(tuple(energy_bins)) - filters.append('energyout') + filters.append(openmc.EnergyoutFilter) if len(delayed_groups) != 0: filter_bins.append(tuple(delayed_groups)) - filters.append('delayedgroup') + filters.append(openmc.DelayedGroupFilter) if filters != []: @@ -1218,7 +1219,7 @@ class ChiDelayed(MDGXS): if not isinstance(groups, basestring): cv.check_iterable_type('groups', groups, Integral) for group in groups: - filters.append('energyout') + filters.append(openmc.EnergyoutFilter) filter_bins.append( (self.energy_groups.get_group_bounds(group),)) @@ -1226,7 +1227,7 @@ class ChiDelayed(MDGXS): if not isinstance(delayed_groups, basestring): cv.check_type('delayed groups', delayed_groups, list, int) for delayed_group in delayed_groups: - filters.append('delayedgroup') + filters.append(openmc.DelayedGroupFilter) filter_bins.append((delayed_group,)) # If chi delayed was computed for each nuclide in the domain @@ -1248,7 +1249,8 @@ class ChiDelayed(MDGXS): (nuclides=nuclides) # Remove coarse energy filter to keep it out of tally arithmetic - energy_filter = delayed_nu_fission_in.find_filter('energy') + energy_filter = delayed_nu_fission_in.find_filter( + openmc.EnergyFilter) delayed_nu_fission_in.remove_filter(energy_filter) # Compute chi and store it as the xs_tally attribute so we can diff --git a/openmc/mgxs/mgxs.py b/openmc/mgxs/mgxs.py index 1d2e9098d3..c5de13d76b 100644 --- a/openmc/mgxs/mgxs.py +++ b/openmc/mgxs/mgxs.py @@ -47,6 +47,13 @@ DOMAIN_TYPES = ['cell', 'material', 'mesh'] +# Filter types corresponding to each domain +_DOMAIN_TO_FILTER = {'cell': openmc.CellFilter, + 'distribcell': openmc.DistribcellFilter, + 'universe': openmc.UniverseFilter, + 'material': openmc.MaterialFilter, + 'mesh': openmc.MeshFilter} + # Supported domain classes _DOMAINS = (openmc.Cell, openmc.Universe, @@ -242,7 +249,7 @@ class MGXS(object): @property def filters(self): group_edges = self.energy_groups.group_edges - energy_filter = openmc.Filter('energy', group_edges) + energy_filter = openmc.EnergyFilter(group_edges) return [[energy_filter]] * len(self.scores) @property @@ -263,7 +270,8 @@ class MGXS(object): self._tallies = OrderedDict() # Create a domain Filter object - domain_filter = openmc.Filter(self.domain_type, self.domain.id) + filter_type = _DOMAIN_TO_FILTER[self.domain_type] + domain_filter = filter_type(self.domain.id) # If a mesh domain, give the mesh to the domain filter if self.domain_type == 'mesh': @@ -322,7 +330,8 @@ class MGXS(object): @property def num_subdomains(self): - domain_filter = self.xs_tally.find_filter(self.domain_type) + filter_type = _DOMAIN_TO_FILTER[self.domain_type] + domain_filter = self.xs_tally.find_filter(filter_type) return domain_filter.num_bins @property @@ -683,11 +692,11 @@ class MGXS(object): # Use tally "slicing" to ensure that tallies correspond to our domain # NOTE: This is important if tally merging was used if self.domain_type == 'mesh': - filters = [self.domain_type] + filters = [_DOMAIN_TO_FILTER[self.domain_type]] xyz = [range(1, x+1) for x in self.domain.dimension] filter_bins = [tuple(itertools.product(*xyz))] elif self.domain_type != 'distribcell': - filters = [self.domain_type] + filters = [_DOMAIN_TO_FILTER[self.domain_type]] filter_bins = [(self.domain.id,)] # Distribcell filters only accept single cell - neglect it when slicing else: @@ -704,9 +713,14 @@ class MGXS(object): # Find, slice and store Tallies from StatePoint # The tally slicing is needed if tally merging was used for tally_type, tally in self.tallies.items(): - sp_tally = statepoint.get_tally( - tally.scores, tally.filters, tally.nuclides, - estimator=tally.estimator, exact_filters=True) + if isinstance(self, Chi): + sp_tally = statepoint.get_tally( + tally.scores, tally.filters, tally.nuclides, + estimator=tally.estimator, exact_filters=True) + else: + sp_tally = statepoint.get_tally( + tally.scores, tally.filters, tally.nuclides, + estimator=tally.estimator, exact_filters=True) sp_tally = sp_tally.get_slice( tally.scores, filters, filter_bins, tally.nuclides) sp_tally.sparse = self.sparse @@ -787,7 +801,7 @@ class MGXS(object): if not isinstance(groups, basestring): cv.check_iterable_type('groups', groups, Integral) for group in groups: - filters.append('energy') + filters.append(openmc.EnergyFilter) filter_bins.append((self.energy_groups.get_group_bounds(group),)) # Construct a collection of the nuclides to retrieve from the xs tally @@ -895,7 +909,8 @@ class MGXS(object): # Sum across all applicable fine energy group filters for i, tally_filter in enumerate(tally.filters): - if 'energy' not in tally_filter.type: + if not isinstance(tally_filter, (openmc.EnergyFilter, + openmc.EnergyoutFilter)): continue elif len(tally_filter.bins) != len(fine_edges): continue @@ -964,7 +979,8 @@ class MGXS(object): # Average each of the tallies across subdomains for tally_type, tally in avg_xs.tallies.items(): - tally_avg = tally.average(filter_type=self.domain_type, + filt_type = _DOMAIN_TO_FILTER[self.domain_type] + tally_avg = tally.average(filter_type=filt_type, filter_bins=subdomains) avg_xs.tallies[tally_type] = tally_avg @@ -1011,7 +1027,7 @@ class MGXS(object): group_bounds = self.energy_groups.get_group_bounds(group) energy_bins.append(group_bounds) filter_bins.append(tuple(energy_bins)) - filters.append('energy') + filters.append(openmc.EnergyFilter) # Clone this MGXS to initialize the sliced version slice_xs = copy.deepcopy(self) @@ -1021,7 +1037,7 @@ class MGXS(object): # Slice each of the tallies across nuclides and energy groups for tally_type, tally in slice_xs.tallies.items(): slice_nuclides = [nuc for nuc in nuclides if nuc in tally.nuclides] - if len(groups) != 0 and tally.contains_filter('energy'): + if len(groups) != 0 and tally.contains_filter(openmc.EnergyFilter): tally_slice = tally.get_slice(filters=filters, filter_bins=filter_bins, nuclides=slice_nuclides) @@ -1696,8 +1712,8 @@ class MatrixMGXS(MGXS): def filters(self): # Create the non-domain specific Filters for the Tallies group_edges = self.energy_groups.group_edges - energy = openmc.Filter('energy', group_edges) - energyout = openmc.Filter('energyout', group_edges) + energy = openmc.EnergyFilter(group_edges) + energyout = openmc.EnergyoutFilter(group_edges) return [[energy], [energy, energyout]] @@ -1782,7 +1798,7 @@ class MatrixMGXS(MGXS): if not isinstance(in_groups, basestring): cv.check_iterable_type('groups', in_groups, Integral) for group in in_groups: - filters.append('energy') + filters.append(openmc.EnergyFilter) filter_bins.append(( self.energy_groups.get_group_bounds(group),)) @@ -1790,7 +1806,7 @@ class MatrixMGXS(MGXS): if not isinstance(out_groups, basestring): cv.check_iterable_type('groups', out_groups, Integral) for group in out_groups: - filters.append('energyout') + filters.append(openmc.EnergyoutFilter) filter_bins.append(( self.energy_groups.get_group_bounds(group),)) @@ -1902,9 +1918,10 @@ class MatrixMGXS(MGXS): # Slice each of the tallies across energyout groups for tally_type, tally in slice_xs.tallies.items(): - if tally.contains_filter('energyout'): - tally_slice = tally.get_slice(filters=['energyout'], - filter_bins=filter_bins) + if tally.contains_filter(openmc.EnergyoutFilter): + tally_slice = tally.get_slice( + filters=[openmc.EnergyoutFilter], + filter_bins=filter_bins) slice_xs.tallies[tally_type] = tally_slice slice_xs.sparse = self.sparse @@ -2254,14 +2271,19 @@ class TransportXS(MGXS): @property def filters(self): group_edges = self.energy_groups.group_edges - energy_filter = openmc.Filter('energy', group_edges) - energyout_filter = openmc.Filter('energyout', group_edges) + energy_filter = openmc.EnergyFilter(group_edges) + energyout_filter = openmc.EnergyoutFilter(group_edges) return [[energy_filter], [energy_filter], [energyout_filter]] @property def rxn_rate_tally(self): if self._rxn_rate_tally is None: - self.tallies['scatter-1'].filters[-1].type = 'energy' + # Switch EnergyoutFilter to EnergyFilter. + old_filt = self.tallies['scatter-1'].filters[-1] + new_filt = openmc.EnergyFilter(old_filt.bins) + new_filt.stride = old_filt.stride + self.tallies['scatter-1'].filters[-1] = new_filt + self._rxn_rate_tally = \ self.tallies['total'] - self.tallies['scatter-1'] self._rxn_rate_tally.sparse = self.sparse @@ -3353,8 +3375,8 @@ class ScatterMatrixXS(MatrixMGXS): @property def filters(self): group_edges = self.energy_groups.group_edges - energy = openmc.Filter('energy', group_edges) - energyout = openmc.Filter('energyout', group_edges) + energy = openmc.EnergyFilter(group_edges) + energyout = openmc.EnergyoutFilter(group_edges) if self.correction == 'P0' and self.legendre_order == 0: filters = [[energy], [energy, energyout], [energyout]] @@ -3372,7 +3394,7 @@ class ScatterMatrixXS(MatrixMGXS): if self.correction == 'P0' and self.legendre_order == 0: scatter_p0 = self.tallies['{}-0'.format(self.rxn_type)] scatter_p1 = self.tallies['{}-1'.format(self.rxn_type)] - energy_filter = scatter_p0.find_filter('energy') + energy_filter = scatter_p0.find_filter(openmc.EnergyFilter) energy_filter = copy.deepcopy(energy_filter) scatter_p1 = scatter_p1.diagonalize_filter(energy_filter) self._rxn_rate_tally = scatter_p0 - scatter_p1 @@ -3515,9 +3537,9 @@ class ScatterMatrixXS(MatrixMGXS): # Slice each of the tallies across energyout groups for tally_type, tally in slice_xs.tallies.items(): - if tally.contains_filter('energyout'): - tally_slice = tally.get_slice(filters=['energyout'], - filter_bins=filter_bins) + if tally.contains_filter(openmc.EnergyoutFilter): + tally_slice = tally.get_slice( + filters=[openmc.EnergyoutFilter], filter_bins=filter_bins) slice_xs.tallies[tally_type] = tally_slice slice_xs.sparse = self.sparse @@ -3610,14 +3632,14 @@ class ScatterMatrixXS(MatrixMGXS): if not isinstance(in_groups, basestring): cv.check_iterable_type('groups', in_groups, Integral) for group in in_groups: - filters.append('energy') + filters.append(openmc.EnergyFilter) filter_bins.append((self.energy_groups.get_group_bounds(group),)) # Construct list of energy group bounds tuples for all requested groups if not isinstance(out_groups, basestring): cv.check_iterable_type('groups', out_groups, Integral) for group in out_groups: - filters.append('energyout') + filters.append(openmc.EnergyoutFilter) filter_bins.append((self.energy_groups.get_group_bounds(group),)) # Construct CrossScore for requested scattering moment @@ -4121,8 +4143,8 @@ class MultiplicityMatrixXS(MatrixMGXS): def filters(self): # Create the non-domain specific Filters for the Tallies group_edges = self.energy_groups.group_edges - energy = openmc.Filter('energy', group_edges) - energyout = openmc.Filter('energyout', group_edges) + energy = openmc.EnergyFilter(group_edges) + energyout = openmc.EnergyoutFilter(group_edges) return [[energy, energyout], [energy, energyout]] @@ -4385,8 +4407,8 @@ class Chi(MGXS): def filters(self): # Create the non-domain specific Filters for the Tallies group_edges = self.energy_groups.group_edges - energyout = openmc.Filter('energyout', group_edges) - energyin = openmc.Filter('energy', [group_edges[0], group_edges[-1]]) + energyout = openmc.EnergyoutFilter(group_edges) + energyin = openmc.EnergyFilter([group_edges[0], group_edges[-1]]) return [[energyin], [energyout]] @property @@ -4407,12 +4429,11 @@ class Chi(MGXS): nu_fission_in = self.tallies['nu-fission-in'] # Remove coarse energy filter to keep it out of tally arithmetic - energy_filter = nu_fission_in.find_filter('energy') + energy_filter = nu_fission_in.find_filter(openmc.EnergyFilter) nu_fission_in.remove_filter(energy_filter) # Compute chi self._xs_tally = self.rxn_rate_tally / nu_fission_in - super(Chi, self)._compute_xs() # Add the coarse energy filter back to the nu-fission tally nu_fission_in.filters.append(energy_filter) @@ -4448,7 +4469,7 @@ class Chi(MGXS): # Temporarily remove energy filter from nu-fission-in since its # group structure will work in super MGXS.get_slice(...) method nu_fission_in = self.tallies['nu-fission-in'] - energy_filter = nu_fission_in.find_filter('energy') + energy_filter = nu_fission_in.find_filter(openmc.EnergyFilter) nu_fission_in.remove_filter(energy_filter) # Call super class method and null out derived tallies @@ -4466,8 +4487,8 @@ class Chi(MGXS): # Slice nu-fission-out tally along energyout filter nu_fission_out = slice_xs.tallies['nu-fission-out'] - tally_slice = nu_fission_out.get_slice(filters=['energyout'], - filter_bins=filter_bins) + tally_slice = nu_fission_out.get_slice( + filters=[openmc.EnergyoutFilter], filter_bins=filter_bins) slice_xs._tallies['nu-fission-out'] = tally_slice # Add energy filter back to nu-fission-in tallies @@ -4599,7 +4620,7 @@ class Chi(MGXS): if not isinstance(groups, basestring): cv.check_iterable_type('groups', groups, Integral) for group in groups: - filters.append('energyout') + filters.append(openmc.EnergyoutFilter) filter_bins.append((self.energy_groups.get_group_bounds(group),)) # If chi was computed for each nuclide in the domain @@ -4619,7 +4640,7 @@ class Chi(MGXS): nu_fission_out = nu_fission_out.summation(nuclides=nuclides) # Remove coarse energy filter to keep it out of tally arithmetic - energy_filter = nu_fission_in.find_filter('energy') + energy_filter = nu_fission_in.find_filter(openmc.EnergyFilter) nu_fission_in.remove_filter(energy_filter) # Compute chi and store it as the xs_tally attribute so we can diff --git a/openmc/tallies.py b/openmc/tallies.py index aad2446ec7..b6c7d62edc 100644 --- a/openmc/tallies.py +++ b/openmc/tallies.py @@ -3198,7 +3198,7 @@ class Tally(object): std_dev = self.get_reshaped_data(value='std_dev') # Average across any filter bins specified by the user - if isinstnace(filter_type, openmc.filter.FilterMeta): + if isinstance(filter_type, openmc.filter.FilterMeta): find_filter = self.find_filter(filter_type) # If user did not specify filter bins, average across all bins @@ -3219,7 +3219,7 @@ class Tally(object): # Average across the bins in the user-specified filter for i, self_filter in enumerate(self.filters): - if self_filter.type == filter_type: + if isinstance(self_filter, filter_type): mean = np.take(mean, indices=bin_indices, axis=i) std_dev = np.take(std_dev, indices=bin_indices, axis=i) mean = np.mean(mean, axis=i, keepdims=True) diff --git a/tests/test_tally_aggregation/test_tally_aggregation.py b/tests/test_tally_aggregation/test_tally_aggregation.py index 76284ef9dc..955d7fecbb 100644 --- a/tests/test_tally_aggregation/test_tally_aggregation.py +++ b/tests/test_tally_aggregation/test_tally_aggregation.py @@ -21,9 +21,8 @@ class TallyAggregationTestHarness(PyAPITestHarness): pu239 = openmc.Nuclide('Pu239') # Initialize the filters - energy_filter = openmc.Filter(type='energy', bins=[0.0, 0.253e-6, - 1.0e-3, 1.0, 20.0]) - distrib_filter = openmc.Filter(type='distribcell', bins=[60]) + energy_filter = openmc.EnergyFilter([0.0, 0.253e-6, 1.0e-3, 1.0, 20.0]) + distrib_filter = openmc.DistribcellFilter(60) # Initialized the tallies tally = openmc.Tally(name='distribcell tally') @@ -50,12 +49,12 @@ class TallyAggregationTestHarness(PyAPITestHarness): outstr = '' # Sum across all energy filter bins - tally_sum = tally.summation(filter_type='energy') + tally_sum = tally.summation(filter_type=openmc.EnergyFilter) outstr += ', '.join(map(str, tally_sum.mean)) outstr += ', '.join(map(str, tally_sum.std_dev)) # Sum across all distribcell filter bins - tally_sum = tally.summation(filter_type='distribcell') + tally_sum = tally.summation(filter_type=openmc.DistribcellFilter) outstr += ', '.join(map(str, tally_sum.mean)) outstr += ', '.join(map(str, tally_sum.std_dev))