PFASST and MSSDC seems to be back to work with MG now..

Author: pancetta

playgrounds/HeatEquation/periodic_playground.py

@@ -25,19 +25,19 @@ def main():
     level_params = dict()
     level_params['restol'] = 1E-08
     level_params['dt'] = 1.0 / num_proc
-    level_params['nsweeps'] = [3, 1]
+    level_params['nsweeps'] = [3]
 
     # initialize sweeper parameters
     sweeper_params = dict()
     sweeper_params['collocation_class'] = CollGaussRadau_Right
     sweeper_params['num_nodes'] = [3]
-    sweeper_params['QI'] = ['LU2', 'LU']  # For the IMEX sweeper, the LU-trick can be activated for the implicit part
+    sweeper_params['QI'] = ['LU']  # For the IMEX sweeper, the LU-trick can be activated for the implicit part
 
     # initialize problem parameters
     problem_params = dict()
     problem_params['nu'] = 0.1  # diffusion coefficient
     problem_params['freq'] = -1  # frequency for the test value
-    problem_params['nvars'] = [128, 64]  # number of degrees of freedom for each level
+    problem_params['nvars'] = [128]  # number of degrees of freedom for each level
 
     # initialize step parameters
     step_params = dict()

pySDC/implementations/controller_classes/allinclusive_multigrid_nonMPI.py

@@ -35,8 +35,6 @@ def __init__(self, num_procs, controller_params, description):
         if self.params.dump_setup:
             self.dump_setup(step=self.MS[0], controller_params=controller_params, description=description)
 
-        assert not (len(self.MS) > 1 and len(self.MS[0].levels) == 1), "ERROR: multigrid cannot do MSSDC"
-
         if num_procs > 1 and len(self.MS[0].levels) > 1:
             for S in self.MS:
                 for L in S.levels:
@@ -142,7 +140,7 @@ def restart_block(self, active_slots, time, u0):
             self.MS[p].init_step(u0)
             # reset some values
             self.MS[p].status.done = False
-            self.MS[p].status.iter = 1
+            self.MS[p].status.iter = 0
             self.MS[p].status.stage = 'SPREAD'
             for l in self.MS[p].levels:
                 l.tag = None
@@ -267,8 +265,7 @@ def pfasst(self, MS):
                 if len(S.levels) > 1 and self.params.predict:  # MLSDC or PFASST with predict
                     S.status.stage = 'PREDICT'
                 else:
-                    self.hooks.pre_iteration(step=S, level_number=0)
-                    S.status.stage = 'IT_FINE'
+                    S.status.stage = 'IT_CHECK'
 
             return MS
 
@@ -278,23 +275,6 @@ def pfasst(self, MS):
             MS = self.predictor(MS)
 
             for S in MS:
-                # update stage
-                self.hooks.pre_iteration(step=S, level_number=0)
-                S.status.stage = 'IT_FINE'
-
-            return MS
-
-        elif stage == 'IT_FINE':
-            # do fine sweep for all steps (virtually parallel)
-
-            for S in MS:
-                # standard sweep workflow: update nodes, compute residual, log progress
-                self.hooks.pre_sweep(step=S, level_number=0)
-                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)
-
                 # update stage
                 S.status.stage = 'IT_CHECK'
 
@@ -305,9 +285,25 @@ def pfasst(self, MS):
             # check whether to stop iterating (parallel)
 
             for S in MS:
-                self.hooks.post_iteration(step=S, level_number=0)
+
+                # send updated values forward
+                if self.params.fine_comm and not S.status.last:
+                    self.logger.debug('Process %2i provides data on level %2i with tag %s'
+                                      % (S.status.slot, 0, S.status.iter))
+                    self.send(S.levels[0], tag=(0, S.status.iter, S.status.slot))
+
+                # # receive values
+                if self.params.fine_comm and not S.status.first:
+                    self.logger.debug('Process %2i receives from %2i on level %2i with tag %s' %
+                                      (S.status.slot, S.prev.status.slot, 0, S.status.iter))
+                    self.recv(S.levels[0], S.prev.levels[0], tag=(0, S.status.iter, S.prev.status.slot))
+
+                S.levels[0].sweep.compute_residual()
                 S.status.done = self.check_convergence(S)
 
+                if S.status.iter > 0:
+                    self.hooks.post_iteration(step=S, level_number=0)
+
             # if not everyone is ready yet, keep doing stuff
             if not all(S.status.done for S in MS):
 
@@ -316,11 +312,7 @@ def pfasst(self, MS):
                     # increment iteration count here (and only here)
                     S.status.iter += 1
                     self.hooks.pre_iteration(step=S, level_number=0)
-                    # multi-level or single-level?
-                    if len(S.levels) > 1:  # MLSDC or PFASST
-                        S.status.stage = 'IT_UP'
-                    else:  # SDC
-                        S.status.stage = 'IT_FINE'
+                    S.status.stage = 'IT_FINE'
 
             else:
                 # if everyone is ready, end
@@ -331,6 +323,25 @@ def pfasst(self, MS):
 
             return MS
 
+        elif stage == 'IT_FINE':
+            # do fine sweep for all steps (virtually parallel)
+
+            for S in MS:
+                # standard sweep workflow: update nodes, compute residual, log progress
+                self.hooks.pre_sweep(step=S, level_number=0)
+                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)
+
+                # update stage
+                if len(S.levels) > 1:  # MLSDC or PFASST
+                    S.status.stage = 'IT_UP'
+                else:  # SDC
+                    S.status.stage = 'IT_CHECK'
+
+            return MS
+
         elif stage == 'IT_UP':
             # go up the hierarchy from finest to coarsest level (parallel)
 
@@ -396,28 +407,31 @@ def pfasst(self, MS):
                     # prolong values
                     S.transfer(source=S.levels[l], target=S.levels[l - 1])
 
-                    # send updated values forward
-                    if self.params.fine_comm and not S.status.last:
-                        self.logger.debug('Process %2i provides data on level %2i with tag %s'
-                                          % (S.status.slot, l - 1, S.status.iter))
-                        self.send(S.levels[l - 1], tag=(l - 1, S.status.iter, S.status.slot))
+                    # on middle levels: do communication and sweep as usual
+                    if l - 1 > 0:
+
+                        # send updated values forward
+                        if self.params.fine_comm and not S.status.last:
+                            self.logger.debug('Process %2i provides data on level %2i with tag %s'
+                                              % (S.status.slot, l - 1, S.status.iter))
+                            self.send(S.levels[l - 1], tag=(l - 1, S.status.iter, S.status.slot))
+
+                        # # receive values
+                        if self.params.fine_comm and not S.status.first:
+                            self.logger.debug('Process %2i receives from %2i on level %2i with tag %s' %
+                                              (S.status.slot, S.prev.status.slot, l - 1, S.status.iter))
+                            self.recv(S.levels[l - 1], S.prev.levels[l - 1], tag=(l - 1, S.status.iter, S.prev.status.slot))
 
-                    # # receive values
-                    if self.params.fine_comm and not S.status.first:
-                        self.logger.debug('Process %2i receives from %2i on level %2i with tag %s' %
-                                          (S.status.slot, S.prev.status.slot, l - 1, S.status.iter))
-                        self.recv(S.levels[l - 1], S.prev.levels[l - 1], tag=(l - 1, S.status.iter, S.prev.status.slot))
 
-                    # on middle levels: do sweep as usual
-                    if l - 1 > 0:
                         self.hooks.pre_sweep(step=S, level_number=l - 1)
                         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)
+                    # on finest level, first check for convergence (where we will communication, too)
 
                 # update stage
-                S.status.stage = 'IT_FINE'
+                S.status.stage = 'IT_CHECK'
 
             return MS