Implemented test for basic configurations

Author: brownbaerchen

pySDC/implementations/hooks/log_solution.py

@@ -266,12 +266,11 @@ def post_run(self, step, level_number):
         L = step.levels[level_number]
 
         value_exists = True in [abs(me - (L.time + L.dt)) < np.finfo(float).eps * 1000 for me in self.outfile.times]
-        if value_exists and not self.allow_overwriting:
-            raise DataError(f'Already have recorded data for time {L.time + L.dt} in this file!')
-        self.outfile.addField(time=L.time + L.dt, field=L.prob.processSolutionForOutput(L.uend))
-        self.logger.info(f'Written solution at t={L.time+L.dt:.4f} to file')
-        self.t_next_log = max([L.time + L.dt, self.t_next_log]) + self.time_increment
-        type(self).counter = len(self.outfile.times)
+        if not value_exists:
+            self.outfile.addField(time=L.time + L.dt, field=L.prob.processSolutionForOutput(L.uend))
+            self.logger.info(f'Written solution at t={L.time+L.dt:.4f} to file')
+            self.t_next_log = max([L.time + L.dt, self.t_next_log]) + self.time_increment
+            type(self).counter = len(self.outfile.times)
 
     @classmethod
     def load(cls, index):

pySDC/projects/GPU/configs/base_config.py

@@ -192,13 +192,13 @@ def get_initial_condition(self, P, *args, restart_idx=0, **kwargs):
 class LogStats(ConvergenceController):
 
     def get_stats_path(self, index=0):
-        return f'{self.params.path}_{self.counter:06d}-stats.pickle'
+        return f'{self.params.path}_{index:06d}-stats.pickle'
 
     def merge_all_stats(self, controller):
         hook = self.params.hook
 
         stats = {}
-        for i in range(hook.counter):
+        for i in range(hook.counter - 1):
             with open(self.get_stats_path(index=i), 'rb') as file:
                 _stats = pickle.load(file)
                 stats = {**stats, **_stats}
@@ -226,11 +226,8 @@ def post_step_processing(self, controller, S, **kwargs):
 
         P = S.levels[0].prob
 
-        if self.counter == 0:
-            self.counter = hook.counter - 1
-
         while self.counter < hook.counter:
-            path = self.get_stats_path(index=self.counter - 1)
+            path = self.get_stats_path(index=hook.counter - 2)
             stats = controller.return_stats()
             store = True
             if hasattr(S.levels[0].sweep, 'comm') and S.levels[0].sweep.comm.rank > 0:
@@ -241,12 +238,15 @@ def post_step_processing(self, controller, S, **kwargs):
                 with open(path, 'wb') as file:
                     pickle.dump(stats, file)
                     self.log(f'Stored stats in {path!r}', S)
+                # print(stats)
                 self.reset_stats(controller)
             self.counter = hook.counter
 
-    def post_run_processing(self, controller, *args, **kwargs):
+    def post_run_processing(self, controller, S, **kwargs):
         stats = self.merge_all_stats(controller)
 
+        self.post_step_processing(controller, S, **kwargs)
+
         def return_stats():
             return stats
 

pySDC/projects/GPU/tests/test_configs.py

@@ -38,6 +38,10 @@ def create_directories():
 def test_run(tmpdir):
     from pySDC.projects.GPU.configs.base_config import get_config
     from pySDC.projects.GPU.run_experiment import run_experiment
+    from pySDC.helpers.stats_helper import get_sorted
+    from pySDC.helpers.fieldsIO import FieldsIO
+    import pickle
+    import numpy as np
 
     args = {
         'config': 'RBC',
@@ -50,6 +54,7 @@ def test_run(tmpdir):
         'restart_idx': 0,
     }
     config = get_config(args)
+    type(config).base_path = args['o']
 
     def get_LogToFile(self, *args, **kwargs):
         if self.comms[1].rank > 0:
@@ -63,89 +68,39 @@ def get_LogToFile(self, *args, **kwargs):
         return LogToFile
 
     type(config).get_LogToFile = get_LogToFile
+    stats_path = f'{config.base_path}/data/{config.get_path()}-stats-whole-run.pickle'
+    file_path = config.get_file_name()
 
     # first run for a short time
     dt = config.get_description()['level_params']['dt']
     config.Tend = 2 * dt
     run_experiment(args, config)
 
+    # check data
+    data = FieldsIO.fromFile(file_path)
+    with open(stats_path, 'rb') as file:
+        stats = pickle.load(file)
 
-@pytest.mark.order(1)
-def test_run_experiment(restart_idx=0):
-    from pySDC.projects.GPU.configs.base_config import Config
-    from pySDC.projects.GPU.run_experiment import run_experiment, parse_args
-    from pySDC.helpers.stats_helper import get_sorted
-    import pickle
-    import numpy as np
-
-    create_directories()
-
-    class VdPConfig(Config):
-        sweeper_type = 'generic_implicit'
-        Tend = 1
-
-        def get_description(self, *args, **kwargs):
-            from pySDC.implementations.problem_classes.Van_der_Pol_implicit import vanderpol
-
-            desc = super().get_description(*args, **kwargs)
-            desc['problem_class'] = vanderpol
-            desc['problem_params'].pop('useGPU')
-            desc['problem_params'].pop('comm')
-            desc['sweeper_params']['num_nodes'] = 2
-            desc['sweeper_params']['quad_type'] = 'RADAU-RIGHT'
-            desc['sweeper_params']['QI'] = 'LU'
-            desc['level_params']['dt'] = 0.1
-            desc['step_params']['maxiter'] = 3
-            return desc
-
-        def get_LogToFile(self, ranks=None):
-            from pySDC.implementations.hooks.log_solution import LogToPickleFileAfterXS as LogToFile
-
-            LogToFile.path = './data/'
-            LogToFile.file_name = f'{self.get_path(ranks=ranks)}-solution'
-            LogToFile.time_increment = 2e-1
-
-            def logging_condition(L):
-                sweep = L.sweep
-                if hasattr(sweep, 'comm'):
-                    if sweep.comm.rank == sweep.comm.size - 1:
-                        return True
-                    else:
-                        return False
-                else:
-                    return True
-
-            LogToFile.logging_condition = logging_condition
-            return LogToFile
+    dts = get_sorted(stats, type='dt')
+    assert len(dts) == len(data.times) - 1
+    assert np.allclose(data.times, 0.1 * np.arange(3)), 'Did not record solutions at expected times'
 
-    args = {
-        'procs': [1, 1, 1],
-        'useGPU': False,
-        'res': -1,
-        'logger_level': 15,
-        'restart_idx': restart_idx,
-        'mode': 'run',
-    }
-    config = VdPConfig(args)
+    # restart run
+    args['restart_idx'] = -1
+    config.Tend = 4 * dt
     run_experiment(args, config)
 
-    with open(f'data/{config.get_path()}-stats-whole-run.pickle', 'rb') as file:
+    # check data
+    data = FieldsIO.fromFile(file_path)
+    with open(stats_path, 'rb') as file:
         stats = pickle.load(file)
+    dts = get_sorted(stats, type='dt')
 
-    k_Newton = get_sorted(stats, type='work_newton')
-    assert len(k_Newton) == 10
-    assert sum([me[1] for me in k_Newton]) == 91
-
-
-@pytest.mark.order(2)
-def test_restart():
-    test_run_experiment(3)
+    assert len(dts) == len(data.times) - 1
+    assert np.allclose(data.times, 0.1 * np.arange(5)), 'Did not record solutions at expected times after restart'
 
 
 if __name__ == '__main__':
-    test_run('.')
-    exit()
-
     import argparse
 
     parser = argparse.ArgumentParser()
@@ -155,9 +110,5 @@ def test_restart():
 
     if args.test == 'get_comms':
         test_get_comms(False)
-    elif args.test == 'run_experiment':
-        test_run_experiment()
-    elif args.test == 'restart':
-        test_restart()
     else:
         raise NotImplementedError