feat: add tqdm progress bar

GPUSimulators/Common.py

@@ -35,6 +35,8 @@ import gc
 import netCDF4
 import json
 
+from tqdm import trange
+
 #import pycuda.compiler as cuda_compiler
 #import pycuda.gpuarray
 #import pycuda.driver as cuda
@@ -178,8 +180,8 @@ def runSimulation(simulator, simulator_args, outfile, save_times, save_var_names
         profiling_data_sim_runner["end"]["t_sim_init"] = time.time()
 
         #Start simulation loop
-        progress_printer = ProgressPrinter(save_times[-1], print_every=10)
+        # progress_printer = ProgressPrinter(save_times[-1], print_every=10)
-        for k in range(len(save_times)):
+        for k in trange(len(save_times)):
             #Get target time and step size there
             t_step = t_steps[k]
             t_end = save_times[k]
@@ -211,9 +213,9 @@ def runSimulation(simulator, simulator_args, outfile, save_times, save_var_names
             profiling_data_sim_runner["end"]["t_nc_write"] += time.time()
 
             #Write progress to screen
-            print_string = progress_printer.getPrintString(t_end)
+            # print_string = progress_printer.getPrintString(t_end)
-            if (print_string):
+            # if (print_string):
-                logger.debug(print_string)
+            #     logger.debug(print_string)
                 
         logger.debug("Simulated to t={:f} in {:d} timesteps (average dt={:f})".format(t_end, sim.simSteps(), sim.simTime() / sim.simSteps()))
         
@@ -433,58 +435,58 @@ class DataDumper(object):
         
 
 
-class ProgressPrinter(object):
+# class ProgressPrinter(object):
-    """
+#     """
-    Small helper class for 
+#     Small helper class for 
-    """
+#     """
-    def __init__(self, total_steps, print_every=5):
+#     def __init__(self, total_steps, print_every=5):
-        self.logger = logging.getLogger(__name__)
+#         self.logger = logging.getLogger(__name__)
-        self.start = time.time()
+#         self.start = time.time()
-        self.total_steps = total_steps
+#         self.total_steps = total_steps
-        self.print_every = print_every
+#         self.print_every = print_every
-        self.next_print_time = self.print_every
+#         self.next_print_time = self.print_every
-        self.last_step = 0
+#         self.last_step = 0
-        self.secs_per_iter = None
+#         self.secs_per_iter = None
         
-    def getPrintString(self, step):
+#     def getPrintString(self, step):
-        elapsed =  time.time() - self.start
+#         elapsed =  time.time() - self.start
-        if (elapsed > self.next_print_time):            
+#         if (elapsed > self.next_print_time):            
-            dt = elapsed - (self.next_print_time - self.print_every)
+#             dt = elapsed - (self.next_print_time - self.print_every)
-            dsteps = step - self.last_step
+#             dsteps = step - self.last_step
-            steps_remaining = self.total_steps - step
+#             steps_remaining = self.total_steps - step
                         
-            if (dsteps == 0):
+#             if (dsteps == 0):
-                return
+#                 return
                 
-            self.last_step = step
+#             self.last_step = step
-            self.next_print_time = elapsed + self.print_every
+#             self.next_print_time = elapsed + self.print_every
             
-            if not self.secs_per_iter:
+#             if not self.secs_per_iter:
-                self.secs_per_iter = dt / dsteps
+#                 self.secs_per_iter = dt / dsteps
-            self.secs_per_iter = 0.2*self.secs_per_iter + 0.8*(dt / dsteps)
+#             self.secs_per_iter = 0.2*self.secs_per_iter + 0.8*(dt / dsteps)
             
-            remaining_time = steps_remaining * self.secs_per_iter
+#             remaining_time = steps_remaining * self.secs_per_iter
 
-            return "{:s}. Total: {:s}, elapsed: {:s}, remaining: {:s}".format(
+#             return "{:s}. Total: {:s}, elapsed: {:s}, remaining: {:s}".format(
-                ProgressPrinter.progressBar(step, self.total_steps), 
+#                 ProgressPrinter.progressBar(step, self.total_steps), 
-                ProgressPrinter.timeString(elapsed + remaining_time), 
+#                 ProgressPrinter.timeString(elapsed + remaining_time), 
-                ProgressPrinter.timeString(elapsed), 
+#                 ProgressPrinter.timeString(elapsed), 
-                ProgressPrinter.timeString(remaining_time))
+#                 ProgressPrinter.timeString(remaining_time))
 
-    def timeString(seconds):
+#     def timeString(seconds):
-        seconds = int(max(seconds, 1))
+#         seconds = int(max(seconds, 1))
-        minutes, seconds = divmod(seconds, 60)
+#         minutes, seconds = divmod(seconds, 60)
-        hours, minutes = divmod(minutes, 60)
+#         hours, minutes = divmod(minutes, 60)
-        periods = [('h', hours), ('m', minutes), ('s', seconds)]
+#         periods = [('h', hours), ('m', minutes), ('s', seconds)]
-        time_string = ' '.join('{}{}'.format(value, name)
+#         time_string = ' '.join('{}{}'.format(value, name)
-                                for name, value in periods
+#                                 for name, value in periods
-                                if value)
+#                                 if value)
-        return time_string
+#         return time_string
 
-    def progressBar(step, total_steps, width=30):
+#     def progressBar(step, total_steps, width=30):
-        progress = np.round(width * step / total_steps).astype(np.int32)
+#         progress = np.round(width * step / total_steps).astype(np.int32)
-        progressbar = "0% [" + "#"*(progress) + "="*(width-progress) + "] 100%"
+#         progressbar = "0% [" + "#"*(progress) + "="*(width-progress) + "] 100%"
-        return progressbar
+#         return progressbar
 
 
 """

GPUSimulators/Simulator.py

@@ -25,6 +25,7 @@ import numpy as np
 import math
 import logging
 from enum import IntEnum
+from tqdm import tqdm
 
 #import pycuda.compiler as cuda_compiler
 #import pycuda.gpuarray
@@ -195,7 +196,7 @@ class BaseSimulator(object):
         Requires that the step() function is implemented in the subclasses
         """
 
-        printer = Common.ProgressPrinter(t)
+        # printer = Common.ProgressPrinter(t)
         
         t_start = self.simTime()
         t_end = t_start + t
@@ -205,6 +206,7 @@ class BaseSimulator(object):
             update_dt = False
             self.dt = dt
         
+        with tqdm(total=t_end) as pbar:
             while(self.simTime() < t_end):
                 # Update dt every 100 timesteps and cross your fingers it works
                 # for the next 100
@@ -223,14 +225,17 @@ class BaseSimulator(object):
                 self.step(current_dt)
 
                 #Print info
-            print_string = printer.getPrintString(self.simTime() - t_start)
+                pbar.update(current_dt)
-            if (print_string):
+                # print_string = printer.getPrintString(self.simTime() - t_start)
-                self.logger.info("%s: %s", self, print_string)
+                # if (print_string):
-                try:
+                #     self.logger.info("%s: %s", self, print_string)
-                    self.check()
+                #     try:
-                except AssertionError as e:
+                #         self.check()
-                    e.args += ("Step={:d}, time={:f}".format(self.simSteps(), self.simTime()),)
+                #     except AssertionError as e:
-                    raise
+                #         e.args += ("Step={:d}, time={:f}".format(self.simSteps(), self.simTime()),)
+                #         raise
+
+        print("Done")
 
 
     def step(self, dt):

conda_environment_lumi.yml

@@ -5,15 +5,17 @@ channels:
 - conda-forge
 
 dependencies:
-- python=3.9.13
+- python=3.11.11
+- pip
 - numpy
 - mpi4py
 - six
 - pytools
 - netcdf4
 - scipy
+- tqdm
 - pip:
-  - hip-python==5.4.3.470.16
+  - hip-python==6.2.0.499.16
   - -i https://test.pypi.org/simple/ 
 
 

mpiTesting.py

@@ -178,7 +178,7 @@ def genSim(grid, **kwargs):
     return sim
 
 
-outfile, sim_runner_profiling_data, sim_profiling_data = Common.runSimulation(
+(outfile, sim_runner_profiling_data, sim_profiling_data) = Common.runSimulation(
     genSim, arguments, outfile, save_times, save_var_names, dt)
 
 if(args.profile):