Merge pull request #97 from CiwPython/time_dependent

Time dependent

Author: geraintpalmer

ciw/arrival_node.py

@@ -33,13 +33,15 @@ def __repr__(self):
 
     def decide_baulk(self, next_node, next_individual):
         """
-        Either makes an individual baulk, or sends the individual to the next node
+        Either makes an individual baulk, or sends the individual
+        to the next node
         """
         if next_node.baulking_functions[self.next_class] == None:
             self.send_individual(next_node, next_individual)
         else:
             rnd_num = random()
-            if rnd_num < next_node.baulking_functions[self.next_class](next_node.number_of_individuals):
+            if rnd_num < next_node.baulking_functions[self.next_class](
+                next_node.number_of_individuals):
                 self.record_baulk(next_node)
             else:
                 self.send_individual(next_node, next_individual)
@@ -65,7 +67,8 @@ def have_event(self):
         Send new arrival to relevent node.
         """
         self.number_of_individuals += 1
-        priority_class = self.simulation.network.priority_class_mapping[self.next_class]
+        priority_class = self.simulation.network.priority_class_mapping[
+            self.next_class]
         next_individual = Individual(self.number_of_individuals,
                                      self.next_class,
                                      priority_class)
@@ -75,7 +78,8 @@ def have_event(self):
             self.next_class] = self.increment_time(
             self.event_dates_dict[self.next_node][
             self.next_class], self.inter_arrival(
-            self.next_node, self.next_class))
+            self.next_node, self.next_class,
+            self.next_event_date))
         self.find_next_event_date()
 
     def increment_time(self, original, increment):
@@ -92,12 +96,15 @@ def initialise_event_dates_dict(self):
         for nd in self.event_dates_dict:
             for cls in self.event_dates_dict[nd]:
                 self.event_dates_dict[nd][
-                cls] = self.simulation.inter_arrival_times[nd][cls]()
+                cls] = self.inter_arrival(nd, cls, 0.0)
 
-    def inter_arrival(self, nd, cls):
+    def inter_arrival(self, nd, cls, current_time):
         """
         Samples the inter-arrival time for next class and node.
         """
+        if self.simulation.network.customer_classes[
+            cls].arrival_distributions[nd-1][0] == "TimeDependent":
+            return self.simulation.inter_arrival_times[nd][cls](current_time)
         return self.simulation.inter_arrival_times[nd][cls]()
 
     def record_baulk(self, next_node):

ciw/exactnode.py

@@ -14,12 +14,15 @@ def increment_time(self, original, increment):
         """
         return Decimal(str(original)) + Decimal(str(increment))
 
-    def get_service_time(self, cls):
+    def get_service_time(self, cls, current_time):
         """
         Returns a service time for the given customer class
         """
+        if self.simulation.network.customer_classes[cls].service_distributions[self.id_number-1][0] == "TimeDependent":
+            return Decimal(str(self.simulation.service_times[self.id_number][cls](current_time)))
         return Decimal(str(self.simulation.service_times[self.id_number][cls]()))
 
+
     def get_now(self, current_time):
         """
         Gets the current time
@@ -39,8 +42,11 @@ def increment_time(self, original, increment):
         """
         return Decimal(str(original)) + Decimal(str(increment))
 
-    def inter_arrival(self, nd, cls):
+    def inter_arrival(self, nd, cls, current_time):
         """
         Samples the inter-arrival time for next class and node.
         """
+        if self.simulation.network.customer_classes[cls].arrival_distributions[nd-1][0] == "TimeDependent":
+            return Decimal(str(self.simulation.inter_arrival_times[nd][cls](current_time)))
         return Decimal(str(self.simulation.inter_arrival_times[nd][cls]()))
+

ciw/import_params.py

@@ -6,7 +6,8 @@
 
 def create_network(params):
     """
-    Identifies the type of parameters that is input and calls the correct function
+    Identifies the type of parameters that is input and
+    calls the correct function
     """
     if isinstance(params, dict):
         return create_network_from_dictionary(params)
@@ -174,7 +175,8 @@ def validify_dictionary(params):
     if not set(dists).issubset(set([
         'Uniform', 'Triangular', 'Deterministic',
         'Exponential', 'Gamma', 'Lognormal',
-        'Weibull', 'Empirical', 'Custom', 'UserDefined'])):
+        'Weibull', 'Empirical', 'Custom', 'UserDefined',
+        'TimeDependent'])):
         raise ValueError('Ensure that valid Arrival and Service Distributions are used.')
     neg_numservers = any([(isinstance(obs, int) and obs <= 0) for obs in params['Number_of_servers']])
     valid_capacities = all([((isinstance(obs, int) and obs >= 0) or obs=='Inf') for obs in params['Queue_capacities']])

ciw/node.py

@@ -28,7 +28,8 @@ def __init__(self, id_, simulation):
             self.schedule = [list(pair) for pair in zip(boundaries, servers)]
             self.c = self.schedule[0][1]
             raw_schedule_boundaries = [row[0] for row in raw_schedule]
-            self.date_generator = self.date_from_schedule_generator(raw_schedule_boundaries)
+            self.date_generator = self.date_from_schedule_generator(
+                raw_schedule_boundaries)
             self.next_shift_change = next(self.date_generator)
         else:
             self.c = node.number_of_servers
@@ -114,7 +115,7 @@ def begin_service_if_possible_accept(self,
         """
         next_individual.arrival_date = self.get_now(current_time)
         next_individual.service_time = self.get_service_time(
-            next_individual.customer_class)
+            next_individual.customer_class, current_time)
         if self.free_server():
             if self.c < float('Inf'):
                 self.attach_server(self.find_free_server(),
@@ -130,8 +131,10 @@ def begin_interrupted_individuals_service(self, current_time, srvr):
         """
         ind = [i for i in self.interrupted_individuals][0]
         self.attach_server(srvr, ind)
-        ind.service_time = self.get_service_time(ind.customer_class)
-        ind.service_end_date = self.increment_time(self.get_now(current_time), ind.service_time)
+        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.interrupted_individuals.remove(ind)
 
     def begin_service_if_possible_change_shift(self, current_time):
@@ -348,10 +351,13 @@ def release_blocked_individual(self, current_time):
             node_to_receive_from.release(individual_to_receive_index,
                 self, current_time)
 
-    def get_service_time(self, cls):
+    def get_service_time(self, cls, current_time):
         """
         Returns a service time for the given customer class
         """
+        if self.simulation.network.customer_classes[cls].service_distributions[
+            self.id_number-1][0] == 'TimeDependent':
+            return self.simulation.service_times[self.id_number][cls](current_time)
         return self.simulation.service_times[self.id_number][cls]()
 
     def take_servers_off_duty(self):
@@ -429,11 +435,15 @@ def write_individual_record(self, individual):
         individual.destination = False
 
     def date_from_schedule_generator(self, boundaries):
-        """A generator that yields the next time according to a given schedule"""
+        """
+        A generator that yields the next time according to a given schedule.
+        """
         boundaries_len = len(boundaries)
         index = 0
         date = 0
         while True:
-            date = self.increment_time(boundaries[index % boundaries_len], (index) // boundaries_len * boundaries[-1])
+            date = self.increment_time(
+                boundaries[index % boundaries_len],
+                (index) // boundaries_len * boundaries[-1])
             index += 1
             yield date

ciw/simulation.py

@@ -22,7 +22,11 @@ class Simulation(object):
     """
     Overall simulation class
     """
-    def __init__(self, network, exact=False, name='Simulation', tracker=False, deadlock_detector=False,
+    def __init__(self, network,
+                 exact=False,
+                 name='Simulation',
+                 tracker=False,
+                 deadlock_detector=False,
         node_class=None, arrival_node_class=None):
         """
         Initialise a queue instance.
@@ -62,9 +66,16 @@ def check_userdef_dist(self, func):
         """
         sample = func()
         if not isinstance(sample, float) or sample < 0:
-            raise ValueError("UserDefined function must return positive float.")
+            raise ValueError("UserDefined func must return positive float.")
         return sample
 
+    def check_timedependent_dist(self, func, current_time):
+        sample = func(current_time)
+        if not isinstance(sample, float) or sample < 0:
+            raise ValueError("TimeDependent func must return positive float.")
+        return sample
+
+
     def choose_tracker(self, tracker, deadlock_detector):
         """
         Chooses the state tracker to use for the simulation.
@@ -128,6 +139,8 @@ def find_distributions(self, n, c, kind):
                 empirical_dist = self.import_empirical(self.source(c, n, kind)[1])
                 return lambda : nprandom.choice(empirical_dist)
             return lambda : nprandom.choice(self.source(c, n, kind)[1])
+        if self.source(c, n, kind)[0] == 'TimeDependent':
+            return lambda t : self.check_timedependent_dist(self.source(c, n, kind)[1], t)
 
     def find_next_active_node(self):
         """

ciw/tests/test_arrival_node.py

@@ -126,7 +126,7 @@ def test_no_arrivals_example(self):
         Q = ciw.Simulation(ciw.create_network(params))
         AN = Q.nodes[0]
         self.assertEqual(AN.simulation.network.customer_classes[0].arrival_distributions[0], 'NoArrivals')
-        self.assertEqual(AN.inter_arrival(1, 0), float('Inf'))
+        self.assertEqual(AN.inter_arrival(1, 0, 0.0), float('Inf'))
 
     def test_rejection_dict(self):
         params = {'Arrival_distributions':[['Deterministic', 3.0], ['Deterministic', 4.0]],
@@ -137,7 +137,7 @@ def test_rejection_dict(self):
         Q = ciw.Simulation(ciw.create_network(params))
         self.assertEqual(Q.rejection_dict, {1: {0: []}, 2: {0:[]}})
         Q.simulate_until_max_time(20)
-        self.assertEqual(Q.rejection_dict, {1: {0: [9.0, 12.0, 18.0]}, 2: {0:[12.0, 16.0]}})
+        self.assertEqual(Q.rejection_dict, {1: {0: [9.0, 12.0, 18.0]}, 2: {0: [12.0, 16.0]}})
 
     def test_send_individual(self):
         params = {'Arrival_distributions':[['Exponential', 3.0]],