Add tqdm progress bar (and tests).

Closes #52

Some careful checks for the increment need to be included so that the
end value of the progress bar is correct.

Author: drvinceknight

ciw/simulation.py

@@ -7,6 +7,7 @@
 from decimal import Decimal, getcontext
 from collections import namedtuple
 
+import tqdm
 import yaml
 import numpy.random as nprandom
 
@@ -20,7 +21,6 @@
 from .state_tracker import *
 from .deadlock_detector import *
 
-
 Record = namedtuple('Record', 'id_number customer_class node arrival_date waiting_time service_start_date service_time service_end_date time_blocked exit_date destination queue_size_at_arrival queue_size_at_departure')
 
 class Simulation(object):
@@ -86,6 +86,31 @@ def choose_tracker(self, tracker, deadlock_detector):
             return NaiveTracker(self)
         return StateTracker(self)
 
+    def detect_deadlock(self):
+        """
+        Detects whether the system is in a deadlocked state,
+        that is, is there a knot. Note that this code is taken
+        and adapted from the NetworkX Developer Zone Ticket
+        #663 knot.py (09/06/2015)
+        """
+        knots = []
+        for subgraph in nx.strongly_connected_component_subgraphs(self.digraph):
+            nodes = set(subgraph.nodes())
+            if len(nodes) == 1:
+                n = nodes.pop()
+                nodes.add(n)
+                if set(self.digraph.successors(n)) == nodes:
+                    knots.append(subgraph)
+            else:
+                for n in nodes:
+                    successors = nx.descendants(self.digraph, n)
+                    if successors <= nodes:
+                        knots.append(subgraph)
+                        break
+        if len(knots) > 0:
+            return True
+        return False
+
     def choose_deadlock_detection(self, deadlock_detector):
         """
         Chooses the deadlock detection mechanism to use for the
@@ -236,20 +261,35 @@ def simulate_until_deadlock(self):
             time_of_deadlock - self.times_dictionary[state]
             for state in self.times_dictionary.keys()}
 
-    def simulate_until_max_time(self, max_simulation_time):
+    def simulate_until_max_time(self, max_simulation_time, progress_bar=False):
         """
         Runs the simulation until max_simulation_time is reached.
         """
         self.nodes[0].update_next_event_date()
         next_active_node = self.find_next_active_node()
         current_time = next_active_node.next_event_date
+
+        if progress_bar is not False:
+            self.progress_bar = tqdm.tqdm(total=max_simulation_time)
+
         while current_time < max_simulation_time:
             next_active_node.have_event()
             for node in self.transitive_nodes:
                 node.update_next_event_date(current_time)
             next_active_node = self.find_next_active_node()
+
+            if progress_bar:
+                remaining_time = max_simulation_time - self.progress_bar.n
+                time_increment = next_active_node.next_event_date - current_time
+                self.progress_bar.update(min(time_increment, remaining_time))
+
             current_time = next_active_node.next_event_date
 
+        if progress_bar:
+            remaining_time = max(max_simulation_time - self.progress_bar.n, 0)
+            self.progress_bar.update(remaining_time)
+            self.progress_bar.close()
+
     def source(self, c, n, kind):
         """
         Returns the location of class c node n's arrival or

ciw/tests/test_simulation.py

@@ -104,6 +104,22 @@ def test_simulate_until_max_time_method(self):
             drl.append((dr.customer_class, dr.service_time))
         self.assertEqual(drl, [(1, 10.0), (0, 5.0), (0, 5.0)])
 
+    def test_simulate_until_max_time_with_pbar_method(self):
+        set_seed(2)
+        Q = ciw.Simulation(ciw.create_network(
+            'ciw/tests/testing_parameters/params.yml'))
+        Q.simulate_until_max_time(150, progress_bar=True)
+        self.assertEqual(Q.progress_bar.total, 150)
+        self.assertEqual(Q.progress_bar.n, 150)
+
+        # Check that results are the same
+        L = Q.get_all_records()
+        self.assertEqual(round(
+            L[300].service_start_date, 8), 2.49842838)
+
+
+
+
     def test_simulate_until_deadlock_method(self):
         ciw.seed(3)
         Q = ciw.Simulation(ciw.create_network(

requirements.txt

@@ -1,4 +1,5 @@
 PyYAML
 networkx
 hypothesis
-numpy
+numpy
+tqdm

setup.py

@@ -18,5 +18,5 @@
     packages=['ciw'],
     description='A discrete event simulation library for open queueing networks',
     long_description=readme + '\n\n' + changes + '\n\n' + authors,
-    install_requires=["PyYAML", "networkx", "hypothesis", "numpy"],
+    install_requires=["PyYAML", "networkx", "hypothesis", "numpy", "tqdm"]
 )