From d0471f75ec4c99900a9433049de4473676a7824b Mon Sep 17 00:00:00 2001
From: Thomas Baumann <t.baumann@fz-juelich.de>
Date: Tue, 13 Sep 2022 11:55:56 +0200
Subject: [PATCH 1/8] Added Runge Kutta methods as sweepers

---
 .../AdvectionEquation_1D_FD.py                |   3 +-
 .../sweeper_classes/Runge_Kutta.py            | 197 ++++++++++++++++++
 pySDC/projects/Resilience/accuracy_check.py   |  91 ++++++--
 3 files changed, 269 insertions(+), 22 deletions(-)
 create mode 100644 pySDC/implementations/sweeper_classes/Runge_Kutta.py

diff --git a/pySDC/implementations/problem_classes/AdvectionEquation_1D_FD.py b/pySDC/implementations/problem_classes/AdvectionEquation_1D_FD.py
index 7b34aa79f9..ba53e165b0 100644
--- a/pySDC/implementations/problem_classes/AdvectionEquation_1D_FD.py
+++ b/pySDC/implementations/problem_classes/AdvectionEquation_1D_FD.py
@@ -167,12 +167,13 @@ def solve_system(self, rhs, factor, u0, t):
         me[:] = L.solve(rhs)
         return me
 
-    def u_exact(self, t):
+    def u_exact(self, t, u_init=None, t_init=None):
         """
         Routine to compute the exact solution at time t
 
         Args:
             t (float): current time
+            u_init, t_init: unused parameters for common interface reasons
 
         Returns:
             dtype_u: exact solution
diff --git a/pySDC/implementations/sweeper_classes/Runge_Kutta.py b/pySDC/implementations/sweeper_classes/Runge_Kutta.py
new file mode 100644
index 0000000000..e1d578593d
--- /dev/null
+++ b/pySDC/implementations/sweeper_classes/Runge_Kutta.py
@@ -0,0 +1,197 @@
+import numpy as np
+import logging
+
+from pySDC.core.Sweeper import _Pars
+from pySDC.core.Errors import ParameterError
+from pySDC.implementations.sweeper_classes.generic_implicit import generic_implicit
+
+
+class ButcherTableau(object):
+    def __init__(self, weights, nodes, matrix):
+        """
+        Initialization routine for an collocation object
+
+        Args:
+            weights (numpy.ndarray): Butcher tableau weights
+            nodes (numpy.ndarray): Butcher tableau nodes
+            matrix (numpy.ndarray): Butcher tableau entries
+        """
+        # check if the arguments have the correct form
+        if type(matrix) != np.ndarray:
+            raise ParameterError('Runge-Kutta matrix needs to be supplied as  a numpy array!')
+        elif len(np.unique(matrix.shape)) != 1 or len(matrix.shape) != 2:
+            raise ParameterError('Runge-Kutta matrix needs to be a square 2D numpy array!')
+
+        if type(weights) != np.ndarray:
+            raise ParameterError('Weights need to be supplied as a numpy array!')
+        elif len(weights.shape) != 1:
+            raise ParameterError(f'Incompatible dimension of weights! Need 1, got {len(weights.shape)}')
+        elif len(weights) != matrix.shape[0]:
+            raise ParameterError(f'Incompatible number of weights! Need {matrix.shape[0]}, got {len(weights)}')
+
+        if type(nodes) != np.ndarray:
+            raise ParameterError('Nodes need to be supplied as a numpy array!')
+        elif len(nodes.shape) != 1:
+            raise ParameterError(f'Incompatible dimension of nodes! Need 1, got {len(nodes.shape)}')
+        elif len(nodes) != matrix.shape[0]:
+            raise ParameterError(f'Incompatible number of nodes! Need {matrix.shape[0]}, got {len(nodes)}')
+
+        # Set number of nodes, left and right interval boundaries
+        self.num_nodes = matrix.shape[0]
+        self.tleft = 0.
+        self.tright = 1.
+
+        self.nodes = np.append(nodes, [1])
+        self.weights = weights
+        self.Qmat = np.zeros([self.num_nodes + 1, self.num_nodes + 1])
+        self.Qmat[:-1, :-1] = matrix
+        self.Qmat[-1, :-1] = weights  # this is for computing the solution to the step from the previous stages
+
+        self.left_is_node = True
+        self.right_is_node = self.nodes[-1] == self.tright
+
+        # compute distances between the nodes
+        if self.num_nodes > 1:
+            self.delta_m = self.nodes[1:] - self.nodes[:-1]
+        else:
+            self.delta_m = np.zeros(1)
+        self.delta_m[0] = self.nodes[0] - self.tleft
+
+        # check if the RK scheme is implicit
+        self.implicit = any([matrix[i, i] != 0 for i in range(self.num_nodes)])
+
+
+class RungeKutta(generic_implicit):
+    """
+    Runge-Kutta scheme that fits the interface of a sweeper.
+    However, this is not a sweeper at all, since Runge-Kutta schemes are direct methods. We perform exactly one
+    "iteration" of generic SDC and by choosing Q = Q_Delta = <Butcher tableau>, we can implement a Runge-Kutta to
+    compare to the various flavours of SDC that we can think of.
+
+    I want to emphasize that this sweeper does not fit the intendet purpose of the class it inherits from, but allows
+    to make time measurements to compare SDC to popular schemes that are actually in use.
+
+    This class only supports lower triangular Butcher tableaus such that the system can be solved with forward
+    subsitution. In this way, we don't get the maximum order that we could for the number of stages, but computing the
+    stages is much cheaper. In particular, if the Butcher tableaus is strictly lower trianglar, we get an explicit
+    method, which does not require us to solve a system of equations to compute the stages.
+
+    Attribues:
+        butcher_tableau (ButcherTableau): Butcher tableau for the Runge-Kutta scheme that you want
+    """
+
+    def __init__(self, params):
+        """
+        Initialization routine for the custom sweeper
+
+        Args:
+            params: parameters for the sweeper
+        """
+        # set up logger
+        self.logger = logging.getLogger('sweeper')
+
+        essential_keys = ['butcher_tableau', 'num_nodes']
+        for key in essential_keys:
+            if key not in params:
+                msg = 'need %s to instantiate step, only got %s' % (key, str(params.keys()))
+                self.logger.error(msg)
+                raise ParameterError(msg)
+
+        self.params = _Pars(params)
+
+        self.coll = params['butcher_tableau']
+
+        if not self.coll.right_is_node and not self.params.do_coll_update:
+            self.logger.warning('we need to do a collocation update here, since the right end point is not a node. '
+                                'Changing this!')
+            self.params.do_coll_update = True
+
+        # This will be set as soon as the sweeper is instantiated at the level
+        self.__level = None
+
+        self.parallelizable = False
+
+    def update_nodes(self):
+        """
+        Update the u- and f-values at the collocation nodes -> corresponds to a single sweep over all nodes
+
+        Returns:
+            None
+        """
+
+        # get current level and problem description
+        L = self.level
+        P = L.prob
+
+        # only if the level has been touched before
+        assert L.status.unlocked
+
+        # evaluate at the first node
+        L.f[0] = P.eval_f(L.u[0], L.time)
+
+        # compute the stages
+        for m in range(0, self.coll.num_nodes):
+            # initialize variable to store the solution at which to evaluate to compute the new stage
+            u_temp = L.u[0]
+
+            # add the stages to compute the solution at which to evaluate for the next stage
+            for j in range(0, m + 1):
+                u_temp += L.dt * self.coll.Qmat[m + 1, j] * L.f[j]
+
+            # compute the new stage
+            if self.coll.implicit:
+                L.u[m + 1] = P.solve_system(u_temp, L.dt * self.coll.Qmat[m + 1, m + 1], L.u[m + 1],
+                                            L.time + L.dt * self.coll.nodes[m])
+            else:
+                L.u[m + 1] = u_temp
+            L.f[m + 1] = P.eval_f(L.u[m + 1], L.time + L.dt * self.coll.nodes[m])
+
+        # indicate presence of new values at this level
+        L.status.updated = True
+
+        return None
+
+
+class RK1(RungeKutta):
+    def __init__(self, params):
+        implicit = params.get('implicit', False)
+        nodes = np.array([0.])
+        weights = np.array([1.])
+        if implicit:
+            matrix = np.array([[1.], ])
+        else:
+            matrix = np.array([[0.], ])
+        params['butcher_tableau'] = ButcherTableau(weights, nodes, matrix)
+        super(RK1, self).__init__(params)
+
+
+class MidpointMethod(RungeKutta):
+    '''
+    Runge-Kutta method of second order
+    '''
+    def __init__(self, params):
+        implicit = params.get('implicit', False)
+        nodes = np.array([0, 0.5])
+        weights = np.array([0, 1])
+        matrix = np.zeros((2, 2))
+        if implicit:
+            matrix[1, 1] = 0.5
+        else:
+            matrix[1, 0] = 0.5
+        params['butcher_tableau'] = ButcherTableau(weights, nodes, matrix)
+        super(MidpointMethod, self).__init__(params)
+
+
+class RK4(RungeKutta):
+    '''
+    Explicit Runge-Kutta of fourth order: Everybodies darling.
+    '''
+    def __init__(self, params):
+        nodes = np.array([0, 0.5, 0.5, 1])
+        weights = np.array([1., 2., 2., 1.]) / 6.
+        matrix = np.zeros((4, 4))
+        matrix[1, 0] = 0.5
+        matrix[2, 1] = 0.5
+        matrix[3, 2] = 1.
+        params['butcher_tableau'] = ButcherTableau(weights, nodes, matrix)
+        super(RK4, self).__init__(params)
diff --git a/pySDC/projects/Resilience/accuracy_check.py b/pySDC/projects/Resilience/accuracy_check.py
index 8900c8cf45..c6de943f3b 100644
--- a/pySDC/projects/Resilience/accuracy_check.py
+++ b/pySDC/projects/Resilience/accuracy_check.py
@@ -12,6 +12,10 @@
 from pySDC.projects.Resilience.piline import run_piline
 
 
+class do_nothing(hooks):
+    pass
+
+
 class log_errors(hooks):
 
     def post_step(self, step, level_number):
@@ -44,28 +48,41 @@ def setup_mpl(font_size=8):
     mpl.rcParams.update(style_options)
 
 
-def get_results_from_stats(stats, var, val):
-    e_extrapolated = np.array(get_sorted(stats, type='e_extrapolated'))[:, 1]
-
-    e_loc = np.array(get_sorted(stats, type='e_loc'))[:, 1]
-
+def get_results_from_stats(stats, var, val, hook_class=log_errors):
     results = {
-        'e_embedded': get_sorted(stats, type='e_embedded')[-1][1],
-        'e_extrapolated': e_extrapolated[e_extrapolated != [None]][-1],
-        'e': max([e_loc[-1], np.finfo(float).eps]),
+        'e_embedded': 0.,
+        'e_extrapolated': 0.,
+        'e': 0.,
         var: val,
     }
 
+    if hook_class == log_errors:
+        e_extrapolated = np.array(get_sorted(stats, type='e_extrapolated'))[:, 1]
+        e_embedded = np.array(get_sorted(stats, type='e_embedded'))[:, 1]
+        e_loc = np.array(get_sorted(stats, type='e_loc'))[:, 1]
+
+        if len(e_extrapolated[e_extrapolated != [None]]) > 0:
+            results['e_extrapolated'] = e_extrapolated[e_extrapolated != [None]][-1]
+
+        if len(e_loc[e_loc != [None]]) > 0:
+            results['e'] = max([e_loc[e_loc != [None]][-1], np.finfo(float).eps])
+
+        if len(e_embedded[e_embedded != [None]]) > 0:
+            results['e_embedded'] = e_embedded[e_embedded != [None]][-1]
+
     return results
 
 
-def multiple_runs(ax, k=5, serial=True, Tend_fixed=None):
+def multiple_runs(k=5, serial=True, Tend_fixed=None, custom_description=None, prob=run_piline, dt_list=None,
+                  hook_class=log_errors):
     """
     A simple test program to compute the order of accuracy in time
     """
 
     # assemble list of dt
-    if Tend_fixed:
+    if dt_list is not None:
+        pass
+    elif Tend_fixed:
         dt_list = 0.1 * 10.**-(np.arange(5) / 2)
     else:
         dt_list = 0.01 * 10.**-(np.arange(20) / 10.)
@@ -82,11 +99,19 @@ def multiple_runs(ax, k=5, serial=True, Tend_fixed=None):
                 EstimateExtrapolationErrorNonMPI: {'no_storage': not serial},
             }
         }
+        if custom_description is not None:
+            desc = {**desc, **custom_description}
         Tend = Tend_fixed if Tend_fixed else 30 * dt_list[i]
-        stats, _, _ = run_piline(custom_description=desc, num_procs=num_procs, Tend=Tend,
-                                 hook_class=log_errors)
+        stats, controller, _ = prob(custom_description=desc, num_procs=num_procs, Tend=Tend,
+                                    hook_class=hook_class)
+
+        level = controller.MS[-1].levels[-1]
+        e_glob = abs(level.prob.u_exact(t=level.time + level.dt) - level.u[-1])
+        e_loc = abs(level.prob.u_exact(t=level.time + level.dt, u_init=level.u[0], t_init=level.time) - level.u[-1])
 
-        res_ = get_results_from_stats(stats, 'dt', dt_list[i])
+        res_ = get_results_from_stats(stats, 'dt', dt_list[i], hook_class)
+        res_['e_glob'] = e_glob
+        res_['e_loc'] = e_loc
 
         if i == 0:
             res = res_.copy()
@@ -95,9 +120,19 @@ def multiple_runs(ax, k=5, serial=True, Tend_fixed=None):
         else:
             for key in res_.keys():
                 res[key].append(res_[key])
+    return res
 
-    # visualize results
-    plot(res, ax, k)
+
+def plot_order(res, ax, k):
+    color = plt.rcParams['axes.prop_cycle'].by_key()['color'][k - 2]
+
+    key = 'e_loc'
+    order = get_accuracy_order(res, key=key, thresh=1e-11)
+    label = f'k={k}, p={np.mean(order):.2f}'
+    ax.loglog(res['dt'], res[key], color=color, ls='-', label=label)
+    ax.set_xlabel(r'$\Delta t$')
+    ax.set_ylabel(r'$\epsilon$')
+    ax.legend(frameon=False, loc='lower right')
 
 
 def plot(res, ax, k):
@@ -106,7 +141,7 @@ def plot(res, ax, k):
     color = plt.rcParams['axes.prop_cycle'].by_key()['color'][k - 2]
 
     for i in range(len(keys)):
-        order = get_accuracy_order(res, key=keys[i], order=k)
+        order = get_accuracy_order(res, key=keys[i])
         if keys[i] == 'e_embedded':
             label = rf'$k={{{np.mean(order):.2f}}}$'
             assert np.isclose(np.mean(order), k, atol=3e-1), f'Expected embedded error estimate to have order {k} \
@@ -123,12 +158,13 @@ def plot(res, ax, k):
     ax.legend(frameon=False, loc='lower right')
 
 
-def get_accuracy_order(results, key='e_embedded', order=5):
+def get_accuracy_order(results, key='e_embedded', thresh=1e-14):
     """
     Routine to compute the order of accuracy in time
 
     Args:
-        results: the dictionary containing the errors
+        results (dict): the dictionary containing the errors
+        key (str): The key in the dictionary correspdoning to a specific error
 
     Returns:
         the list of orders
@@ -144,7 +180,7 @@ def get_accuracy_order(results, key='e_embedded', order=5):
         # compute order as log(prev_error/this_error)/log(this_dt/old_dt) <-- depends on the sorting of the list!
         try:
             tmp = np.log(results[key][i] / results[key][i - 1]) / np.log(dt_list[i] / dt_list[i - 1])
-            if results[key][i] > 1e-14 and results[key][i - 1] > 1e-14:
+            if results[key][i] > thresh and results[key][i - 1] > thresh:
                 order.append(tmp)
         except TypeError:
             print('Type Warning', results[key])
@@ -152,10 +188,23 @@ def get_accuracy_order(results, key='e_embedded', order=5):
     return order
 
 
-def plot_all_errors(ax, ks, serial, Tend_fixed=None):
+def plot_orders(ax, ks, serial, Tend_fixed=None, custom_description=None, prob=run_piline, dt_list=None):
+    for i in range(len(ks)):
+        k = ks[i]
+        res = multiple_runs(k=k, serial=serial, Tend_fixed=Tend_fixed, custom_description=custom_description,
+                            prob=prob, dt_list=dt_list, hook_class=do_nothing)
+        plot_order(res, ax, k)
+
+
+def plot_all_errors(ax, ks, serial, Tend_fixed=None, custom_description=None, prob=run_piline):
     for i in range(len(ks)):
         k = ks[i]
-        multiple_runs(k=k, ax=ax, serial=serial, Tend_fixed=Tend_fixed)
+        res = multiple_runs(k=k, serial=serial, Tend_fixed=Tend_fixed, custom_description=custom_description,
+                            prob=prob)
+
+        # visualize results
+        plot(res, ax, k)
+
     ax.plot([None, None], color='black', label=r'$\epsilon_\mathrm{embedded}$', ls='-')
     ax.plot([None, None], color='black', label=r'$\epsilon_\mathrm{extrapolated}$', ls=':')
     ax.plot([None, None], color='black', label=r'$e$', ls='-.')

From 7e694c320484d84e5af6b584687b8337aa636d90 Mon Sep 17 00:00:00 2001
From: Thomas Baumann <t.baumann@fz-juelich.de>
Date: Tue, 13 Sep 2022 13:58:59 +0200
Subject: [PATCH 2/8] Tested the order of the implemented RK rules

---
 .../sweeper_classes/Runge_Kutta.py            |   7 +-
 .../Runge_Kutta/Runge-Kutta-Methods.ipynb     | 107 ++++++++++++++++++
 pySDC/playgrounds/Runge_Kutta/test_order.py   |  53 +++++++++
 3 files changed, 165 insertions(+), 2 deletions(-)
 create mode 100644 pySDC/playgrounds/Runge_Kutta/Runge-Kutta-Methods.ipynb
 create mode 100644 pySDC/playgrounds/Runge_Kutta/test_order.py

diff --git a/pySDC/implementations/sweeper_classes/Runge_Kutta.py b/pySDC/implementations/sweeper_classes/Runge_Kutta.py
index e1d578593d..84c214708c 100644
--- a/pySDC/implementations/sweeper_classes/Runge_Kutta.py
+++ b/pySDC/implementations/sweeper_classes/Runge_Kutta.py
@@ -113,7 +113,7 @@ def __init__(self, params):
 
     def update_nodes(self):
         """
-        Update the u- and f-values at the collocation nodes -> corresponds to a single sweep over all nodes
+        Update the u- and f-values at the collocation nodes
 
         Returns:
             None
@@ -125,6 +125,7 @@ def update_nodes(self):
 
         # only if the level has been touched before
         assert L.status.unlocked
+        assert L.status.sweep <= 1, "RK schemes are direct solvers. Please perform only 1 iteration!"
 
         # evaluate at the first node
         L.f[0] = P.eval_f(L.u[0], L.time)
@@ -138,12 +139,14 @@ def update_nodes(self):
             for j in range(0, m + 1):
                 u_temp += L.dt * self.coll.Qmat[m + 1, j] * L.f[j]
 
-            # compute the new stage
+            # compute the new intermediate solution
             if self.coll.implicit:
                 L.u[m + 1] = P.solve_system(u_temp, L.dt * self.coll.Qmat[m + 1, m + 1], L.u[m + 1],
                                             L.time + L.dt * self.coll.nodes[m])
             else:
                 L.u[m + 1] = u_temp
+
+            # evaluate the new stage
             L.f[m + 1] = P.eval_f(L.u[m + 1], L.time + L.dt * self.coll.nodes[m])
 
         # indicate presence of new values at this level
diff --git a/pySDC/playgrounds/Runge_Kutta/Runge-Kutta-Methods.ipynb b/pySDC/playgrounds/Runge_Kutta/Runge-Kutta-Methods.ipynb
new file mode 100644
index 0000000000..cc6649242a
--- /dev/null
+++ b/pySDC/playgrounds/Runge_Kutta/Runge-Kutta-Methods.ipynb
@@ -0,0 +1,107 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "4473b4af",
+   "metadata": {},
+   "source": [
+    "# Runge-Kutta Methods\n",
+    "Runge-Kutta (RK) methods are single step time marching schemes that use a quadrature rule to compute cheap intermediate solutions and from a combination of these, they compute a final, high order solution to the step.\n",
+    "Sounds familiar?\n",
+    "Indeed, there are a lot of similarities between RK schemes and spectral deferred corrections (SDC)!\n",
+    "\n",
+    "So what are the differences?\n",
+    "The most pronounced difference is that RK methods are direct instead of iterative, but SDC is a direct method as well, if you always perform the same number of iterations.\n",
+    "Actually, in the special case of a single iteration and without preconditioning, SDC is an RK method!\n",
+    "\n",
+    "Significant differences arise in practice from how people deal with the fact that the quadrature matrix is dense, making a direct solution computationally expensive.\n",
+    "In SDC, we take a preconditioner such that we never have to solve the full dense system but iterate with cheaper problems that get us closer to the solution of the dense system.\n",
+    "In RK schemes, however, people usually use different quadrature rules that rely on more intermediate solutions (stages in the RK jargon) to reach the same order but which are lower diagonal like the preconditioners in SDC.\n",
+    "Now we can solve the systems easily again with forward substitution.\n",
+    "In fact, some of the most popular RK schemes are explicit, meaning the quadrature rules are striclty lower triangular and we don't have to solve anything at all!\n",
+    "\n",
+    "## Implementation as a sweeper in pySDC\n",
+    "The fact that there are so many similarities between the RK schemes that people use in practice and SDC means we can easily misuse the sweeper module and change some parameters to get RK behaviour within the same framework we know and love.\n",
+    "\n",
+    "The sweeper does the same thing as other sweepers: It sweeps through the collocation nodes and updates the solutions at the nodes, but it completely forgoes the preconditioner.\n",
+    "\n",
+    "A general lower triangular RK scheme is usually written like this:\n",
+    "$$u_{n+1} = u_n + \\Delta t \\sum_{i=1}^s b_i k_i,$$\n",
+    "with the stages\n",
+    "$$k_i = f\\left(u_n+\\Delta t\\sum_{j=1}^i a_{ij}k_j, t_n+c_i\\Delta t\\right),$$\n",
+    "and the nodes $c_i$.\n",
+    "$f$, $u$, and $\\Delta t$ follow the usual definitions of right hand side, solution and step size.\n",
+    "$s$ is the number of stages of the scheme.\n",
+    "Defining the method are the Runge-Kutta matrix $a_{ij}$ and the weights $b_i$.\n",
+    "These are written in a Butcher tableau.\n",
+    "\n",
+    "We are familiar with nodes.\n",
+    "We have them in SDC the same way as here.\n",
+    "What is the connection between $a_{ij}$ and $b_i$ and the quadrature matrix $q_{ij}$?\n",
+    "In SDC, we had a collocation matrix one larger in each direction than the number of nodes to store the initial conditions.\n",
+    "Here, we generate a collocation one larger in both directions to store the final solution.\n",
+    "That means the last row of the quadrature matrix will carry the weights: $q_{s+1,j}=b_j$ and we just put the rule to compute intermediate stages in the rest of the quadrature matrix: $q_{ij}=a_{ij}$ for $i,j\\leq s$.\n",
+    "\n",
+    "We could now set the preconditioner to the same as the quadrature matrix and use existing sweepers, but to avoid overhead by multiplying many things by zeros, we build a new sweeper with no preconditioner.\n",
+    "\n",
+    "## Practical tests\n",
+    "We confirm that this works by using a few popular RK schemes.\n",
+    "Namely, we try implicit Euler (RK1), implicit midpoint method and explicit RK4 on the van der Pol problem:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "d710dbc2",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAY8AAAEMCAYAAAA8vjqRAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8/fFQqAAAACXBIWXMAAAsTAAALEwEAmpwYAAA8DklEQVR4nO3deVyV1fb48c8WU3FMUzPFWRxRQBElZ8uycM5K8/ar7GbW9TZ8b4NlDlle7eb9dq28t7LZW5b51bJySstssBQV51kxwQlyyAEZ1++PDRxAQBDOec6B9X69eOV5znOes9ATi/3stdc2IoJSSilVFOWcDkAppZTv0eShlFKqyDR5KKWUKjJNHkoppYpMk4dSSqki0+ShlFKqyMo7HYAn1K5dW5o0aeJ0GEop5VM2bNiQICJ18nquTCSPJk2aEBUV5XQYSinlU4wxh/J7Tm9bKaWUKjJNHkoppYpMk4dSSqki0+ShlFKqyDR5KKWUKjJNHkoppYqsTJTqKqVUWZOaChs2QFoaXH99yV9fk4dSSpUCIrB3L6xcCd98A999B2fOQN++sGpVyb+fJg+llPJRx4/Dt9/aZLFyJRw+bI83bgy33w433miThzto8lBKKR9x/jz88IMrWWzZYo/XrGmTxLPPQr9+0KwZGOPeWDR5KKWUl8qct8hMFj//DCkpUKECdO8Of/+7TRahoeDn59nYfDJ5GGOGAJFAXWC2iKxwNiKllCq+zHmLzGSROW8BNkE89phNFt26QeXKjobq+eRhjHkXGACcEJGgbMf7A7MAP+BtEZmR3zVE5HPgc2NMTWAmoMlDKeWTjh+3E9orV+Y9b9GvH/TpA3Xy7G3rHCdGHu8DrwMfZh4wxvgBs4F+QCyw3hizGJtIpud6/WgROZHx5+cyXqeUUj7h/HlYs8aVLHLPW0yYYCe6PTFvURweTx4issYY0yTX4XBgn4gcADDGfAIMFpHp2FFKDsYYA8wAlorIRjeHrJRSVyw1FaKiXMki97zF9Ok2WTgxb1Ec3jLn0QA4nO1xLNClgPP/CtwI1DDGtBCRN3KfYIwZA4wBaNSoUQmGqpRS+ROBPXtcySL3vMXjj9tk4Q3zFsXhLckjr8GZ5HeyiLwKvFrQBUXkLeAtgLCwsHyvpZRSxZXfvEWTJnDHHa71FrVrOxpmifKW5BELNMz2OAA44lAsSilVoILmLW64wXfmLYrDW5LHeiDQGNMUiANGAHc5G5JSSlknT8Ivv9j5ih9+gLVr7bxFxYq+PW9RHE6U6s4DegO1jTGxwGQReccYMw5Yjq2weldEtns6NqWUSk+3cxY//+z62rnTPufnByEhpWfeojicqLYamc/xJcASD4ejlCrjzp+H9etdiWLtWjvSAKhVCyIi4E9/sp1pO3eGKlWcjddbeMttK6WUcjsRO5mdfVQRHW3blgO0aQNDh9pEcf310LIllNNdj/KkyUMpVWolJ9vkkD1ZxMXZ5ypXhi5dYPx4myi6drUjDVU4mjyUUqVGfLy97ZSZKNavh4sX7XNNmkCvXjZRRERAhw5QvjT/BPz9d/jiC3uf7c47S/zypfmvTilViqWlwY4dOUcV+/bZ5666Cjp1gocfdiWL+vWdjdcjjh+Hzz+HBQvs6sS0NBgwQJOHUqrs+uMP+PVXV6L45Rd7DGzTwG7dYMwYmyw6dYJKlZyN12OOHIGFC23C+OEHWy4WGAhPPQXDh9v6YTfQ5KGU8joicOBAzlHF1q32uDHQvj3cdZdrYrs0L8bL02+/wf/9n00YP/9sj7VrBxMnwm23QVCQ2/9CNHkopRx38aLd9Ch7sjiR0Tu7enU7mT1smE0U4eFQo4az8Tpi/35Xwli/3h4LCYEXXrAJo00bj4ajyUMp5VEiEBNjb0H98ov92rjRrtgGaNEC+vd3jSrati07q7YvsWuXK2FER9tjnTvDjBk2YbRo4VhomjyUUm519qz9RfmXX1wJI3NU4e8PYWF2h7xu3ezEdt26jobrLBHYvt0miwUL7J/BZtF//tMOv5o0cTTETJo8lFIlJi3NtvLIPqrYvt3+TARo1QpuucWur+ja1d6av+oqZ2N2nIgdVWQmjD177HxFz57w6qs2YTRo4HSUl9DkoZS6YidO2ESRmSzWrbMjDbAdZrt0sQU/XbvauYqaNZ2N12uI2OFYZsI4eNDem+vTxzbOGjIE6tVzOsoCafJQShVKUhJs3uwaUfz6q62IAvtzLzjY9oDq2tV+BQaWsQqoy0lPtysYFyyw8xiHD9th14032h7ugwf71IYfmjyUUpcQgUOHcs5TbNxo230ABATYUcVDD9n/dupUdrvLFigtza69WLDArsU4etT2cb/pJnjxRRg40GeHY5o8lFKcPWv32c4+qjh+3D6XOan96KM2UXTpYpOHykdKCqxebRPG55/be3v+/nDrrbZCKjLS1h/7OE0eSpUx6el5T2qnp9vnW7aEm2923X7SSe1CSEqy+9AuWGD7SZ08CVWr2tYgt91mqwRKWS93TR5KlXLx8a5E8euvdlI7s61H5qT2sGGuSW3tLFtIiYmwYoVNGIsX27/U6tXt3MVtt9lbU/7+TkfpNpo8lCpFMie1s48qsk9qd+gAo0bZRNGli53U1v0qiuD8eVi61CaMr7+Gc+dstr3tNltWdsMNdk6jDNDkoZSPErEdKzJLZX/91S4XyJzUrl/fLrobO9YmC53UvkKnTsGXX9oJ7+XLbS+VOnVsc63hw6F3b++9r5d4FFLOQvWWJX5pTR5K+YiTJ+0tp8xEsW6d3bIBbFLQSe0SdOyYnexeuNC2Nk9NtX+hY8bYrQZ79PDunilpSbD7X7DtRagVBjd+V+JvoclDKS+U/fZT5lfmXhXG2AaqQ4a4EkXbtqV8YyNPOHgQFi2yCePnn+3QLjAQnnjCTgqFhXn/whURiPsSNv4PnNsPDQZB6Ey3vJV+3JRyWGb78eyJYtOmnLefunSB+++3/w0Lg2rVnI25VBCxu0ktXGi/MhsPhoTA88/bhNG2rfcnjExndsCGx+DYN1C9DfReBvVvdtvb+WzyMMZUAdYAk0XkK6fjUaqw9PaTg0TsgpbMhLFnjz1+/fUwc6a9JdWsmbMxFlXyKdgyBfbOhvLVoNMsCHwIyrl3HsbjycMY8y4wADghIkHZjvcHZgF+wNsiMuMyl3oamO+2QJUqAcnJl95+2rvXPmeM/cV28GBXomjXTm8/lbi0NPjxR5ssFi2ybUH8/KBvX9vOd8gQuO46p6MsuvRU2D8Htky0CaT5GOgwFSrV8cjbO/ExfR94Hfgw84Axxg+YDfQDYoH1xpjF2EQyPdfrRwMdgB1AWdloUvmA3Lef1q2zt5+Skuzz111nE8To0Xr7ye2SkuDbb23C+OILu9ilUiW7+vHFF+3iPV9e0HL8O3uL6vQWqNvLjjZqBns0BI8nDxFZY4xpkutwOLBPRA4AGGM+AQaLyHTsKCUHY0wfoArQFkg0xiwRkfRc54wBxgA0atSoxL8PpU6duvT2U0KCfa5yZVsa+9e/5rz95Cu3z33SuXOwbJlNGF99ZXuuVKtmE8WwYXaHqapVnY6yeM4dhE1PwuH/gyqNoftn0PA2Rz5Y3jJAbgAczvY4FuiS38kiMgHAGHMvkJA7cWSc8xbwFkBYWJiUZLCq7Ml9+2ndOtft8szbT4MG6e0nj8trDUbt2nDHHTZhlJZFe6nnYft02DkTjB90eAFa/w3KO7eC3Vs+3nmlzcv+wBeR90s+FFXWZS6+yxxV5L79VK+eTRD33uu6/VQK+tz5jqNH7a2o/NZgdO9eejK3CMR8DNFPQ2IcNL4LQl+Cys5XUXjL33As0DDb4wDgiEOxqDImIcHuy5N9VHHypH0us/pJbz857MAB1xqMtWt9cw1GUf0eBRsegYS1UKsTdP8U6nRzOqos3pI81gOBxpimQBwwArjL2ZBUaXTxoh1FZB9V7N9vnytXzt5uGjpUF985rrStwSiKxGOw+Vk48B5Uqgtd3oFm94LxriZkTpTqzgN6A7WNMbHYdRrvGGPGAcuxFVbvish2T8emSpf0dDsvkX1Se/Nme5cD7AgiPNze7cjc0MjX51N9Wmlcg1EUaUmwe5ZtKZJ+Edo8CUHPwVXeeU/UiJT+ueSwsDCJiopyOgzlZsePu0YTv/5qb0WdOWOfq1YNOne2yaJLF/vf+vWdjVdhM/mPP7puScXGutZgDB3qu2swikIE4r7KaCmyD+oPgI7/C9UDnY4MY8wGEQnL6zkdkCufdOECbNiQc1Tx22/2uczW4yNGuBJF69be3ceuTLl40W6ctHCh3QcjIcG1BmPaNN9fg1EUZ3bAhsfh2Aqo3hp6L4X6/Z2OqlA0eSivl5bm2vkuM1ls22aPAzRpYluOZ7b0CA3V1uNe5+xZWLLEjjAy98GoXt0miqFDS8cajKJIPgVbn4c9r0P5qtDxX9DyYbe3FClJmjyU14mLy1n5FBVlf9YAXH21HUkMHGgTRefOcO21joar8pOQYEcWCxfCypW21rluXRg50k549+lTOtZgFEV6WkZLkecg6SS0GGPXbHiopUhJ0uShHHX2rE0O2UcVRzKKtK+6yhbX3HOP6/aT7nzn5Q4ftqOLRYtgzRpbtdC4MTz8sB1hXH992b1/eHw1bHg0o6VIz4yWIiFOR3XFNHkoj0lJsbeb1q1zJYodO+x8IUCLFnZTtswy2eBgeytcebndu11NB9evt8fatoVnn7UjjJCQ0llSW1jnYjJaiiyAyo2g+3xoONzn/040eSi3EIGYmJyJYuNGSEy0z19zjR1J3H676/bTNdc4GrIqLBH7j5lZIbVzpz0eHg7Tp9sRRqtWzsboDVLPw46XYOfLgIH2U6HNE462FClJmjxUiTh50v7SmX3xXXy8fa5SJejYER580FUq27Spz//iVbakpcFPP7lGGL/9Zm8/9expb0kNGaIbj2QSgUPzYNNTGS1FRkLIS1Cl4eVf60M0eagiS0qyC36zJ4rse1S0bg2Rka5E0b69nb9QPiYpyZbULlrkamtesSLcdBNMmWKrFmrXdjpK73JyA0Q9Agk/Q82O0O0TqNvd6ajcQpOHKlB6uk0M2RNFdLSdvwDXHhX33edapV2jhqMhq+I4dw6WLrUjjK+/drU1j4x0tTXXTUgulXgMNk/IaClSB7q8DU3vhXKltzhAk4fK4fjxnIli/Xo4fdo+V6WKnZt4/HHXqKJBA7395PN+/93V1nzFCjviqF0b7rzTzl+Ulrbm7pCWDHteha1TM1qK/A3aPQcVSv9vUJo8yrDz5+28Z2aiWLcODh2yz/n52dtNd9zhShRt2pTdKstSJzYWPv/c3pL6/ns7p9GoEYwda0cY3brpP3ZBRODI17alyNm9UD8yo6VIS6cj8xhNHmVEWpoti80+qsi9SrtLF1fr8dBQO9JQpciePa4KqXXr7LE2beDpp23C6NhRh5GFcWYnbHwcji6H6q2g9xKof4vTUXmcJo9SSMT+Ypk9UURF2ZEG6CrtMkPETlBlVkhtz2hUHRYGf/+7vSXVurWjIfqUiwmwbSrs/Q+Ur2JHGi3H+VRLkZKkyaMUOHPm0lXax47Z5ypUsGu0Mie0w8PtYjxdpV1KpaXBzz+7VnnHxNh/7J49YdYsW1LbqJHTUfqWtIu2Vfr2v9u1G83/DB2m2r02yjBNHj4mORm2bMm5+G7XLtfzgYFw442ueYrgYJ3rLPWSk+Hbb+0I44sv4MQJ+1tDv34wcaIdYtbxvd5JjpN0iJlnN2a68JttlR76EtRo63RkXkGThxe73F7aderYBDFqlE0WYWFlp5N1mXfuHCxb5iqp/eMP25U2MtLejrrlFt1YvTiOfw+b/mbXbdQMha7vQb2+TkflVTR5eJH4eNeIIvMr+17anTrBuHGuUUWjRjq/WaZkltQuWmRLai9etCW1w4fbCe8bbtBmYMV1ZhdEPw1xi6FyAER8CE1Ged0WsN5Ak4dDEhNtmWz2208HD9rnMvfSHjbMJorwcPtY99Iug+LibEntwoWuktqGDe3euZkltfrBKL6LJ+z+GvveBL/KEPx3aPVYqelD5Q76qfOAtDQ7L5H99tOWLa4y2YYN7UjioYdsotC9tMu4vEpqW7e2JbVDh9oPiA45S0ZqIuz+F2yfDmkXoMWD0H5ymZ8MLwxNHm6QuZlR5qgiKsp2eQDbuqNzZxg/3iaKzp1L/xbN6jIKKqmdNs0mjDZtHA2x1JF0iPnIthS5cBgCBkPwDKihpcuF5ZPJwxhTDngBqA5EicgHTsXyxx82OWQfVeTezOj//T/XPIVuZqSAnCW1Cxfapf1aUusZx7+DjX+DU5ugVieImAvX9nI6Kp/j8eRhjHkXGACcEJGgbMf7A7MAP+BtEZlRwGUGAw2Ak0CsG8PNISUFtm7NmSh27nRtZhQYaHfWzFxPoZsZqRySkmxJbWaX2uwltZMmaUmtu53ZadukH/nKbsp0/UfQeIROhl8hJ0Ye7wOvAx9mHjDG+AGzgX7YZLDeGLMYm0im53r9aKAVsFZE3jTGLABWuSPQ06dtg9HM208bN9oCF3CVyY4Y4br9pGWy6hJaUuu8xOOwdYrdO7x8Fbu3RqtHwE9/sysOjycPEVljjGmS63A4sE9EDgAYYz4BBovIdOwoJQdjTCyQnPEwzV2xxsXBXXeBv7+do3z4YdeoonFjnbNU+cheUrt8uatL7e23u7rU6pDU/VIvwK5XYMcMu0o88GEImgSVdA+SkuAtcx4NgMPZHscCXQo4fyHwmjGmB7AmrxOMMWOAMQCNrvDecevWdlFeUJBWQ6rLyKtLbcOGtkvt0KFaUutJ6WkQ8187GZ4YBwFDIWRGmep46wne8mnO63d4ye9kEbkA3F/QBUXkLeAtgLCwsHyvVRA/PzvhrVSetEut9zm2EjY9CaeioVZn6DYP6vZwOqpSyVuSRyyQfYPfAOCIQ7EolTcROxTNTBg7dtjj2qXWeae326RxdClUaQzXz4PGd+hkuBt5S/JYDwQaY5oCccAI4C5nQ1IKV0lt5hqM7CW1Dz6oJbVOSzwGWybBgXegfDUIfdm2SdfJcLdzolR3HtAbqJ0x8T1ZRN4xxowDlmMrrN4Vke2ejk0pQEtqfUHqedj5T9j5D0hPhpZ/haCJUPEapyMrM5yothqZz/ElwBIPh6OUde6crctetMhVUlutWs6S2mrVnI5SpafBwQ9gy0RIPAINb7OT4dVaOB1ZmeMtt62U8rzff4fFi11darOX1GZ2qdXNULzH0RWw6Qk4vRWu6QLd50Odbk5HVWZp8lBlS2ZJ7cKFsGaNltT6gtNbMybDl0OVpjZpNByulWwO0/9LVOm3e7drW9bsJbXjx9uEoSW13unCEdg6CQ68B1fVsHuGBz4Mfjoa9AaaPFTpk1lSm1khlVlS27mzltT6gpRzsHMm7HwZJMXuq9FuAlTU/j/eRJOHKh3S0uCnn2zC+PxzV0ltr172ltSQIfb2lPJe6Wl2lLFlIlw8Bo3usJsyVWvudGQqD5o8lO9KSoJVq1wltfHxdoK7Xz+YPNmW1NbWPkZeT8TOZ2x6Es5sg9rXQ4+FUCfC6chUATR5KN9y9mzOktqzZ10ltcOGQf/+WlLrS05utHuGH1sJVZtD9wXQcJjOQfkATR7K+yUk2C61CxfCN9/YEUedOnDnna4utVpS61vOHYTNz8Ghj+3Cvo6vZEyGV3A6MlVImjyUdzp8OGdJbXq6bQPy0EOuklo/P6ejVEV1MQG2vwh7/w2mPLR7Fto8BRVqOB2ZKiJNHsp77NrlKqldv94ea9sWnn3WJozQUL2d4atSL8Duf8GOlyD1HDQbDe2nQOUGTkemrpAmD+UcEbs9Y2ZJ7c6d9nh4OEyfbhNGq1bOxqiKJz0VDrwPWyfbdiINBkHIdKjR1unIVDFp8lCelZYGP/7oGmH89pu9/dSrl92qccgQCAhwOkpVXCIQtxiin4E/dkLtCOj2KdTt7nRkqoRo8lDul5QEK1e6SmoTEuwE9003wfPP25Laa7QbaqkR/zNEPwXxP0H1VrbsNmCI3nIsZTR5KPc4exaWLLEJY8kS+7h69ZwltVWrOh2lKklndsHmZyF2EVSqB53fgOb3Qzn9MVMa6b+qKjkJCbZL7cKFdqSRlAR168KIEXb+om9fLaktjRKPwtYpsP8d8POH9lOhzf9A+SpOR6bcSJOHKp7ffnOV1P7wgy2pbdzYzl8MHQrXX68ltaVVyh+w42XY9b+2B1XgwxD0HFSq63RkygM0eaii27nTNeEdFWWPtWsHEybYhBESove3S7O0ZNj3JmybCkkJ0OhOCJ6mPajKGE0e6vJEYMMGV0ntrl32eJcuMGOGTRgtWzobo3I/SYdD82HLBDh3AK7tCyEvwTVhTkemHKDJQ+UtNTVnSe3hw/b2U+/eMG6cLaltoAu8yoxj39oKqpMb4OoO0HspXHezjjDLME0eyuXiRVdJ7eLFdgK8UiVbUvvCCzBggJbUljWnNkP0eDi6DCo3gq4fQJNRUE7nsco6TR5lXWZJ7cKF9r/nztmS2gEDbEntzTdrSW1ZdP4QbJ4IMf+FCldD6Exo+Rfwq+R0ZMpL+GTyMMY0Al4HEoA9IjLD4ZB8S3y8HVksWmS71CYn25Lau+5yldRW0O6mZVLSSdj+d9jzGmCgzZPQbjxUqOl0ZMrLeDx5GGPeBQYAJ0QkKNvx/sAswA94+zIJoSXwtYi8aYz50K0Blxa//eaav8gsqW3SxM5fDB0KERFaUluWpSbCnldh+3RbgtvsHrteo4ruvqjydtnkYYxZKyIR2R5XA1qIyKYrfM/3saOGrB/6xhg/YDbQD4gF1htjFmMTyfRcrx8NbAImGGPuBOZeYRyl386drgqpDRvssaAgW1I7bBgEB+uEZ1mXngYHP4Stk+BCLNSPtI0Lr27vdGTKyxVm5FERwBjzvyLyPyJy1hjzb+CK9ogUkTXGmCa5DocD+0TkQMZ7fQIMFpHp2FFKDsaYJ4DJGddaALx3JbGUOiJ23cWiRTZp7N5tj3fpAi+9ZEcYgYHOxqi8gwgcWWInw89sg2vCIeK/cG0vpyNTPqIwycMYY+oCfzLG/E1EBPAv4TgaAIezPY4FuhRw/jJgijHmLiAmrxOMMWOAMQCNGjUqmSi9UWqqvQ21aJFd6Z29pPaRR2DwYC2pVTkl/Gq3fj3xPVRtAd3nQ8PhOgpVRVKY5PEM8CPwMfCKMWYPUK6E48jrUyv5nSwi24DhBV1QRN4C3gIICwvL91o+KbOkduFCO/H9+++2pPbmm21J7cCBUKuW01Eqb/PHXtu48PAC20IkbDa0eADKXeV0ZMoHXTZ5iMgy7AQ1xpgI4Hbg/hKOIxbIPjMXABwp4ffwbX/84SqpXbrUVVI7cKC9HdW/P1TRRnQqD4nHbSuRfW+BX0UImgxt/gZXVXM6MuXDilRtJSJrgbVuiGM9EGiMaQrEASOAu9zwPr7lxAlXSe3Klbak9tprYdQomzD69NGSWpW/lLOw85+wayakXYQWYyBoEvjXczoyVQo4Uao7D+gN1DbGxGInvt8xxowDlmMrrN4Vke2ejs0rHDrkKqn98UdbUtu0qS2pHTYMunbVklpVsPQU2DcHtj0PF0/Y+YzgaVBd+4+pkuPx5CEiI/M5vgRY4uFwnCeSs6R240Z7vH17eO45mzA6dNDJTHV5kg6/fQabn4Nz+6BuT+i5GGoXVHui1JXxyRXmPk8E1q93ldTu2WOPd+0K//iHvSXVooWzMSrfcmwlbHoaTm20azR6fQX1b9VfOpTbaPLwlNRUWLPGVVIbGwvly9uS2scesyW19es7HKTyOSc32LUax1ZClcYQ8SE0vksbFyq30+ThThcv2t5RCxfCl1/aklp/f1tSO22abT6oJbXqSvyxF7Y8B7/Nh4rXQMdXIPAhW02llAdo8ihpZ87kLKk9fx5q1HCV1N58s5bUqiuXeCyj7HYOlKsAQROhzRNwVXWnI1NljCaPknDiBHzxhaukNiUF6tWDu++2CaN3by2pVcWTfAZ2vgy7XoH05Iyy24ladqsco8njSsXE5CypFYFmzWxLkMyS2nIlvRBflTlpF2Hvf2D7NEj6HRqPgA4vQDUtqFDO0uRRWCKwY4erpHZTRlPhDh1g0iQ7wtCSWlVS0tPsRkxbJsGF36BeP9vttlYnpyNTCtDkUbD09JwltXv32uMREfDyyzZhNG/ubIyqdBGBI19D9DO2222tTtD1Xah3g9ORKZWDJo+CrF9vbz+VL29bgfzP/9iS2uuuczoyVRrF/2y73cb/aLvddvsUGg0Ho7c/lffR5FGQzp3h449t08Gaug2ncpPT222327jFUKkedP4PNL9fu90qr6bJoyDlysHIPLupKFV85w/D1slw8AMoXxU6vAitH4PyWsqtvJ8mD6U8Lel3u1f4ntcBgVaPQbtn7WI/pXyEJg+lPCX1POyeBTtesu3Sm90D7Z+HKqV4p0tVamnyUMrd0lNg/7u2RXriUWgwEIL/DlcHOR2ZUldMk4dS7iJit3zdPAHO7oU63aDbfKjb3enIlCo2TR5KucOxb22325ProUY76PmFHXHoIlJVSmjyUKokndyU0SJ9BVRuCF3fgyZ3a4t0Vepo8lCqJJzdb1ukH/oEKtSC0JnQ8i/gV8npyJRyC00eShVH4nHY9gLse9Mu6mv3LLR5CirUcDoypdxKk4dSVyLlD9g5E3b9r+182/zPEDQJKutukKps0OShVFGkJcHeN2D7i5CUAI1utyvDq7d0OjKlPMrrk4cxphkwAaghIsMzjlUB/g0kA6tF5CMHQ1RlQXoaHPrYtkg/HwPX9oWQl+CaMKcjU8oRbm3XaYx51xhzwhizLdfx/saY3caYfcaY8QVdQ0QOiMj9uQ4PAxaIyAPAoBIOWykXEYj7GpZ1hLX/DyrUhD7Loe9KTRyqTHP3yON94HXgw8wDxhg/YDbQD4gF1htjFgN+wPRcrx8tIifyuG4AsDXjz2klHLNSVvxPdl+N+B+ganO4fh40vkNbpCuFm5OHiKwxxjTJdTgc2CciBwCMMZ8Ag0VkOjCgkJeOxSaQaPIZPRljxgBjABo10t5BqghOb8tokf5lRov0f9sJcW2RrlQWJ36FagAczvY4NuNYnowx1xhj3gBCjTHPZBxeCNxmjPkP8GVerxORt0QkTETC6tSpU0Khq1Lt/CFYew8s6QAnvofgaTBoHwQ+pIlDqVycmDDPqz+D5HeyiPwOjM117DxwXwnHpcqqi/GwfRrs/Q9goM3foO14bZGuVAGcSB6xQMNsjwOAIw7Eocq6lLN2ncbOmZB2AZrdB+2nQOUApyNTyus5kTzWA4HGmKZAHDACuMuBOFRZlZZkV4RvexGS4qHhMOgwDWq0djoypXyGW5OHMWYe0BuobYyJBSaLyDvGmHHAcmyF1bsist2dcSgF5LFWow8Ez4Da4U5HppTPcXe1VZ4bgIvIEmCJO99bqSwicORrW0F1eivUDIXwN6FeP22RrtQV8voV5koVS/xPtkV6/I9QtQV0+8S2FNG1GkoViyYPVTqd3mp38Iv7Evyvg85vQPPRWnKrVAnR5KFKl3MxsHUyHJwLV1WH4OnQ6hEoX9npyJQqVTR5qNLh4gnYNg32/QeMH7R5Eto+DRVrOR2ZUqWSJg/l21LOws5/wq5/QloiNBsN7SfpWg2l3EyTh/JNuffVaDgcgl+E6q2cjkypMkGTh/It6WkQ8xFsnWR7UV3bF0JmwDWdnY5MqTJFk4fyDSIQ95Vdq3FmG9TqBF3ehno3Oh2ZUmWSJg/l/U78CJvH2zUb1QKh+3xoeJuu1VDKQZo8lPc6vRWin4UjX9m1GuFv2uaFulZDKcdp8lDe59xB2DIZYv4LV9Wwcxot/6prNZTyIpo8lPfIvVaj7VN2rUaFmk5HppTKRZOHcl7KH9nWalyE5vdD0CSonO8Gk0oph2nyUM5JS7K7922fZtdqNLoDOrwA1Vs6HZlS6jI0eSjPS0+z8xlbJ9u1GvX6QfDf4ZowpyNTShWSJg/lOSIQt9h2uz2zHWqFQZd3oN4NTkemlCoiTR7KM45/b/fV+P0X20Kk+wK7/atuxqSUT9LkodzrVDREPwNHl4F/A7sqvOk9UE4/ekr5Mv0/WLnH2X12r/BD86BCLQidCYEPQ3l/pyNTSpUATR6qZCUehW0vwL45UK4CtJtg99aoUMPpyJRSJcgnkocxphkwAaghIsMzjg0BIoG6wGwRWeFchIrk07DjH7D7X5CeAi0ehKDnwL+e05EppdzA7Z3ljDHvGmNOGGO25Tre3xiz2xizzxgzvqBriMgBEbk/17HPReQB4F7gzhIPXBVO6gWbNBY3gx0z7CT4wN3Q+XVNHEqVYp4YebwPvA58mHnAGOMHzAb6AbHAemPMYsAPmJ7r9aNF5EQB138u41rKk9JT4MB7sPV5SDwC9SMheBrUDHY6MqWUB7h95CEia4CTuQ6HA/syRhTJwCfAYBHZKiIDcn3lmTiM9RKwVEQ2uve7UFkkHQ7Nh6/bwboHoWpTuHEN9P5KE4eP8vPzIyQkhKCgIAYOHMjp06cBiImJISgoKOu8OXPm0LFjR06dOsVnn31Gu3btKFeuHFFRUR6Nd9SoUbRq1YqgoCBGjx5NSkpKnuf179+fq6++mgEDBuQ4/vrrr9OiRQuMMSQkJHgi5FLJqQ0RGgCHsz2OzTiWJ2PMNcaYN4BQY8wzGYf/CtwIDDfGjM3jNWOMMVHGmKj4+PgSDL2MEoGjK2BZZ/jpTihXEXp9CTf+AHV7OB2dKgZ/f3+io6PZtm0btWrVYvbsSwfyc+fO5bXXXmPFihXUrFmToKAgFi5cSM+ePT0e76hRo9i1axdbt24lMTGRt99+O8/znnzySebOnXvJ8W7durFy5UoaN27s7lBLNacmzPNaGSb5nSwivwNjcx17FXi1gNe8BbwFEBYWlu+1VSEk/Aqbn4Hj30GVJhAxFxqPhHJ+TkemSlhERARbtmzJcWz+/PnMmDGDVatWUbt2bQDatGlTrPeZMmUK+/fvJy4ujsOHD/PUU0/xwAMPFOq1t956a9afw8PDiY2NzfO8G264gdWrV19yPDQ09IpiVjk5lTxigYbZHgcARxyKReXnzE7bSiR2EVSsA51ehRZjwK+i05GVSo89BtHRJXvNkBD4178Kd25aWhqrVq3i/vtdtSmHDh1i3LhxbNq0iXr1SrYAYsuWLfzyyy+cP3+e0NBQIiMjqVatGj165D2S/fjjj2nbtm3W45SUFObOncusWbNKNC5VOE4lj/VAoDGmKRAHjADucigWldv53+xE+MH3wa8KtJ8KrR+Dq6o5HZlyg8TEREJCQoiJiaFTp07069cv67k6depQq1Yt5s+fz+OPP16i7zt48GD8/f3x9/enT58+rFu3jiFDhhBdyAz68MMP07Nnz3yTjXIvtycPY8w8oDdQ2xgTC0wWkXeMMeOA5dgKq3dFZLu7Y1GXcTEBdkyHPRn3vFs9Bm2fgUq1HQ2rrCjsCKGkZc55nDlzhgEDBjB79mweeeQRACpXrszSpUvp3r07devWZdSoUYW+7oQJE/j6668B8kwIJldfM2MMZ8+eLdTI4/nnnyc+Pp4333yz0PGoEiYipf6rU6dOogqQfFZky1SRT6uJfFxOZO1okXOHnI5KeUiVKlWy/rxx40Zp2LChJCcny8GDB6Vdu3YiInLgwAFp1KiRLFu2LMdre/XqJevXry/ye06ePFmCg4MlMTFREhISpGHDhhIXF1eo186ZM0ciIiLkwoULlz33u+++k8jIyDyfa9y4scTHxxcp7rIGiJJ8fq46VW2lvEFaEux+Db5sDlsnwXX94NZt0PUdqNLI6eiUA0JDQwkODuaTTz7Jcbxp06YsXryY0aNH8+uvv7Jo0SICAgJYu3YtkZGR3HzzzUV+r/DwcCIjI+natSsTJ06kfv36hXrd2LFjOX78OBEREYSEhDB16lQAoqKi+POf/5x1Xo8ePbj99ttZtWoVAQEBLF++HIBXX32VgIAAYmNj6dChQ47XqMIzNrmUbmFhYeLpWnSvlp4Ghz62jQvPx8C1fSB4OtTu4nRkqoyYMmUKVatW5YknnnA6FFUAY8wGEclzlzaf6G2lSogIxH0Fm5+FM9ugZkcIf9Pu5Kf7aiilikCTR1lx4ge7ViP+J6gWCN0+hUbDweidS+V5U6ZMcToEVUyaPEq7U5vtSOPIEvCvb0caze6Dclc5HZlSyodp8iitzh2AzRPtZkxX1YCQl6DlOChf2enIlFKlgCaP0ibxGGx7Efa9aUcXbcdD2yehQk2nI1NKlSKaPEqL5DOw82XY9QqkJ0OLByBoIvhf53RkSqlSSGdLfV1qIuycaTdj2j4NAgbBgJ3Q+d+aOFShGGO4++67sx6npqZSp06drFbmixcvZsaMGXm+tmrVqlf8vrfeemtW+/f8vP/++xw54mp717t3bxo1akT2JQZDhgy5bBynT5/m3//+d9bj1atXX9KqvSiK+/qi6t+/P8HBwbRr146xY8eSlpaW53nTp0+nRYsWtGrVKmtdy4ULF4iMjKR169a0a9eO8eML3Huv0DR5+Kr0VLtP+JeBsOlJuKYL9N8I3eZBtRZOR6d8SJUqVdi2bRuJiYkAfPPNNzRo4NohYdCgQSX2Aye7JUuWcPXVVxd4Tu7kAXD11Vfz008/ATYpHD169LLvlTt5+Jr58+ezefNmtm3bRnx8PJ999tkl5+zYsYNPPvmE7du3s2zZMh5++OGsJPPEE0+wa9cuNm3axE8//cTSpUuLHZMmD18j6fDbZxmbMY2xK8FvWA19lkAtbTWtrswtt9yS1Ydq3rx5jBw5Muu5999/n3HjxgFw8OBBIiIi6Ny5MxMnTsw6Z/Xq1fTs2ZOhQ4fStm1bxo4dS3p6etb12rdvT1BQEE8//XTWa5o0aUJCQgIxMTG0adOGBx54gHbt2nHTTTeRmJjIggULiIqKYtSoUYSEhGQltxEjRmStgF+4cCHDhg3L8b28/PLLdO7cmQ4dOjB58mQAxo8fz/79+wkJCeHJJ58E4Ny5cwwfPpzWrVszatSorNHMqlWrCA0NpX379owePZqkpCQAli1bRuvWrenevTsLFy4s8t/xvffey9ixY+nRowctW7bkq6++KvRrq1evDthRYXJy8iV9wQC++OILRowYQcWKFWnatCktWrRg3bp1VK5cmT59+gBQoUIFOnbsmG8b+yLJr29JafoqFb2t0tNFjqwQWdpJ5CNEvmoncvgLe1yVDo8+KtKrV8l+PfroZd+2SpUqsnnzZrntttskMTFRgoODc/SEeu+99+Qvf/mLiIgMHDhQPvjgAxERef3117P6Yn333XdSsWJF2b9/v6SmpsqNN94on332mcTFxUnDhg3lxIkTkpKSIn369JFFixaJiKu31MGDB8XPz082bdokIiK33367zJ07V0Qu7Z3Vq1cv+eWXX6R9+/aSmpoq/fr1k4MHD2bFsXz5cnnggQckPT1d0tLSJDIyUr7//vscfboy461evbocPnxY0tLSpGvXrvLDDz9IYmKiBAQEyO7du0VE5O6775ZXXnkl6/iePXskPT1dbr/99nx7ZuXnnnvukZtvvlnS0tJkz5490qBBA0lMTJRdu3ZJcHBwnl+nTp3Kev1NN90kV199tYwcOVJSU1Mvuf5f/vKXrL83EZHRo0fLZ599luOcU6dOSdOmTWX//v2FihntbeXjEtbBtzfCdzdBUgJ0/QBu2WznN3RluCoBHTp0ICYmhnnz5uXYbCm3n376KWtUkn2eBGyvqmbNmuHn58fIkSP58ccfWb9+Pb1796ZOnTqUL1+eUaNGsWbNmkuu27RpU0JCQgDo1KkTMTEx+cbg5+dH9+7d+fTTT0lMTKRJkyZZz61YsYIVK1YQGhpKx44d2bVrF3v37s3zOuHh4QQEBFCuXLmslvS7d++madOmtGzZEoB77rmHNWvWsGvXLpo2bUpgYCDGGP70pz/lG19B7rjjDsqVK0dgYCDNmjVj165dtGrViujo6Dy/st/WW758OUePHiUpKYlvv/32kmtLHq2mso9QUlNTGTlyJI888gjNmjW7oviz02orb6abMZUtTvVkzzBo0CCeeOIJVq9eze+//57veXndMsnruDEmzx9oealY0fWZ9vPzy7pFlZ8RI0YwdOjQS1aqiwjPPPMMDz74YI7jeSWj3O+ZmppaYLz5fd/Z3XfffWzatIn69euzZMmSy17DGMPu3bu5884787ze6tWrcySQSpUqMWjQIL744osc+64ABAQEcPiwa3fv2NjYHM0mx4wZQ2BgII899thlv4/C0JGHNzr/G/wyGpYEwbGVdjOmQfuh1V81cSi3GT16NJMmTaJ9+/b5ntOtW7es+YaPPvoox3Pr1q3j4MGDpKen8+mnn9K9e3e6dOnC999/T0JCAmlpacybN49evXoVOqZq1apx9uzZS4736NGDZ555JsfcDMDNN9/Mu+++y7lz5wCIi4vjxIkT+V4nt9atWxMTE8O+ffsAu3d7r169aN26NQcPHmT//v2AncfJy3vvvUd0dHSeiQPgs88+Iz09nf3793PgwAFatWp12ZHHuXPnsooCUlNTWbJkCa1bt77k2oMGDeKTTz4hKSmJgwcPsnfvXsLDwwF47rnnOHPmDP8qwV9QdOThTS7Gw/bpsHc2YHQzJuVRAQEBPProowWeM2vWLO666y5mzZrFbbfdluO5iIgIxo8fz9atW7Mmz8uVK8f06dPp06cPIsKtt97K4MGDCx1T5iSzv78/a9euzTpujMmzI+9NN93Ezp07iYiIAGwp8X//+1+aN29Ot27dCAoK4pZbbiEyMjLP96tUqRLvvfcet99+O6mpqXTu3JmxY8dSsWJF3nrrLSIjI6lduzbdu3dn27Zthf4+MrVq1YpevXpx/Phx3njjDSpVqnTZ15w/f55BgwaRlJREWloaffv2ZezYsYAto46KimLq1Km0a9eOO+64g7Zt21K+fHlmz56Nn58fsbGxTJs2jdatW9OxY0cAxo0bV+xW9NqS3RuknLWL+3bOhLTz0PReaD9Z99RQPmP16tXMnDmzSBVEZc29997LgAEDGD58uNOhFJq2ZPdWaUm2jci2FyEpHhreBh1egBptnI5MKaUKpCMPJ6SnQcx/YetkOH8Iru2bsRlTuNORKaVUFh15eAsRiFucsRnTDqjVCbq8DfVudDoypZQqEk0ennL8e4geD7//AtVaQvfP7G0qXaehlPJBXl+qa4xpZox5xxizINfxKsaYDcYYz3UnuxInN8J3/WFVb7hw2I40Irdn7OKniUMp5ZvcmjyMMe8aY04YY7blOt7fGLPbGLPPGFNgxzUROSAi9+fx1NPA/JKMt0T9sRd+HAHLOsHv6yF0JgzcC83vh3I64FNK+TZ3jzzeB/pnP2CM8QNmA7cAbYGRxpi2xpj2xpivcn3VzeuixpgbgR3AcfeGfwUuHIF1Y+HrNhD3JbR7DgYdgDZ/g/L+Tken1CX8/PwICQkhKCiIgQMHZrVJj4mJISgoKOu8OXPm0LFjR06dOpV1bObMmRhjSEhI8Fi89957b1Y7k5CQEKKjoy85Jzo6moiICNq1a0eHDh349NNPs54bNWoUrVq1IigoiNGjR5OSkuKx2EsTtyYPEVkDnMx1OBzYlzGiSAY+AQaLyFYRGZDr60Q+l+4DdAXuAh4wxlzyfRhjxhhjoowxUfHx8SX4XeUj+ZSd0/iyBRx4FwIfskkj+AWoUMP976/UFfL39yc6Oppt27ZRq1YtZs+efck5c+fO5bXXXmPFihXUrGl3pTx8+DDffPMNjRp5fj3Syy+/nLUKO7MnVnaVK1fmww8/zGpP/thjj2UlxVGjRrFr1y62bt1KYmIib7/9tmeDLyWcmPNoABzO9jg241iejDHXGGPeAEKNMc8AiMgEEXkM+BiYIyLpuV8nIm+JSJiIhNWpU6dEv4EcUs/bVeFfNIUd/7CT4AN2Qdhr4H+t+95XKTeIiIggLi4ux7H58+czY8YMVqxYQe3arm4Hjz/+OP/4xz8K1fMptylTpnD33XfTt29fAgMDmTNnTrFjz65ly5YEBgYCUL9+ferWrUvmL5G33norxhiMMYSHh5dMe/IyyImb73l90vJdbCIivwNj83nu/RKKqejSU2D/27B1Klw8Bg0GQvA0uDr/vkBKFWjDY3AqumSvWTMEOv2rUKempaWxatUq7r/fNcV46NAhxo0bx6ZNm6hXr17W8cWLF9OgQQOCg4OvOLQtW7bwyy+/cP78eUJDQ4mMjKRatWr06NEjz/M//vhj2rZtC8CECROYOnUqN9xwAzNmzMjR5DC3devWkZycTPPmzXMcT0lJYe7cucyaNeuKv4eyzInkEQs0zPY4ADiSz7neR9Lh0KewZSKc2w91ukOPBVCnm9ORKXVFEhMTs1qSd+rUKUe31jp16lCrVi3mz5/P448/DthtTadNm8aKFSuK9b6DBw/G398ff39/+vTpw7p16xgyZEiecxjZTZ8+nXr16pGcnMyYMWN46aWXmDRpUp7nHj16lLvvvpsPPviAcuVy3mh5+OGH6dmzZ77JShXMieSxHgg0xjQF4oAR2LkL7yYCR5dB9DNwejNc3QF6fQ31b9GSW1UyCjlCKGmZcx5nzpxhwIABzJ49m0ceeQSwcwdLly6le/fu1K1bl1GjRrF//34OHjyYNeqIjY2lY8eOrFu3LsfoZMKECVm7E+aVEPJqT3727NnLjjyuu+46wLZUv++++5g5c2ae5//xxx9ERkby4osv0rVr1xzPPf/888THx/Pmm28W4m9I5Sm/XaJK4guYBxwFUrAjjvszjt8K7AH2AxPcGYOUxE6CJ34S+aan3cHvi2YiBz8SSU8r3jWV8hKZu/CJiGzcuFEaNmwoycnJOXbfO3DggDRq1EiWLVt2yeszdwQsismTJ0twcLAkJiZKQkKCNGzYUOLi4gr12iNHjoiISHp6ujz66KPy9NNPX3JOUlKS9O3bV1555ZVLnpszZ45ERETIhQsXihRzWYRTOwmKyEgRuU5ErhKRABF5J+P4EhFpKSLNRWSaO2MolnMx8P1g+KYb/LEHOv8bIndCk7vg0gIvpXxeaGgowcHBWXt2ZGratCmLFy9m9OjR/PrrryXyXuHh4URGRtK1a1cmTpyYY+OigowaNYr27dvTvn17EhISeO655wCIiorKajM+f/581qxZw/vvv39JSe/YsWM5fvw4ERERhISEMHXq1BL5fsoabYxYkAtxsCwMWj1iv8pXKfnglCqDpkyZQtWqVfPck0N5D22MeKUqN4DBh8CvgtORKKWUV9HkcTmaOJQqcbn3Hle+R2/cK6WUKjJNHkoppYpMk4dSSqki0+ShlFKqyDR5KKWUKjJNHkoppYpMk4dSSqkiKxMrzI0x8cChYl6mBnDGA68rzPnFPaeg52oDntsWrniu9N/EqffwxGeosOde7jz9/Hjf+zjx+WksInlviJRf0yv9uqTJ41ueeF1hzi/uOZd5Lt9GaN72daX/Jk69hyc+Q4U993Ln6efH+97Hmz4/Im5ujFjKfOmh1xXm/OKec6Xfi7fxxPdRku/hic9QYc+93Hn6+fG+9/Gmz0/ZuG2lCs8YEyX5NEJT6nL081N26MhD5faW0wEon6afnzJCRx5KKaWKTEceSimlikyTh1JKqSLT5KGUUqrINHmoQjHGtDHGvGGMWWCMecjpeJTvMcYMMcbMMcZ8YYy5yel4VPFo8igDjDHvGmNOGGO25Tre3xiz2xizzxgzvqBriMhOERkL3AFoKWYZU0Kfoc9F5AHgXuBON4arPECrrcoAY0xP4BzwoYgEZRzzA/YA/YBYYD0wEvADpue6xGgROWGMGQSMB14XkY89Fb9yXkl9hjJe90/gIxHZ6KHwlRto8igjjDFNgK+y/Y8fAUwRkZszHj8DICK5/6fP61pfi0ikG8NVXqi4nyFjjAFmAN+IyEqPBK3cprzTASjHNAAOZ3scC3TJ72RjTG9gGFARWOLOwJTPKNJnCPgrcCNQwxjTQkTecGdwyr00eZRdJo9j+Q5DRWQ1sNpdwSifVNTP0KvAq+4LR3mSTpiXXbFAw2yPA4AjDsWifJN+hsowTR5l13og0BjT1BhTARgBLHY4JuVb9DNUhmnyKAOMMfOAtUArY0ysMeZ+EUkFxgHLgZ3AfBHZ7mScynvpZ0jlptVWSimlikxHHkoppYpMk4dSSqki0+ShlFKqyDR5KKWUKjJNHkoppYpMk4dSSqki0+ShlFKqyDR5KKWUKjJNHkp5mDFmqDFGjDGtsx0LMMboBknKZ2jyUMrzRgJR2F5QmW4AOjoTjlJFp+1JlPIgY0xVYD92973PRKSVMaY78AVwGjgLDBWRg85FqdTl6chDKc8aAqwUkS3AeWNMRxH5EduhdrCIhGjiUL5Ak4dSnjUSmJ/x5/kZjwFaAbsdiUipK6DJQykPMcZcA4QDyzIOfQrcmXH8jIikOBacUkWkyUMpzxkOLBGRJICM21PHgLboDnzKx+iEuVIeYoxZDXQA/sh2+BpgAdAOqAyMEZGfPR+dUkWjyUMppVSR6W0rpZRSRabJQymlVJFp8lBKKVVkmjyUUkoVmSYPpZRSRabJQymlVJFp8lBKKVVkmjyUUkoV2f8HZxPX4ktqP4MAAAAASUVORK5CYII=\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "from pySDC.playgrounds.Runge_Kutta.test_order import test_vdp\n",
+    "test_vdp()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7fa01a8e",
+   "metadata": {},
+   "source": [
+    "In the above plot, you can see the local error versus the step size and p in the legend refers to the numerically computed order of the scheme.\n",
+    "Since we have a method of order 1, 2 and 4, we are happy to see the local error is of order 2, 3 and 5, just as we expect."
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.10"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/pySDC/playgrounds/Runge_Kutta/test_order.py b/pySDC/playgrounds/Runge_Kutta/test_order.py
new file mode 100644
index 0000000000..09280c4f55
--- /dev/null
+++ b/pySDC/playgrounds/Runge_Kutta/test_order.py
@@ -0,0 +1,53 @@
+import matplotlib.pyplot as plt
+import numpy as np
+
+from pySDC.projects.Resilience.accuracy_check import plot_orders
+
+from pySDC.projects.Resilience.advection import run_advection
+from pySDC.projects.Resilience.vdp import run_vdp
+
+from pySDC.implementations.sweeper_classes.Runge_Kutta import RK1, RK4, MidpointMethod
+
+
+def plot_order(sweeper, prob, dt_list, description=None, ax=None, Tend_fixed=None):
+    if ax is None:
+        fig, ax = plt.subplots(1, 1)
+
+    description = dict() if description is None else description
+    description['sweeper_class'] = sweeper
+    description['sweeper_params'] = {'implicit': True}
+
+    # determine the order
+    plot_orders(ax, [1], True, Tend_fixed=Tend_fixed, custom_description=description, dt_list=dt_list, prob=prob)
+
+    # decorate
+    colors = {
+        RK1: 'blue',
+        MidpointMethod: 'red',
+        RK4: 'orange',
+    }
+    ax.get_lines()[-1].set_color(colors.get(sweeper, 'black'))
+
+    label = f'{sweeper.__name__} - {ax.get_lines()[-1].get_label()[5:]}'
+    ax.get_lines()[-1].set_label(label)
+    ax.legend(frameon=False)
+
+
+def plot_all_orders(prob, dt_list, Tend):
+    fig, ax = plt.subplots(1, 1)
+    sweepers = [RK1, MidpointMethod, RK4]
+    for i in range(len(sweepers)):
+        plot_order(sweepers[i], prob, dt_list, Tend_fixed=Tend, ax=ax)
+
+
+def test_vdp():
+    Tend = 5e-2
+    plot_all_orders(run_vdp, Tend * 2.**(-np.arange(8)), Tend)
+
+
+def test_advection():
+    plot_all_orders(run_advection, 1.e-3 * 2.**(-np.arange(8)), None)
+
+
+if __name__ == '__main__':
+    test_vdp()

From eeb8260fd143993c125b9e484b204bf954281e98 Mon Sep 17 00:00:00 2001
From: Thomas Baumann <t.baumann@fz-juelich.de>
Date: Tue, 13 Sep 2022 23:43:23 +0200
Subject: [PATCH 3/8] RK methods finally work, both with existing sweepers as
 well as with the new sweepers which avoids integration with both
 preconditioner and quadrature matrix. The nodes might be wrong, which would
 only show up in problems with time-dependent right hand sides.

---
 .../sweeper_classes/Runge_Kutta.py            | 63 ++++++++++++-------
 pySDC/playgrounds/Runge_Kutta/test_order.py   |  8 ++-
 2 files changed, 45 insertions(+), 26 deletions(-)

diff --git a/pySDC/implementations/sweeper_classes/Runge_Kutta.py b/pySDC/implementations/sweeper_classes/Runge_Kutta.py
index 84c214708c..a3f7724eda 100644
--- a/pySDC/implementations/sweeper_classes/Runge_Kutta.py
+++ b/pySDC/implementations/sweeper_classes/Runge_Kutta.py
@@ -1,3 +1,4 @@
+# TODO: Fix the nodes!
 import numpy as np
 import logging
 
@@ -37,15 +38,15 @@ def __init__(self, weights, nodes, matrix):
             raise ParameterError(f'Incompatible number of nodes! Need {matrix.shape[0]}, got {len(nodes)}')
 
         # Set number of nodes, left and right interval boundaries
-        self.num_nodes = matrix.shape[0]
+        self.num_nodes = matrix.shape[0] + 1
         self.tleft = 0.
         self.tright = 1.
 
-        self.nodes = np.append(nodes, [1])
+        self.nodes = np.append(np.append([0], nodes), [1])
         self.weights = weights
         self.Qmat = np.zeros([self.num_nodes + 1, self.num_nodes + 1])
-        self.Qmat[:-1, :-1] = matrix
-        self.Qmat[-1, :-1] = weights  # this is for computing the solution to the step from the previous stages
+        self.Qmat[1:-1, 1:-1] = matrix
+        self.Qmat[-1, 1:-1] = weights  # this is for computing the solution to the step from the previous stages
 
         self.left_is_node = True
         self.right_is_node = self.nodes[-1] == self.tright
@@ -58,7 +59,7 @@ def __init__(self, weights, nodes, matrix):
         self.delta_m[0] = self.nodes[0] - self.tleft
 
         # check if the RK scheme is implicit
-        self.implicit = any([matrix[i, i] != 0 for i in range(self.num_nodes)])
+        self.implicit = any([matrix[i, i] != 0 for i in range(self.num_nodes - 1)])
 
 
 class RungeKutta(generic_implicit):
@@ -110,6 +111,7 @@ def __init__(self, params):
         self.__level = None
 
         self.parallelizable = False
+        self.QI = self.coll.Qmat
 
     def update_nodes(self):
         """
@@ -127,26 +129,22 @@ def update_nodes(self):
         assert L.status.unlocked
         assert L.status.sweep <= 1, "RK schemes are direct solvers. Please perform only 1 iteration!"
 
-        # evaluate at the first node
-        L.f[0] = P.eval_f(L.u[0], L.time)
+        # get number of collocation nodes for easier access
+        M = self.coll.num_nodes
 
-        # compute the stages
-        for m in range(0, self.coll.num_nodes):
-            # initialize variable to store the solution at which to evaluate to compute the new stage
-            u_temp = L.u[0]
+        for m in range(0, M):
+            # build rhs, consisting of the known values from above and new values from previous nodes (at k+1)
+            rhs = L.u[0]
+            for j in range(1, m + 1):
+                rhs += L.dt * self.QI[m + 1, j] * L.f[j]
 
-            # add the stages to compute the solution at which to evaluate for the next stage
-            for j in range(0, m + 1):
-                u_temp += L.dt * self.coll.Qmat[m + 1, j] * L.f[j]
-
-            # compute the new intermediate solution
+            # implicit solve with prefactor stemming from the diagonal of Qd
             if self.coll.implicit:
-                L.u[m + 1] = P.solve_system(u_temp, L.dt * self.coll.Qmat[m + 1, m + 1], L.u[m + 1],
+                L.u[m + 1] = P.solve_system(rhs, L.dt * self.QI[m + 1, m + 1], L.u[m + 1],
                                             L.time + L.dt * self.coll.nodes[m])
             else:
-                L.u[m + 1] = u_temp
-
-            # evaluate the new stage
+                L.u[m + 1] = rhs
+            # update function values
             L.f[m + 1] = P.eval_f(L.u[m + 1], L.time + L.dt * self.coll.nodes[m])
 
         # indicate presence of new values at this level
@@ -168,18 +166,35 @@ def __init__(self, params):
         super(RK1, self).__init__(params)
 
 
+class CrankNicholson(RungeKutta):
+    '''
+    Implicit Runge-Kutta method of second order
+    '''
+    def __init__(self, params):
+        nodes = np.array([0, 1])
+        weights = np.array([0.5, 0.5])
+        matrix = np.zeros((2, 2))
+        matrix[1, 0] = 0.5
+        matrix[1, 1] = 0.5
+        params['butcher_tableau'] = ButcherTableau(weights, nodes, matrix)
+        super(CrankNicholson, self).__init__(params)
+
+
 class MidpointMethod(RungeKutta):
     '''
     Runge-Kutta method of second order
     '''
     def __init__(self, params):
         implicit = params.get('implicit', False)
-        nodes = np.array([0, 0.5])
-        weights = np.array([0, 1])
-        matrix = np.zeros((2, 2))
         if implicit:
-            matrix[1, 1] = 0.5
+            nodes = np.array([0.5])
+            weights = np.array([1])
+            matrix = np.zeros((1, 1))
+            matrix[0, 0] = 1. / 2.
         else:
+            nodes = np.array([0, 0.5])
+            weights = np.array([0, 1])
+            matrix = np.zeros((2, 2))
             matrix[1, 0] = 0.5
         params['butcher_tableau'] = ButcherTableau(weights, nodes, matrix)
         super(MidpointMethod, self).__init__(params)
diff --git a/pySDC/playgrounds/Runge_Kutta/test_order.py b/pySDC/playgrounds/Runge_Kutta/test_order.py
index 09280c4f55..9c1ce8ff35 100644
--- a/pySDC/playgrounds/Runge_Kutta/test_order.py
+++ b/pySDC/playgrounds/Runge_Kutta/test_order.py
@@ -6,7 +6,7 @@
 from pySDC.projects.Resilience.advection import run_advection
 from pySDC.projects.Resilience.vdp import run_vdp
 
-from pySDC.implementations.sweeper_classes.Runge_Kutta import RK1, RK4, MidpointMethod
+from pySDC.implementations.sweeper_classes.Runge_Kutta import RK1, RK4, MidpointMethod, CrankNicholson
 
 
 def plot_order(sweeper, prob, dt_list, description=None, ax=None, Tend_fixed=None):
@@ -25,6 +25,7 @@ def plot_order(sweeper, prob, dt_list, description=None, ax=None, Tend_fixed=Non
         RK1: 'blue',
         MidpointMethod: 'red',
         RK4: 'orange',
+        CrankNicholson: 'purple',
     }
     ax.get_lines()[-1].set_color(colors.get(sweeper, 'black'))
 
@@ -35,7 +36,10 @@ def plot_order(sweeper, prob, dt_list, description=None, ax=None, Tend_fixed=Non
 
 def plot_all_orders(prob, dt_list, Tend):
     fig, ax = plt.subplots(1, 1)
-    sweepers = [RK1, MidpointMethod, RK4]
+    sweepers = [RK1]
+    sweepers = [RK4]
+    sweepers = [MidpointMethod]
+    sweepers = [RK1, MidpointMethod, CrankNicholson, RK4]
     for i in range(len(sweepers)):
         plot_order(sweepers[i], prob, dt_list, Tend_fixed=Tend, ax=ax)
 

From b1df96f4983455db10b8b41e1fc9ce67aa9462ba Mon Sep 17 00:00:00 2001
From: Thomas Baumann <t.baumann@fz-juelich.de>
Date: Wed, 14 Sep 2022 00:04:14 +0200
Subject: [PATCH 4/8] Added unit test for the Runge-Kutta sweeper

---
 pySDC/playgrounds/Runge_Kutta/test_order.py   | 23 +++++++++++++------
 .../test_projects/test_resilience/test_rk.py  |  7 ++++++
 2 files changed, 23 insertions(+), 7 deletions(-)
 create mode 100644 pySDC/tests/test_projects/test_resilience/test_rk.py

diff --git a/pySDC/playgrounds/Runge_Kutta/test_order.py b/pySDC/playgrounds/Runge_Kutta/test_order.py
index 9c1ce8ff35..e26cead824 100644
--- a/pySDC/playgrounds/Runge_Kutta/test_order.py
+++ b/pySDC/playgrounds/Runge_Kutta/test_order.py
@@ -20,6 +20,18 @@ def plot_order(sweeper, prob, dt_list, description=None, ax=None, Tend_fixed=Non
     # determine the order
     plot_orders(ax, [1], True, Tend_fixed=Tend_fixed, custom_description=description, dt_list=dt_list, prob=prob)
 
+    # check if we got the expected order for the local error
+    orders = {
+        RK1: 2,
+        MidpointMethod: 3,
+        RK4: 5,
+        CrankNicholson: 3,
+    }
+    numerical_order = float(ax.get_lines()[-1].get_label()[7:])
+    expected_order = orders.get(sweeper, numerical_order)
+    assert np.isclose(numerical_order, expected_order, atol=2.5e-1),\
+        f"Expected order {expected_order}, got {numerical_order}!"
+
     # decorate
     colors = {
         RK1: 'blue',
@@ -34,24 +46,21 @@ def plot_order(sweeper, prob, dt_list, description=None, ax=None, Tend_fixed=Non
     ax.legend(frameon=False)
 
 
-def plot_all_orders(prob, dt_list, Tend):
+def plot_all_orders(prob, dt_list, Tend, sweepers):
     fig, ax = plt.subplots(1, 1)
-    sweepers = [RK1]
-    sweepers = [RK4]
-    sweepers = [MidpointMethod]
-    sweepers = [RK1, MidpointMethod, CrankNicholson, RK4]
     for i in range(len(sweepers)):
         plot_order(sweepers[i], prob, dt_list, Tend_fixed=Tend, ax=ax)
 
 
 def test_vdp():
     Tend = 5e-2
-    plot_all_orders(run_vdp, Tend * 2.**(-np.arange(8)), Tend)
+    plot_all_orders(run_vdp, Tend * 2.**(-np.arange(8)), Tend, [RK1, MidpointMethod, CrankNicholson, RK4])
 
 
 def test_advection():
-    plot_all_orders(run_advection, 1.e-3 * 2.**(-np.arange(8)), None)
+    plot_all_orders(run_advection, 1.e-3 * 2.**(-np.arange(8)), None, [RK1, MidpointMethod, CrankNicholson])
 
 
 if __name__ == '__main__':
     test_vdp()
+    test_advection()
diff --git a/pySDC/tests/test_projects/test_resilience/test_rk.py b/pySDC/tests/test_projects/test_resilience/test_rk.py
new file mode 100644
index 0000000000..84035b7a34
--- /dev/null
+++ b/pySDC/tests/test_projects/test_resilience/test_rk.py
@@ -0,0 +1,7 @@
+import pytest
+
+from pySDC.playgrounds.Runge_Kutta.test_order import test_vdp, test_advection
+
+def test_main():
+    test_vdp()
+    test_advection()

From 8201e6e4e46d1866b506b6081065456b8d313aa2 Mon Sep 17 00:00:00 2001
From: Thomas Baumann <t.baumann@fz-juelich.de>
Date: Wed, 14 Sep 2022 11:47:19 +0200
Subject: [PATCH 5/8] Checked stability of the methods also in the notebook

---
 .../sweeper_classes/Runge_Kutta.py            |  11 +-
 .../playgrounds/Preconditioners/dahlquist.py  | 139 ++++++++++++++++++
 .../Runge_Kutta/Runge-Kutta-Methods.ipynb     |  50 ++++++-
 pySDC/playgrounds/Runge_Kutta/test_order.py   |  49 +++++-
 4 files changed, 230 insertions(+), 19 deletions(-)
 create mode 100644 pySDC/playgrounds/Preconditioners/dahlquist.py

diff --git a/pySDC/implementations/sweeper_classes/Runge_Kutta.py b/pySDC/implementations/sweeper_classes/Runge_Kutta.py
index a3f7724eda..999123a7b7 100644
--- a/pySDC/implementations/sweeper_classes/Runge_Kutta.py
+++ b/pySDC/implementations/sweeper_classes/Runge_Kutta.py
@@ -1,4 +1,3 @@
-# TODO: Fix the nodes!
 import numpy as np
 import logging
 
@@ -65,12 +64,12 @@ def __init__(self, weights, nodes, matrix):
 class RungeKutta(generic_implicit):
     """
     Runge-Kutta scheme that fits the interface of a sweeper.
-    However, this is not a sweeper at all, since Runge-Kutta schemes are direct methods. We perform exactly one
-    "iteration" of generic SDC and by choosing Q = Q_Delta = <Butcher tableau>, we can implement a Runge-Kutta to
-    compare to the various flavours of SDC that we can think of.
+    Actually, the sweeper idea fits the Runge-Kutta idea when using only lower triangular rules, where solutions
+    at the nodes are succesively computed from earlier nodes. However, we only perform a single iteration of this.
 
-    I want to emphasize that this sweeper does not fit the intendet purpose of the class it inherits from, but allows
-    to make time measurements to compare SDC to popular schemes that are actually in use.
+    We have two choices to realise a Runge-Kutta sweeper: We can choose Q = Q_Delta = <Butcher tableau>, but in this
+    implementation, that would lead to a lot of wasted FLOPS from integrating with Q and then with Q_Delta and
+    subtracting the two. For that reason, we built this new sweeper, which does not have a preconditioner.
 
     This class only supports lower triangular Butcher tableaus such that the system can be solved with forward
     subsitution. In this way, we don't get the maximum order that we could for the number of stages, but computing the
diff --git a/pySDC/playgrounds/Preconditioners/dahlquist.py b/pySDC/playgrounds/Preconditioners/dahlquist.py
new file mode 100644
index 0000000000..a956b0474e
--- /dev/null
+++ b/pySDC/playgrounds/Preconditioners/dahlquist.py
@@ -0,0 +1,139 @@
+# script to run a simple advection problem
+from pySDC.implementations.collocation_classes.gauss_radau_right import CollGaussRadau_Right
+from pySDC.implementations.problem_classes.TestEquation_0D import testequation0d
+from pySDC.implementations.sweeper_classes.generic_implicit import generic_implicit
+from pySDC.implementations.controller_classes.controller_nonMPI import controller_nonMPI
+from pySDC.core.Hooks import hooks
+from pySDC.helpers.stats_helper import get_sorted
+import numpy as np
+import matplotlib.pyplot as plt
+
+
+class log_data(hooks):
+
+    def post_iteration(self, step, level_number):
+
+        super(log_data, self).post_iteration(step, level_number)
+
+        # some abbreviations
+        L = step.levels[level_number]
+
+        L.sweep.compute_end_point()
+
+        self.add_to_stats(process=step.status.slot, time=L.time + L.dt, level=L.level_index, iter=step.status.iter,
+                          sweep=L.status.sweep, type='u', value=L.uend)
+        self.add_to_stats(process=step.status.slot, time=L.time, level=L.level_index, iter=0,
+                          sweep=L.status.sweep, type='dt', value=L.dt)
+
+    def pre_run(self, step, level_number):
+        super(log_data, self).pre_run(step, level_number)
+        L = step.levels[level_number]
+        self.add_to_stats(process=0, time=0, level=0, iter=0, sweep=0, type='lambdas', value=L.prob.params.lambdas)
+
+
+def run_dahlquist(custom_description=None, num_procs=1, Tend=1., hook_class=log_data, fault_stuff=None,
+                  custom_controller_params=None, custom_problem_params=None):
+
+    # initialize level parameters
+    level_params = dict()
+    level_params['dt'] = 1.
+
+    # initialize sweeper parameters
+    sweeper_params = dict()
+    sweeper_params['collocation_class'] = CollGaussRadau_Right
+    sweeper_params['num_nodes'] = 3
+    sweeper_params['QI'] = 'LMMpar'
+
+    # build lambdas
+    re = np.linspace(-30, 30, 400)
+    im = np.linspace(-50, 50, 400)
+    lambdas = np.array([[complex(re[i], im[j]) for i in range(len(re))] for j in range(len(im))]).\
+        reshape((len(re) * len(im)))
+
+    problem_params = {
+        'lambdas': lambdas,
+        'u0': 1.,
+    }
+
+    if custom_problem_params is not None:
+        problem_params = {**problem_params, **custom_problem_params}
+
+    # initialize step parameters
+    step_params = dict()
+    step_params['maxiter'] = 5
+
+    # initialize controller parameters
+    controller_params = dict()
+    controller_params['logger_level'] = 30
+    controller_params['hook_class'] = hook_class
+    controller_params['mssdc_jac'] = False
+
+    if custom_controller_params is not None:
+        controller_params = {**controller_params, **custom_controller_params}
+
+    # fill description dictionary for easy step instantiation
+    description = dict()
+    description['problem_class'] = testequation0d  # pass problem class
+    description['problem_params'] = problem_params  # pass problem parameters
+    description['sweeper_class'] = generic_implicit  # pass sweeper
+    description['sweeper_params'] = sweeper_params  # pass sweeper parameters
+    description['level_params'] = level_params  # pass level parameters
+    description['step_params'] = step_params
+
+    if custom_description is not None:
+        for k in custom_description.keys():
+            if k == 'sweeper_class':
+                description[k] = custom_description[k]
+                continue
+            description[k] = {**description.get(k, {}), **custom_description.get(k, {})}
+
+    # set time parameters
+    t0 = 0.0
+
+    # instantiate controller
+    controller = controller_nonMPI(num_procs=num_procs, controller_params=controller_params,
+                                   description=description)
+
+    # insert faults
+    if fault_stuff is not None:
+        raise NotImplementedError('No fault stuff here...')
+
+    # get initial values on finest level
+    P = controller.MS[0].levels[0].prob
+    uinit = P.u_exact(t0)
+
+    # call main function to get things done...
+    uend, stats = controller.run(u0=uinit, t0=t0, Tend=Tend)
+    return stats, controller, Tend
+
+
+def plot_stability(stats, ax=None, iter=None, colors=None):
+    lambdas = get_sorted(stats, type='lambdas')[0][1]
+    u = get_sorted(stats, type='u', sortby='iter')
+
+    if ax is None:
+        fig, ax = plt.subplots(1, 1)
+
+    iter = [1] if iter is None else iter
+    colors = ['blue', 'red', 'violet', 'green'] if colors is None else colors
+
+    for i in iter:
+        # isolate the solutions from the iteration you want
+        U = np.reshape([me[1] for me in u if me[0] == i], (len(np.unique(lambdas.real)), len(np.unique(lambdas.imag))))
+
+        # get a grid for plotting
+        X, Y = np.meshgrid(np.unique(lambdas.real), np.unique(lambdas.imag))
+        ax.contour(X, Y, U, levels=[1], colors=colors[i - 1])
+        ax.plot([None], [None], color=colors[i - 1], label=f'k={i}')
+
+    # decorate
+    ax.axhline(0, color='black')
+    ax.axvline(0, color='black')
+    ax.legend(frameon=False)
+
+
+if __name__ == '__main__':
+    custom_description = None
+    stats, controller, Tend = run_dahlquist(custom_description=custom_description)
+    plot_stability(stats, iter=[1, 2, 3])
+    plt.show()
diff --git a/pySDC/playgrounds/Runge_Kutta/Runge-Kutta-Methods.ipynb b/pySDC/playgrounds/Runge_Kutta/Runge-Kutta-Methods.ipynb
index cc6649242a..e5598b0f3f 100644
--- a/pySDC/playgrounds/Runge_Kutta/Runge-Kutta-Methods.ipynb
+++ b/pySDC/playgrounds/Runge_Kutta/Runge-Kutta-Methods.ipynb
@@ -39,14 +39,16 @@
     "We have them in SDC the same way as here.\n",
     "What is the connection between $a_{ij}$ and $b_i$ and the quadrature matrix $q_{ij}$?\n",
     "In SDC, we had a collocation matrix one larger in each direction than the number of nodes to store the initial conditions.\n",
-    "Here, we generate a collocation one larger in both directions to store the final solution.\n",
-    "That means the last row of the quadrature matrix will carry the weights: $q_{s+1,j}=b_j$ and we just put the rule to compute intermediate stages in the rest of the quadrature matrix: $q_{ij}=a_{ij}$ for $i,j\\leq s$.\n",
+    "Here, we generate a quadrature matrix two larger in both directions to store the initial conditions as well as the final solution.\n",
+    "That means the last row of the quadrature matrix will carry the weights: $q_{s+1,j+1}=b_j$ and we just put the rule to compute intermediate stages in the rest of the quadrature matrix: $q_{ij}=a_{ij}$ for $1 < i,j\\leq s$.\n",
     "\n",
-    "We could now set the preconditioner to the same as the quadrature matrix and use existing sweepers, but to avoid overhead by multiplying many things by zeros, we build a new sweeper with no preconditioner.\n",
+    "Don't worry about the shifted indices.\n",
+    "There is no interesting maths here, it's just needed to conform to the decision to add a row and column for the initial conditinons in the regular sweepers.\n",
+    "We could now actually set the preconditioner to the same as the quadrature matrix and use existing sweepers, but to avoid overhead by adding a lot of stuff and subtracting the same stuff again, we build a new sweeper with no preconditioner.\n",
     "\n",
     "## Practical tests\n",
     "We confirm that this works by using a few popular RK schemes.\n",
-    "Namely, we try implicit Euler (RK1), implicit midpoint method and explicit RK4 on the van der Pol problem:"
+    "Namely, we try implicit Euler (RK1), implicit midpoint method, Crank-Nicholson and explicit RK4 on the van der Pol problem:"
    ]
   },
   {
@@ -57,7 +59,7 @@
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -69,7 +71,7 @@
     }
    ],
    "source": [
-    "from pySDC.playgrounds.Runge_Kutta.test_order import test_vdp\n",
+    "from pySDC.playgrounds.Runge_Kutta.test_order import test_vdp, plot_all_stability\n",
     "test_vdp()"
    ]
   },
@@ -79,7 +81,41 @@
    "metadata": {},
    "source": [
     "In the above plot, you can see the local error versus the step size and p in the legend refers to the numerically computed order of the scheme.\n",
-    "Since we have a method of order 1, 2 and 4, we are happy to see the local error is of order 2, 3 and 5, just as we expect."
+    "Since we have a method of order 1, 2 and 4, we are happy to see the local error is of order 2, 3 and 5, just as we expect.\n",
+    "\n",
+    "Let's look at stability next."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "93ae79c9",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 792x360 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plot_all_stability()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "19c56583",
+   "metadata": {},
+   "source": [
+    "In the left panel, we have implicit methods and in the right panel we have explicit methods.\n",
+    "The implicit midpoint and Crank-Nicholson methods have the same regions of stability and all implicit methods are A-stable, while explicit methods are only conditionally stable."
    ]
   }
  ],
diff --git a/pySDC/playgrounds/Runge_Kutta/test_order.py b/pySDC/playgrounds/Runge_Kutta/test_order.py
index e26cead824..ba7a4f4cb9 100644
--- a/pySDC/playgrounds/Runge_Kutta/test_order.py
+++ b/pySDC/playgrounds/Runge_Kutta/test_order.py
@@ -2,6 +2,7 @@
 import numpy as np
 
 from pySDC.projects.Resilience.accuracy_check import plot_orders
+from pySDC.playgrounds.Preconditioners.dahlquist import run_dahlquist, plot_stability
 
 from pySDC.projects.Resilience.advection import run_advection
 from pySDC.projects.Resilience.vdp import run_vdp
@@ -9,6 +10,14 @@
 from pySDC.implementations.sweeper_classes.Runge_Kutta import RK1, RK4, MidpointMethod, CrankNicholson
 
 
+colors = {
+    RK1: 'blue',
+    MidpointMethod: 'red',
+    RK4: 'orange',
+    CrankNicholson: 'purple',
+}
+
+
 def plot_order(sweeper, prob, dt_list, description=None, ax=None, Tend_fixed=None):
     if ax is None:
         fig, ax = plt.subplots(1, 1)
@@ -33,12 +42,6 @@ def plot_order(sweeper, prob, dt_list, description=None, ax=None, Tend_fixed=Non
         f"Expected order {expected_order}, got {numerical_order}!"
 
     # decorate
-    colors = {
-        RK1: 'blue',
-        MidpointMethod: 'red',
-        RK4: 'orange',
-        CrankNicholson: 'purple',
-    }
     ax.get_lines()[-1].set_color(colors.get(sweeper, 'black'))
 
     label = f'{sweeper.__name__} - {ax.get_lines()[-1].get_label()[5:]}'
@@ -46,6 +49,38 @@ def plot_order(sweeper, prob, dt_list, description=None, ax=None, Tend_fixed=Non
     ax.legend(frameon=False)
 
 
+def plot_stability_single(sweeper, ax=None, description=None, implicit=True):
+    if ax is None:
+        fig, ax = plt.subplots(1, 1)
+
+    description = dict() if description is None else description
+    description['sweeper_class'] = sweeper
+    description['sweeper_params'] = {'implicit': implicit}
+
+    stats, _, _ = run_dahlquist(custom_description=description)
+    plot_stability(stats, ax=ax, iter=[1], colors=[colors.get(sweeper, 'black')])
+
+    ax.get_lines()[-3].set_label(sweeper.__name__)
+    ax.legend(frameon=False)
+
+
+def plot_all_stability():
+    fig, axs = plt.subplots(1, 2, figsize=(11, 5))
+
+    impl = [True, False]
+    sweepers = [[RK1, MidpointMethod, CrankNicholson], [RK1, MidpointMethod, RK4]]
+    titles = ['implicit', 'explicit']
+
+    for j in range(len(impl)):
+        for i in range(len(sweepers[j])):
+            plot_stability_single(sweepers[j][i], implicit=impl[j], ax=axs[j])
+        axs[j].set_title(titles[j])
+
+    axs[0].set_xlim([-4, 4])
+    axs[0].set_ylim([-4, 4])
+    fig.tight_layout()
+
+
 def plot_all_orders(prob, dt_list, Tend, sweepers):
     fig, ax = plt.subplots(1, 1)
     for i in range(len(sweepers)):
@@ -64,3 +99,5 @@ def test_advection():
 if __name__ == '__main__':
     test_vdp()
     test_advection()
+    plot_all_stability()
+    plt.show()

From af36ecea7bf376a5e4f8cc4c819d8cc26c0d8e90 Mon Sep 17 00:00:00 2001
From: Thomas Baumann <t.baumann@fz-juelich.de>
Date: Wed, 14 Sep 2022 13:15:36 +0200
Subject: [PATCH 6/8] RK sweeper will now give a warning if any conflicting
 options for collocation are given and I shaded the regions of stability in
 the plot

---
 .../sweeper_classes/Runge_Kutta.py            |  5 +++-
 .../playgrounds/Preconditioners/dahlquist.py  | 12 +++++---
 .../Runge_Kutta/Runge-Kutta-Methods.ipynb     | 26 ++++++++++++----
 pySDC/playgrounds/Runge_Kutta/test_order.py   | 30 ++++++++++++++-----
 pySDC/projects/Resilience/accuracy_check.py   | 10 ++++---
 5 files changed, 60 insertions(+), 23 deletions(-)

diff --git a/pySDC/implementations/sweeper_classes/Runge_Kutta.py b/pySDC/implementations/sweeper_classes/Runge_Kutta.py
index 999123a7b7..f3ee9d9315 100644
--- a/pySDC/implementations/sweeper_classes/Runge_Kutta.py
+++ b/pySDC/implementations/sweeper_classes/Runge_Kutta.py
@@ -90,7 +90,7 @@ def __init__(self, params):
         # set up logger
         self.logger = logging.getLogger('sweeper')
 
-        essential_keys = ['butcher_tableau', 'num_nodes']
+        essential_keys = ['butcher_tableau']
         for key in essential_keys:
             if key not in params:
                 msg = 'need %s to instantiate step, only got %s' % (key, str(params.keys()))
@@ -99,6 +99,9 @@ def __init__(self, params):
 
         self.params = _Pars(params)
 
+        if 'collocation_class' in params or 'num_nodes' in params:
+            self.logger.warning('You supplied parameters to setup a collocation problem to the Runge-Kutta sweeper. \
+Please be aware that they are ignored since the quadrature matrix is entirely determined by the Butcher tableau.')
         self.coll = params['butcher_tableau']
 
         if not self.coll.right_is_node and not self.params.do_coll_update:
diff --git a/pySDC/playgrounds/Preconditioners/dahlquist.py b/pySDC/playgrounds/Preconditioners/dahlquist.py
index a956b0474e..af617df5c3 100644
--- a/pySDC/playgrounds/Preconditioners/dahlquist.py
+++ b/pySDC/playgrounds/Preconditioners/dahlquist.py
@@ -107,10 +107,15 @@ def run_dahlquist(custom_description=None, num_procs=1, Tend=1., hook_class=log_
     return stats, controller, Tend
 
 
-def plot_stability(stats, ax=None, iter=None, colors=None):
+def plot_stability(stats, ax=None, iter=None, colors=None, crosshair=True, fill=False):
     lambdas = get_sorted(stats, type='lambdas')[0][1]
     u = get_sorted(stats, type='u', sortby='iter')
 
+    # decorate
+    if crosshair:
+        ax.axhline(0, color='black', alpha=1.)
+        ax.axvline(0, color='black', alpha=1.)
+
     if ax is None:
         fig, ax = plt.subplots(1, 1)
 
@@ -123,12 +128,11 @@ def plot_stability(stats, ax=None, iter=None, colors=None):
 
         # get a grid for plotting
         X, Y = np.meshgrid(np.unique(lambdas.real), np.unique(lambdas.imag))
+        if fill:
+            ax.contourf(X, Y, U, levels=[-np.inf, 1 - np.finfo(float).eps], colors=colors[i - 1], alpha=0.5)
         ax.contour(X, Y, U, levels=[1], colors=colors[i - 1])
         ax.plot([None], [None], color=colors[i - 1], label=f'k={i}')
 
-    # decorate
-    ax.axhline(0, color='black')
-    ax.axvline(0, color='black')
     ax.legend(frameon=False)
 
 
diff --git a/pySDC/playgrounds/Runge_Kutta/Runge-Kutta-Methods.ipynb b/pySDC/playgrounds/Runge_Kutta/Runge-Kutta-Methods.ipynb
index e5598b0f3f..70df61d8a7 100644
--- a/pySDC/playgrounds/Runge_Kutta/Runge-Kutta-Methods.ipynb
+++ b/pySDC/playgrounds/Runge_Kutta/Runge-Kutta-Methods.ipynb
@@ -88,13 +88,21 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
-   "id": "93ae79c9",
+   "execution_count": 2,
+   "id": "011b01c5",
    "metadata": {},
    "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/opt/homebrew/Caskroom/miniconda/base/lib/python3.9/site-packages/numpy/ma/core.py:2825: ComplexWarning: Casting complex values to real discards the imaginary part\n",
+      "  _data = np.array(data, dtype=dtype, copy=copy,\n"
+     ]
+    },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 792x360 with 2 Axes>"
       ]
@@ -111,11 +119,17 @@
   },
   {
    "cell_type": "markdown",
-   "id": "19c56583",
+   "id": "d118bef7",
    "metadata": {},
    "source": [
-    "In the left panel, we have implicit methods and in the right panel we have explicit methods.\n",
-    "The implicit midpoint and Crank-Nicholson methods have the same regions of stability and all implicit methods are A-stable, while explicit methods are only conditionally stable."
+    "Please excuse the rainbow!\n",
+    "The contours devide into unstable and stable regions and you can identify stable regions by the color mix being made up in part of the color of the method.\n",
+    "Going from the non-shaded regions, you can more easily identify, based on the contours, which method is stable where.\n",
+    "\n",
+    "In the left panel, the implicit methods are all A-stable, with RK1 being unstable in a smaller ellipse on the right half-plane than Midpoint and Crank-Nicholson.\n",
+    "in the right panel, no explicit method is stable in the wedge on the right.\n",
+    "That means explicit Euler is stable on the left half plane, which is very unusual!\n",
+    "RK4 is stable in the \"diagonal-cross\" region and the explicit Midpoint method is stable in the hourglass shaped region."
    ]
   }
  ],
diff --git a/pySDC/playgrounds/Runge_Kutta/test_order.py b/pySDC/playgrounds/Runge_Kutta/test_order.py
index ba7a4f4cb9..4daee81a08 100644
--- a/pySDC/playgrounds/Runge_Kutta/test_order.py
+++ b/pySDC/playgrounds/Runge_Kutta/test_order.py
@@ -26,8 +26,11 @@ def plot_order(sweeper, prob, dt_list, description=None, ax=None, Tend_fixed=Non
     description['sweeper_class'] = sweeper
     description['sweeper_params'] = {'implicit': True}
 
+    custom_controller_params = {'logger_level': 40}
+
     # determine the order
-    plot_orders(ax, [1], True, Tend_fixed=Tend_fixed, custom_description=description, dt_list=dt_list, prob=prob)
+    plot_orders(ax, [1], True, Tend_fixed=Tend_fixed, custom_description=description, dt_list=dt_list, prob=prob,
+                custom_controller_params=custom_controller_params)
 
     # check if we got the expected order for the local error
     orders = {
@@ -49,7 +52,7 @@ def plot_order(sweeper, prob, dt_list, description=None, ax=None, Tend_fixed=Non
     ax.legend(frameon=False)
 
 
-def plot_stability_single(sweeper, ax=None, description=None, implicit=True):
+def plot_stability_single(sweeper, ax=None, description=None, implicit=True, re=None, im=None, crosshair=True):
     if ax is None:
         fig, ax = plt.subplots(1, 1)
 
@@ -57,10 +60,19 @@ def plot_stability_single(sweeper, ax=None, description=None, implicit=True):
     description['sweeper_class'] = sweeper
     description['sweeper_params'] = {'implicit': implicit}
 
-    stats, _, _ = run_dahlquist(custom_description=description)
-    plot_stability(stats, ax=ax, iter=[1], colors=[colors.get(sweeper, 'black')])
+    custom_controller_params = {'logger_level': 40}
+
+    re = np.linspace(-30, 30, 400) if re is None else re
+    im = np.linspace(-50, 50, 400) if im is None else im
+    lambdas = np.array([[complex(re[i], im[j]) for i in range(len(re))] for j in range(len(im))]).\
+        reshape((len(re) * len(im)))
+    custom_problem_params = {'lambdas': lambdas}
+
+    stats, _, _ = run_dahlquist(custom_description=description, custom_problem_params=custom_problem_params,
+                                custom_controller_params=custom_controller_params)
+    plot_stability(stats, ax=ax, iter=[1], colors=[colors.get(sweeper, 'black')], crosshair=crosshair, fill=True)
 
-    ax.get_lines()[-3].set_label(sweeper.__name__)
+    ax.get_lines()[-1].set_label(sweeper.__name__)
     ax.legend(frameon=False)
 
 
@@ -70,14 +82,16 @@ def plot_all_stability():
     impl = [True, False]
     sweepers = [[RK1, MidpointMethod, CrankNicholson], [RK1, MidpointMethod, RK4]]
     titles = ['implicit', 'explicit']
+    res = [np.linspace(-3, 3, 400), np.linspace(-30, 30, 400)]
+    ims = [np.linspace(-3, 3, 400), np.linspace(-30, 30, 400)]
+    crosshair = [True, False, False]
 
     for j in range(len(impl)):
         for i in range(len(sweepers[j])):
-            plot_stability_single(sweepers[j][i], implicit=impl[j], ax=axs[j])
+            plot_stability_single(sweepers[j][i], implicit=impl[j], ax=axs[j], re=res[j], im=ims[j],
+                                  crosshair=crosshair[i])
         axs[j].set_title(titles[j])
 
-    axs[0].set_xlim([-4, 4])
-    axs[0].set_ylim([-4, 4])
     fig.tight_layout()
 
 
diff --git a/pySDC/projects/Resilience/accuracy_check.py b/pySDC/projects/Resilience/accuracy_check.py
index c6de943f3b..dbd8a22c0e 100644
--- a/pySDC/projects/Resilience/accuracy_check.py
+++ b/pySDC/projects/Resilience/accuracy_check.py
@@ -74,7 +74,7 @@ def get_results_from_stats(stats, var, val, hook_class=log_errors):
 
 
 def multiple_runs(k=5, serial=True, Tend_fixed=None, custom_description=None, prob=run_piline, dt_list=None,
-                  hook_class=log_errors):
+                  hook_class=log_errors, custom_controller_params=None):
     """
     A simple test program to compute the order of accuracy in time
     """
@@ -103,7 +103,7 @@ def multiple_runs(k=5, serial=True, Tend_fixed=None, custom_description=None, pr
             desc = {**desc, **custom_description}
         Tend = Tend_fixed if Tend_fixed else 30 * dt_list[i]
         stats, controller, _ = prob(custom_description=desc, num_procs=num_procs, Tend=Tend,
-                                    hook_class=hook_class)
+                                    hook_class=hook_class, custom_controller_params=custom_controller_params)
 
         level = controller.MS[-1].levels[-1]
         e_glob = abs(level.prob.u_exact(t=level.time + level.dt) - level.u[-1])
@@ -188,11 +188,13 @@ def get_accuracy_order(results, key='e_embedded', thresh=1e-14):
     return order
 
 
-def plot_orders(ax, ks, serial, Tend_fixed=None, custom_description=None, prob=run_piline, dt_list=None):
+def plot_orders(ax, ks, serial, Tend_fixed=None, custom_description=None, prob=run_piline, dt_list=None,
+                custom_controller_params=None):
     for i in range(len(ks)):
         k = ks[i]
         res = multiple_runs(k=k, serial=serial, Tend_fixed=Tend_fixed, custom_description=custom_description,
-                            prob=prob, dt_list=dt_list, hook_class=do_nothing)
+                            prob=prob, dt_list=dt_list, hook_class=do_nothing,
+                            custom_controller_params=custom_controller_params)
         plot_order(res, ax, k)
 
 

From a1bfc50fe1e15799d260e0b51362cb949dd78b75 Mon Sep 17 00:00:00 2001
From: Thomas Baumann <t.baumann@fz-juelich.de>
Date: Wed, 14 Sep 2022 13:26:57 +0200
Subject: [PATCH 7/8] Moved the test to the resilience project

---
 pySDC/playgrounds/Runge_Kutta/Runge-Kutta-Methods.ipynb     | 6 +++---
 .../Preconditioners => projects/Resilience}/dahlquist.py    | 0
 .../Resilience/test_Runge_Kutta_sweeper.py}                 | 2 +-
 pySDC/tests/test_projects/test_resilience/test_rk.py        | 2 +-
 4 files changed, 5 insertions(+), 5 deletions(-)
 rename pySDC/{playgrounds/Preconditioners => projects/Resilience}/dahlquist.py (100%)
 rename pySDC/{playgrounds/Runge_Kutta/test_order.py => projects/Resilience/test_Runge_Kutta_sweeper.py} (97%)

diff --git a/pySDC/playgrounds/Runge_Kutta/Runge-Kutta-Methods.ipynb b/pySDC/playgrounds/Runge_Kutta/Runge-Kutta-Methods.ipynb
index 70df61d8a7..56bcadf05b 100644
--- a/pySDC/playgrounds/Runge_Kutta/Runge-Kutta-Methods.ipynb
+++ b/pySDC/playgrounds/Runge_Kutta/Runge-Kutta-Methods.ipynb
@@ -71,7 +71,7 @@
     }
    ],
    "source": [
-    "from pySDC.playgrounds.Runge_Kutta.test_order import test_vdp, plot_all_stability\n",
+    "from pySDC.projects.Resilience.test_Runge_Kutta_sweeper import test_vdp, plot_all_stability\n",
     "test_vdp()"
    ]
   },
@@ -89,7 +89,7 @@
   {
    "cell_type": "code",
    "execution_count": 2,
-   "id": "011b01c5",
+   "id": "a75fc075",
    "metadata": {},
    "outputs": [
     {
@@ -119,7 +119,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "d118bef7",
+   "id": "a3c259d3",
    "metadata": {},
    "source": [
     "Please excuse the rainbow!\n",
diff --git a/pySDC/playgrounds/Preconditioners/dahlquist.py b/pySDC/projects/Resilience/dahlquist.py
similarity index 100%
rename from pySDC/playgrounds/Preconditioners/dahlquist.py
rename to pySDC/projects/Resilience/dahlquist.py
diff --git a/pySDC/playgrounds/Runge_Kutta/test_order.py b/pySDC/projects/Resilience/test_Runge_Kutta_sweeper.py
similarity index 97%
rename from pySDC/playgrounds/Runge_Kutta/test_order.py
rename to pySDC/projects/Resilience/test_Runge_Kutta_sweeper.py
index 4daee81a08..244b22385e 100644
--- a/pySDC/playgrounds/Runge_Kutta/test_order.py
+++ b/pySDC/projects/Resilience/test_Runge_Kutta_sweeper.py
@@ -2,7 +2,7 @@
 import numpy as np
 
 from pySDC.projects.Resilience.accuracy_check import plot_orders
-from pySDC.playgrounds.Preconditioners.dahlquist import run_dahlquist, plot_stability
+from pySDC.projects.Resilience.dahlquist import run_dahlquist, plot_stability
 
 from pySDC.projects.Resilience.advection import run_advection
 from pySDC.projects.Resilience.vdp import run_vdp
diff --git a/pySDC/tests/test_projects/test_resilience/test_rk.py b/pySDC/tests/test_projects/test_resilience/test_rk.py
index 84035b7a34..4ad7bb09cc 100644
--- a/pySDC/tests/test_projects/test_resilience/test_rk.py
+++ b/pySDC/tests/test_projects/test_resilience/test_rk.py
@@ -1,6 +1,6 @@
 import pytest
 
-from pySDC.playgrounds.Runge_Kutta.test_order import test_vdp, test_advection
+from pySDC.projects.Resilience.test_Runge_Kutta_sweeper import test_vdp, test_advection
 
 def test_main():
     test_vdp()

From 7851cc8f1be2d6e96a03d66a08020a65a18f29fa Mon Sep 17 00:00:00 2001
From: Thomas Baumann <t.baumann@fz-juelich.de>
Date: Wed, 14 Sep 2022 14:28:20 +0200
Subject: [PATCH 8/8] Fixed extremely embarrassing bug. Will go and review
 crucial life decisions now.

---
 .../Runge_Kutta/Runge-Kutta-Methods.ipynb     | 25 +++++--------------
 pySDC/projects/Resilience/dahlquist.py        |  4 +--
 .../Resilience/test_Runge_Kutta_sweeper.py    |  6 ++---
 3 files changed, 11 insertions(+), 24 deletions(-)

diff --git a/pySDC/playgrounds/Runge_Kutta/Runge-Kutta-Methods.ipynb b/pySDC/playgrounds/Runge_Kutta/Runge-Kutta-Methods.ipynb
index 56bcadf05b..f382157115 100644
--- a/pySDC/playgrounds/Runge_Kutta/Runge-Kutta-Methods.ipynb
+++ b/pySDC/playgrounds/Runge_Kutta/Runge-Kutta-Methods.ipynb
@@ -89,20 +89,12 @@
   {
    "cell_type": "code",
    "execution_count": 2,
-   "id": "a75fc075",
+   "id": "8a2ad4e9",
    "metadata": {},
    "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/opt/homebrew/Caskroom/miniconda/base/lib/python3.9/site-packages/numpy/ma/core.py:2825: ComplexWarning: Casting complex values to real discards the imaginary part\n",
-      "  _data = np.array(data, dtype=dtype, copy=copy,\n"
-     ]
-    },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 792x360 with 2 Axes>"
       ]
@@ -119,17 +111,12 @@
   },
   {
    "cell_type": "markdown",
-   "id": "a3c259d3",
+   "id": "ad7d65e7",
    "metadata": {},
    "source": [
-    "Please excuse the rainbow!\n",
-    "The contours devide into unstable and stable regions and you can identify stable regions by the color mix being made up in part of the color of the method.\n",
-    "Going from the non-shaded regions, you can more easily identify, based on the contours, which method is stable where.\n",
-    "\n",
-    "In the left panel, the implicit methods are all A-stable, with RK1 being unstable in a smaller ellipse on the right half-plane than Midpoint and Crank-Nicholson.\n",
-    "in the right panel, no explicit method is stable in the wedge on the right.\n",
-    "That means explicit Euler is stable on the left half plane, which is very unusual!\n",
-    "RK4 is stable in the \"diagonal-cross\" region and the explicit Midpoint method is stable in the hourglass shaped region."
+    "in the above plot you can see the regions of stability for implicit and explicit methods.\n",
+    "Please be aware that implicit Euler is also stable in the left half plane.\n",
+    "The plot clearly shows why implicit"
    ]
   }
  ],
diff --git a/pySDC/projects/Resilience/dahlquist.py b/pySDC/projects/Resilience/dahlquist.py
index af617df5c3..a73fb417ee 100644
--- a/pySDC/projects/Resilience/dahlquist.py
+++ b/pySDC/projects/Resilience/dahlquist.py
@@ -129,8 +129,8 @@ def plot_stability(stats, ax=None, iter=None, colors=None, crosshair=True, fill=
         # get a grid for plotting
         X, Y = np.meshgrid(np.unique(lambdas.real), np.unique(lambdas.imag))
         if fill:
-            ax.contourf(X, Y, U, levels=[-np.inf, 1 - np.finfo(float).eps], colors=colors[i - 1], alpha=0.5)
-        ax.contour(X, Y, U, levels=[1], colors=colors[i - 1])
+            ax.contourf(X, Y, abs(U), levels=[-np.inf, 1 - np.finfo(float).eps], colors=colors[i - 1], alpha=0.5)
+        ax.contour(X, Y, abs(U), levels=[1], colors=colors[i - 1])
         ax.plot([None], [None], color=colors[i - 1], label=f'k={i}')
 
     ax.legend(frameon=False)
diff --git a/pySDC/projects/Resilience/test_Runge_Kutta_sweeper.py b/pySDC/projects/Resilience/test_Runge_Kutta_sweeper.py
index 244b22385e..75ed35f41b 100644
--- a/pySDC/projects/Resilience/test_Runge_Kutta_sweeper.py
+++ b/pySDC/projects/Resilience/test_Runge_Kutta_sweeper.py
@@ -82,13 +82,13 @@ def plot_all_stability():
     impl = [True, False]
     sweepers = [[RK1, MidpointMethod, CrankNicholson], [RK1, MidpointMethod, RK4]]
     titles = ['implicit', 'explicit']
-    res = [np.linspace(-3, 3, 400), np.linspace(-30, 30, 400)]
-    ims = [np.linspace(-3, 3, 400), np.linspace(-30, 30, 400)]
+    re = np.linspace(-3, 3, 400)
+    im = np.linspace(-3, 3, 400)
     crosshair = [True, False, False]
 
     for j in range(len(impl)):
         for i in range(len(sweepers[j])):
-            plot_stability_single(sweepers[j][i], implicit=impl[j], ax=axs[j], re=res[j], im=ims[j],
+            plot_stability_single(sweepers[j][i], implicit=impl[j], ax=axs[j], re=re, im=im,
                                   crosshair=crosshair[i])
         axs[j].set_title(titles[j])