Increment number_of_individuals, remove len(all_individuals)

Author: geraintpalmer

ciw/exit_node.py

@@ -9,10 +9,10 @@ def __init__(self):
         Initialise a node.
         """
         self.all_individuals = []
+        self.number_of_individuals = 0
         self.id_number = -1
         self.next_event_date = float("Inf")
         self.node_capacity = float("Inf")
-        self.number_completed = 0
 
     def __repr__(self):
         """
@@ -25,7 +25,7 @@ def accept(self, next_individual, current_time):
         Adds customer to the list of completed customers
         """
         self.all_individuals.append(next_individual)
-        self.number_completed += 1
+        self.number_of_individuals += 1
 
     def update_next_event_date(self):
         """

ciw/node.py

@@ -42,6 +42,7 @@ def __init__(self, id_, simulation):
         self.class_change = node.class_change_matrix
         self.individuals = [[] for _ in
                 range(simulation.number_of_priority_classes)]
+        self.number_of_individuals = 0
         self.id_number = id_
         self.baulking_functions = [self.simulation.network.customer_classes[
             clss].baulking_functions[id_-1] for clss in range(
@@ -66,9 +67,9 @@ def all_individuals(self):
         return [i for priority_class in self.individuals
                 for i in priority_class]
 
-    @property
-    def number_of_individuals(self):
-        return len(self.all_individuals)
+    # @property
+    # def number_of_individuals(self):
+    #     return len(self.all_individuals)
 
 
     def __repr__(self):
@@ -87,6 +88,7 @@ def accept(self, next_individual, current_time):
             next_individual, current_time)
         next_individual.queue_size_at_arrival = self.number_of_individuals
         self.individuals[next_individual.priority_class].append(next_individual)
+        self.number_of_individuals += 1
         self.simulation.statetracker.change_state_accept(
             self.id_number, next_individual.customer_class)
 
@@ -299,7 +301,7 @@ def finish_service(self):
         self.change_customer_class(next_individual)
         next_node = self.next_node(next_individual.customer_class)
         next_individual.destination = next_node.id_number
-        if len(next_node.all_individuals) < next_node.node_capacity:
+        if next_node.number_of_individuals < next_node.node_capacity:
             self.release(next_individual_index, next_node,
                 self.next_event_date)
         else:
@@ -352,6 +354,7 @@ def release(self, next_individual_index, next_node, current_time):
         """
         next_individual =  self.all_individuals[next_individual_index]
         self.individuals[next_individual.prev_priority_class].remove(next_individual)
+        self.number_of_individuals -= 1
         next_individual.queue_size_at_departure = len(self.all_individuals)
         next_individual.exit_date = current_time
         if self.c < float('Inf'):

ciw/simulation.py

@@ -322,7 +322,7 @@ def simulate_until_max_customers(self, max_customers,
             self.progress_bar = tqdm.tqdm(total=max_customers)
 
         if method == 'Finish':
-            check = lambda : self.nodes[-1].number_completed
+            check = lambda : self.nodes[-1].number_of_individuals
         elif method == 'Arrive':
             check = lambda : self.nodes[0].number_of_individuals
         elif method == 'Accept':

ciw/tests/test_node.py

@@ -61,14 +61,16 @@ def test_finish_service_method(self):
             N.accept(inds[int(current_time*100 - 1)], current_time)
         self.assertEqual([str(obs) for obs in N.all_individuals],
             ['Individual 1', 'Individual 2', 'Individual 3'])
-        self.assertEqual([[str(obs) for obs in pr_cls] for pr_cls in N.individuals],
+        self.assertEqual(
+            [[str(obs) for obs in pr_cls] for pr_cls in N.individuals],
             [['Individual 1', 'Individual 2', 'Individual 3']])
         N.update_next_event_date(0.03)
         self.assertEqual(round(N.next_event_date, 5), 0.03604)
         N.finish_service()
         self.assertEqual([str(obs) for obs in N.all_individuals],
             ['Individual 1', 'Individual 3'])
-        self.assertEqual([[str(obs) for obs in pr_cls] for pr_cls in N.individuals],
+        self.assertEqual(
+            [[str(obs) for obs in pr_cls] for pr_cls in N.individuals],
             [['Individual 1', 'Individual 3']])
 
     def test_change_customer_class_method(self):
@@ -187,7 +189,8 @@ def test_release_method(self):
             N.accept(inds[int(current_time*100 - 1)], current_time)
         self.assertEqual([str(obs) for obs in N.all_individuals],
             ['Individual 1', 'Individual 2', 'Individual 3'])
-        self.assertEqual([[str(obs) for obs in pr_cls] for pr_cls in N.individuals],
+        self.assertEqual(
+            [[str(obs) for obs in pr_cls] for pr_cls in N.individuals],
             [['Individual 1', 'Individual 2', 'Individual 3']])
         N.update_next_event_date(0.03)
         self.assertEqual(round(N.next_event_date, 5), 0.03604)
@@ -197,7 +200,8 @@ def test_release_method(self):
         N.release(1, Q.transitive_nodes[1], N.next_event_date)
         self.assertEqual([str(obs) for obs in N.all_individuals],
             ['Individual 1', 'Individual 3'])
-        self.assertEqual([[str(obs) for obs in pr_cls] for pr_cls in N.individuals],
+        self.assertEqual(
+            [[str(obs) for obs in pr_cls] for pr_cls in N.individuals],
             [['Individual 1', 'Individual 3']])
         N.update_next_event_date(N.next_event_date + 0.00001)
         self.assertEqual(round(N.next_event_date, 5), 0.06447)
@@ -539,46 +543,78 @@ def test_if_putting_individuals_in_correct_priority_queue(self):
         N1 = Q.transitive_nodes[0]
         N2 = Q.transitive_nodes[1]
 
-        self.assertEqual([[str(obs) for obs in lst] for lst in N1.individuals], [[], []])
-        self.assertEqual([str(obs) for obs in N1.all_individuals], [])
-        self.assertEqual([[str(obs) for obs in lst] for lst in N2.individuals], [[], []])
-        self.assertEqual([str(obs) for obs in N2.all_individuals], [])
+        self.assertEqual(
+            [[str(obs) for obs in lst] for lst in N1.individuals], [[], []])
+        self.assertEqual(
+            [str(obs) for obs in N1.all_individuals], [])
+        self.assertEqual(
+            [[str(obs) for obs in lst] for lst in N2.individuals], [[], []])
+        self.assertEqual(
+            [str(obs) for obs in N2.all_individuals], [])
 
         Q.nodes[0].next_node = 1
         Q.nodes[0].next_class = 0
         Q.nodes[0].have_event()
 
-        self.assertEqual([[str(obs) for obs in lst] for lst in N1.individuals], [['Individual 1'], []])
-        self.assertEqual([str(obs) for obs in N1.all_individuals], ['Individual 1'])
-        self.assertEqual([[str(obs) for obs in lst] for lst in N2.individuals], [[], []])
-        self.assertEqual([str(obs) for obs in N2.all_individuals], [])
+        self.assertEqual(
+            [[str(obs) for obs in lst] for lst in N1.individuals],
+            [['Individual 1'], []])
+        self.assertEqual(
+            [str(obs) for obs in N1.all_individuals],
+            ['Individual 1'])
+        self.assertEqual(
+            [[str(obs) for obs in lst] for lst in N2.individuals], [[], []])
+        self.assertEqual(
+            [str(obs) for obs in N2.all_individuals], [])
 
         Q.nodes[0].next_node = 1
         Q.nodes[0].next_class = 1
         Q.nodes[0].have_event()
 
-        self.assertEqual([[str(obs) for obs in lst] for lst in N1.individuals], [['Individual 1'], ['Individual 2']])
-        self.assertEqual([str(obs) for obs in N1.all_individuals], ['Individual 1', 'Individual 2'])
-        self.assertEqual([[str(obs) for obs in lst] for lst in N2.individuals], [[], []])
-        self.assertEqual([str(obs) for obs in N2.all_individuals], [])
+        self.assertEqual(
+            [[str(obs) for obs in lst] for lst in N1.individuals],
+            [['Individual 1'], ['Individual 2']])
+        self.assertEqual(
+            [str(obs) for obs in N1.all_individuals],
+            ['Individual 1', 'Individual 2'])
+        self.assertEqual(
+            [[str(obs) for obs in lst] for lst in N2.individuals], [[], []])
+        self.assertEqual(
+            [str(obs) for obs in N2.all_individuals], [])
 
         Q.nodes[0].next_node = 2
         Q.nodes[0].next_class = 0
         Q.nodes[0].have_event()
 
-        self.assertEqual([[str(obs) for obs in lst] for lst in N1.individuals], [['Individual 1'], ['Individual 2']])
-        self.assertEqual([str(obs) for obs in N1.all_individuals], ['Individual 1', 'Individual 2'])
-        self.assertEqual([[str(obs) for obs in lst] for lst in N2.individuals], [['Individual 3'], []])
-        self.assertEqual([str(obs) for obs in N2.all_individuals], ['Individual 3'])
+        self.assertEqual(
+            [[str(obs) for obs in lst] for lst in N1.individuals],
+            [['Individual 1'], ['Individual 2']])
+        self.assertEqual(
+            [str(obs) for obs in N1.all_individuals],
+            ['Individual 1', 'Individual 2'])
+        self.assertEqual(
+            [[str(obs) for obs in lst] for lst in N2.individuals],
+            [['Individual 3'], []])
+        self.assertEqual(
+            [str(obs) for obs in N2.all_individuals],
+            ['Individual 3'])
 
         Q.nodes[0].next_node = 2
         Q.nodes[0].next_class = 1
         Q.nodes[0].have_event()
 
-        self.assertEqual([[str(obs) for obs in lst] for lst in N1.individuals], [['Individual 1'], ['Individual 2']])
-        self.assertEqual([str(obs) for obs in N1.all_individuals], ['Individual 1', 'Individual 2'])
-        self.assertEqual([[str(obs) for obs in lst] for lst in N2.individuals], [['Individual 3'], ['Individual 4']])
-        self.assertEqual([str(obs) for obs in N2.all_individuals], ['Individual 3', 'Individual 4'])
+        self.assertEqual(
+            [[str(obs) for obs in lst] for lst in N1.individuals],
+            [['Individual 1'], ['Individual 2']])
+        self.assertEqual(
+            [str(obs) for obs in N1.all_individuals],
+            ['Individual 1', 'Individual 2'])
+        self.assertEqual(
+            [[str(obs) for obs in lst] for lst in N2.individuals],
+            [['Individual 3'], ['Individual 4']])
+        self.assertEqual(
+            [str(obs) for obs in N2.all_individuals],
+            ['Individual 3', 'Individual 4'])
 
     def test_server_utilisation(self):
         # Single server
@@ -603,11 +639,37 @@ def test_server_utilisation(self):
 
     def test_server_utilisation_with_schedules(self):
         N = ciw.create_network(
-            Arrival_distributions=[['Sequential', [2.0, 4.0, 4.0, 0.0, 7.0, 1000.0]]],
-            Service_distributions=[['Sequential', [4.0, 2.0, 6.0, 6.0, 3.0]]],
+            Arrival_distributions=[['Sequential',
+                [2.0, 4.0, 4.0, 0.0, 7.0, 1000.0]]],
+            Service_distributions=[['Sequential',
+                [4.0, 2.0, 6.0, 6.0, 3.0]]],
             Number_of_servers=[[[1, 9], [2, 23]]]
         )
         Q = ciw.Simulation(N)
         Q.simulate_until_max_time(23)
         recs = Q.get_all_records()
         self.assertEqual(Q.transitive_nodes[0].server_utilisation, 21.0/37.0)
+
+    def test_num_inds_equal_len_all_inds(self):
+        # Create a Simulatin class that inherits form ciw.Simulation so that
+        # an assertion than number_of_individuals == len(all_individuals)
+        # every time self.event_and_return_nextnode is called.
+        class AssertSim(ciw.Simulation):
+            def event_and_return_nextnode(simself, next_active_node, current_time):
+                """
+                Carries out the event of current next_active_node, and return the next
+                next_active_node
+                """
+                next_active_node.have_event()
+                for node in simself.transitive_nodes:
+                    node.update_next_event_date(current_time)
+                    self.assertEqual(
+                        node.number_of_individuals, len(node.all_individuals))
+                return simself.find_next_active_node()
+
+        # Now carry out the tests by running a simulation with this new
+        # inherited Node class.
+        N = ciw.create_network_from_yml(
+            'ciw/tests/testing_parameters/params.yml')
+        Q = AssertSim(N)
+        Q.simulate_until_max_time(100)

ciw/tests/test_simulation.py

@@ -124,14 +124,14 @@ def test_simulate_until_max_customers_finish(self):
         ciw.seed(2)
         Q1 = ciw.Simulation(N)
         Q1.simulate_until_max_customers(10, method='Finish')
-        self.assertEqual(Q1.nodes[-1].number_completed, 10)
+        self.assertEqual(Q1.nodes[-1].number_of_individuals, 10)
         self.assertEqual(len(Q1.nodes[-1].all_individuals), 10)
 
         # Test 'Finish' method
         ciw.seed(2)
         Q2 = ciw.Simulation(N)
         Q2.simulate_until_max_customers(10)
-        self.assertEqual(Q2.nodes[-1].number_completed, 10)
+        self.assertEqual(Q2.nodes[-1].number_of_individuals, 10)
         self.assertEqual(len(Q2.nodes[-1].all_individuals), 10)
 
         next_active_node = Q2.find_next_active_node()