Server utilisation works across server schedules

Author: geraintpalmer

ciw/exactnode.py

@@ -1,13 +1,20 @@
 from .node import Node
 from .arrival_node import ArrivalNode
 from decimal import Decimal, getcontext
+from .server import Server
 
 class ExactNode(Node):
     """
     Inherits from the Node class, implements a more
     precise version of addition to fix discrepencies
     with floating point numbers.
     """
+    def create_starting_servers(self):
+        """
+        Initialise the servers
+        """
+        return [Server(self, i + 1, Decimal('0.0')) for i in range(self.c)]
+
     def increment_time(self, original, increment):
         """
         Increments the original time by the increment

ciw/node.py

@@ -52,7 +52,7 @@ def __init__(self, id_, simulation):
             self.next_event_date = float("Inf")
         self.blocked_queue = []
         if self.c < float('Inf'):
-            self.servers = [Server(self, i + 1) for i in range(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
@@ -96,7 +96,7 @@ def add_new_servers(self, shift_indx):
         num_servers = self.schedule[shift_indx][1]
         for i in range(num_servers):
             self.highest_id += 1
-            self.servers.append(Server(self, self.highest_id))
+            self.servers.append(Server(self, self.highest_id, self.next_event_date))
 
     def attach_server(self, server, individual):
         """
@@ -218,7 +218,6 @@ def change_shift(self):
         self.begin_service_if_possible_change_shift(
             self.next_event_date)
 
-
     def check_if_shiftchange(self):
         """
         Check whether current time is a shift change.
@@ -227,6 +226,12 @@ def check_if_shiftchange(self):
             return self.next_event_date == self.next_shift_change
         return False
 
+    def create_starting_servers(self):
+        """
+        Initialise the servers
+        """
+        return [Server(self, i + 1, 0.0) for i in range(self.c)]
+
     def detatch_server(self, server, individual):
         """
         Detatches a server from an individual, and vice versa
@@ -240,7 +245,7 @@ def detatch_server(self, server, individual):
             server.busy_time = (individual.exit_date - individual.service_start_date)
         else:
             server.busy_time += (individual.exit_date - individual.service_start_date)
-        server.total_time = individual.exit_date
+        server.total_time = self.increment_time(individual.exit_date, -server.start_date)
         if server.offduty:
             self.kill_server(server)
 
@@ -320,10 +325,13 @@ def increment_time(self, original, increment):
         """
         return original + increment
 
-    def kill_server(self,srvr):
+    def kill_server(self, srvr):
         """
         Kills server.
         """
+        srvr.total_time = self.increment_time(self.next_event_date, -srvr.start_date)
+        self.all_servers_busy.append(srvr.busy_time)
+        self.all_servers_total.append(srvr.total_time)
         indx = self.servers.index(srvr)
         del self.servers[indx]
 
@@ -417,6 +425,18 @@ def update_next_event_date(self, current_time):
         else:
             self.next_event_date = next_end_service
 
+    def wrap_up_servers(self, current_time):
+        """
+        Updates the servers' total_time and busy_time
+        as the end of the simulation run.
+        """
+        if self.c != float('Inf'):
+            for srvr in self.servers:
+                srvr.total_time = current_time - srvr.start_date
+                if srvr.busy:
+                    srvr.busy_time += (current_time - srvr.cust.arrival_date)
+
+
     def write_individual_record(self, individual):
         """
         Write a data record for an individual:

ciw/server.py

@@ -4,7 +4,7 @@ class Server(object):
     """
     A class to contain server information
     """
-    def __init__(self, node, id_number):
+    def __init__(self, node, id_number, start_date=0.0):
         """
         Initialise the server object
         """
@@ -14,6 +14,7 @@ def __init__(self, node, id_number):
         self.busy = False
         self.offduty = False
         self.all_time = False
+        self.start_date = start_date
         self.busy_time = False
         self.total_time = False
 

ciw/simulation.py

@@ -351,15 +351,12 @@ def simulate_until_max_customers(self, max_customers,
 
     def wrap_up_servers(self, current_time):
         """
-        Updates the servers' total_time and busy_time
-        as the end of the simulation run.
+        Updates the servers' total_time and busy_time as
+        the end of the simulation run. Finds the overall
+        server utilisation for each node.
         """
         for nd in self.transitive_nodes:
-            if nd.c != float('Inf'):
-                for srvr in nd.servers:
-                    srvr.total_time = current_time
-                    if srvr.busy:
-                        srvr.busy_time += (current_time - srvr.cust.arrival_date)
+            nd.wrap_up_servers(current_time)
             nd.find_server_utilisation()
 
     def source(self, c, n, kind):

ciw/tests/test_node.py

@@ -599,4 +599,15 @@ def test_server_utilisation(self):
         )
         Q = ciw.Simulation(N)
         Q.simulate_until_max_time(20.0)
-        self.assertEqual(Q.transitive_nodes[0].server_utilisation, 4.0/15.0)
+        self.assertEqual(Q.transitive_nodes[0].server_utilisation, 4.0/15.0)
+
+    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]]],
+            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)