Static errors continuation (#2557)

Co-authored-by: Christina Cai <[email protected]>
Co-authored-by: christinacai123 <[email protected]>

openmc/arithmetic.py

@@ -61,26 +61,26 @@ def __repr__(self):
     def left_score(self):
         return self._left_score
 
-    @property
-    def right_score(self):
-        return self._right_score
-
-    @property
-    def binary_op(self):
-        return self._binary_op
-
     @left_score.setter
     def left_score(self, left_score):
         cv.check_type('left_score', left_score,
                       (str, CrossScore, AggregateScore))
         self._left_score = left_score
 
+    @property
+    def right_score(self):
+        return self._right_score
+
     @right_score.setter
     def right_score(self, right_score):
         cv.check_type('right_score', right_score,
                       (str, CrossScore, AggregateScore))
         self._right_score = right_score
 
+    @property
+    def binary_op(self):
+        return self._binary_op
+
     @binary_op.setter
     def binary_op(self, binary_op):
         cv.check_type('binary_op', binary_op, str)
@@ -132,14 +132,32 @@ def __repr__(self):
     def left_nuclide(self):
         return self._left_nuclide
 
+    @left_nuclide.setter
+    def left_nuclide(self, left_nuclide):
+        cv.check_type('left_nuclide', left_nuclide,
+                      (openmc.Nuclide, CrossNuclide, AggregateNuclide))
+        self._left_nuclide = left_nuclide
+
     @property
     def right_nuclide(self):
         return self._right_nuclide
 
+    @right_nuclide.setter
+    def right_nuclide(self, right_nuclide):
+        cv.check_type('right_nuclide', right_nuclide,
+                      (openmc.Nuclide, CrossNuclide, AggregateNuclide))
+        self._right_nuclide = right_nuclide
+
     @property
     def binary_op(self):
         return self._binary_op
 
+    @binary_op.setter
+    def binary_op(self, binary_op):
+        cv.check_type('binary_op', binary_op, str)
+        cv.check_value('binary_op', binary_op, _TALLY_ARITHMETIC_OPS)
+        self._binary_op = binary_op
+
     @property
     def name(self):
 
@@ -163,24 +181,6 @@ def name(self):
 
         return string
 
-    @left_nuclide.setter
-    def left_nuclide(self, left_nuclide):
-        cv.check_type('left_nuclide', left_nuclide,
-                      (openmc.Nuclide, CrossNuclide, AggregateNuclide))
-        self._left_nuclide = left_nuclide
-
-    @right_nuclide.setter
-    def right_nuclide(self, right_nuclide):
-        cv.check_type('right_nuclide', right_nuclide,
-                      (openmc.Nuclide, CrossNuclide, AggregateNuclide))
-        self._right_nuclide = right_nuclide
-
-    @binary_op.setter
-    def binary_op(self, binary_op):
-        cv.check_type('binary_op', binary_op, str)
-        cv.check_value('binary_op', binary_op, _TALLY_ARITHMETIC_OPS)
-        self._binary_op = binary_op
-
 
 class CrossFilter:
     """A special-purpose filter used to encapsulate all combinations of two
@@ -241,14 +241,32 @@ def __repr__(self):
     def left_filter(self):
         return self._left_filter
 
+    @left_filter.setter
+    def left_filter(self, left_filter):
+        cv.check_type('left_filter', left_filter,
+                      (openmc.Filter, CrossFilter, AggregateFilter))
+        self._left_filter = left_filter
+
     @property
     def right_filter(self):
         return self._right_filter
 
+    @right_filter.setter
+    def right_filter(self, right_filter):
+        cv.check_type('right_filter', right_filter,
+                      (openmc.Filter, CrossFilter, AggregateFilter))
+        self._right_filter = right_filter
+
     @property
     def binary_op(self):
         return self._binary_op
 
+    @binary_op.setter
+    def binary_op(self, binary_op):
+        cv.check_type('binary_op', binary_op, str)
+        cv.check_value('binary_op', binary_op, _TALLY_ARITHMETIC_OPS)
+        self._binary_op = binary_op
+
     @property
     def type(self):
         left_type = self.left_filter.type
@@ -266,24 +284,6 @@ def num_bins(self):
         else:
             return 0
 
-    @left_filter.setter
-    def left_filter(self, left_filter):
-        cv.check_type('left_filter', left_filter,
-                      (openmc.Filter, CrossFilter, AggregateFilter))
-        self._left_filter = left_filter
-
-    @right_filter.setter
-    def right_filter(self, right_filter):
-        cv.check_type('right_filter', right_filter,
-                      (openmc.Filter, CrossFilter, AggregateFilter))
-        self._right_filter = right_filter
-
-    @binary_op.setter
-    def binary_op(self, binary_op):
-        cv.check_type('binary_op', binary_op, str)
-        cv.check_value('binary_op', binary_op, _TALLY_ARITHMETIC_OPS)
-        self._binary_op = binary_op
-
     def get_bin_index(self, filter_bin):
         """Returns the index in the CrossFilter for some bin.
 
@@ -412,28 +412,28 @@ def __repr__(self):
     def scores(self):
         return self._scores
 
-    @property
-    def aggregate_op(self):
-        return self._aggregate_op
-
-    @property
-    def name(self):
-
-        # Append each score in the aggregate to the string
-        string = '(' + ', '.join(self.scores) + ')'
-        return string
-
     @scores.setter
     def scores(self, scores):
         cv.check_iterable_type('scores', scores, str)
         self._scores = scores
 
+    @property
+    def aggregate_op(self):
+        return self._aggregate_op
+
     @aggregate_op.setter
     def aggregate_op(self, aggregate_op):
         cv.check_type('aggregate_op', aggregate_op, (str, CrossScore))
         cv.check_value('aggregate_op', aggregate_op, _TALLY_AGGREGATE_OPS)
         self._aggregate_op = aggregate_op
 
+    @property
+    def name(self):
+
+        # Append each score in the aggregate to the string
+        string = '(' + ', '.join(self.scores) + ')'
+        return string
+
 
 class AggregateNuclide:
     """A special-purpose tally nuclide used to encapsulate an aggregate of a
@@ -486,10 +486,21 @@ def __repr__(self):
     def nuclides(self):
         return self._nuclides
 
+    @nuclides.setter
+    def nuclides(self, nuclides):
+        cv.check_iterable_type('nuclides', nuclides, (str, CrossNuclide))
+        self._nuclides = nuclides
+
     @property
     def aggregate_op(self):
         return self._aggregate_op
 
+    @aggregate_op.setter
+    def aggregate_op(self, aggregate_op):
+        cv.check_type('aggregate_op', aggregate_op, str)
+        cv.check_value('aggregate_op', aggregate_op, _TALLY_AGGREGATE_OPS)
+        self._aggregate_op = aggregate_op
+
     @property
     def name(self):
 
@@ -499,17 +510,6 @@ def name(self):
         string = '(' + ', '.join(map(str, names)) + ')'
         return string
 
-    @nuclides.setter
-    def nuclides(self, nuclides):
-        cv.check_iterable_type('nuclides', nuclides, (str, CrossNuclide))
-        self._nuclides = nuclides
-
-    @aggregate_op.setter
-    def aggregate_op(self, aggregate_op):
-        cv.check_type('aggregate_op', aggregate_op, str)
-        cv.check_value('aggregate_op', aggregate_op, _TALLY_AGGREGATE_OPS)
-        self._aggregate_op = aggregate_op
-
 
 class AggregateFilter:
     """A special-purpose tally filter used to encapsulate an aggregate of a
@@ -588,26 +588,26 @@ def __repr__(self):
     def aggregate_filter(self):
         return self._aggregate_filter
 
+    @aggregate_filter.setter
+    def aggregate_filter(self, aggregate_filter):
+        cv.check_type('aggregate_filter', aggregate_filter,
+                      (openmc.Filter, CrossFilter))
+        self._aggregate_filter = aggregate_filter
+
     @property
     def aggregate_op(self):
         return self._aggregate_op
 
+    @aggregate_op.setter
+    def aggregate_op(self, aggregate_op):
+        cv.check_type('aggregate_op', aggregate_op, str)
+        cv.check_value('aggregate_op', aggregate_op, _TALLY_AGGREGATE_OPS)
+        self._aggregate_op = aggregate_op
+
     @property
     def type(self):
         return self._type
 
-    @property
-    def bins(self):
-        return self._bins
-
-    @property
-    def num_bins(self):
-        return len(self.bins) if self.aggregate_filter else 0
-
-    @property
-    def shape(self):
-        return (self.num_bins,)
-
     @type.setter
     def type(self, filter_type):
         if filter_type not in _FILTER_TYPES:
@@ -617,22 +617,22 @@ def type(self, filter_type):
 
         self._type = filter_type
 
-    @aggregate_filter.setter
-    def aggregate_filter(self, aggregate_filter):
-        cv.check_type('aggregate_filter', aggregate_filter,
-                      (openmc.Filter, CrossFilter))
-        self._aggregate_filter = aggregate_filter
+    @property
+    def bins(self):
+        return self._bins
 
     @bins.setter
     def bins(self, bins):
         cv.check_iterable_type('bins', bins, Iterable)
         self._bins = list(map(tuple, bins))
 
-    @aggregate_op.setter
-    def aggregate_op(self, aggregate_op):
-        cv.check_type('aggregate_op', aggregate_op, str)
-        cv.check_value('aggregate_op', aggregate_op, _TALLY_AGGREGATE_OPS)
-        self._aggregate_op = aggregate_op
+    @property
+    def num_bins(self):
+        return len(self.bins) if self.aggregate_filter else 0
+
+    @property
+    def shape(self):
+        return (self.num_bins,)
 
     def get_bin_index(self, filter_bin):
         """Returns the index in the AggregateFilter for some bin.