Merge branch 'correct_residual'

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/core/Hooks.py

@@ -123,7 +123,8 @@ def post_sweep(self, step, level_number):
 
         L = step.levels[level_number]
 
-        self.logger.info('Process %2i on time %8.6f at stage %15s: Level: %s -- Iteration: %2i -- Residual: %12.8e',
+        self.logger.info('Process %2i on time %8.6f at stage %15s: Level: %s -- Iteration: %2i -- '
+                         'lagged residual: %12.8e',
                          step.status.slot, L.time, step.status.stage, L.level_index, step.status.iter,
                          L.status.residual)
 

pySDC/implementations/controller_classes/allinclusive_classic_MPI.py

@@ -43,6 +43,8 @@ def __init__(self, controller_params, description, comm):
 
         num_levels = len(self.S.levels)
 
+        assert not (num_procs > 1 and num_levels == 1), "ERROR: classic cannot do MSSDC"
+
         if num_procs > 1 and num_levels > 1:
             for L in self.S.levels:
                 if not L.sweep.coll.right_is_node or L.sweep.params.do_coll_update:
@@ -136,7 +138,7 @@ def restart_block(self, size, time, u0):
         self.S.init_step(u0)
         # reset some values
         self.S.status.done = False
-        self.S.status.iter = 1
+        self.S.status.iter = 0
         self.S.status.stage = 'SPREAD'
         for l in self.S.levels:
             l.tag = None
@@ -237,67 +239,33 @@ def pfasst(self, comm, num_procs):
             # update stage
             if len(self.S.levels) > 1 and self.params.predict:  # MLSDC or PFASST with predict
                 self.S.status.stage = 'PREDICT'
-            elif len(self.S.levels) > 1:  # MLSDC or PFASST without predict
-                self.hooks.pre_iteration(step=self.S, level_number=0)
-                self.S.status.stage = 'IT_FINE'
-            elif num_procs > 1:  # MSSDC
-                self.hooks.pre_iteration(step=self.S, level_number=0)
-                self.S.status.stage = 'IT_COARSE'
-            elif num_procs == 1:  # SDC
-                self.hooks.pre_iteration(step=self.S, level_number=0)
-                self.S.status.stage = 'IT_FINE'
             else:
-                raise ControllerError("Don't know what to do after spread, aborting")
+                self.S.status.stage = 'IT_CHECK'
 
         elif stage == 'PREDICT':
 
             # call predictor (serial)
 
             self.predictor(comm)
 
-            # update stage
-            self.hooks.pre_iteration(step=self.S, level_number=0)
-            self.S.status.stage = 'IT_FINE'
-
-        elif stage == 'IT_FINE':
-
-            # do fine sweep
-
-            # standard sweep workflow: update nodes, compute residual, log progress
-            self.hooks.pre_sweep(step=self.S, level_number=0)
-            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)
-
-            # wait for pending sends before computing uend, if any
-            if len(self.req_send) > 0 and not self.S.status.last and self.params.fine_comm:
-                self.req_send[0].wait()
-
-            self.S.levels[0].sweep.compute_end_point()
-
-            if not self.S.status.last and self.params.fine_comm:
-                self.logger.debug('isend data: process %s, stage %s, time %s, target %s, tag %s, iter %s' %
-                                  (self.S.status.slot, self.S.status.stage, self.S.time, self.S.next,
-                                   0, self.S.status.iter))
-                self.req_send.append(comm.isend(self.S.levels[0].uend, dest=self.S.next, tag=0))
-
             # update stage
             self.S.status.stage = 'IT_CHECK'
 
         elif stage == 'IT_CHECK':
 
             # check whether to stop iterating (parallel)
 
-            self.hooks.post_iteration(step=self.S, level_number=0)
-
             # check if an open request of the status send is pending
             if self.req_status is not None:
                 self.req_status.wait()
 
             # check for convergence or abort
+            self.S.levels[0].sweep.compute_residual()
             self.S.status.done = self.check_convergence(self.S)
 
+            if self.S.status.iter > 0:
+                self.hooks.post_iteration(step=self.S, level_number=0)
+
             # send status forward
             if not self.S.status.last:
                 self.logger.debug('isend status: status %s, process %s, time %s, target %s, tag %s, iter %s' %
@@ -318,21 +286,43 @@ def pfasst(self, comm, num_procs):
                 # increment iteration count here (and only here)
                 self.S.status.iter += 1
                 self.hooks.pre_iteration(step=self.S, level_number=0)
-                # multi-level or single-level?
-                if len(self.S.levels) > 1:  # MLSDC or PFASST
-                    self.S.status.stage = 'IT_UP'
-                elif num_procs > 1:  # MSSDC
-                    self.S.status.stage = 'IT_COARSE_RECV'
-                elif num_procs == 1:  # SDC
-                    self.S.status.stage = 'IT_FINE'
-                else:
-                    raise ControllerError("Weird stage in IT_CHECK")
+                self.S.status.stage = 'IT_FINE'
 
             else:
                 self.S.levels[0].sweep.compute_end_point()
                 self.hooks.post_step(step=self.S, level_number=0)
                 self.S.status.stage = 'DONE'
 
+        elif stage == 'IT_FINE':
+
+            # do fine sweep
+
+            # standard sweep workflow: update nodes, compute residual, log progress
+            self.hooks.pre_sweep(step=self.S, level_number=0)
+            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)
+
+            # wait for pending sends before computing uend, if any
+            if len(self.req_send) > 0 and not self.S.status.last and self.params.fine_comm:
+                self.req_send[0].wait()
+
+            self.S.levels[0].sweep.compute_end_point()
+
+            if not self.S.status.last and self.params.fine_comm:
+                self.logger.debug('isend data: process %s, stage %s, time %s, target %s, tag %s, iter %s' %
+                                  (self.S.status.slot, self.S.status.stage, self.S.time, self.S.next,
+                                   0, self.S.status.iter))
+                self.req_send.append(comm.isend(self.S.levels[0].uend, dest=self.S.next, tag=0))
+
+            # update stage
+            # multi-level or single-level?
+            if len(self.S.levels) > 1:  # MLSDC or PFASST
+                self.S.status.stage = 'IT_UP'
+            else:  # SDC
+                self.S.status.stage = 'IT_CHECK'
+
         elif stage == 'IT_UP':
 
             # go up the hierarchy from finest to coarsest level (parallel)
@@ -397,10 +387,7 @@ def pfasst(self, comm, num_procs):
                 self.send(source=self.S.levels[-1], target=self.S.next, tag=len(self.S.levels) - 1, comm=comm)
 
             # update stage
-            if len(self.S.levels) > 1:  # MLSDC or PFASST
-                self.S.status.stage = 'IT_DOWN'
-            else:  # MSSDC
-                self.S.status.stage = 'IT_CHECK'
+            self.S.status.stage = 'IT_DOWN'
 
         elif stage == 'IT_DOWN':
 
@@ -427,7 +414,7 @@ def pfasst(self, comm, num_procs):
                     self.hooks.post_sweep(step=self.S, level_number=l - 1)
 
             # update stage
-            self.S.status.stage = 'IT_FINE'
+            self.S.status.stage = 'IT_CHECK'
 
         else:
 

pySDC/implementations/controller_classes/allinclusive_classic_nonMPI.py

@@ -30,6 +30,8 @@ def __init__(self, num_procs, controller_params, description):
         for p in range(num_procs):
             self.MS.append(stepclass.step(description))
 
+        assert not (len(self.MS) > 1 and len(self.MS[0].levels) == 1), "ERROR: classic cannot do MSSDC"
+
         if self.params.dump_setup:
             self.dump_setup(step=self.MS[0], controller_params=controller_params, description=description)
 
@@ -144,7 +146,7 @@ def restart_block(self, active_slots, time, u0):
             # reset some values
             self.MS[p].status.done = False
             self.MS[p].status.pred_cnt = active_slots.index(p) + 1
-            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 = False
@@ -216,17 +218,8 @@ def pfasst(self, S, num_procs):
             # update stage
             if len(S.levels) > 1 and self.params.predict:  # MLSDC or PFASST with predict
                 S.status.stage = 'PREDICT_RESTRICT'
-            elif len(S.levels) > 1:  # MLSDC or PFASST without predict
-                self.hooks.pre_iteration(step=S, level_number=0)
-                S.status.stage = 'IT_FINE_SWEEP'
-            elif num_procs > 1:  # MSSDC
-                self.hooks.pre_iteration(step=S, level_number=0)
-                S.status.stage = 'IT_COARSE_SWEEP'
-            elif num_procs == 1:  # SDC
-                self.hooks.pre_iteration(step=S, level_number=0)
-                S.status.stage = 'IT_FINE_SWEEP'
-            else:
-                raise ControllerError("Don't know what to do after spread, aborting")
+            else:  # SDC
+                S.status.stage = 'IT_CHECK'
 
             return S
 
@@ -292,8 +285,34 @@ def pfasst(self, S, num_procs):
                 S.transfer(source=S.levels[l], target=S.levels[l - 1])
 
             # update stage and return
-            self.hooks.pre_iteration(step=S, level_number=0)
-            S.status.stage = 'IT_FINE_SWEEP'
+            S.status.stage = 'IT_CHECK'
+            return S
+
+        elif stage == 'IT_CHECK':
+
+            # check whether to stop iterating
+
+            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 the previous step is still iterating but I am done, un-do me to still forward values
+            if not S.status.first and S.status.done and (S.prev.status.done is not None and not S.prev.status.done):
+                S.status.done = False
+
+            # if I am done, signal accordingly, otherwise proceed
+            if S.status.done:
+                S.levels[0].sweep.compute_end_point()
+                self.hooks.post_step(step=S, level_number=0)
+                S.status.stage = 'DONE'
+            else:
+                # increment iteration count here (and only here)
+                S.status.iter += 1
+                self.hooks.pre_iteration(step=S, level_number=0)
+                S.status.stage = 'IT_FINE_SWEEP'
+            # return
             return S
 
         elif stage == 'IT_FINE_SWEEP':
@@ -321,39 +340,12 @@ def pfasst(self, S, num_procs):
                     self.logger.debug('Process %2i provides data on level %2i with tag %s'
                                       % (S.status.slot, 0, True))
                     self.send(S.levels[0], tag=True)
-                S.status.stage = 'IT_CHECK'
-            else:
-                S.status.stage = 'IT_FINE_SEND'
-            # return
-            return S
-
-        elif stage == 'IT_CHECK':
-
-            # check whether to stop iterating
-
-            self.hooks.post_iteration(step=S, level_number=0)
-
-            S.status.done = self.check_convergence(S)
-
-            # if the previous step is still iterating but I am done, un-do me to still forward values
-            if not S.status.first and S.status.done and (S.prev.status.done is not None and not S.prev.status.done):
-                S.status.done = False
-
-            # if I am done, signal accordingly, otherwise proceed
-            if S.status.done:
-                S.levels[0].sweep.compute_end_point()
-                self.hooks.post_step(step=S, level_number=0)
-                S.status.stage = 'DONE'
-            else:
-                # increment iteration count here (and only here)
-                S.status.iter += 1
-                self.hooks.pre_iteration(step=S, level_number=0)
                 if len(S.levels) > 1:
                     S.status.stage = 'IT_UP'
-                elif num_procs > 1:  # MSSDC
-                    S.status.stage = 'IT_COARSE_RECV'
-                elif num_procs == 1:  # SDC
-                    S.status.stage = 'IT_FINE_SWEEP'
+                else:  # SDC
+                    S.status.stage = 'IT_CHECK'
+            else:
+                S.status.stage = 'IT_FINE_SEND'
             # return
             return S
 
@@ -422,7 +414,6 @@ def pfasst(self, S, num_procs):
             for k in range(S.levels[-1].params.nsweeps):
                 S.levels[-1].sweep.update_nodes()
             S.levels[-1].sweep.compute_residual()
-
             self.hooks.post_sweep(step=S, level_number=len(S.levels) - 1)
 
             # update stage and return
@@ -438,10 +429,7 @@ def pfasst(self, S, num_procs):
                                   % (S.status.slot, len(S.levels) - 1, True))
                 self.send(S.levels[-1], tag=True)
                 # update stage
-                if len(S.levels) > 1:  # MLSDC or PFASST
-                    S.status.stage = 'IT_DOWN'
-                else:  # MSSDC
-                    S.status.stage = 'IT_CHECK'
+                S.status.stage = 'IT_DOWN'
             else:
                 S.status.stage = 'IT_COARSE_SEND'
             # return
@@ -475,7 +463,7 @@ def pfasst(self, S, num_procs):
                     self.hooks.post_sweep(step=S, level_number=l - 1)
 
             # update stage and return
-            S.status.stage = 'IT_FINE_SWEEP'
+            S.status.stage = 'IT_CHECK'
             return S
 
         else: