loop over sevrers only when determining next_event_date

Author: geraintpalmer

ciw/node.py

@@ -67,11 +67,6 @@ 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)
-
-
     def __repr__(self):
         """
         Representation of a node.
@@ -108,6 +103,7 @@ def attach_server(self, server, individual):
         server.cust = individual
         server.busy = True
         individual.server = server
+        server.next_end_service_date = individual.service_end_date
         self.simulation.deadlock_detector.action_at_attach_server(
             self, server, individual)
 
@@ -122,24 +118,24 @@ def begin_service_if_possible_accept(self,
         next_individual.service_time = self.get_service_time(
             next_individual.customer_class, current_time)
         if self.free_server():
-            if self.c < float('Inf'):
-                self.attach_server(self.find_free_server(),
-                                   next_individual)
             next_individual.service_start_date = self.get_now(current_time)
             next_individual.service_end_date = self.increment_time(
                 current_time, next_individual.service_time)
+            if self.c < float('Inf'):
+                self.attach_server(self.find_free_server(),
+                                   next_individual)
 
     def begin_interrupted_individuals_service(self, current_time, srvr):
         """
         Restarts the next interrupted individual's service (by
         resampking service time)
         """
         ind = [i for i in self.interrupted_individuals][0]
-        self.attach_server(srvr, ind)
         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)
+        self.attach_server(srvr, ind)
         self.interrupted_individuals.remove(ind)
 
     def begin_service_if_possible_change_shift(self, current_time):
@@ -153,10 +149,10 @@ def begin_service_if_possible_change_shift(self, current_time):
                 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]
-                self.attach_server(srvr, ind)
                 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):
         """
@@ -169,10 +165,10 @@ def begin_service_if_possible_release(self, current_time):
                 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]
-                self.attach_server(srvr, ind)
                 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):
         """
@@ -301,6 +297,8 @@ 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 self.c < float('Inf'):
+            next_individual.server.next_end_service_date = float('Inf')
         if next_node.number_of_individuals < next_node.node_capacity:
             self.release(next_individual_index, next_node,
                 self.next_event_date)
@@ -422,10 +420,14 @@ def update_next_event_date(self, current_time):
         """
         Finds the time of the next event at this node
         """
-        next_end_service = min([ind.service_end_date
-            for ind in self.all_individuals
-            if not ind.is_blocked
-            if ind.service_end_date >= current_time] + [float("Inf")])
+        if self.c != float('Inf'):
+            next_end_service = min([s.next_end_service_date
+                for s in self.servers] + [float("Inf")])
+        else:
+            next_end_service = min([ind.service_end_date
+                for ind in self.all_individuals
+                if not ind.is_blocked
+                if ind.service_end_date >= current_time] + [float("Inf")])
         if self.schedule:
             next_shift_change = self.next_shift_change
             self.next_event_date = min(

ciw/server.py

@@ -18,6 +18,7 @@ def __init__(self, node, id_number, start_date=0.0):
         self.busy_time = False
         self.total_time = False
         self.shift_end = False
+        self.next_end_service_date = float('Inf')
 
     @property
     def utilisation(self):

ciw/tests/test_node.py

@@ -194,18 +194,28 @@ def test_release_method(self):
             [['Individual 1', 'Individual 2', 'Individual 3']])
         N.update_next_event_date(0.03)
         self.assertEqual(round(N.next_event_date, 5), 0.03604)
-        N.all_individuals[1].exit_date = 0.04
-        N.update_next_event_date(N.next_event_date + 0.00001)
-        self.assertEqual(round(N.next_event_date, 5), 0.03708)
+
+        N.servers[1].next_end_service_date = float('Inf')
         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],
             [['Individual 1', 'Individual 3']])
-        N.update_next_event_date(N.next_event_date + 0.00001)
+        N.update_next_event_date(N.next_event_date)
+        self.assertEqual(round(N.next_event_date, 5), 0.03708)
+
+        N.servers[0].next_end_service_date = float('Inf')
+        N.release(0, Q.transitive_nodes[1], N.next_event_date)
+        self.assertEqual([str(obs) for obs in N.all_individuals],
+            ['Individual 3'])
+        self.assertEqual(
+            [[str(obs) for obs in pr_cls] for pr_cls in N.individuals],
+            [['Individual 3']])
+        N.update_next_event_date(N.next_event_date)
         self.assertEqual(round(N.next_event_date, 5), 0.06447)
 
+
     def test_begin_service_if_possible_release_method(self):
         ciw.seed(50)
         Q = ciw.Simulation(ciw.create_network_from_yml(
@@ -402,8 +412,12 @@ def test_begin_service_if_possible_accept_method(self):
         self.assertEqual(round(ind.service_end_date, 5), 300.03382)
 
     def test_update_next_event_date_method(self):
-        Q = ciw.Simulation(ciw.create_network_from_yml(
-            'ciw/tests/testing_parameters/params.yml'))
+        Net = ciw.create_network(
+            Arrival_distributions=[['Deterministic', 10.0]],
+            Service_distributions=[['Sequential', [0.5, 0.2]]],
+            Number_of_servers=[5]
+        )
+        Q = ciw.Simulation(Net)
         N = Q.transitive_nodes[0]
         self.assertEqual(N.next_event_date, float('Inf'))
         self.assertEqual(N.all_individuals, [])
@@ -412,49 +426,25 @@ def test_update_next_event_date_method(self):
 
         ind1 = ciw.Individual(1)
         ind1.arrival_date = 0.3
-        ind1.service_time = 0.2
-        ind1.service_end_date = 0.5
         N.next_event_date = 0.3
-        N.individuals = [[ind1]]
-        N.update_next_event_date(N.next_event_date + 0.000001)
-        self.assertEqual(N.next_event_date, 0.5)
+        N.accept(ind1, 0.3)
+        N.update_next_event_date(N.next_event_date)
+        self.assertEqual(N.next_event_date, 0.8)
 
         ind2 = ciw.Individual(2)
         ind2.arrival_date = 0.4
-        ind2.service_time = 0.2
-        ind2.service_end_date = 0.6
-        ind2.exit_date = False
-
-        N.individuals = [[ind1, ind2]]
+        N.accept(ind2, 0.4)
         N.update_next_event_date(N.next_event_date + 0.000001)
-        self.assertEqual(N.next_event_date, 0.6)
+        self.assertEqual(round(N.next_event_date, 4), 0.6)
 
-        ind2.exit_date = 0.9
+        N.finish_service()
+        N.update_next_event_date(N.next_event_date)
+        self.assertEqual(N.next_event_date, 0.8)
 
-        N.update_next_event_date(N.next_event_date + 0.000001)
+        N.finish_service()
+        N.update_next_event_date(N.next_event_date)
         self.assertEqual(N.next_event_date, float('Inf'))
 
-
-        Q = ciw.Simulation(ciw.create_network_from_yml(
-            'ciw/tests/testing_parameters/params_schedule.yml'))
-        N = Q.transitive_nodes[0]
-        self.assertEqual(N.next_event_date, 30)
-        self.assertEqual(N.individuals, [[]])
-        N.update_next_event_date(0.0)
-        self.assertEqual(N.next_event_date, 30)
-
-        ind1 = ciw.Individual(1)
-        ind1.arrival_date = 0.3
-        ind1.service_time = 0.2
-        ind1.service_end_date = 0.5
-        N.next_event_date = 0.3
-        N.individuals = [[ind1]]
-        N.update_next_event_date(N.next_event_date + 0.000001)
-        self.assertEqual(N.next_event_date, 0.5)
-
-        N.update_next_event_date(N.next_event_date + 0.000001)
-        self.assertEqual(N.next_event_date, 30)
-
     def test_next_node_method(self):
         ciw.seed(6)
         Q = ciw.Simulation(ciw.create_network_from_yml(

ciw/tests/test_simulation.py

@@ -180,24 +180,25 @@ def test_simulate_until_max_customers_with_pbar_method(self):
         N = ciw.create_network_from_yml(
             'ciw/tests/testing_parameters/params.yml')
 
+        max_custs = 250
+
         ciw.seed(1)
         Q1 = ciw.Simulation(N)
-        Q1.simulate_until_max_customers(10, progress_bar=True, method='Finish')
-        self.assertEqual(Q1.progress_bar.total, 10)
-        self.assertEqual(Q1.progress_bar.n, 10)
+        Q1.simulate_until_max_customers(max_custs, progress_bar=True, method='Finish')
+        self.assertEqual(Q1.progress_bar.total, max_custs)
+        self.assertEqual(Q1.progress_bar.n, max_custs)
 
         ciw.seed(1)
         Q2 = ciw.Simulation(N)
-        Q2.simulate_until_max_customers(10, progress_bar=True, method='Arrive')
-        self.assertEqual(Q2.progress_bar.total, 10)
-        self.assertEqual(Q2.progress_bar.n, 10)
+        Q2.simulate_until_max_customers(max_custs, progress_bar=True, method='Arrive')
+        self.assertEqual(Q2.progress_bar.total, max_custs)
+        self.assertEqual(Q2.progress_bar.n, max_custs)
 
         ciw.seed(1)
         Q3 = ciw.Simulation(N)
-        Q3.simulate_until_max_customers(10, progress_bar=True, method='Accept')
-        self.assertEqual(Q3.progress_bar.total, 10)
-        self.assertEqual(Q3.progress_bar.n, 10)
-
+        Q3.simulate_until_max_customers(max_custs, progress_bar=True, method='Accept')
+        self.assertEqual(Q3.progress_bar.total, max_custs)
+        self.assertEqual(Q3.progress_bar.n, max_custs)
 
     def test_simulate_until_deadlock_method(self):
         ciw.seed(3)
@@ -341,7 +342,6 @@ def test_writing_data_files(self):
         self.assertEqual(len(data[0]), len(ciw.data_record.DataRecord._fields))
         os.remove('ciw/tests/testing_parameters/data_2.csv')
 
-
     def test_simultaneous_events_example(self):
         # This should yield 3 or 2 customers finishing service.
         # Due to randomly choosing the order of events, the seed has