Merge pull request #149 from CiwPython/interrupted-inds-bug-fix

Interrupted inds bug fix

Author: geraintpalmer

ciw/.hypothesis/examples/12f74f4ca7e3bcdb/168c69a5c5f28601

@@ -44,4 +44,10 @@ def truncated_normal(mean, sd):
 	sample = random.normalvariate(mean, sd)
 	while sample <= 0.0:
 		sample = random.normalvariate(mean, sd)
-	return sample
+	return sample
+
+def flatten_list(list_of_lists):
+	flat = []
+	for a_list in list_of_lists:
+		flat += a_list
+	return flat

ciw/auxiliary.py

@@ -24,6 +24,7 @@ def __init__(self, id_number, customer_class=0, priority_class=0):
         self.queue_size_at_arrival = False
         self.queue_size_at_departure = False
         self.destination = False
+        self.interrupted = False
 
     def __repr__(self):
         """

ciw/individual.py

@@ -6,7 +6,7 @@
 
 import networkx as nx
 
-from .auxiliary import random_choice
+from .auxiliary import random_choice, flatten_list
 from .data_record import DataRecord
 from .server import Server
 
@@ -54,19 +54,20 @@ def __init__(self, id_, simulation):
         else:
             self.next_event_date = float("Inf")
         self.blocked_queue = []
+        self.len_blocked_queue = 0
         if not isinf(self.c):
             self.servers = self.create_starting_servers()
         self.highest_id = self.c
         self.simulation.deadlock_detector.initialise_at_node(self)
         self.preempt = node.preempt
         self.interrupted_individuals = []
+        self.number_interrupted_individuals = 0
         self.all_servers_total = []
         self.all_servers_busy = []
 
     @property
     def all_individuals(self):
-        return [i for priority_class in self.individuals
-                for i in priority_class]
+        return flatten_list(self.individuals)
 
     def __repr__(self):
         """
@@ -132,12 +133,20 @@ def begin_interrupted_individuals_service(self, current_time, srvr):
         resampling service time)
         """
         ind = [i for i in self.interrupted_individuals][0]
+        if ind.is_blocked:
+            node_blocked_to = self.simulation.nodes[ind.destination]
+            ind.destination = False
+            node_blocked_to.blocked_queue.remove((self.id_number, ind.id_number))
+            node_blocked_to.len_blocked_queue -= 1
+            ind.is_blocked = False
         ind.service_time = self.get_service_time(ind.customer_class,
                                                  current_time)
         ind.service_end_date = self.increment_time(self.get_now(current_time),
                                                    ind.service_time)
+        ind.interrupted = False
         self.attach_server(srvr, ind)
         self.interrupted_individuals.remove(ind)
+        self.number_interrupted_individuals -= 1
 
     def begin_service_if_possible_change_shift(self, current_time):
         """
@@ -146,14 +155,16 @@ def begin_service_if_possible_change_shift(self, current_time):
         """
         free_servers = [s for s in self.servers if not s.busy]
         for srvr in free_servers:
-            if len(self.interrupted_individuals) > 0:
+            if self.number_interrupted_individuals > 0:
                 self.begin_interrupted_individuals_service(current_time, srvr)
-            elif len([i for i in self.all_individuals if not i.server]) > 0:
-                ind = [i for i in self.all_individuals if not i.server][0]
-                ind.service_start_date = self.get_now(current_time)
-                ind.service_end_date = self.increment_time(
-                    ind.service_start_date, ind.service_time)
-                self.attach_server(srvr, ind)
+            else:
+                inds_without_server = [i for i in self.all_individuals if not i.server]
+                if len(inds_without_server) > 0:
+                    ind = inds_without_server[0]
+                    ind.service_start_date = self.get_now(current_time)
+                    ind.service_end_date = self.increment_time(
+                        ind.service_start_date, ind.service_time)
+                    self.attach_server(srvr, ind)
 
     def begin_service_if_possible_release(self, current_time):
         """
@@ -162,14 +173,16 @@ def begin_service_if_possible_release(self, current_time):
         """
         if self.free_server() and (not isinf(self.c)):
             srvr = self.find_free_server()
-            if len(self.interrupted_individuals) > 0:
+            if self.number_interrupted_individuals > 0:
                 self.begin_interrupted_individuals_service(current_time, srvr)
-            elif len([i for i in self.all_individuals if not i.server]) > 0:
-                ind = [i for i in self.all_individuals if not i.server][0]
-                ind.service_start_date = self.get_now(current_time)
-                ind.service_end_date = self.increment_time(
-                    ind.service_start_date, ind.service_time)
-                self.attach_server(srvr, ind)
+            else:
+                inds_without_server = [i for i in self.all_individuals if not i.server]
+                if len(inds_without_server) > 0:
+                    ind = inds_without_server[0]
+                    ind.service_start_date = self.get_now(current_time)
+                    ind.service_end_date = self.increment_time(
+                        ind.service_start_date, ind.service_time)
+                    self.attach_server(srvr, ind)
 
     def block_individual(self, individual, next_node):
         """
@@ -181,8 +194,10 @@ def block_individual(self, individual, next_node):
             individual.customer_class)
         next_node.blocked_queue.append(
             (self.id_number, individual.id_number))
+        next_node.len_blocked_queue += 1
         self.simulation.deadlock_detector.action_at_blockage(
             individual, next_node)
+        self.simulation.unchecked_blockage = True
 
     def change_customer_class(self,individual):
         """
@@ -192,7 +207,7 @@ def change_customer_class(self,individual):
         if self.class_change:
             individual.previous_class = individual.customer_class
             individual.customer_class = random_choice(
-                range(len(self.class_change)),
+                range(self.simulation.network.number_of_classes),
                 self.class_change[individual.previous_class])
             individual.prev_priority_class = individual.priority_class
             individual.priority_class = self.simulation.network.priority_class_mapping[individual.customer_class]
@@ -370,7 +385,7 @@ def release_blocked_individual(self, current_time):
         Releases an individual who becomes unblocked
         when another individual is released.
         """
-        if len(self.blocked_queue) > 0 and self.number_of_individuals < self.node_capacity:
+        if self.len_blocked_queue > 0 and self.number_of_individuals < self.node_capacity:
             node_to_receive_from = self.simulation.nodes[
                 self.blocked_queue[0][0]]
             individual_to_receive_index = [ind.id_number
@@ -379,6 +394,11 @@ def release_blocked_individual(self, current_time):
             individual_to_receive = node_to_receive_from.all_individuals[
                 individual_to_receive_index]
             self.blocked_queue.pop(0)
+            self.len_blocked_queue -= 1
+            if individual_to_receive.interrupted:
+                individual_to_receive.interrupted = False
+                node_to_receive_from.interrupted_individuals.remove(individual_to_receive)
+                node_to_receive_from.number_interrupted_individuals -= 1
             node_to_receive_from.release(individual_to_receive_index,
                 self, current_time)
 
@@ -409,13 +429,16 @@ def take_servers_off_duty(self):
                 s.shift_end = self.next_event_date
                 if s.cust is not False:
                     self.interrupted_individuals.append(s.cust)
+                    s.cust.interrupted = True
+                    self.number_interrupted_individuals += 1
                     self.interrupted_individuals[-1].service_end_date = False
                     self.interrupted_individuals[-1].service_time = False
             self.interrupted_individuals.sort(key=lambda x: (x.priority_class,
                                                              x.arrival_date))
         for obs in to_delete:
             self.kill_server(obs)
 
+
     def update_next_event_date(self, current_time):
         """
         Finds the time of the next event at this node

ciw/node.py

@@ -52,6 +52,7 @@ def __init__(self, network,
         self.times_to_deadlock = {}
         self.rejection_dict = self.nodes[0].rejection_dict
         self.baulked_dict = self.nodes[0].baulked_dict
+        self.unchecked_blockage = False
 
     def __repr__(self):
         """
@@ -268,7 +269,9 @@ def simulate_until_deadlock(self):
             current_state = self.statetracker.hash_state()
             if current_state not in self.times_dictionary:
                 self.times_dictionary[current_state] = current_time
-            deadlocked = self.deadlock_detector.detect_deadlock()
+            if self.unchecked_blockage:
+                deadlocked = self.deadlock_detector.detect_deadlock()
+                self.unchecked_blockage = False
             if deadlocked:
                 time_of_deadlock = current_time
             current_time = next_active_node.next_event_date

ciw/simulation.py

@@ -77,4 +77,10 @@ def test_randomchoice(self):
         self.assertEqual(choice_counts, {'Exit Node': 100})
         self.assertEqual(r1, r2)
 
-
+    def test_flatten_list(self):
+        for seed in range(20):
+            random.seed(seed)
+            all_classes = [[random.random() for _ in range(random.randrange(3, 30, 1))] for _ in range(random.randrange(5, 20, 1))]
+            A = [i for priority in all_classes for i in priority]
+            B = ciw.flatten_list(all_classes)
+            self.assertEqual(A, B)

ciw/tests/test_auxiliary.py

@@ -300,6 +300,7 @@ def test_release_blocked_individual_method(self):
              'Individual 108'])
 
         N1.blocked_queue = [(1, 1), (2, 100)]
+        N1.len_blocked_queue = 2
         rel_ind = N1.individuals[0].pop(0)
         N1.detatch_server(rel_ind.server, rel_ind)
 

ciw/tests/test_node.py

@@ -768,3 +768,29 @@ def test_find_generators(self):
         self.assertTrue(isinstance(Q_all.generators['Ser'][0][1], cycle))
         self.assertTrue(isinstance(Q_all.generators['Ser'][1][0], cycle))
         self.assertTrue(isinstance(Q_all.generators['Ser'][1][1], cycle))
+
+    def test_schedules_and_blockages_work_together(self):
+        N = ciw.create_network(
+            Arrival_distributions={
+                'Class 0': [['Exponential', 0.5], ['Exponential', 0.9]],
+                'Class 1': [['Exponential', 0.6], ['Exponential', 1.0]]},
+            Service_distributions={
+                'Class 0': [['Exponential', 0.8], ['Exponential', 1.2]],
+                'Class 1': [['Exponential', 0.5], ['Exponential', 1.0]]},
+            Number_of_servers=[([[1, 10], [0, 20], [2, 30]], True), 2],
+            Transition_matrices={
+                'Class 0': [[0.1, 0.3], [0.2, 0.2]],
+                'Class 1': [[0.0, 0.6], [0.2, 0.1]]},
+            Class_change_matrices={
+                'Node 1': [[0.8, 0.2],
+                           [0.5, 0.5]],
+                'Node 2': [[1.0, 0.0],
+                           [0.1, 0.9]]},
+            Queue_capacities=[2, 2]
+        )
+
+        ciw.seed(6)
+        Q = ciw.Simulation(N, deadlock_detector='StateDigraph')
+        Q.simulate_until_deadlock()
+        ttd = Q.times_to_deadlock[((0, 0), (0, 0))]
+        self.assertEqual(round(ttd, 5), 92.49468)

ciw/tests/test_simulation.py

@@ -43,7 +43,7 @@ The system uses the following eight distributions:
    + Always sample 0.2.
 + :code:`['Empirical', [0.1, 0.1, 0.1, 0.2]`:
    + Randomly sample from the numbers 0.1, 0.1, 0.1 and 0.2.
-+ :code:`['Custom', [[0.5, 0.2], [0.5, 0.4]]]`:
++ :code:`['Custom', [0.2, 0.4], [0.5, 0.5]]`:
    + Sample 0.2 half the time, and 0.4 half the time.
 + :code:`['Exponential', 6.0]`:
    + Sample from the `exponential <https://en.wikipedia.org/wiki/Exponential_distribution>`_ distribution with parameter :math:`\lambda = 6.0`. Expected mean of 0.1666...

docs/Guides/set_distributions.rst

@@ -33,6 +33,7 @@
     'sphinx.ext.autodoc',
     'sphinx.ext.mathjax',
     'sphinx.ext.viewcode',
+    'sphinx.ext.imgconverter',
 ]
 
 # Add any paths that contain templates here, relative to this directory.