added nsweeps parameter to level + LU2 for MG testing

Author: pancetta

playgrounds/HeatEquation/HookClass_error_output.py

@@ -0,0 +1,47 @@
+from __future__ import division
+from pySDC.core.Hooks import hooks
+
+
+class error_output(hooks):
+    """
+    Hook class to add output of error
+    """
+
+    def pre_iteration(self, step, level_number):
+
+        super(error_output, self).pre_iteration(step, level_number)
+
+        # some abbreviations
+        L = step.levels[level_number]
+        P = L.prob
+
+        for m in range(1, L.sweep.coll.num_nodes + 1):
+            L.uold[m] = P.dtype_u(L.u[m])
+
+    def post_iteration(self, step, level_number):
+        """
+        Default routine called after each iteration
+        Args:
+            step: the current step
+            level_number: the current level number
+        """
+
+        super(error_output, self).post_iteration(step, level_number)
+
+        # some abbreviations
+        L = step.levels[level_number]
+        P = L.prob
+
+        L.sweep.compute_end_point()
+
+        uex = P.u_exact(step.time + step.dt)
+        err = abs(uex - L.uend)
+
+        est = []
+
+        for m in range(1, L.sweep.coll.num_nodes + 1):
+            est.append(abs(L.uold[m] - L.u[m]))
+
+        est_all = max(est)
+
+        print(step.status.iter, err, est_all, L.status.residual)

playgrounds/HeatEquation/periodic_playground.py

@@ -6,9 +6,12 @@
 from pySDC.implementations.sweeper_classes.generic_implicit import generic_implicit
 from pySDC.implementations.transfer_classes.TransferMesh import mesh_to_mesh
 from pySDC.implementations.controller_classes.allinclusive_classic_nonMPI import allinclusive_classic_nonMPI
+from pySDC.implementations.controller_classes.allinclusive_multigrid_nonMPI import allinclusive_multigrid_nonMPI
 
 from pySDC.helpers.stats_helper import filter_stats, sort_stats
 
+from playgrounds.HeatEquation.HookClass_error_output import error_output
+
 
 def main():
     """
@@ -17,19 +20,19 @@ def main():
 
     # initialize level parameters
     level_params = dict()
-    level_params['restol'] = 1E-10
+    level_params['restol'] = 1E-08
     level_params['dt'] = 0.25
 
     # initialize sweeper parameters
     sweeper_params = dict()
     sweeper_params['collocation_class'] = CollGaussRadau_Right
     sweeper_params['num_nodes'] = [3]
-    sweeper_params['QI'] = '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'] = 1  # diffusion coefficient
-    problem_params['freq'] = 8  # frequency for the test value
+    problem_params['nu'] = 1E+05  # diffusion coefficient
+    problem_params['freq'] = 4  # frequency for the test value
     problem_params['nvars'] = [128, 64]  # number of degrees of freedom for each level
 
     # initialize step parameters
@@ -45,6 +48,7 @@ def main():
     # initialize controller parameters
     controller_params = dict()
     controller_params['logger_level'] = 30
+    # controller_params['hook_class'] = error_output
 
     # fill description dictionary for easy step instantiation
     description = dict()
@@ -61,7 +65,7 @@ def main():
 
     # set time parameters
     t0 = 0.0
-    Tend = 1.0
+    Tend = 4 * level_params['dt']
 
     # set up number of parallel time-steps to run PFASST with
     num_proc = 4

pySDC/core/Level.py

@@ -51,6 +51,7 @@ class __Pars(FrozenClass):
             def __init__(self, params):
                 self.dt = None
                 self.restol = 0.0
+                self.nsweeps = 1
                 for k, v in params.items():
                     setattr(self, k, v)
                 # freeze class, no further attributes allowed from this point

pySDC/core/Sweeper.py

@@ -76,6 +76,10 @@ def rho(x):
             QT = coll.Qmat[1:, 1:].T
             [_, _, U] = scipy.linalg.lu(QT, overwrite_a=True)
             QDmat[1:, 1:] = U.T
+        elif qd_type == 'LU2':
+            QT = coll.Qmat[1:, 1:].T
+            [_, _, U] = scipy.linalg.lu(QT, overwrite_a=True)
+            QDmat[1:, 1:] = 2 * U.T
         elif qd_type == 'IE':
             for m in range(coll.num_nodes + 1):
                 QDmat[m, 1:m + 1] = coll.delta_m[0:m]
@@ -150,7 +154,7 @@ def compute_residual(self):
         L = self.level
 
         # check if there are new values (e.g. from a sweep)
-        assert L.status.updated
+        # assert L.status.updated
 
         # compute the residual for each node
 

pySDC/implementations/controller_classes/allinclusive_classic_nonMPI.py

@@ -301,7 +301,9 @@ def pfasst(self, S, num_procs):
 
             # 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)
 
@@ -363,7 +365,8 @@ def pfasst(self, S, num_procs):
             # 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)
 
@@ -416,7 +419,8 @@ def pfasst(self, S, num_procs):
 
             # standard sweep workflow: update nodes, compute residual, log progress
             self.hooks.pre_sweep(step=S, level_number=len(S.levels) - 1)
-            S.levels[-1].sweep.update_nodes()
+            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)
@@ -465,7 +469,8 @@ def pfasst(self, S, num_procs):
                 # 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)