Made projection a local variable for all classes.

Limiter.py

@@ -38,51 +38,49 @@ class MinMod(Limiter):
         # Pop unnecessary parameter
         config.pop('cell_len')
 
-        self.projection = []
         self.cell = 0
 
     def apply(self, projection, cell):
-        self.projection = projection
         self.cell = cell
-        self._set_cell_slope()
-        is_good_cell = self._determine_modification()
+        self._set_cell_slope(projection)
+        is_good_cell = self._determine_modification(projection)
 
         if is_good_cell:
-            return self.projection[:, self.cell]
+            return projection[:, self.cell]
 
-        adapted_projection = self.projection[:, self.cell].copy()
+        adapted_projection = projection[:, self.cell].copy()
         for i in range(len(adapted_projection)):
             if i > self.erase_degree:
                 adapted_projection[i] = 0
         return adapted_projection
 
-    def _set_cell_slope(self):
+    def _set_cell_slope(self, projection):
         tic = timeit.default_timer()
         slope = []
-        transposed_projection = np.transpose(self.projection)
+        transposed_projection = np.transpose(projection)
         for cell in range(len(transposed_projection)):
             new_entry = sum(transposed_projection[cell][degree] * (degree+0.5)**0.5
-                            for degree in range(1, len(self.projection)))
+                            for degree in range(1, len(projection)))
             slope.append(new_entry)
         toc = timeit.default_timer()
-        print('Trans:', toc-tic)
+        # print('Trans:', toc-tic)
 
         tic = timeit.default_timer()
         slope1 = []
-        transposed_projection = self.projection
+        transposed_projection = projection
         for cell in range(len(transposed_projection[0])):
             new_entry = sum(transposed_projection[degree][cell] * (degree+0.5)**0.5
-                            for degree in range(1, len(self.projection)))
+                            for degree in range(1, len(projection)))
             slope1.append(new_entry)
         toc = timeit.default_timer()
-        print('Vecto:', toc-tic)
-
-        print(slope == slope1)
+        # print('Vecto:', toc-tic)
+        #
+        # print(slope == slope1)
         self.cell_slope = slope[self.cell]
 
-    def _determine_modification(self):
-        forward_slope = (self.projection[0][self.cell+1] - self.projection[0][self.cell]) * (0.5**0.5)
-        backward_slope = (self.projection[0][self.cell] - self.projection[0][self.cell-1]) * (0.5**0.5)
+    def _determine_modification(self, projection):
+        forward_slope = (projection[0][self.cell+1] - projection[0][self.cell]) * (0.5**0.5)
+        backward_slope = (projection[0][self.cell] - projection[0][self.cell-1]) * (0.5**0.5)
 
         return (forward_slope <= 0) & (backward_slope <= 0) & (self.cell_slope <= 0) \
             | (forward_slope >= 0) & (backward_slope >= 0) & (self.cell_slope >= 0)
@@ -98,11 +96,10 @@ class ModifiedMinMod(MinMod):
         # Set name of function
         self.function_name = 'ModifiedMinMod' + str(self.erase_degree)
 
-        self.projection = []
         self.cell = 0
 
-    def _determine_modification(self):
+    def _determine_modification(self, projection):
         if abs(self.cell_slope) <= self.mod_factor*self.cell_len**2:
             return True
 
-        return super()._determine_modification()
+        return super()._determine_modification(projection)

Troubled_Cell_Detector.py

@@ -155,14 +155,12 @@ class Theoretical(WaveletDetector):
         # comment to line above: or 2 or 3
 
         self.multiwavelet_coeffs = []
-        self.projection = []
         self.max_avg = None
 
     def _get_cells(self, multiwavelet_coeffs, projection):
         self.multiwavelet_coeffs = multiwavelet_coeffs
-        self.projection = projection
         troubled_cells = []
-        self.max_avg = max(1, max(abs(self.projection[0][degree]) for degree in range(self.polynom_degree+1)))
+        self.max_avg = max(1, max(abs(projection[0][degree]) for degree in range(self.polynom_degree+1)))
 
         for cell in range(int(self.num_grid_cells/2)):
             if self._is_troubled_cell(cell):