fxed the other controllers, random initial data

Author: pancetta

playgrounds/HeatEquation/periodic_playground.py

@@ -22,6 +22,7 @@ def main():
     level_params = dict()
     level_params['restol'] = 1E-08
     level_params['dt'] = 0.25
+    level_params['nsweeps'] = [2, 1]
 
     # initialize sweeper parameters
     sweeper_params = dict()
@@ -31,8 +32,8 @@ def main():
 
     # initialize problem parameters
     problem_params = dict()
-    problem_params['nu'] = 1E+05  # diffusion coefficient
-    problem_params['freq'] = 4  # frequency for the test value
+    problem_params['nu'] = 1E-06  # diffusion coefficient
+    problem_params['freq'] = -1  # frequency for the test value
     problem_params['nvars'] = [128, 64]  # number of degrees of freedom for each level
 
     # initialize step parameters
@@ -71,8 +72,8 @@ def main():
     num_proc = 4
 
     # instantiate controller
-    controller = allinclusive_classic_nonMPI(num_procs=num_proc, controller_params=controller_params,
-                                             description=description)
+    controller = allinclusive_multigrid_nonMPI(num_procs=num_proc, controller_params=controller_params,
+                                               description=description)
 
     # get initial values on finest level
     P = controller.MS[0].levels[0].prob

pySDC/implementations/controller_classes/allinclusive_classic_MPI.py

@@ -265,7 +265,8 @@ def pfasst(self, comm, num_procs):
 
             # standard sweep workflow: update nodes, compute residual, log progress
             self.hooks.pre_sweep(step=self.S, level_number=0)
-            self.S.levels[0].sweep.update_nodes()
+            for k in range(self.S.levels[0].params.nsweeps):
+                self.S.levels[0].sweep.update_nodes()
             self.S.levels[0].sweep.compute_residual()
             self.hooks.post_sweep(step=self.S, level_number=0)
 
@@ -341,7 +342,8 @@ def pfasst(self, comm, num_procs):
             # sweep and send on middle levels (not on finest, not on coarsest, though)
             for l in range(1, len(self.S.levels) - 1):
                 self.hooks.pre_sweep(step=self.S, level_number=l)
-                self.S.levels[l].sweep.update_nodes()
+                for k in range(self.S.levels[l].params.nsweeps):
+                    self.S.levels[l].sweep.update_nodes()
                 self.S.levels[l].sweep.compute_residual()
                 self.hooks.post_sweep(step=self.S, level_number=l)
 
@@ -381,7 +383,8 @@ def pfasst(self, comm, num_procs):
 
             # do the sweep
             self.hooks.pre_sweep(step=self.S, level_number=len(self.S.levels) - 1)
-            self.S.levels[-1].sweep.update_nodes()
+            for k in range(self.S.levels[-1].params.nsweeps):
+                self.S.levels[-1].sweep.update_nodes()
             self.S.levels[-1].sweep.compute_residual()
             self.hooks.post_sweep(step=self.S, level_number=len(self.S.levels) - 1)
             self.S.levels[-1].sweep.compute_end_point()
@@ -418,7 +421,8 @@ def pfasst(self, comm, num_procs):
                 # on middle levels: do sweep as usual
                 if l - 1 > 0:
                     self.hooks.pre_sweep(step=self.S, level_number=l - 1)
-                    self.S.levels[l - 1].sweep.update_nodes()
+                    for k in range(self.S.levels[l - 1].params.nsweeps):
+                        self.S.levels[l - 1].sweep.update_nodes()
                     self.S.levels[l - 1].sweep.compute_residual()
                     self.hooks.post_sweep(step=self.S, level_number=l - 1)
 

pySDC/implementations/controller_classes/allinclusive_multigrid_MPI.py

@@ -267,7 +267,8 @@ def pfasst(self, comm, num_procs):
 
             # standard sweep workflow: update nodes, compute residual, log progress
             self.hooks.pre_sweep(step=self.S, level_number=0)
-            self.S.levels[0].sweep.update_nodes()
+            for k in range(self.S.levels[0].params.nsweeps):
+                self.S.levels[0].sweep.update_nodes()
             self.S.levels[0].sweep.compute_residual()
             self.hooks.post_sweep(step=self.S, level_number=0)
 
@@ -312,7 +313,8 @@ def pfasst(self, comm, num_procs):
             # sweep and send on middle levels (not on finest, not on coarsest, though)
             for l in range(1, len(self.S.levels) - 1):
                 self.hooks.pre_sweep(step=self.S, level_number=l)
-                self.S.levels[l].sweep.update_nodes()
+                for k in range(self.S.levels[l].params.nsweeps):
+                    self.S.levels[l].sweep.update_nodes()
                 self.S.levels[l].sweep.compute_residual()
                 self.hooks.post_sweep(step=self.S, level_number=l)
 
@@ -341,7 +343,8 @@ def pfasst(self, comm, num_procs):
 
             # do the sweep
             self.hooks.pre_sweep(step=self.S, level_number=len(self.S.levels) - 1)
-            self.S.levels[-1].sweep.update_nodes()
+            for k in range(self.S.levels[-1].params.nsweeps):
+                self.S.levels[-1].sweep.update_nodes()
             self.S.levels[-1].sweep.compute_residual()
             self.hooks.post_sweep(step=self.S, level_number=len(self.S.levels) - 1)
             self.S.levels[-1].sweep.compute_end_point()
@@ -389,7 +392,8 @@ def pfasst(self, comm, num_procs):
                 # on middle levels: do sweep as usual
                 if l - 1 > 0:
                     self.hooks.pre_sweep(step=self.S, level_number=l - 1)
-                    self.S.levels[l - 1].sweep.update_nodes()
+                    for k in range(self.S.levels[l - 1].params.nsweeps):
+                        self.S.levels[l - 1].sweep.update_nodes()
                     self.S.levels[l - 1].sweep.compute_residual()
                     self.hooks.post_sweep(step=self.S, level_number=l - 1)
 

pySDC/implementations/controller_classes/allinclusive_multigrid_nonMPI.py

@@ -290,7 +290,8 @@ def pfasst(self, MS):
             for S in MS:
                 # standard sweep workflow: update nodes, compute residual, log progress
                 self.hooks.pre_sweep(step=S, level_number=0)
-                S.levels[0].sweep.update_nodes()
+                for k in range(S.levels[0].params.nsweeps):
+                    S.levels[0].sweep.update_nodes()
                 S.levels[0].sweep.compute_residual()
                 self.hooks.post_sweep(step=S, level_number=0)
 
@@ -340,7 +341,8 @@ def pfasst(self, MS):
                 # sweep and send on middle levels (not on finest, not on coarsest, though)
                 for l in range(1, len(S.levels) - 1):
                     self.hooks.pre_sweep(step=S, level_number=l)
-                    S.levels[l].sweep.update_nodes()
+                    for k in range(S.levels[l].params.nsweeps):
+                        S.levels[l].sweep.update_nodes()
                     S.levels[l].sweep.compute_residual()
                     self.hooks.post_sweep(step=S, level_number=l)
 
@@ -409,7 +411,8 @@ def pfasst(self, MS):
                     # on middle levels: do sweep as usual
                     if l - 1 > 0:
                         self.hooks.pre_sweep(step=S, level_number=l - 1)
-                        S.levels[l - 1].sweep.update_nodes()
+                        for k in range(S.levels[l - 1].params.nsweeps):
+                            S.levels[l - 1].sweep.update_nodes()
                         S.levels[l - 1].sweep.compute_residual()
                         self.hooks.post_sweep(step=S, level_number=l - 1)
 

pySDC/implementations/problem_classes/HeatEquation_1D_FD_periodic.py

@@ -36,7 +36,7 @@ def __init__(self, problem_params, dtype_u, dtype_f):
                 raise ParameterError(msg)
 
         # make sure parameters have the correct form
-        if problem_params['freq'] % 2 != 0:
+        if problem_params['freq'] >= 0 and problem_params['freq'] % 2 != 0:
             raise ProblemError('need even number of frequencies due to periodic BCs')
         if problem_params['nvars'] % 2 != 0:
             raise ProblemError('the setup requires nvars = 2^p per dimension')
@@ -122,8 +122,13 @@ def u_exact(self, t):
         """
 
         me = self.dtype_u(self.init)
-        xvalues = np.array([i * self.dx for i in range(self.params.nvars)])
-        me.values = np.sin(np.pi * self.params.freq * xvalues) * \
-            np.exp(-t * self.params.nu * (np.pi * self.params.freq) ** 2)
+
+        if self.params.freq >= 0:
+            xvalues = np.array([i * self.dx for i in range(self.params.nvars)])
+            me.values = np.sin(np.pi * self.params.freq * xvalues) * \
+                np.exp(-t * self.params.nu * (np.pi * self.params.freq) ** 2)
+        else:
+            np.random.seed(1)
+            me.values = np.random.rand(self.params.nvars)
         me.values = me.values.flatten()
         return me