Error estimating convergence controllers will now add hooks to record

their estimates

Author: Thomas Baumann

pySDC/core/Controller.py

@@ -42,12 +42,11 @@ def __init__(self, controller_params, description):
 
         # check if we have a hook on this list. If not, use default class.
         self.__hooks = []
-        self.hook_classes = [default_hooks]
+        hook_classes = [default_hooks]
         user_hooks = controller_params.get('hook_class', [])
-        self.hook_classes += user_hooks if type(user_hooks) == list else [user_hooks]
-        for hook in self.hook_classes:
-            self.__hooks += [hook()]
-        controller_params['hook_class'] = controller_params.get('hook_class', self.hook_classes)
+        hook_classes += user_hooks if type(user_hooks) == list else [user_hooks]
+        [self.add_hook(hook) for hook in hook_classes]
+        controller_params['hook_class'] = controller_params.get('hook_class', hook_classes)
 
         for hook in self.hooks:
             hook.pre_setup(step=None, level_number=None)
@@ -107,6 +106,20 @@ def __setup_custom_logger(level=None, log_to_file=None, fname=None):
         else:
             pass
 
+    def add_hook(self, hook):
+        """
+        Add a hook to the controller which will be called in addition to all other hooks whenever something happens.
+        The hook is only added if a hook of the same class is not already present.
+
+        Args:
+            hook (pySDC.Hook): A hook class that is derived from the core hook class
+
+        Returns:
+            None
+        """
+        if hook not in [type(me) for me in self.hooks]:
+            self.__hooks += [hook()]
+
     def welcome_message(self):
         out = (
             "Welcome to the one and only, really very astonishing and 87.3% bug free"

pySDC/core/Hooks.py

@@ -1,5 +1,4 @@
 import logging
-import time
 from collections import namedtuple
 
 
@@ -9,20 +8,6 @@ class hooks(object):
     Hook class to contain the functions called during the controller runs (e.g. for calling user-routines)
 
     Attributes:
-        __t0_setup (float): private variable to get starting time of setup
-        __t0_run (float): private variable to get starting time of the run
-        __t0_predict (float): private variable to get starting time of the predictor
-        __t0_step (float): private variable to get starting time of the step
-        __t0_iteration (float): private variable to get starting time of the iteration
-        __t0_sweep (float): private variable to get starting time of the sweep
-        __t0_comm (list): private variable to get starting time of the communication
-        __t1_run (float): private variable to get end time of the run
-        __t1_predict (float): private variable to get end time of the predictor
-        __t1_step (float): private variable to get end time of the step
-        __t1_iteration (float): private variable to get end time of the iteration
-        __t1_sweep (float): private variable to get end time of the sweep
-        __t1_setup (float): private variable to get end time of setup
-        __t1_comm (list): private variable to hold timing of the communication (!)
         __num_restarts (int): number of restarts of the current step
         logger: logger instance for output
         __stats (dict): dictionary for gathering the statistics of a run

pySDC/implementations/controller_classes/controller_MPI.py

@@ -807,7 +807,7 @@ def it_up(self, comm, num_procs):
                     self.S.levels[l - 1].sweep.update_nodes()
                     self.S.levels[l - 1].sweep.compute_residual()
                     for hook in self.hooks:
-                        hooks.post_sweep(step=self.S, level_number=l - 1)
+                        hook.post_sweep(step=self.S, level_number=l - 1)
 
         # update stage
         self.S.status.stage = 'IT_FINE'

pySDC/implementations/convergence_controller_classes/estimate_embedded_error.py

@@ -2,6 +2,7 @@
 
 from pySDC.core.ConvergenceController import ConvergenceController, Pars
 from pySDC.implementations.convergence_controller_classes.store_uold import StoreUOld
+from pySDC.implementations.hooks.log_embedded_error_estimate import log_embedded_error_estimate
 
 from pySDC.implementations.sweeper_classes.Runge_Kutta import RungeKutta
 
@@ -16,7 +17,7 @@ class EstimateEmbeddedError(ConvergenceController):
 
     def __init__(self, controller, params, description, **kwargs):
         """
-        Initalization routine. Add the buffers for communication.
+        Initialisation routine. Add the buffers for communication.
 
         Args:
             controller (pySDC.Controller): The controller
@@ -25,6 +26,7 @@ def __init__(self, controller, params, description, **kwargs):
         """
         super(EstimateEmbeddedError, self).__init__(controller, params, description, **kwargs)
         self.buffers = Pars({'e_em_last': 0.0})
+        controller.add_hook(log_embedded_error_estimate)
 
     @classmethod
     def get_implementation(cls, flavor):
@@ -123,7 +125,7 @@ def reset_status_variables(self, controller, **kwargs):
 class EstimateEmbeddedErrorNonMPI(EstimateEmbeddedError):
     def reset_buffers_nonMPI(self, controller, **kwargs):
         """
-        Reset buffers for immitated communication.
+        Reset buffers for imitated communication.
 
         Args:
             controller (pySDC.controller): The controller

pySDC/implementations/convergence_controller_classes/estimate_extrapolation_error.py

@@ -4,6 +4,7 @@
 from pySDC.core.ConvergenceController import ConvergenceController, Status
 from pySDC.core.Errors import DataError
 from pySDC.implementations.datatype_classes.mesh import mesh, imex_mesh
+from pySDC.implementations.hooks.log_extrapolated_error_estimate import log_extrapolated_error_estimate
 
 
 class EstimateExtrapolationErrorBase(ConvergenceController):
@@ -27,6 +28,7 @@ def __init__(self, controller, params, description, **kwargs):
         self.prev = Status(["t", "u", "f", "dt"])  # store solutions etc. of previous steps here
         self.coeff = Status(["u", "f", "prefactor"])  # store coefficients for extrapolation here
         super(EstimateExtrapolationErrorBase, self).__init__(controller, params, description)
+        controller.add_hook(log_extrapolated_error_estimate)
 
     def setup(self, controller, params, description, **kwargs):
         """

pySDC/projects/PinTSimE/switch_estimator.py

@@ -95,7 +95,7 @@ def get_new_step_size(self, controller, S):
                             dt_search = self.t_switch - L.time
                             L.prob.params.set_switch[self.count_switches] = self.switch_detected
                             L.prob.params.t_switch[self.count_switches] = self.t_switch
-                            controller.hooks.add_to_stats(
+                            controller.hooks[0].add_to_stats(
                                 process=S.status.slot,
                                 time=L.time,
                                 level=L.level_index,

pySDC/projects/Resilience/accuracy_check.py

@@ -34,24 +34,6 @@ def post_step(self, step, 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=0,
-            sweep=L.status.sweep,
-            type='e_embedded',
-            value=L.status.error_embedded_estimate,
-        )
-        self.add_to_stats(
-            process=step.status.slot,
-            time=L.time + L.dt,
-            level=L.level_index,
-            iter=0,
-            sweep=L.status.sweep,
-            type='e_extrapolated',
-            value=L.status.get('error_extrapolation_estimate'),
-        )
         self.add_to_stats(
             process=step.status.slot,
             time=L.time,
@@ -105,8 +87,8 @@ def get_results_from_stats(stats, var, val, hook_class=log_errors):
     }
 
     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_extrapolated = np.array(get_sorted(stats, type='error_extrapolation_estimate'))[:, 1]
+        e_embedded = np.array(get_sorted(stats, type='error_embedded_estimate'))[:, 1]
         e_loc = np.array(get_sorted(stats, type='e_loc'))[:, 1]
 
         if len(e_extrapolated[e_extrapolated != [None]]) > 0:

pySDC/projects/Resilience/advection.py

@@ -6,7 +6,7 @@
 from pySDC.core.Hooks import hooks
 from pySDC.helpers.stats_helper import get_sorted
 import numpy as np
-from pySDC.projects.Resilience.hook import log_error_estimates
+from pySDC.projects.Resilience.hook import log_data
 
 
 def plot_embedded(stats, ax):
@@ -21,17 +21,8 @@ def plot_embedded(stats, ax):
     ax.legend(frameon=False)
 
 
-class log_data(hooks):
-    def pre_run(self, step, level_number):
-        """
-        Record los conditiones initiales
-        """
-        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='u0', value=L.u[0])
-
+class log_every_iteration(hooks):
     def post_iteration(self, step, level_number):
-        super(log_data, self).post_iteration(step, level_number)
         if step.status.iter == step.params.maxiter - 1:
             L = step.levels[level_number]
             L.sweep.compute_end_point()
@@ -45,58 +36,12 @@ def post_iteration(self, step, level_number):
                 value=L.uold[-1],
             )
 
-    def post_step(self, step, level_number):
-
-        super(log_data, self).post_step(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=0,
-            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,
-        )
-        self.add_to_stats(
-            process=step.status.slot,
-            time=L.time + L.dt,
-            level=L.level_index,
-            iter=0,
-            sweep=L.status.sweep,
-            type='e_embedded',
-            value=L.status.get('error_embedded_estimate'),
-        )
-        self.add_to_stats(
-            process=step.status.slot,
-            time=L.time + L.dt,
-            level=L.level_index,
-            iter=0,
-            sweep=L.status.sweep,
-            type='e_extrapolated',
-            value=L.status.get('error_extrapolation_estimate'),
-        )
-
 
 def run_advection(
     custom_description=None,
     num_procs=1,
     Tend=2e-1,
-    hook_class=log_error_estimates,
+    hook_class=log_data,
     fault_stuff=None,
     custom_controller_params=None,
     custom_problem_params=None,

pySDC/projects/Resilience/heat.py

@@ -5,15 +5,15 @@
 from pySDC.implementations.controller_classes.controller_nonMPI import controller_nonMPI
 from pySDC.core.Hooks import hooks
 from pySDC.helpers.stats_helper import get_sorted
-from pySDC.projects.Resilience.hook import log_error_estimates
+from pySDC.projects.Resilience.hook import log_data
 import numpy as np
 
 
 def run_heat(
     custom_description=None,
     num_procs=1,
     Tend=2e-1,
-    hook_class=log_error_estimates,
+    hook_class=log_data,
     fault_stuff=None,
     custom_controller_params=None,
     custom_problem_params=None,

pySDC/projects/Resilience/hook.py

@@ -1,7 +1,13 @@
 from pySDC.core.Hooks import hooks
+from pySDC.implementations.hooks.log_solution import log_solution
+from pySDC.implementations.hooks.log_embedded_error_estimate import log_embedded_error_estimate
+from pySDC.implementations.hooks.log_extrapolated_error_estimate import log_extrapolated_error_estimate
 
 
-class log_error_estimates(hooks):
+hook_collection = [log_solution, log_embedded_error_estimate, log_extrapolated_error_estimate]
+
+
+class log_data(hooks):
     """
     Record data required for analysis of problems in the resilience project
     """
@@ -10,30 +16,18 @@ def pre_run(self, step, level_number):
         """
         Record los conditiones initiales
         """
-        super(log_error_estimates, 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='u0', value=L.u[0])
 
     def post_step(self, step, level_number):
         """
         Record final solutions as well as step size and error estimates
         """
-        super(log_error_estimates, self).post_step(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=0,
-            sweep=L.status.sweep,
-            type='u',
-            value=L.uend,
-        )
         self.add_to_stats(
             process=step.status.slot,
             time=L.time,
@@ -43,24 +37,6 @@ def post_step(self, step, level_number):
             type='dt',
             value=L.dt,
         )
-        self.add_to_stats(
-            process=step.status.slot,
-            time=L.time + L.dt,
-            level=L.level_index,
-            iter=0,
-            sweep=L.status.sweep,
-            type='e_embedded',
-            value=L.status.__dict__.get('error_embedded_estimate', None),
-        )
-        self.add_to_stats(
-            process=step.status.slot,
-            time=L.time + L.dt,
-            level=L.level_index,
-            iter=0,
-            sweep=L.status.sweep,
-            type='e_extrapolated',
-            value=L.status.__dict__.get('error_extrapolation_estimate', None),
-        )
         self.add_to_stats(
             process=step.status.slot,
             time=L.time,