black fixes

Author: pancetta

pySDC/core/Controller.py

@@ -101,16 +101,18 @@ def __setup_custom_logger(level=None, log_to_file=None, fname=None):
             pass
 
     def welcome_message(self):
-        out = 'Welcome to the one and only, really very astonishing and 87.3% bug free' + \
-              '\n                                 _____ _____   _____ ' + \
-              '\n                                / ____|  __ \ / ____|' + \
-              '\n                    _ __  _   _| (___ | |  | | |     ' + \
-              '\n                   | \'_ \| | | |\___ \| |  | | |     ' + \
-              '\n                   | |_) | |_| |____) | |__| | |____ ' + \
-              '\n                   | .__/ \__, |_____/|_____/ \_____|' + \
-              '\n                   | |     __/ |                     ' + \
-              '\n                   |_|    |___/                      ' + \
-              '\n                                                     '
+        out = (
+            'Welcome to the one and only, really very astonishing and 87.3% bug free'
+            + '\n                                 _____ _____   _____ '
+            + '\n                                / ____|  __ \ / ____|'
+            + '\n                    _ __  _   _| (___ | |  | | |     '
+            + '\n                   | \'_ \| | | |\___ \| |  | | |     '
+            + '\n                   | |_) | |_| |____) | |__| | |____ '
+            + '\n                   | .__/ \__, |_____/|_____/ \_____|'
+            + '\n                   | |     __/ |                     '
+            + '\n                   |_|    |___/                      '
+            + '\n                                                     '
+        )
         self.logger.info(out)
 
     def dump_setup(self, step, controller_params, description):

pySDC/implementations/convergence_controller_classes/adaptivity.py

@@ -199,8 +199,9 @@ def get_new_step_size(self, controller, S):
             order = S.status.iter  # embedded error estimate is same order as time marching
 
             e_est = self.get_local_error_estimate(controller, S)
-            L.status.dt_new = self.compute_optimal_step_size(self.params.beta, L.params.dt, self.params.e_tol, e_est,
-                                                             order)
+            L.status.dt_new = self.compute_optimal_step_size(
+                self.params.beta, L.params.dt, self.params.e_tol, e_est, order
+            )
             self.log(f'Adjusting step size from {L.params.dt:.2e} to {L.status.dt_new:.2e}', S)
 
         return None
@@ -223,6 +224,7 @@ class AdaptivityRK(Adaptivity):
     '''
     Adaptivity for Runge-Kutta methods. Basically, we need to change the order in the step size update
     '''
+
     def check_parameters(self, controller, params, description):
         '''
         Check whether parameters are compatible with whatever assumptions went into the step size functions etc.
@@ -238,8 +240,11 @@ def check_parameters(self, controller, params, description):
             str: The error message
         '''
         if 'update_order' not in params.keys():
-            return False, 'Adaptivity needs an order for the update rule! Please set some up in \
-description[\'convergence_control_params\'][\'update_order\']!'
+            return (
+                False,
+                'Adaptivity needs an order for the update rule! Please set some up in \
+description[\'convergence_control_params\'][\'update_order\']!',
+            )
 
         return super(AdaptivityRK, self).check_parameters(controller, params, description)
 
@@ -261,8 +266,9 @@ def get_new_step_size(self, controller, S):
             # compute next step size
             order = self.params.update_order
             e_est = self.get_local_error_estimate(controller, S)
-            L.status.dt_new = self.compute_optimal_step_size(self.params.beta, L.params.dt, self.params.e_tol, e_est,
-                                                             order)
+            L.status.dt_new = self.compute_optimal_step_size(
+                self.params.beta, L.params.dt, self.params.e_tol, e_est, order
+            )
             self.log(f'Adjusting step size from {L.params.dt:.2e} to {L.status.dt_new:.2e}', S)
 
         return None

pySDC/implementations/convergence_controller_classes/estimate_embedded_error.py

@@ -63,8 +63,10 @@ def estimate_embedded_error_serial(self, L):
             # order rises by one between sweeps, making this so ridiculously easy
             return abs(L.uold[-1] - L.u[-1])
         else:
-            raise NotImplementedError(f'Don\'t know how to estimate embedded error for sweeper type \
-{self.params.sweeper_type}')
+            raise NotImplementedError(
+                f'Don\'t know how to estimate embedded error for sweeper type \
+{self.params.sweeper_type}'
+            )
 
 
 class EstimateEmbeddedErrorNonMPI(EstimateEmbeddedError):

pySDC/implementations/sweeper_classes/Runge_Kutta.py

@@ -38,8 +38,8 @@ def __init__(self, weights, nodes, matrix):
 
         # Set number of nodes, left and right interval boundaries
         self.num_nodes = matrix.shape[0] + 1
-        self.tleft = 0.
-        self.tright = 1.
+        self.tleft = 0.0
+        self.tright = 1.0
 
         self.nodes = np.append(np.append([0], nodes), [1])
         self.weights = weights
@@ -95,8 +95,8 @@ def __init__(self, weights, nodes, matrix):
 
         # Set number of nodes, left and right interval boundaries
         self.num_nodes = matrix.shape[0] + 2
-        self.tleft = 0.
-        self.tright = 1.
+        self.tleft = 0.0
+        self.tright = 1.0
 
         self.nodes = np.append(np.append([0], nodes), [1, 1])
         self.weights = weights
@@ -158,13 +158,16 @@ 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.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:
-            self.logger.warning('we need to do a collocation update here, since the right end point is not a node. '
-                                'Changing this!')
+            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
@@ -200,8 +203,9 @@ def update_nodes(self):
 
             # implicit solve with prefactor stemming from the diagonal of Qd
             if self.coll.implicit:
-                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])
+                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] = rhs
             # update function values
@@ -216,12 +220,20 @@ def update_nodes(self):
 class RK1(RungeKutta):
     def __init__(self, params):
         implicit = params.get('implicit', False)
-        nodes = np.array([0.])
-        weights = np.array([1.])
+        nodes = np.array([0.0])
+        weights = np.array([1.0])
         if implicit:
-            matrix = np.array([[1.], ])
+            matrix = np.array(
+                [
+                    [1.0],
+                ]
+            )
         else:
-            matrix = np.array([[0.], ])
+            matrix = np.array(
+                [
+                    [0.0],
+                ]
+            )
         params['butcher_tableau'] = ButcherTableau(weights, nodes, matrix)
         super(RK1, self).__init__(params)
 
@@ -230,6 +242,7 @@ 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])
@@ -244,13 +257,14 @@ class MidpointMethod(RungeKutta):
     '''
     Runge-Kutta method of second order
     '''
+
     def __init__(self, params):
         implicit = params.get('implicit', False)
         if implicit:
             nodes = np.array([0.5])
             weights = np.array([1])
             matrix = np.zeros((1, 1))
-            matrix[0, 0] = 1. / 2.
+            matrix[0, 0] = 1.0 / 2.0
         else:
             nodes = np.array([0, 0.5])
             weights = np.array([0, 1])
@@ -264,13 +278,14 @@ 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.
+        weights = np.array([1.0, 2.0, 2.0, 1.0]) / 6.0
         matrix = np.zeros((4, 4))
         matrix[1, 0] = 0.5
         matrix[2, 1] = 0.5
-        matrix[3, 2] = 1.
+        matrix[3, 2] = 1.0
         params['butcher_tableau'] = ButcherTableau(weights, nodes, matrix)
         super(RK4, self).__init__(params)
 
@@ -279,6 +294,7 @@ class Heun_Euler(RungeKutta):
     '''
     Second order explicit embedded Runge-Kutta
     '''
+
     def __init__(self, params):
         nodes = np.array([0, 1])
         weights = np.array([[0.5, 0.5], [1, 0]])
@@ -292,15 +308,20 @@ class Cash_Karp(RungeKutta):
     '''
     Fifth order explicit embedded Runge-Kutta
     '''
+
     def __init__(self, params):
-        nodes = np.array([0, 0.2, 0.3, 0.6, 1., 7. / 8.])
-        weights = np.array([[37. / 378., 0., 250. / 621., 125. / 594., 0., 512. / 1771.],
-                            [2825. / 27648., 0., 18575. / 48384., 13525. / 55296., 277. / 14336., 1. / 4.]])
+        nodes = np.array([0, 0.2, 0.3, 0.6, 1.0, 7.0 / 8.0])
+        weights = np.array(
+            [
+                [37.0 / 378.0, 0.0, 250.0 / 621.0, 125.0 / 594.0, 0.0, 512.0 / 1771.0],
+                [2825.0 / 27648.0, 0.0, 18575.0 / 48384.0, 13525.0 / 55296.0, 277.0 / 14336.0, 1.0 / 4.0],
+            ]
+        )
         matrix = np.zeros((6, 6))
-        matrix[1, 0] = 1. / 5.
-        matrix[2, :2] = [3. / 40., 9. / 40.]
+        matrix[1, 0] = 1.0 / 5.0
+        matrix[2, :2] = [3.0 / 40.0, 9.0 / 40.0]
         matrix[3, :3] = [0.3, -0.9, 1.2]
-        matrix[4, :4] = [-11. / 54., 5. / 2., -70. / 27., 35. / 27.]
-        matrix[5, :5] = [1631. / 55296., 175. / 512., 575. / 13824., 44275. / 110592., 253. / 4096.]
+        matrix[4, :4] = [-11.0 / 54.0, 5.0 / 2.0, -70.0 / 27.0, 35.0 / 27.0]
+        matrix[5, :5] = [1631.0 / 55296.0, 175.0 / 512.0, 575.0 / 13824.0, 44275.0 / 110592.0, 253.0 / 4096.0]
         params['butcher_tableau'] = ButcherTableauEmbedded(weights, nodes, matrix)
         super(Cash_Karp, self).__init__(params)

pySDC/projects/Resilience/accuracy_check.py

@@ -71,9 +71,9 @@ def setup_mpl(font_size=8):
 
 def get_results_from_stats(stats, var, val, hook_class=log_errors):
     results = {
-        'e_embedded': 0.,
-        'e_extrapolated': 0.,
-        'e': 0.,
+        'e_embedded': 0.0,
+        'e_extrapolated': 0.0,
+        'e': 0.0,
         var: val,
     }
 
@@ -94,8 +94,16 @@ def get_results_from_stats(stats, var, val, hook_class=log_errors):
     return results
 
 
-def multiple_runs(k=5, serial=True, Tend_fixed=None, custom_description=None, prob=run_piline, dt_list=None,
-                  hook_class=log_errors, custom_controller_params=None):
+def multiple_runs(
+    k=5,
+    serial=True,
+    Tend_fixed=None,
+    custom_description=None,
+    prob=run_piline,
+    dt_list=None,
+    hook_class=log_errors,
+    custom_controller_params=None,
+):
     """
     A simple test program to compute the order of accuracy in time
     """
@@ -104,7 +112,7 @@ def multiple_runs(k=5, serial=True, Tend_fixed=None, custom_description=None, pr
     if dt_list is not None:
         pass
     elif Tend_fixed:
-        dt_list = 0.1 * 10.**-(np.arange(5) / 2)
+        dt_list = 0.1 * 10.0 ** -(np.arange(5) / 2)
     else:
         dt_list = 0.01 * 10.0 ** -(np.arange(20) / 10.0)
 
@@ -123,8 +131,13 @@ def multiple_runs(k=5, serial=True, Tend_fixed=None, custom_description=None, pr
         if custom_description is not None:
             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, custom_controller_params=custom_controller_params)
+        stats, controller, _ = prob(
+            custom_description=desc,
+            num_procs=num_procs,
+            Tend=Tend,
+            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])
@@ -162,17 +175,21 @@ def plot(res, ax, k):
     color = plt.rcParams['axes.prop_cycle'].by_key()['color'][k - 2]
 
     for i in range(len(keys)):
-        if all([me == 0. for me in res[keys[i]]]):
+        if all([me == 0.0 for me in res[keys[i]]]):
             continue
         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=4e-1), f'Expected embedded error estimate to have order {k} \
+            assert np.isclose(
+                np.mean(order), k, atol=4e-1
+            ), f'Expected embedded error estimate to have order {k} \
 but got {np.mean(order):.2f}'
 
         elif keys[i] == 'e_extrapolated':
             label = None
-            assert np.isclose(np.mean(order), k + 1, rtol=3e-1), f'Expected extrapolation error estimate to have order \
+            assert np.isclose(
+                np.mean(order), k + 1, rtol=3e-1
+            ), f'Expected extrapolation error estimate to have order \
 {k+1} but got {np.mean(order):.2f}'
         else:
             label = None
@@ -213,22 +230,52 @@ 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,
-                custom_controller_params=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,
-                            custom_controller_params=custom_controller_params)
+        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,
+            custom_controller_params=custom_controller_params,
+        )
         plot_order(res, ax, k)
 
 
-def plot_all_errors(ax, ks, serial, Tend_fixed=None, custom_description=None, prob=run_piline, dt_list=None,
-                    custom_controller_params=None):
+def plot_all_errors(
+    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, custom_controller_params=custom_controller_params)
+        res = multiple_runs(
+            k=k,
+            serial=serial,
+            Tend_fixed=Tend_fixed,
+            custom_description=custom_description,
+            prob=prob,
+            dt_list=dt_list,
+            custom_controller_params=custom_controller_params,
+        )
 
         # visualize results
         plot(res, ax, k)