Added a hook for logging the error at the end of the run.

Author: Thomas Baumann

pySDC/implementations/hooks/log_errors.py

@@ -0,0 +1,62 @@
+import numpy as np
+from pySDC.core.Hooks import hooks
+
+
+class LogGlobalErrorPostRun(hooks):
+    """
+    Compute the global error once after the run is finished.
+    """
+
+    def __init__(self):
+        """
+        Add an attribute for when the last solution was added.
+        """
+        super().__init__()
+        self.__t_last_solution = 0
+
+    def post_step(self, step, level_number):
+        """
+        Store the time at which the solution is stored.
+        This is required because between the `post_step` hook where the solution is stored and the `post_run` hook
+        where the error is stored, the step size can change.
+
+        Args:
+            step (pySDC.Step.step): The current step
+            level_number (int): The index of the level
+
+        Returns:
+            None
+        """
+        super().post_step(step, level_number)
+        self.__t_last_solution = step.levels[0].time + step.levels[0].dt
+
+    def post_run(self, step, level_number):
+        """
+        Log the global error.
+
+        Args:
+            step (pySDC.Step.step): The current step
+            level_number (int): The index of the level
+
+        Returns:
+            None
+        """
+        super().post_run(step, level_number)
+
+        if level_number == 0:
+            L = step.levels[level_number]
+
+            e_glob = np.linalg.norm(L.prob.u_exact(t=self.__t_last_solution) - L.uend, np.inf)
+
+            if step.status.last:
+                self.logger.info(f'Finished with a global error of e={e_glob:.2e}')
+
+            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='e_global',
+                value=e_glob,
+            )

pySDC/implementations/problem_classes/Lorenz.py

@@ -13,7 +13,7 @@ class LorenzAttractor(ptype):
 
     Since the problem is non-linear, we need to use a Newton solver.
 
-    Problem and initial conditions does not originate from, but was taken from doi.org/10.2140/camcos.2015.10.1
+    Problem and initial conditions do not originate from, but were taken from doi.org/10.2140/camcos.2015.10.1
     """
 
     def __init__(self, problem_params):
@@ -93,7 +93,7 @@ def solve_system(self, rhs, dt, u0, t):
         # start Newton iterations
         u = self.dtype_u(u0)
         res = np.inf
-        for n in range(0, self.params.newton_maxiter):
+        for _n in range(0, self.params.newton_maxiter):
 
             # assemble G such that G(u) = 0 at the solution to the step
             G = np.array(

pySDC/projects/Resilience/Lorentz.py

@@ -66,7 +66,7 @@ def run_Lorenz(
     # initialize controller parameters
     controller_params = dict()
     controller_params['logger_level'] = 30
-    controller_params['hook_class'] = hook_collection + [hook_class]
+    controller_params['hook_class'] = hook_collection + hook_class if type(hook_class) == list else [hook_class]
     controller_params['mssdc_jac'] = False
 
     if custom_controller_params is not None:
@@ -148,6 +148,7 @@ def plot_solution(stats):
 def check_solution(stats, controller, thresh=5e-4):
     """
     Check if the global error solution wrt. a scipy reference solution is tolerable.
+    This is also a check for the global error hook.
 
     Args:
         stats (dict): The stats object of the run
@@ -159,8 +160,12 @@ def check_solution(stats, controller, thresh=5e-4):
     """
     u = get_sorted(stats, type='u')
     u_exact = controller.MS[0].levels[0].prob.u_exact(t=u[-1][0])
-    error = np.linalg.norm(u[-1][1] - u_exact)
+    error = np.linalg.norm(u[-1][1] - u_exact, np.inf)
+    error_hook = get_sorted(stats, type='e_global')[-1][1]
 
+    dt = get_sorted(stats, type='dt')
+
+    assert error == error_hook, f'Expected errors to match, got {error:.2e} and {error_hook:.2e}!'
     assert error < thresh, f"Error too large, got e={error:.2e}"
 
 
@@ -174,11 +179,16 @@ def main(plotting=True):
     Returns:
         None
     """
+    from pySDC.implementations.hooks.log_errors import LogGlobalErrorPostRun
+
     custom_description = {}
     custom_description['convergence_controllers'] = {Adaptivity: {'e_tol': 1e-5}}
-    custom_controller_params = {'logger_level': 30}
+    custom_controller_params = {'logger_level': 15}
     stats, controller, _ = run_Lorenz(
-        custom_description=custom_description, custom_controller_params=custom_controller_params, Tend=10
+        custom_description=custom_description,
+        custom_controller_params=custom_controller_params,
+        Tend=10,
+        hook_class=[log_data, LogGlobalErrorPostRun],
     )
     check_solution(stats, controller, 5e-4)
     if plotting:

pySDC/tests/test_projects/test_resilience/test_Lorenz.py

@@ -5,4 +5,4 @@
 def test_main():
     from pySDC.projects.Resilience.Lorentz import main
 
-    main(False)
+    main(plotting=False)