From 95e6d27bd99724ad040bb8bb8a36cf5b517b5b9c Mon Sep 17 00:00:00 2001 From: "wbinventor@gmail.com" Date: Thu, 14 Jan 2016 18:03:20 -0500 Subject: [PATCH] Renamed local filter variables so as not to shadow Python built-in filter method --- openmc/aggregate.py | 26 +++--- openmc/filter.py | 18 ++--- openmc/mgxs/mgxs.py | 14 ++-- openmc/statepoint.py | 46 +++++------ openmc/summary.py | 6 +- openmc/tallies.py | 189 ++++++++++++++++++++++--------------------- 6 files changed, 151 insertions(+), 148 deletions(-) diff --git a/openmc/aggregate.py b/openmc/aggregate.py index cef4365552..908ca4b5c5 100644 --- a/openmc/aggregate.py +++ b/openmc/aggregate.py @@ -218,17 +218,17 @@ class AggregateFilter(object): """ - def __init__(self, filter=None, bins=None, aggregate_op=None): + def __init__(self, aggregate_filter=None, bins=None, aggregate_op=None): - self._type = '{0}({1})'.format(aggregate_op, filter.type) + self._type = '{0}({1})'.format(aggregate_op, aggregate_filter.type) self._bins = None self._stride = None - self._filter = None + self._aggregate_filter = None self._aggregate_op = None - if filter is not None: - self.filter = filter + if aggregate_filter is not None: + self.aggregate_filter = aggregate_filter if bins is not None: self.bins = bins if aggregate_op is not None: @@ -256,7 +256,7 @@ class AggregateFilter(object): if existing is None: clone = type(self).__new__(type(self)) clone._type = self.type - clone._filter = self.filter + clone._filter = self.aggregate_filter clone._aggregate_op = self.aggregate_op clone._bins = self._bins clone._stride = self.stride @@ -270,8 +270,8 @@ class AggregateFilter(object): return existing @property - def filter(self): - return self._filter + def aggregate_filter(self): + return self._aggregate_filter @property def aggregate_op(self): @@ -287,7 +287,7 @@ class AggregateFilter(object): @property def num_bins(self): - if self.filter: + if self.aggregate_filter: return 1 else: return 0 @@ -305,10 +305,10 @@ class AggregateFilter(object): self._type = filter_type - @filter.setter - def filter(self, filter): - cv.check_type('filter', filter, (Filter, CrossFilter)) - self._filter = filter + @aggregate_filter.setter + def aggregate_filter(self, aggregate_filter): + cv.check_type('aggregate_filter', aggregate_filter, (Filter, CrossFilter)) + self._aggregate_filter = aggregate_filter @bins.setter def bins(self, bins): diff --git a/openmc/filter.py b/openmc/filter.py index d61fb648f6..4d12d7561b 100644 --- a/openmc/filter.py +++ b/openmc/filter.py @@ -227,12 +227,12 @@ class Filter(object): self._stride = stride - def can_merge(self, filter): + def can_merge(self, other): """Determine if filter can be merged with another. Parameters ---------- - filter : Filter + other : Filter Filter to compare with Returns @@ -242,11 +242,11 @@ class Filter(object): """ - if not isinstance(filter, Filter): + if not isinstance(other, Filter): return False # Filters must be of the same type - elif self.type != filter.type: + elif self.type != other.type: return False # Distribcell filters cannot have more than one bin @@ -264,12 +264,12 @@ class Filter(object): else: return True - def merge(self, filter): + def merge(self, other): """Merge this filter with another. Parameters ---------- - filter : Filter + other : Filter Filter to merge with Returns @@ -279,16 +279,16 @@ class Filter(object): """ - if not self.can_merge(filter): + if not self.can_merge(other): msg = 'Unable to merge "{0}" with "{1}" ' \ - 'filters'.format(self.type, filter.type) + 'filters'.format(self.type, other.type) raise ValueError(msg) # Create deep copy of filter to return as merged filter merged_filter = copy.deepcopy(self) # Merge unique filter bins - merged_bins = list(set(np.concatenate((self.bins, filter.bins)))) + merged_bins = list(set(np.concatenate((self.bins, other.bins)))) merged_filter.bins = merged_bins merged_filter.num_bins = len(merged_bins) diff --git a/openmc/mgxs/mgxs.py b/openmc/mgxs/mgxs.py index 47154357ef..e20a6a320e 100644 --- a/openmc/mgxs/mgxs.py +++ b/openmc/mgxs/mgxs.py @@ -521,8 +521,8 @@ class MGXS(object): self.tallies[key].add_trigger(trigger_clone) # Add all non-domain specific Filters (e.g., 'energy') to the Tally - for filter in filters: - self.tallies[key].add_filter(filter) + for add_filter in filters: + self.tallies[key].add_filter(add_filter) # If this is a by-nuclide cross-section, add all nuclides to Tally if self.by_nuclide and score != 'flux': @@ -787,15 +787,15 @@ class MGXS(object): std_dev = tally.get_reshaped_data(value='std_dev') # Sum across all applicable fine energy group filters - for i, filter in enumerate(tally.filters): - if 'energy' not in filter.type: + for i, tally_filter in enumerate(tally.filters): + if 'energy' not in tally_filter.type: continue - elif len(filter.bins) != len(fine_edges): + elif len(tally_filter.bins) != len(fine_edges): continue - elif not np.allclose(filter.bins, fine_edges): + elif not np.allclose(tally_filter.bins, fine_edges): continue else: - filter.bins = coarse_groups.group_edges + tally_filter.bins = coarse_groups.group_edges mean = np.add.reduceat(mean, energy_indices, axis=i) std_dev = np.add.reduceat(std_dev**2, energy_indices, axis=i) std_dev = np.sqrt(std_dev) diff --git a/openmc/statepoint.py b/openmc/statepoint.py index 3c0759f124..76a14a80cf 100644 --- a/openmc/statepoint.py +++ b/openmc/statepoint.py @@ -377,18 +377,18 @@ class StatePoint(object): bins = self._f['{0}{1}/bins'.format(subbase, j)].value # Create Filter object - filter = openmc.Filter(filter_type, bins) - filter.num_bins = n_bins + new_filter = openmc.Filter(filter_type, bins) + new_filter.num_bins = n_bins if filter_type == 'mesh': mesh_ids = self._f['tallies/meshes/ids'].value mesh_keys = self._f['tallies/meshes/keys'].value key = mesh_keys[mesh_ids == bins][0] - filter.mesh = self.meshes[key] + new_filter.mesh = self.meshes[key] # Add Filter to the Tally - tally.add_filter(filter) + tally.add_filter(new_filter) # Read Nuclide bins nuclide_names = \ @@ -406,11 +406,11 @@ class StatePoint(object): # Compute and set the filter strides for i in range(n_filters): - filter = tally.filters[i] - filter.stride = n_score_bins * len(nuclide_names) + tally_filter = tally.filters[i] + tally_filter.stride = n_score_bins * len(nuclide_names) for j in range(i+1, n_filters): - filter.stride *= tally.filters[j].num_bins + tally_filter.stride *= tally.filters[j].num_bins # Read scattering moment order strings (e.g., P3, Y1,2, etc.) moments = self._f['{0}{1}/moment_orders'.format( @@ -544,13 +544,13 @@ class StatePoint(object): contains_filters = True # Iterate over the Filters requested by the user - for filter in filters: + for outer_filter in filters: contains_filters = False # Test if requested filter is a subset of any of the test # tally's filters and if so continue to next filter - for test_filter in test_tally.filters: - if test_filter.is_subset(filter): + for inner_filter in test_tally.filters: + if inner_filter.is_subset(outer_filter): contains_filters = True break @@ -616,29 +616,29 @@ class StatePoint(object): tally.name = summary.tallies[tally_id].name tally.with_summary = True - for filter in tally.filters: - if filter.type == 'surface': + for tally_filter in tally.filters: + if tally_filter.type == 'surface': surface_ids = [] - for bin in filter.bins: + for bin in tally_filter.bins: surface_ids.append(summary.surfaces[bin].id) - filter.bins = surface_ids + tally_filter.bins = surface_ids - if filter.type in ['cell', 'distribcell']: + if tally_filter.type in ['cell', 'distribcell']: distribcell_ids = [] - for bin in filter.bins: + for bin in tally_filter.bins: distribcell_ids.append(summary.cells[bin].id) - filter.bins = distribcell_ids + tally_filter.bins = distribcell_ids - if filter.type == 'universe': + if tally_filter.type == 'universe': universe_ids = [] - for bin in filter.bins: + for bin in tally_filter.bins: universe_ids.append(summary.universes[bin].id) - filter.bins = universe_ids + tally_filter.bins = universe_ids - if filter.type == 'material': + if tally_filter.type == 'material': material_ids = [] - for bin in filter.bins: + for bin in tally_filter.bins: material_ids.append(summary.materials[bin].id) - filter.bins = material_ids + tally_filter.bins = material_ids self._summary = summary diff --git a/openmc/summary.py b/openmc/summary.py index ad1dd67cae..eb14d3bb81 100644 --- a/openmc/summary.py +++ b/openmc/summary.py @@ -556,11 +556,11 @@ class Summary(object): bins = self._f['{0}/bins'.format(subsubbase)][...] # Create Filter object - filter = openmc.Filter(filter_type, bins) - filter.num_bins = num_bins + new_filter = openmc.Filter(filter_type, bins) + new_filter.num_bins = num_bins # Add Filter to the Tally - tally.add_filter(filter) + tally.add_filter(new_filter) # Add Tally to the global dictionary of all Tallies self.tallies[tally_id] = tally diff --git a/openmc/tallies.py b/openmc/tallies.py index 601a4068a6..b0265b841a 100644 --- a/openmc/tallies.py +++ b/openmc/tallies.py @@ -144,8 +144,8 @@ class Tally(object): clone._results_read = self._results_read clone._filters = [] - for filter in self.filters: - clone.add_filter(copy.deepcopy(filter, memo)) + for self_filter in self.filters: + clone.add_filter(copy.deepcopy(self_filter, memo)) clone._nuclides = [] for nuclide in self.nuclides: @@ -175,8 +175,8 @@ class Tally(object): if len(self.filters) != len(other.filters): return False - for filter in self.filters: - if filter not in other.filters: + for self_filter in self.filters: + if self_filter not in other.filters: return False # Check all nuclides @@ -213,9 +213,9 @@ class Tally(object): string += '{0: <16}{1}\n'.format('\tFilters', '=\t') - for filter in self.filters: - string += '{0: <16}\t\t{1}\t{2}\n'.format('', filter.type, - filter.bins) + for self_filter in self.filters: + string += '{0: <16}\t\t{1}\t{2}\n'.format('', self_filter.type, + self_filter.bins) string += '{0: <16}{1}'.format('\tNuclides', '=\t') @@ -268,8 +268,8 @@ class Tally(object): def num_filter_bins(self): num_bins = 1 - for filter in self.filters: - num_bins *= filter.num_bins + for self_filter in self.filters: + num_bins *= self_filter.num_bins return num_bins @@ -460,12 +460,12 @@ class Tally(object): else: self._name = '' - def add_filter(self, filter): + def add_filter(self, new_filter): """Add a filter to the tally Parameters ---------- - filter : Filter, CrossFilter or AggregateFilter + new_filter : Filter, CrossFilter or AggregateFilter A filter to specify a discretization of the tally across some dimension (e.g., 'energy', 'cell'). The filter should be a Filter object when a user is adding filters to a Tally for input file @@ -475,19 +475,19 @@ class Tally(object): """ - if not isinstance(filter, (Filter, CrossFilter, AggregateFilter)): + if not isinstance(new_filter, (Filter, CrossFilter, AggregateFilter)): msg = 'Unable to add Filter "{0}" to Tally ID="{1}" since it is ' \ - 'not a Filter object'.format(filter, self.id) + 'not a Filter object'.format(new_filter, self.id) raise ValueError(msg) # If the filter is already in the Tally, raise an error - if filter in self.filters: + if new_filter in self.filters: msg = 'Unable to add a duplicate filter "{0}" to Tally ID="{1}" ' \ 'since duplicate filters are not supported in the OpenMC ' \ - 'Python API'.format(filter, self.id) + 'Python API'.format(new_filter, self.id) raise ValueError(msg) - self._filters.append(filter) + self._filters.append(new_filter) def add_nuclide(self, nuclide): """Specify that scores for a particular nuclide should be accumulated @@ -640,22 +640,22 @@ class Tally(object): self._scores.remove(score) - def remove_filter(self, filter): + def remove_filter(self, old_filter): """Remove a filter from the tally Parameters ---------- - filter : openmc.filter.Filter + old_filter : openmc.filter.Filter Filter to remove """ - if filter not in self.filters: + if old_filter not in self.filters: msg = 'Unable to remove filter "{0}" from Tally ID="{1}" since the ' \ - 'Tally does not contain this filter'.format(filter, self.id) + 'Tally does not contain this filter'.format(old_filter, self.id) ValueError(msg) - self._filters.remove(filter) + self._filters.remove(old_filter) def remove_nuclide(self, nuclide): """Remove a nuclide from the tally @@ -799,13 +799,13 @@ class Tally(object): element.set("name", self.name) # Optional Tally filters - for filter in self.filters: + for self_filter in self.filters: subelement = ET.SubElement(element, "filter") - subelement.set("type", str(filter.type)) + subelement.set("type", str(self_filter.type)) - if filter.bins is not None: + if self_filter.bins is not None: bins = '' - for bin in filter.bins: + for bin in self_filter.bins: bins += '{0} '.format(bin) subelement.set("bins", bins.rstrip(' ')) @@ -857,7 +857,7 @@ class Tally(object): Returns ------- - filter : openmc.filter.Filter + filter_found : openmc.filter.Filter Filter from this tally with matching type, or None if no matching Filter is found @@ -868,21 +868,21 @@ class Tally(object): """ - filter = None + filter_found = None # Look through all of this Tally's Filters for the type requested for test_filter in self.filters: if test_filter.type == filter_type: - filter = test_filter + filter_found = test_filter break # If we did not find the Filter, throw an Exception - if filter is None: + if filter_found is None: msg = 'Unable to find filter type "{0}" in ' \ 'Tally ID="{1}"'.format(filter_type, self.id) raise ValueError(msg) - return filter + return filter_found def get_filter_index(self, filter_type, filter_bin): """Returns the index in the Tally's results array for a Filter bin @@ -907,10 +907,10 @@ class Tally(object): """ # Find the equivalent Filter in this Tally's list of Filters - filter = self.find_filter(filter_type) + filter_found = self.find_filter(filter_type) # Get the index for the requested bin from the Filter and return it - filter_index = filter.get_bin_index(filter_bin) + filter_index = filter_found.get_bin_index(filter_bin) return filter_index def get_nuclide_index(self, nuclide): @@ -1030,12 +1030,12 @@ class Tally(object): filter_indices = [] # Loop over all of the Tally's Filters - for i, filter in enumerate(self.filters): + for i, self_filter in enumerate(self.filters): user_filter = False # If a user-requested Filter, get the user-requested bins for j, test_filter in enumerate(filters): - if filter.type == test_filter: + if self_filter.type == test_filter: bins = filter_bins[j] user_filter = True break @@ -1043,36 +1043,36 @@ class Tally(object): # If not a user-requested Filter, get all bins if not user_filter: # Create list of 2- or 3-tuples tuples for mesh cell bins - if filter.type == 'mesh': - dimension = filter.mesh.dimension + if self_filter.type == 'mesh': + dimension = self_filter.mesh.dimension xyz = map(lambda x: np.arange(1, x+1), dimension) bins = list(itertools.product(*xyz)) # Create list of 2-tuples for energy boundary bins - elif filter.type in ['energy', 'energyout']: + elif self_filter.type in ['energy', 'energyout']: bins = [] - for k in range(filter.num_bins): - bins.append((filter.bins[k], filter.bins[k+1])) + for k in range(self_filter.num_bins): + bins.append((self_filter.bins[k], self_filter.bins[k+1])) # Create list of cell instance IDs for distribcell Filters - elif filter.type == 'distribcell': - bins = np.arange(filter.num_bins) + elif self_filter.type == 'distribcell': + bins = np.arange(self_filter.num_bins) # Create list of IDs for bins for all other filter types else: - bins = filter.bins + bins = self_filter.bins # Initialize a NumPy array for the Filter bin indices filter_indices.append(np.zeros(len(bins), dtype=np.int)) # Add indices for each bin in this Filter to the list for j, bin in enumerate(bins): - filter_index = self.get_filter_index(filter.type, bin) + filter_index = self.get_filter_index(self_filter.type, bin) filter_indices[i][j] = filter_index # Account for stride in each of the previous filters for indices in filter_indices[:i]: - indices *= filter.num_bins + indices *= self_filter.num_bins # Apply outer product sum between all filter bin indices filter_indices = list(map(sum, itertools.product(*filter_indices))) @@ -1314,8 +1314,8 @@ class Tally(object): if filters: # Append each Filter's DataFrame to the overall DataFrame - for filter in self.filters: - filter_df = filter.get_pandas_dataframe(data_size, summary) + for self_filter in self.filters: + filter_df = self_filter.get_pandas_dataframe(data_size, summary) df = pd.concat([df, filter_df], axis=1) # Include DataFrame column for nuclides if user requested it @@ -1404,8 +1404,8 @@ class Tally(object): # Build a new array shape with one dimension per filter new_shape = () - for filter in self.filters: - new_shape += (filter.num_bins, ) + for self_filter in self.filters: + new_shape += (self_filter.num_bins, ) new_shape += (self.num_nuclides,) new_shape += (self.num_scores,) @@ -1498,8 +1498,9 @@ class Tally(object): # Create an HDF5 sub-group for the Filters filter_group = tally_group.create_group('filters') - for filter in self.filters: - filter_group.create_dataset(filter.type, data=filter.bins) + for self_filter in self.filters: + filter_group.create_dataset(self_filter.type, + filter=self_filter.bins) # Add all results to the main HDF5 group for the Tally tally_group.create_dataset('sum', data=self.sum) @@ -1542,8 +1543,8 @@ class Tally(object): tally_group['filters'] = {} filter_group = tally_group['filters'] - for filter in self.filters: - filter_group[filter.type] = filter.bins + for self_filter in self.filters: + filter_group[self_filter.type] = self_filter.bins # Add all results to the main sub-dictionary for the Tally tally_group['sum'] = self.sum @@ -1752,9 +1753,9 @@ class Tally(object): """ stride = self.num_nuclides * self.num_scores - for filter in reversed(self.filters): - filter.stride = stride - stride *= filter.num_bins + for self_filter in reversed(self.filters): + self_filter.stride = stride + stride *= self_filter.num_bins def _align_tally_data(self, other, filter_product, nuclide_product, score_product): @@ -1798,26 +1799,26 @@ class Tally(object): set(other.filters).difference(set(self.filters)) # Add filters present in self but not in other to other - for filter in other_missing_filters: - filter = copy.deepcopy(filter) - other._mean = np.repeat(other.mean, filter.num_bins, axis=0) - other._std_dev = np.repeat(other.std_dev, filter.num_bins, axis=0) - other.add_filter(filter) + for other_filter in other_missing_filters: + filter_copy = copy.deepcopy(other_filter) + other._mean = np.repeat(other.mean, filter_copy.num_bins, axis=0) + other._std_dev = np.repeat(other.std_dev, filter_copy.num_bins, axis=0) + other.add_filter(filter_copy) # Add filters present in other but not in self to self - for filter in self_missing_filters: - filter = copy.deepcopy(filter) - self._mean = np.repeat(self.mean, filter.num_bins, axis=0) - self._std_dev = np.repeat(self.std_dev, filter.num_bins, axis=0) - self.add_filter(filter) + for self_filter in self_missing_filters: + filter_copy = copy.deepcopy(self_filter) + self._mean = np.repeat(self.mean, filter_copy.num_bins, axis=0) + self._std_dev = np.repeat(self.std_dev, filter_copy.num_bins, axis=0) + self.add_filter(filter_copy) # Align other filters with self filters - for i, filter in enumerate(self.filters): - other_index = other.filters.index(filter) + for i, self_filter in enumerate(self.filters): + other_index = other.filters.index(self_filter) # If necessary, swap other filter if other_index != i: - other._swap_filters(filter, other.filters[i]) + other._swap_filters(self_filter, other.filters[i]) # Repeat and tile the data by nuclide in preparation for performing # the tensor product across nuclides. @@ -1975,7 +1976,7 @@ class Tally(object): # Construct lists of tuples for the bins in each of the two filters filters = [filter1.type, filter2.type] if filter1.type == 'distribcell': - filter1_bins = np.arange(filter.num_bins) + filter1_bins = np.arange(filter1.num_bins) else: filter1_bins = [(filter1.get_bin(i)) for i in range(filter1.num_bins)] @@ -2200,8 +2201,8 @@ class Tally(object): new_tally.with_summary = self.with_summary new_tally.num_realization = self.num_realizations - for filter in self.filters: - new_tally.add_filter(filter) + for self_filter in self.filters: + new_tally.add_filter(self_filter) for nuclide in self.nuclides: new_tally.add_nuclide(nuclide) for score in self.scores: @@ -2274,8 +2275,8 @@ class Tally(object): new_tally.with_summary = self.with_summary new_tally.num_realization = self.num_realizations - for filter in self.filters: - new_tally.add_filter(filter) + for self_filter in self.filters: + new_tally.add_filter(self_filter) for nuclide in self.nuclides: new_tally.add_nuclide(nuclide) for score in self.scores: @@ -2349,8 +2350,8 @@ class Tally(object): new_tally.with_summary = self.with_summary new_tally.num_realization = self.num_realizations - for filter in self.filters: - new_tally.add_filter(filter) + for self_filter in self.filters: + new_tally.add_filter(self_filter) for nuclide in self.nuclides: new_tally.add_nuclide(nuclide) for score in self.scores: @@ -2424,8 +2425,8 @@ class Tally(object): new_tally.with_summary = self.with_summary new_tally.num_realization = self.num_realizations - for filter in self.filters: - new_tally.add_filter(filter) + for self_filter in self.filters: + new_tally.add_filter(self_filter) for nuclide in self.nuclides: new_tally.add_nuclide(nuclide) for score in self.scores: @@ -2503,8 +2504,8 @@ class Tally(object): new_tally.with_summary = self.with_summary new_tally.num_realization = self.num_realizations - for filter in self.filters: - new_tally.add_filter(filter) + for self_filter in self.filters: + new_tally.add_filter(self_filter) for nuclide in self.nuclides: new_tally.add_nuclide(nuclide) for score in self.scores: @@ -2726,26 +2727,26 @@ class Tally(object): # Determine the filter indices from any of the requested filters for i, filter_type in enumerate(filters): - filter = new_tally.find_filter(filter_type) + find_filter = new_tally.find_filter(filter_type) # Remove and/or reorder filter bins to user specifications bin_indices = [] num_bins = 0 for filter_bin in filter_bins[i]: - bin_index = filter.get_bin_index(filter_bin) + bin_index = find_filter.get_bin_index(filter_bin) if filter_type in ['energy', 'energyout']: bin_indices.extend([bin_index, bin_index+1]) num_bins += 1 elif filter_type == 'distribcell': bin_indices = [0] - num_bins = filter.num_bins + num_bins = find_filter.num_bins else: bin_indices.append(bin_index) num_bins += 1 - filter.bins = filter.bins[bin_indices] - filter.num_bins = num_bins + find_filter.bins = find_filter.bins[bin_indices] + find_filter.num_bins = num_bins # Update the new tally's filter strides new_tally._update_filter_strides() @@ -2810,26 +2811,27 @@ class Tally(object): # Sum across any filter bins specified by the user if filter_type in _FILTER_TYPES: - filter = self.find_filter(filter_type) + find_filter = self.find_filter(filter_type) # If user did not specify filter bins, sum across all bins if len(filter_bins) == 0: - bin_indices = np.arange(filter.num_bins) + bin_indices = np.arange(find_filter.num_bins) if filter_type == 'distribcell': - filter_bins = np.arange(filter.num_bins) + filter_bins = np.arange(find_filter.num_bins) else: + num_bins = find_filter.num_bins filter_bins = \ - [(filter.get_bin(i)) for i in range(filter.num_bins)] + [(find_filter.get_bin(i)) for i in range(num_bins)] # Only sum across bins specified by the user else: bin_indices = \ - [filter.get_bin_index(bin) for bin in filter_bins] + [find_filter.get_bin_index(bin) for bin in filter_bins] # Sum across the bins in the user-specified filter - for i, filter in enumerate(self.filters): - if filter.type == filter_type: + for i, self_filter in enumerate(self.filters): + if self_filter.type == filter_type: mean = np.take(mean, indices=bin_indices, axis=i) std_dev = np.take(std_dev, indices=bin_indices, axis=i) mean = np.sum(mean, axis=i, keepdims=True) @@ -2838,12 +2840,13 @@ class Tally(object): # Add AggregateFilter to the tally sum if not remove_filter: - filter_sum = AggregateFilter(filter, filter_bins, 'sum') + filter_sum = \ + AggregateFilter(self_filter, filter_bins, 'sum') tally_sum.add_filter(filter_sum) # Add a copy of each filter not summed across to the tally sum else: - tally_sum.add_filter(copy.deepcopy(filter)) + tally_sum.add_filter(copy.deepcopy(self_filter)) # Add a copy of this tally's filters to the tally sum else: