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
# a big affect on this.
params = {'arrival_distributions': [ciw.dists.Deterministic(10.0),
ciw.dists.NoArrivals()],
'service_distributions': [ciw.dists.Deterministic(5.0),
ciw.dists.Deterministic(5.0)],
'routing': [[1.0, 0.0], [0.0, 0.0]],
'number_of_servers': [2, 1]}
ciw.seed(36)
Q = ciw.Simulation(ciw.create_network(**params))
Q.simulate_until_max_time(36)
inds = Q.get_all_individuals()
recs = Q.get_all_records()
self.assertEqual(len(inds), 3)
self.assertTrue(all([x[6] == 5.0 for x in recs[1:]]))
ciw.seed(35)
Q = ciw.Simulation(ciw.create_network(**params))
Q.simulate_until_max_time(36)
inds = Q.get_all_individuals()
recs = Q.get_all_records()
self.assertEqual(len(inds), 2)
self.assertTrue(all([x[6] == 5.0 for x in recs[1:]]))
completed_inds = []
for _ in range(1000):
Q = ciw.Simulation(ciw.create_network(**params))
Q.simulate_until_max_time(36)
inds = Q.get_all_individuals()
completed_inds.append(len(inds))
self.assertAlmostEqual(
completed_inds.count(2) / float(1000), 1 / 4.0, places=1)
def test_sampling_empirical_dist(self):
my_empirical_dist = [8.0, 8.0, 8.0, 8.8, 8.8, 12.3]
params = {
'Arrival_distributions': [['Empirical',
'ciw/tests/testing_parameters/sample_empirical_dist.csv']],
'Service_distributions': [['Empirical', my_empirical_dist]],
'Number_of_servers': [1],
'Transition_matrices': [[0.1]]
}
Q = ciw.Simulation(ciw.create_network(params))
Nem = Q.transitive_nodes[0]
ciw.seed(5)
self.assertEqual(round(
Nem.simulation.service_times[Nem.id_number][0](), 2), 8.8)
self.assertEqual(round(
Nem.simulation.service_times[Nem.id_number][0](), 2), 12.3)
self.assertEqual(round(
Nem.simulation.service_times[Nem.id_number][0](), 2), 8.0)
self.assertEqual(round(
Nem.simulation.service_times[Nem.id_number][0](), 2), 8.0)
self.assertEqual(round(
Nem.simulation.service_times[Nem.id_number][0](), 2), 8.0)
self.assertEqual(round(
Nem.simulation.inter_arrival_times[Nem.id_number][0](), 2), 7.7)
self.assertEqual(round(
Nem.simulation.inter_arrival_times[Nem.id_number][0](), 2), 7.7)
self.assertEqual(round(
Nem.simulation.inter_arrival_times[Nem.id_number][0](), 2), 7.1)
self.assertEqual(round(
Nem.simulation.inter_arrival_times[Nem.id_number][0](), 2), 7.1)
self.assertEqual(round(
Nem.simulation.inter_arrival_times[Nem.id_number][0](), 2), 7.7)
def test_sampling_custom_dist(self):
my_custom_dist = [[0.2, 3.7], [0.5, 3.8], [0.3, 4.1]]
params = {
'Arrival_distributions': [['Custom', my_custom_dist]],
'Service_distributions': [['Custom', my_custom_dist]],
'Number_of_servers': [1],
'Transition_matrices': [[0.1]]
}
Q = ciw.Simulation(ciw.create_network(params))
Nc = Q.transitive_nodes[0]
ciw.seed(5)
self.assertEqual(round(
Nc.simulation.service_times[Nc.id_number][0](), 2), 3.8)
self.assertEqual(round(
Nc.simulation.service_times[Nc.id_number][0](), 2), 4.1)
self.assertEqual(round(
Nc.simulation.service_times[Nc.id_number][0](), 2), 3.8)
self.assertEqual(round(
Nc.simulation.service_times[Nc.id_number][0](), 2), 4.1)
self.assertEqual(round(
Nc.simulation.service_times[Nc.id_number][0](), 2), 3.8)
self.assertEqual(round(
Nc.simulation.inter_arrival_times[Nc.id_number][0](), 2), 3.8)
self.assertEqual(round(
Nc.simulation.inter_arrival_times[Nc.id_number][0](), 2), 4.1)
self.assertEqual(round(
Nc.simulation.inter_arrival_times[Nc.id_number][0](), 2), 3.8)
self.assertEqual(round(
Nc.simulation.inter_arrival_times[Nc.id_number][0](), 2), 3.8)
self.assertEqual(round(
Nc.simulation.inter_arrival_times[Nc.id_number][0](), 2), 3.7)
def test_priority_system_compare_literature(self):
params_dict = {
'Arrival_distributions': {'Class 0': [['Exponential', 0.2]],
'Class 1': [['Exponential', 0.6]]},
'Service_distributions': {'Class 0': [['Exponential', 1.0]],
'Class 1': [['Exponential', 1.0]]},
'Transition_matrices': {'Class 0': [[0.0]],
'Class 1': [[0.0]]},
'Number_of_servers': [1],
'Priority_classes': {'Class 0': 0,
'Class 1': 1}
}
# Results expected from analytical queueing theory are:
# expected_throughput_class0 = 2.0, and expected_throughput_class1 = 6.0
# Althought these results seem far from the theoretical, longer runs and
# more runs give the desired results. A compromise was reached here to
# reduce test suite runtime.
throughput_class0 = []
throughput_class1 = []
ciw.seed(3231)
for iteration in range(80):
Q = ciw.Simulation(ciw.create_network(params_dict))
Q.simulate_until_max_time(400)
recs = Q.get_all_records()
throughput_class0.append(mean([r.waiting_time + r.service_time for r in recs if r.customer_class==0 if r.arrival_date > 100]))
throughput_class1.append(mean([r.waiting_time + r.service_time for r in recs if r.customer_class==1 if r.arrival_date > 100]))
self.assertEqual(round(mean(throughput_class0), 5), 1.94852)
self.assertEqual(round(mean(throughput_class1), 5), 5.92823)
def test_sampling_exponential_dist(self):
params = {
'Arrival_distributions': [['Exponential', 4.4]],
'Service_distributions': [['Exponential', 4.4]],
'Number_of_servers': [1],
'Transition_matrices': [[0.1]]
}
Q = ciw.Simulation(ciw.create_network(params))
Ne = Q.transitive_nodes[0]
ciw.seed(5)
self.assertEqual(round(
Ne.simulation.service_times[Ne.id_number][0](), 2), 0.22)
self.assertEqual(round(
Ne.simulation.service_times[Ne.id_number][0](), 2), 0.31)
self.assertEqual(round(
Ne.simulation.service_times[Ne.id_number][0](), 2), 0.36)
self.assertEqual(round(
Ne.simulation.service_times[Ne.id_number][0](), 2), 0.65)
self.assertEqual(round(
Ne.simulation.service_times[Ne.id_number][0](), 2), 0.31)
self.assertEqual(round(
Ne.simulation.inter_arrival_times[Ne.id_number][0](), 2), 0.58)
self.assertEqual(round(
Ne.simulation.inter_arrival_times[Ne.id_number][0](), 2), 0.01)
self.assertEqual(round(
Ne.simulation.inter_arrival_times[Ne.id_number][0](), 2), 0.14)
self.assertEqual(round(
Ne.simulation.inter_arrival_times[Ne.id_number][0](), 2), 0.65)
self.assertEqual(round(
Ne.simulation.inter_arrival_times[Ne.id_number][0](), 2), 0.24)
def test_priority_system_compare_literature(self):
params_dict = {
'Arrival_distributions': {'Class 0': [['Exponential', 0.2]],
'Class 1': [['Exponential', 0.6]]},
'Service_distributions': {'Class 0': [['Exponential', 1.0]],
'Class 1': [['Exponential', 1.0]]},
'Transition_matrices': {'Class 0': [[0.0]],
'Class 1': [[0.0]]},
'Number_of_servers': [1],
'Priority_classes': {'Class 0': 0,
'Class 1': 1}
}
# Results expected from analytical queueing theory are:
# expected_throughput_class0 = 2.0, and expected_throughput_class1 = 6.0
throughput_class0 = []
throughput_class1 = []
ciw.seed(3231)
for iteration in range(80):
Q = ciw.Simulation(ciw.create_network(**params_dict))
Q.simulate_until_max_time(400)
recs = Q.get_all_records()
throughput_c0 = [r.waiting_time + r.service_time for
r in recs if r.customer_class==0 if r.arrival_date > 100]
throughput_c1 = [r.waiting_time + r.service_time for
r in recs if r.customer_class==1 if r.arrival_date > 100]
throughput_class0.append(sum(throughput_c0)/len(throughput_c0))
throughput_class1.append(sum(throughput_c1)/len(throughput_c1))
self.assertEqual(round(sum(throughput_class0)/80.0, 5), 1.94852)
self.assertEqual(round(sum(throughput_class1)/80.0, 5), 5.92823)
def Realnet_data(self):
N = ciw.create_network(
arrival_distributions=[
ciw.dists.Exponential(2.0),
ciw.dists.NoArrivals(),
ciw.dists.NoArrivals(),
ciw.dists.NoArrivals(),
ciw.dists.NoArrivals()
],
service_distributions=[
ciw.dists.Lognormal(torch.tensor(-0.3), torch.tensor(0.1)),
ciw.dists.Lognormal(torch.tensor(0.0), torch.tensor(0.5)),
ciw.dists.Lognormal(torch.tensor(0.5), torch.tensor(0.1)),
ciw.dists.Exponential(1.0),
ciw.dists.Deterministic(0.05)
],
routing=[[0.0, 0.5, 0.0, 0.5, 0.0], [0.0, 0.0, 0.7, 0.0, 0.3],
[0.0, 0.0, 0.0, 0.5, 0.5], [0.2, 0.8, 0.0, 0.0, 0.0],
[0.0, 0.0, 0.0, 0.0, 0.0]],
number_of_servers=[5, 3, 2, 2, 4],
)
num = 200
training_data = []
for i in range(num):
ciw.seed(i)
Q = ciw.Simulation(N)
Q.simulate_until_max_time(80)
recs = Q.get_all_records()
training_data.append(self.recs_parser(recs, 5))
return training_data
def test_release_method(self):
ciw.seed(4)
Q = ciw.Simulation(
ciw.create_network_from_yml(
'ciw/tests/testing_parameters/params.yml'))
N = Q.transitive_nodes[0]
inds = [ciw.Individual(i + 1) for i in range(3)]
for current_time in [0.01, 0.02, 0.03]:
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],
[['Individual 1', 'Individual 2', 'Individual 3']])
N.update_next_event_date(0.03)
self.assertEqual(round(N.next_event_date, 5), 0.03604)
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)
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_timedependent_exact(self):
params = {
'Arrival_distributions':
[['TimeDependent', time_dependent_function_1],
['TimeDependent', time_dependent_function_2]],
'Service_distributions':
[['TimeDependent', time_dependent_function_1],
['TimeDependent', time_dependent_function_2]],
'Number_of_servers': [1, 1],
'Transition_matrices': [[0.1, 0.1], [0.1, 0.1]]
}
Q = ciw.Simulation(ciw.create_network(**params), exact=26)
N1 = Q.transitive_nodes[0]
N2 = Q.transitive_nodes[1]
ciw.seed(5)
self.assertEqual(N1.get_service_time(0, 3.0), 3.0)
self.assertEqual(N1.get_service_time(0, 9.0), 3.0)
self.assertEqual(N1.get_service_time(0, 9.0), 3.0)
self.assertEqual(N1.get_service_time(0, 11.0), 5.0)
self.assertEqual(N1.get_service_time(0, 11.0), 5.0)
self.assertEqual(N2.get_service_time(0, 4.0), 2.0)
self.assertEqual(N2.get_service_time(0, 4.0), 2.0)
self.assertEqual(N2.get_service_time(0, 17.0), 8.5)
self.assertEqual(N2.get_service_time(0, 22.0), 8.0)
self.assertEqual(N2.get_service_time(0, 22.0), 8.0)
def test_sampling_normal_dist(self):
params = {
'Arrival_distributions': [['Normal', 0.5, 0.1]],
'Service_distributions': [['Normal', 0.5, 0.1]],
'Number_of_servers': [1],
'Transition_matrices': [[0.1]]
}
Q = ciw.Simulation(ciw.create_network(**params))
Nw = Q.transitive_nodes[0]
ciw.seed(5)
self.assertEqual(
round(Nw.simulation.service_times[Nw.id_number][0](), 2), 0.58)
self.assertEqual(
round(Nw.simulation.service_times[Nw.id_number][0](), 2), 0.35)
self.assertEqual(
round(Nw.simulation.service_times[Nw.id_number][0](), 2), 0.49)
self.assertEqual(
round(Nw.simulation.service_times[Nw.id_number][0](), 2), 0.52)
self.assertEqual(
round(Nw.simulation.service_times[Nw.id_number][0](), 2), 0.55)
self.assertEqual(
round(Nw.simulation.inter_arrival_times[Nw.id_number][0](), 2),
0.56)
self.assertEqual(
round(Nw.simulation.inter_arrival_times[Nw.id_number][0](), 2),
0.52)
self.assertEqual(
round(Nw.simulation.inter_arrival_times[Nw.id_number][0](), 2),
0.44)
self.assertEqual(
round(Nw.simulation.inter_arrival_times[Nw.id_number][0](), 2),
0.52)
self.assertEqual(
round(Nw.simulation.inter_arrival_times[Nw.id_number][0](), 2),
0.60)
def test_begin_service_if_possible_release_method(self):
ciw.seed(50)
Q = ciw.Simulation(ciw.create_network_from_yml(
'ciw/tests/testing_parameters/params_deadlock.yml'),
deadlock_detector='StateDigraph')
inds = [[ciw.Individual(i) for i in range(30)]]
Q.transitive_nodes[0].individuals = inds
ind = Q.transitive_nodes[0].individuals[0][0]
ind.service_time = 3.14
ind.arrival_date = 100.0
self.assertEqual(set(Q.deadlock_detector.statedigraph.nodes()),
set(['Server 5 at Node 2',
'Server 5 at Node 1',
'Server 3 at Node 2',
'Server 1 at Node 2',
'Server 1 at Node 1',
'Server 2 at Node 1',
'Server 2 at Node 2',
'Server 3 at Node 1',
'Server 4 at Node 1',
'Server 4 at Node 2']))
self.assertEqual(ind.arrival_date, 100.0)
self.assertEqual(ind.service_time, 3.14)
self.assertEqual(ind.service_start_date, False)
self.assertEqual(ind.service_end_date, False)
Q.transitive_nodes[0].begin_service_if_possible_release(200.0)
self.assertEqual(ind.arrival_date, 100.0)
self.assertEqual(round(ind.service_time ,5), 3.14)
self.assertEqual(ind.service_start_date, 200.0)
self.assertEqual(round(ind.service_end_date, 5), 203.14)
def test_batching_multi_node(self):
N = ciw.create_network(
arrival_distributions=[ciw.dists.Deterministic(20),
ciw.dists.Deterministic(23),
ciw.dists.Deterministic(25)],
service_distributions=[ciw.dists.Deterministic(1),
ciw.dists.Deterministic(1),
ciw.dists.Deterministic(1)],
number_of_servers=[10, 10, 10],
batching_distributions=[ciw.dists.Deterministic(3),
ciw.dists.Deterministic(2),
ciw.dists.Deterministic(1)],
routing=[[0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0]]
)
ciw.seed(12)
Q = ciw.Simulation(N)
Q.simulate_until_max_time(28)
recs = Q.get_all_records()
arrivals = [r.arrival_date for r in recs]
nodes = [r.node for r in recs]
classes = [r.customer_class for r in recs]
self.assertEqual(arrivals, [20, 20, 20, 23, 23, 25])
self.assertEqual(nodes, [1, 1, 1, 2, 2, 3])
self.assertEqual(classes, [0, 0, 0, 0, 0, 0])
def test_sampling_weibull_dist(self):
params = {
'Arrival_distributions': [['Weibull', 0.9, 0.8]],
'Service_distributions': [['Weibull', 0.9, 0.8]],
'Number_of_servers': [1],
'Transition_matrices': [[0.1]]
}
Q = ciw.Simulation(ciw.create_network(params))
Nw = Q.transitive_nodes[0]
ciw.seed(5)
self.assertEqual(round(
Nw.simulation.service_times[Nw.id_number][0](), 2), 0.87)
self.assertEqual(round(
Nw.simulation.service_times[Nw.id_number][0](), 2), 1.31)
self.assertEqual(round(
Nw.simulation.service_times[Nw.id_number][0](), 2), 1.60)
self.assertEqual(round(
Nw.simulation.service_times[Nw.id_number][0](), 2), 3.34)
self.assertEqual(round(
Nw.simulation.service_times[Nw.id_number][0](), 2), 1.31)
self.assertEqual(round(
Nw.simulation.inter_arrival_times[Nw.id_number][0](), 2), 2.91)
self.assertEqual(round(
Nw.simulation.inter_arrival_times[Nw.id_number][0](), 2), 0.01)
self.assertEqual(round(
Nw.simulation.inter_arrival_times[Nw.id_number][0](), 2), 0.50)
self.assertEqual(round(
Nw.simulation.inter_arrival_times[Nw.id_number][0](), 2), 3.36)
self.assertEqual(round(
Nw.simulation.inter_arrival_times[Nw.id_number][0](), 2), 0.95)
def test_sampling_triangular_dist(self):
params = {
'Arrival_distributions': [['Triangular', 1.1, 6.6, 1.5]],
'Service_distributions': [['Triangular', 1.1, 6.6, 1.5]],
'Number_of_servers': [1],
'Transition_matrices': [[0.1]]
}
Q = ciw.Simulation(ciw.create_network(params))
Nt = Q.transitive_nodes[0]
ciw.seed(5)
self.assertEqual(round(
Nt.simulation.service_times[Nt.id_number][0](), 2), 3.35)
self.assertEqual(round(
Nt.simulation.service_times[Nt.id_number][0](), 2), 3.91)
self.assertEqual(round(
Nt.simulation.service_times[Nt.id_number][0](), 2), 4.20)
self.assertEqual(round(
Nt.simulation.service_times[Nt.id_number][0](), 2), 5.33)
self.assertEqual(round(
Nt.simulation.service_times[Nt.id_number][0](), 2), 3.90)
self.assertEqual(round(
Nt.simulation.inter_arrival_times[Nt.id_number][0](), 2), 5.12)
self.assertEqual(round(
Nt.simulation.inter_arrival_times[Nt.id_number][0](), 2), 1.35)
self.assertEqual(round(
Nt.simulation.inter_arrival_times[Nt.id_number][0](), 2), 2.73)
self.assertEqual(round(
Nt.simulation.inter_arrival_times[Nt.id_number][0](), 2), 5.34)
self.assertEqual(round(
Nt.simulation.inter_arrival_times[Nt.id_number][0](), 2), 3.46)
def test_priority_output(self):
params_dict = {
'Arrival_distributions': {
'Class 0': [['Deterministic', 1.0]],
'Class 1': [['Deterministic', 1.0]]
},
'Service_distributions': {
'Class 0': [['Deterministic', 0.75]],
'Class 1': [['Deterministic', 0.75]]
},
'Transition_matrices': {
'Class 0': [[0.0]],
'Class 1': [[0.0]]
},
'Number_of_servers': [1],
'Priority_classes': {
'Class 0': 0,
'Class 1': 1
}
}
ciw.seed(36)
Q = ciw.Simulation(ciw.create_network(**params_dict))
Q.simulate_until_max_time(50)
recs = Q.get_all_records()
waits = [
sum([r.waiting_time for r in recs if r.customer_class == cls])
for cls in range(2)
]
# Because of high traffic intensity: the low
# priority individuals have a large wait
self.assertEqual(sorted(waits), [18.75, 245.25])
params_dict = {
'Arrival_distributions': {
'Class 0': [['Deterministic', 1.0]],
'Class 1': [['Deterministic', 1.0]]
},
'Service_distributions': {
'Class 0': [['Deterministic', 0.75]],
'Class 1': [['Deterministic', 0.75]]
},
'Transition_matrices': {
'Class 0': [[0.0]],
'Class 1': [[0.0]]
},
'Number_of_servers': [1]
}
ciw.seed(36)
Q = ciw.Simulation(ciw.create_network(**params_dict))
Q.simulate_until_max_time(50)
recs = Q.get_all_records()
waits = [
sum([r.waiting_time for r in recs if r.customer_class == cls])
for cls in range(2)
]
# Both total waits are now comparable. Total wait is higher
# because more more individuals have gone through the system.
self.assertEqual(sorted(waits), [264, 272])
def test_begin_service_if_possible_accept_method(self):
ciw.seed(50)
Q = ciw.Simulation(ciw.create_network_from_yml(
'ciw/tests/testing_parameters/params_deadlock.yml'),
deadlock_detector='StateDigraph')
ind = ciw.Individual(1)
self.assertEqual(set(Q.deadlock_detector.statedigraph.nodes()),
set(['Server 5 at Node 2',
'Server 5 at Node 1',
'Server 3 at Node 2',
'Server 1 at Node 2',
'Server 1 at Node 1',
'Server 2 at Node 1',
'Server 2 at Node 2',
'Server 3 at Node 1',
'Server 4 at Node 1',
'Server 4 at Node 2']))
self.assertEqual(ind.arrival_date, False)
self.assertEqual(ind.service_time, False)
self.assertEqual(ind.service_start_date, False)
self.assertEqual(ind.service_end_date, False)
Q.transitive_nodes[0].begin_service_if_possible_accept(ind, 300)
self.assertEqual(ind.arrival_date, 300)
self.assertEqual(round(ind.service_time, 5), 0.03382)
self.assertEqual(ind.service_start_date, 300)
self.assertEqual(round(ind.service_end_date, 5), 300.03382)
def test_sampling_uniform_dist(self):
params = {
'Arrival_distributions': [['Uniform', 2.2, 3.3]],
'Service_distributions': [['Uniform', 2.2, 3.3]],
'Number_of_servers': [1],
'Transition_matrices': [[0.1]]
}
Q = ciw.Simulation(ciw.create_network(params))
Nu = Q.transitive_nodes[0]
ciw.seed(5)
self.assertEqual(round(
Nu.simulation.service_times[Nu.id_number][0](), 2), 2.89)
self.assertEqual(round(
Nu.simulation.service_times[Nu.id_number][0](), 2), 3.02)
self.assertEqual(round(
Nu.simulation.service_times[Nu.id_number][0](), 2), 3.07)
self.assertEqual(round(
Nu.simulation.service_times[Nu.id_number][0](), 2), 3.24)
self.assertEqual(round(
Nu.simulation.service_times[Nu.id_number][0](), 2), 3.01)
self.assertEqual(round(
Nu.simulation.inter_arrival_times[Nu.id_number][0](), 2), 3.21)
self.assertEqual(round(
Nu.simulation.inter_arrival_times[Nu.id_number][0](), 2), 2.23)
self.assertEqual(round(
Nu.simulation.inter_arrival_times[Nu.id_number][0](), 2), 2.71)
self.assertEqual(round(
Nu.simulation.inter_arrival_times[Nu.id_number][0](), 2), 3.24)
self.assertEqual(round(
Nu.simulation.inter_arrival_times[Nu.id_number][0](), 2), 2.91)
def test_allow_zero_servers(self):
params_c1 = {
'Arrival_distributions': [['Exponential', 5]],
'Service_distributions': [['Deterministic', 0.2]],
'Number_of_servers': [1]
}
params_c0 = {
'Arrival_distributions': [['Exponential', 5]],
'Service_distributions': [['Deterministic', 0.2]],
'Number_of_servers': [0]
}
ciw.seed(1)
N = ciw.create_network(**params_c1)
Q = ciw.Simulation(N)
Q.simulate_until_max_time(100)
total_inds_1 = len(Q.nodes[-1].all_individuals) + len(Q.nodes[1].all_individuals)
ciw.seed(1)
N = ciw.create_network(**params_c0)
Q = ciw.Simulation(N)
Q.simulate_until_max_time(100)
recs = Q.get_all_records()
total_inds_0 = len(Q.nodes[1].all_individuals)
self.assertEqual(recs, [])
self.assertEqual(total_inds_0, total_inds_1)
def test_timedependent_exact(self):
params = {
'Arrival_distributions':
[['TimeDependent', time_dependent_function_1],
['TimeDependent', time_dependent_function_2]],
'Service_distributions':
[['TimeDependent', time_dependent_function_1],
['TimeDependent', time_dependent_function_2]],
'Number_of_servers': [1, 1],
'Transition_matrices': [[0.1, 0.1], [0.1, 0.1]]
}
Q = ciw.Simulation(ciw.create_network(**params), exact=26)
N1 = Q.transitive_nodes[0]
N2 = Q.transitive_nodes[1]
ciw.seed(5)
samples = []
for t in [3.0, 9.0, 9.0, 11.0, 11.0]:
samples.append(round(N1.get_service_time(0, t), 2))
expected = [3.0, 3.0, 3.0, 5.0, 5.0]
self.assertEqual(samples, expected)
samples = []
for t in [4.0, 4.0, 17.0, 22.0, 22.0]:
samples.append(round(N2.get_service_time(0, t), 2))
expected = [2.0, 2.0, 8.5, 8.0, 8.0]
self.assertEqual(samples, expected)
def test_sampling_custom_dist(self):
my_custom_dist_values = [3.7, 3.8, 4.1]
my_custom_dist_probs = [0.2, 0.5, 0.3]
params = {
'Arrival_distributions': [['Custom', my_custom_dist_values, my_custom_dist_probs]],
'Service_distributions': [['Custom', my_custom_dist_values, my_custom_dist_probs]],
'Number_of_servers': [1]
}
Q = ciw.Simulation(ciw.create_network(**params))
Nc = Q.transitive_nodes[0]
ciw.seed(5)
self.assertEqual(round(
Nc.simulation.service_times[Nc.id_number][0](), 2), 3.8)
self.assertEqual(round(
Nc.simulation.service_times[Nc.id_number][0](), 2), 4.1)
self.assertEqual(round(
Nc.simulation.service_times[Nc.id_number][0](), 2), 4.1)
self.assertEqual(round(
Nc.simulation.service_times[Nc.id_number][0](), 2), 4.1)
self.assertEqual(round(
Nc.simulation.service_times[Nc.id_number][0](), 2), 4.1)
self.assertEqual(round(
Nc.simulation.inter_arrival_times[Nc.id_number][0](), 2), 4.1)
self.assertEqual(round(
Nc.simulation.inter_arrival_times[Nc.id_number][0](), 2), 3.7)
self.assertEqual(round(
Nc.simulation.inter_arrival_times[Nc.id_number][0](), 2), 3.8)
self.assertEqual(round(
Nc.simulation.inter_arrival_times[Nc.id_number][0](), 2), 4.1)
self.assertEqual(round(
Nc.simulation.inter_arrival_times[Nc.id_number][0](), 2), 3.8)
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
# a big affect on this.
params = {'Arrival_distributions': [['Deterministic', 10.0], 'NoArrivals'],
'Service_distributions': [['Deterministic', 5.0], ['Deterministic', 5.0]],
'Transition_matrices': [[1.0, 0.0], [0.0, 0.0]],
'Number_of_servers': [2, 1]}
ciw.seed(36)
Q = ciw.Simulation(ciw.create_network(params))
Q.simulate_until_max_time(36)
inds = Q.get_all_individuals()
recs = Q.get_all_records()
self.assertEqual(len(inds), 2)
self.assertTrue(all([x[6] == 5.0 for x in recs[1:]]))
ciw.seed(40)
Q = ciw.Simulation(ciw.create_network(params))
Q.simulate_until_max_time(36)
inds = Q.get_all_individuals()
recs = Q.get_all_records()
self.assertEqual(len(inds), 3)
self.assertTrue(all([x[6] == 5.0 for x in recs[1:]]))
completed_inds = []
for _ in range(1000):
Q = ciw.Simulation(ciw.create_network(params))
Q.simulate_until_max_time(36)
inds = Q.get_all_individuals()
completed_inds.append(len(inds))
self.assertAlmostEqual(completed_inds.count(2) / float(1000), 1 / 4.0, places=1)
def test_sampling_custom_dist(self):
my_custom_dist_values = [3.7, 3.8, 4.1]
my_custom_dist_probs = [0.2, 0.5, 0.3]
params = {
'Arrival_distributions':
[['Custom', my_custom_dist_values, my_custom_dist_probs]],
'Service_distributions':
[['Custom', my_custom_dist_values, my_custom_dist_probs]],
'Number_of_servers': [1]
}
Q = ciw.Simulation(ciw.create_network(**params))
Nc = Q.transitive_nodes[0]
ciw.seed(5)
samples = [
round(Nc.simulation.service_times[Nc.id_number][0](), 2)
for _ in range(5)
]
expected = [3.8, 4.1, 4.1, 4.1, 4.1]
self.assertEqual(samples, expected)
samples = [
round(Nc.simulation.inter_arrival_times[Nc.id_number][0](), 2)
for _ in range(5)
]
expected = [4.1, 3.7, 3.8, 4.1, 3.8]
self.assertEqual(samples, expected)
def test_exactness(self):
params = {
'Arrival_distributions': [['Exponential', 20]],
'Service_distributions': [['Deterministic', 0.01]],
'Transition_matrices': [[0.0]],
'Number_of_servers': ['server_schedule'],
'server_schedule': [[0.5, 0], [0.55, 1], [3.0, 0]]
}
ciw.seed(777)
Q = ciw.Simulation(ciw.create_network(params))
Q.simulate_until_max_time(10)
recs = Q.get_all_records()
mod_service_starts = [obs % 3 for obs in [r[5] for r in recs]]
self.assertNotEqual(set(mod_service_starts),
set([0.50, 0.51, 0.52, 0.53, 0.54]))
ciw.seed(777)
Q = ciw.Simulation(ciw.create_network(params), exact=14)
Q.simulate_until_max_time(10)
recs = Q.get_all_records()
mod_service_starts = [obs % 3 for obs in [r[5] for r in recs]]
expected_set = set(
[Decimal(k) for k in ['0.50', '0.51', '0.52', '0.53', '0.54']])
self.assertEqual(set(mod_service_starts), expected_set)
def test_simulate_until_deadlock_method(self):
ciw.seed(3)
Q = ciw.Simulation(ciw.create_network(
'ciw/tests/testing_parameters/params_deadlock.yml'),
deadlock_detector='StateDigraph')
Q.simulate_until_deadlock()
self.assertEqual(round(Q.times_to_deadlock[((0, 0), (0, 0))], 8), 23.92401469)
def test_build_custom_node(num_of_servers):
"""
Test to ensure blocking works as expected for extreme cases where the threshold
is set to infinity and -1
"""
ciw.seed(5)
model_1 = ciw.Simulation(
build_model(
lambda_2=0.2, lambda_1=0.15, mu=0.05, num_of_servers=num_of_servers
),
node_class=build_custom_node(np.inf),
)
model_1.simulate_until_max_time(max_simulation_time=100)
records_1 = model_1.get_all_records()
model_1_blocks = [r.time_blocked for r in records_1]
model_1_waits = [r.waiting_time for r in records_1 if r.node == 1]
model_2 = ciw.Simulation(
build_model(
lambda_2=0.2, lambda_1=0.15, mu=0.05, num_of_servers=num_of_servers
),
node_class=build_custom_node(-1),
)
model_2.simulate_until_max_time(max_simulation_time=100)
records_2 = model_2.get_all_records()
model_2_blocks = [r.time_blocked for r in records_2 if r.node == 1]
assert all(b == 0 for b in model_1_blocks)
assert all(w == 0 for w in model_1_waits)
assert len(model_2_blocks) == 0
def test_begin_service_if_possible_accept_method(self):
ciw.seed(50)
Q = ciw.Simulation(ciw.create_network_from_yml(
'ciw/tests/testing_parameters/params_deadlock.yml'),
deadlock_detector=ciw.deadlock.StateDigraph())
ind = ciw.Individual(1)
self.assertEqual(
set(Q.deadlock_detector.statedigraph.nodes()),
set([
'Server 5 at Node 2', 'Server 5 at Node 1',
'Server 3 at Node 2', 'Server 1 at Node 2',
'Server 1 at Node 1', 'Server 2 at Node 1',
'Server 2 at Node 2', 'Server 3 at Node 1',
'Server 4 at Node 1', 'Server 4 at Node 2'
]))
self.assertEqual(ind.arrival_date, False)
self.assertEqual(ind.service_time, False)
self.assertEqual(ind.service_start_date, False)
self.assertEqual(ind.service_end_date, False)
Q.current_time = 300
Q.transitive_nodes[0].begin_service_if_possible_accept(ind)
self.assertEqual(ind.arrival_date, 300)
self.assertEqual(round(ind.service_time, 5), 0.03382)
self.assertEqual(ind.service_start_date, 300)
self.assertEqual(round(ind.service_end_date, 5), 300.03382)
def test_block_individual_method(self):
ciw.seed(4)
Q = ciw.Simulation(ciw.create_network_from_yml(
'ciw/tests/testing_parameters/params_deadlock.yml'),
deadlock_detector=ciw.deadlock.StateDigraph())
inds = [ciw.Individual(i + 1) for i in range(7)]
N1 = Q.transitive_nodes[0]
N1.individuals = [inds[:6]]
N2 = Q.transitive_nodes[1]
Q.current_time = 2
N2.accept(inds[6])
self.assertEqual(inds[6].is_blocked, False)
self.assertEqual(N1.blocked_queue, [])
self.assertEqual(set(Q.deadlock_detector.statedigraph.edges()),
set([]))
N2.block_individual(inds[6], N1)
self.assertEqual(inds[6].is_blocked, True)
[(2, 7)]
self.assertEqual(
set(Q.deadlock_detector.statedigraph.edges()),
set([('Server 1 at Node 2', 'Server 2 at Node 1'),
('Server 1 at Node 2', 'Server 5 at Node 1'),
('Server 1 at Node 2', 'Server 3 at Node 1'),
('Server 1 at Node 2', 'Server 1 at Node 1'),
('Server 1 at Node 2', 'Server 4 at Node 1')]))
def test_allow_zero_servers(self):
params_c1 = {
'Arrival_distributions': [['Exponential', 5]],
'Service_distributions': [['Deterministic', 0.2]],
'Number_of_servers': [1]
}
params_c0 = {
'Arrival_distributions': [['Exponential', 5]],
'Service_distributions': [['Deterministic', 0.2]],
'Number_of_servers': [0]
}
ciw.seed(1)
N = ciw.create_network(**params_c1)
Q = ciw.Simulation(N)
Q.simulate_until_max_time(100)
total_inds_1 = len(Q.nodes[-1].all_individuals) + len(
Q.nodes[1].all_individuals)
ciw.seed(1)
N = ciw.create_network(**params_c0)
Q = ciw.Simulation(N)
Q.simulate_until_max_time(100)
recs = Q.get_all_records()
total_inds_0 = len(Q.nodes[1].all_individuals)
self.assertEqual(recs, [])
self.assertEqual(total_inds_0, total_inds_1)
def test_sampling_gamma_dist(self):
params = {
'Arrival_distributions': [['Gamma', 0.6, 1.2]],
'Service_distributions': [['Gamma', 0.6, 1.2]],
'Number_of_servers': [1],
'Transition_matrices': [[0.1]]
}
Q = ciw.Simulation(ciw.create_network(params))
Ng = Q.transitive_nodes[0]
ciw.seed(5)
self.assertEqual(round(
Ng.simulation.service_times[Ng.id_number][0](), 2), 0.00)
self.assertEqual(round(
Ng.simulation.service_times[Ng.id_number][0](), 2), 2.59)
self.assertEqual(round(
Ng.simulation.service_times[Ng.id_number][0](), 2), 1.92)
self.assertEqual(round(
Ng.simulation.service_times[Ng.id_number][0](), 2), 0.47)
self.assertEqual(round(
Ng.simulation.service_times[Ng.id_number][0](), 2), 0.61)
self.assertEqual(round(
Ng.simulation.inter_arrival_times[Ng.id_number][0](), 2), 0.00)
self.assertEqual(round(
Ng.simulation.inter_arrival_times[Ng.id_number][0](), 2), 1.07)
self.assertEqual(round(
Ng.simulation.inter_arrival_times[Ng.id_number][0](), 2), 1.15)
self.assertEqual(round(
Ng.simulation.inter_arrival_times[Ng.id_number][0](), 2), 0.75)
self.assertEqual(round(
Ng.simulation.inter_arrival_times[Ng.id_number][0](), 2), 0.00)
def test_sampling_empirical_dist(self):
my_empirical_dist = [8.0, 8.0, 8.0, 8.8, 8.8, 12.3]
params = {
'Arrival_distributions': [[
'Empirical',
'ciw/tests/testing_parameters/sample_empirical_dist.csv'
]],
'Service_distributions': [['Empirical', my_empirical_dist]],
'Number_of_servers': [1]
}
Q = ciw.Simulation(ciw.create_network(**params))
Nem = Q.transitive_nodes[0]
ciw.seed(5)
samples = [
round(Nem.simulation.service_times[Nem.id_number][0](), 2)
for _ in range(5)
]
expected = [8.8, 8.8, 8.8, 12.3, 8.8]
self.assertEqual(samples, expected)
samples = [
round(Nem.simulation.inter_arrival_times[Nem.id_number][0](), 2)
for _ in range(5)
]
expected = [7.3, 7.0, 7.7, 7.3, 7.1]
self.assertEqual(samples, expected)
def forward(self, seed):
N = ciw.create_network(
arrival_distributions=[
ciw.dists.Exponential(self.params[0]),
ciw.dists.NoArrivals(),
ciw.dists.NoArrivals(),
ciw.dists.NoArrivals(),
ciw.dists.NoArrivals()
],
service_distributions=[
ciw.dists.Lognormal(self.params[1], self.params[2]),
ciw.dists.Lognormal(self.params[3], self.params[4]),
ciw.dists.Lognormal(self.params[5], self.params[6]),
ciw.dists.Exponential(self.params[7]),
ciw.dists.Deterministic(0.05)
],
routing=[[0.0, 0.5, 0.0, 0.5, 0.0], [0.0, 0.0, 0.7, 0.0, 0.3],
[0.0, 0.0, 0.0, 0.5, 0.5], [0.2, 0.8, 0.0, 0.0, 0.0],
[0.0, 0.0, 0.0, 0.0, 0.0]],
number_of_servers=[5, 3, 2, 2, 4],
)
#batchsize == 20
batch = []
for i in range(10):
ciw.seed(seed + i)
Q = ciw.Simulation(N)
Q.simulate_until_max_time(80)
recs = Q.get_all_records()
batch.append(self.recs_parser(recs, 5))
return batch
def test_userdefined_function_dist_hypothesis(self, const, dist, rm):
my_empirical_dist = [8.0, 8.0, 8.0, 8.8, 8.8, 12.3]
params = {
'Arrival_distributions':
[['UserDefined', lambda: choice(my_empirical_dist)],
['UserDefined', lambda: const]],
'Service_distributions':
[['UserDefined', lambda: random()],
['UserDefined', lambda: custom_function()]],
'Number_of_servers': [1, 1],
'Transition_matrices': [[0.1, 0.1], [0.1, 0.1]]
}
Q = ciw.Simulation(ciw.create_network(**params))
N1 = Q.transitive_nodes[0]
N2 = Q.transitive_nodes[1]
ciw.seed(5)
for itr in range(10): # Because repition happens in the simulation
self.assertTrue(N1.simulation.inter_arrival_times[N1.id_number][0]
() in set(my_empirical_dist))
self.assertTrue(
N2.simulation.inter_arrival_times[N2.id_number][0]() == const)
self.assertTrue(
0.0 <= N1.simulation.service_times[N1.id_number][0]() <= 1.0)
self.assertTrue(
0.0 <= N2.simulation.service_times[N2.id_number][0]() <= 2.0)
def test_simulate_until_deadlock_method(self):
ciw.seed(3)
Q = ciw.Simulation(ciw.create_network_from_yml(
'ciw/tests/testing_parameters/params_deadlock.yml'),
deadlock_detector='StateDigraph')
Q.simulate_until_deadlock()
self.assertEqual(round(Q.times_to_deadlock[((0, 0), (0, 0))], 8), 7.09795845)
def test_sampling_normal_dist(self):
params = {
'Arrival_distributions': [['Normal', 0.5, 0.1]],
'Service_distributions': [['Normal', 0.5, 0.1]],
'Number_of_servers': [1],
'Transition_matrices': [[0.1]]
}
Q = ciw.Simulation(ciw.create_network(**params))
Nw = Q.transitive_nodes[0]
ciw.seed(5)
self.assertEqual(round(
Nw.simulation.service_times[Nw.id_number][0](), 2), 0.58)
self.assertEqual(round(
Nw.simulation.service_times[Nw.id_number][0](), 2), 0.35)
self.assertEqual(round(
Nw.simulation.service_times[Nw.id_number][0](), 2), 0.49)
self.assertEqual(round(
Nw.simulation.service_times[Nw.id_number][0](), 2), 0.52)
self.assertEqual(round(
Nw.simulation.service_times[Nw.id_number][0](), 2), 0.55)
self.assertEqual(round(
Nw.simulation.inter_arrival_times[Nw.id_number][0](), 2), 0.56)
self.assertEqual(round(
Nw.simulation.inter_arrival_times[Nw.id_number][0](), 2), 0.52)
self.assertEqual(round(
Nw.simulation.inter_arrival_times[Nw.id_number][0](), 2), 0.44)
self.assertEqual(round(
Nw.simulation.inter_arrival_times[Nw.id_number][0](), 2), 0.52)
self.assertEqual(round(
Nw.simulation.inter_arrival_times[Nw.id_number][0](), 2), 0.60)
def test_prioritys_with_classchanges(self):
params = {
'Arrival_distributions': {
'Class 0': [['Exponential', 0.5], ['Exponential', 0.5]],
'Class 1': [['Exponential', 0.5], ['Exponential', 0.5]]
},
'Service_distributions': {
'Class 0': [['Uniform', 0.9, 1.1], ['Uniform', 0.9, 1.1]],
'Class 1': [['Uniform', 0.9, 1.1], ['Uniform', 0.9, 1.1]]
},
'Number_of_servers': [1, 1],
'Transition_matrices': {
'Class 0': [[0.0, 1.0], [1.0, 0.0]],
'Class 1': [[0.0, 1.0], [1.0, 0.0]]
},
'Priority_classes': {
'Class 1': 0,
'Class 0': 1
},
'Class_change_matrices': {
'Node 1': [[0.0, 1.0], [1.0, 0.0]],
'Node 2': [[0.0, 1.0], [1.0, 0.0]]
}
}
ciw.seed(1)
N = ciw.create_network(**params)
Q = ciw.Simulation(N)
Q.simulate_until_max_time(25)
recs = Q.get_all_records()
recs_cust1 = sorted([r for r in recs if r.id_number == 1],
key=lambda r: r.arrival_date)
recs_cust2 = sorted([r for r in recs if r.id_number == 2],
key=lambda r: r.arrival_date)
recs_cust3 = sorted([r for r in recs if r.id_number == 3],
key=lambda r: r.arrival_date)
self.assertEqual([0, 1, 0, 1, 0],
[r.customer_class for r in recs_cust1])
self.assertEqual([1, 0, 1, 0, 1],
[r.customer_class for r in recs_cust2])
self.assertEqual([0, 1, 0, 1, 0],
[r.customer_class for r in recs_cust3])
self.assertEqual([1, 2, 1, 2, 1], [r.node for r in recs_cust1])
self.assertEqual([2, 1, 2, 1, 2], [r.node for r in recs_cust2])
self.assertEqual([1, 2, 1, 2, 1], [r.node for r in recs_cust3])
self.assertEqual(
set([r.customer_class for r in Q.nodes[1].individuals[0]]),
set([1]))
self.assertEqual(
set([r.customer_class for r in Q.nodes[1].individuals[1]]),
set([0]))
self.assertEqual(
set([r.customer_class for r in Q.nodes[2].individuals[0]]),
set([1]))
self.assertEqual(
set([r.customer_class for r in Q.nodes[2].individuals[1]]),
set([0]))
def test_begin_service_if_possible_release_method(self):
ciw.seed(50)
Q = ciw.Simulation(ciw.create_network_from_yml(
'ciw/tests/testing_parameters/params_deadlock.yml'),
deadlock_detector='StateDigraph')
inds = [[ciw.Individual(i) for i in range(30)]]
Q.transitive_nodes[0].individuals = inds
ind = Q.transitive_nodes[0].individuals[0][0]
ind.service_time = 3.14
ind.arrival_date = 100.0
self.assertEqual(
set(Q.deadlock_detector.statedigraph.nodes()),
set([
'Server 5 at Node 2', 'Server 5 at Node 1',
'Server 3 at Node 2', 'Server 1 at Node 2',
'Server 1 at Node 1', 'Server 2 at Node 1',
'Server 2 at Node 2', 'Server 3 at Node 1',
'Server 4 at Node 1', 'Server 4 at Node 2'
]))
self.assertEqual(ind.arrival_date, 100.0)
self.assertEqual(ind.service_time, 3.14)
self.assertEqual(ind.service_start_date, False)
self.assertEqual(ind.service_end_date, False)
Q.transitive_nodes[0].begin_service_if_possible_release(200.0)
self.assertEqual(ind.arrival_date, 100.0)
self.assertEqual(round(ind.service_time, 5), 3.14)
self.assertEqual(ind.service_start_date, 200.0)
self.assertEqual(round(ind.service_end_date, 5), 203.14)
def test_sampling_deterministic_dist(self):
params = {
'Arrival_distributions': [['Deterministic', 4.4]],
'Service_distributions': [['Deterministic', 4.4]],
'Number_of_servers': [1],
'Transition_matrices': [[0.1]]
}
Q = ciw.Simulation(ciw.create_network(params))
Nd = Q.transitive_nodes[0]
ciw.seed(5)
self.assertEqual(round(
Nd.simulation.service_times[Nd.id_number][0](), 2), 4.40)
self.assertEqual(round(
Nd.simulation.service_times[Nd.id_number][0](), 2), 4.40)
self.assertEqual(round(
Nd.simulation.service_times[Nd.id_number][0](), 2), 4.40)
self.assertEqual(round(
Nd.simulation.service_times[Nd.id_number][0](), 2), 4.40)
self.assertEqual(round(
Nd.simulation.service_times[Nd.id_number][0](), 2), 4.40)
self.assertEqual(round(
Nd.simulation.inter_arrival_times[Nd.id_number][0](), 2), 4.40)
self.assertEqual(round(
Nd.simulation.inter_arrival_times[Nd.id_number][0](), 2), 4.40)
self.assertEqual(round(
Nd.simulation.inter_arrival_times[Nd.id_number][0](), 2), 4.40)
self.assertEqual(round(
Nd.simulation.inter_arrival_times[Nd.id_number][0](), 2), 4.40)
self.assertEqual(round(
Nd.simulation.inter_arrival_times[Nd.id_number][0](), 2), 4.40)
def test_timedependent_exact(self):
params = {
'Arrival_distributions': [
['TimeDependent', time_dependent_function_1],
['TimeDependent', time_dependent_function_2]],
'Service_distributions': [
['TimeDependent', time_dependent_function_1],
['TimeDependent', time_dependent_function_2]],
'Number_of_servers': [1, 1],
'Transition_matrices': [[0.1, 0.1],
[0.1, 0.1]]
}
Q = ciw.Simulation(ciw.create_network(**params), exact=26)
N1 = Q.transitive_nodes[0]
N2 = Q.transitive_nodes[1]
ciw.seed(5)
self.assertEqual(N1.get_service_time(0, 3.0), 3.0)
self.assertEqual(N1.get_service_time(0, 9.0), 3.0)
self.assertEqual(N1.get_service_time(0, 9.0), 3.0)
self.assertEqual(N1.get_service_time(0, 11.0), 5.0)
self.assertEqual(N1.get_service_time(0, 11.0), 5.0)
self.assertEqual(N2.get_service_time(0, 4.0), 2.0)
self.assertEqual(N2.get_service_time(0, 4.0), 2.0)
self.assertEqual(N2.get_service_time(0, 17.0), 8.5)
self.assertEqual(N2.get_service_time(0, 22.0), 8.0)
self.assertEqual(N2.get_service_time(0, 22.0), 8.0)
def test_sampling_lognormal_dist(self):
params = {
'Arrival_distributions': [['Lognormal', 0.8, 0.2]],
'Service_distributions': [['Lognormal', 0.8, 0.2]],
'Number_of_servers': [1],
'Transition_matrices': [[0.1]]
}
Q = ciw.Simulation(ciw.create_network(params))
Nl = Q.transitive_nodes[0]
ciw.seed(5)
self.assertEqual(round(
Nl.simulation.service_times[Nl.id_number][0](), 2), 2.62)
self.assertEqual(round(
Nl.simulation.service_times[Nl.id_number][0](), 2), 1.64)
self.assertEqual(round(
Nl.simulation.service_times[Nl.id_number][0](), 2), 2.19)
self.assertEqual(round(
Nl.simulation.service_times[Nl.id_number][0](), 2), 2.31)
self.assertEqual(round(
Nl.simulation.service_times[Nl.id_number][0](), 2), 2.48)
self.assertEqual(round(
Nl.simulation.inter_arrival_times[Nl.id_number][0](), 2), 2.51)
self.assertEqual(round(
Nl.simulation.inter_arrival_times[Nl.id_number][0](), 2), 2.33)
self.assertEqual(round(
Nl.simulation.inter_arrival_times[Nl.id_number][0](), 2), 1.96)
self.assertEqual(round(
Nl.simulation.inter_arrival_times[Nl.id_number][0](), 2), 2.32)
self.assertEqual(round(
Nl.simulation.inter_arrival_times[Nl.id_number][0](), 2), 2.70)
def test_userdefined_function_dist_hypothesis(self, const, dist, rm):
my_empirical_dist = [8.0, 8.0, 8.0, 8.8, 8.8, 12.3]
params = {
'Arrival_distributions': [
['UserDefined', lambda : choice(my_empirical_dist)],
['UserDefined', lambda : const]],
'Service_distributions': [
['UserDefined', lambda : random()],
['UserDefined', lambda : custom_function()]],
'Number_of_servers': [1, 1],
'Transition_matrices': [[0.1, 0.1],
[0.1, 0.1]]
}
Q = ciw.Simulation(ciw.create_network(**params))
N1 = Q.transitive_nodes[0]
N2 = Q.transitive_nodes[1]
ciw.seed(5)
for itr in range(10): # Because repition happens in the simulation
self.assertTrue(
N1.simulation.inter_arrival_times[N1.id_number][0]()
in set(my_empirical_dist))
self.assertTrue(
N2.simulation.inter_arrival_times[N2.id_number][0]() == const)
self.assertTrue(
0.0 <= N1.simulation.service_times[N1.id_number][0]() <= 1.0)
self.assertTrue(
0.0 <= N2.simulation.service_times[N2.id_number][0]() <= 2.0)
def test_accept_method(self):
ciw.seed(6)
Q = ciw.Simulation(ciw.create_network_from_yml(
'ciw/tests/testing_parameters/params.yml'))
N = Q.transitive_nodes[0]
N.next_event_date = 0.0
self.assertEqual(N.all_individuals, [])
ind1 = ciw.Individual(1)
ind2 = ciw.Individual(2)
ind3 = ciw.Individual(3)
ind4 = ciw.Individual(4)
ind5 = ciw.Individual(5)
ind6 = ciw.Individual(6)
ind7 = ciw.Individual(7)
ind8 = ciw.Individual(8)
ind9 = ciw.Individual(9)
ind10 = ciw.Individual(10)
N.accept(ind1, 0.01)
self.assertEqual([str(obs) for obs in N.all_individuals],
['Individual 1'])
self.assertEqual(ind1.arrival_date, 0.01)
self.assertEqual(ind1.service_start_date, 0.01)
self.assertEqual(round(ind1.service_time, 5), 0.18695)
self.assertEqual(round(ind1.service_end_date, 5), 0.19695)
N.accept(ind2, 0.02)
N.accept(ind3, 0.03)
N.accept(ind4, 0.04)
self.assertEqual([str(obs) for obs in N.all_individuals],
['Individual 1',
'Individual 2',
'Individual 3',
'Individual 4'])
self.assertEqual(round(ind4.arrival_date, 5), 0.04)
self.assertEqual(round(ind4.service_start_date, 5), 0.04)
self.assertEqual(round(ind4.service_time, 5), 0.1637)
self.assertEqual(round(ind4.service_end_date, 5), 0.2037)
N.accept(ind5, 0.05)
N.accept(ind6, 0.06)
N.accept(ind7, 0.07)
N.accept(ind8, 0.08)
N.accept(ind9, 0.09)
N.accept(ind10, 0.1)
self.assertEqual([str(obs) for obs in N.all_individuals],
['Individual 1',
'Individual 2',
'Individual 3',
'Individual 4',
'Individual 5',
'Individual 6',
'Individual 7',
'Individual 8',
'Individual 9',
'Individual 10'])
self.assertEqual(round(ind10.arrival_date, 5), 0.1)
self.assertEqual(ind10.service_start_date, False)
self.assertEqual(round(ind10.service_time, 5), 0.16534)
def test_userdefined_function_dist(self):
params = {
'Arrival_distributions': [
['UserDefined', lambda : random()],
['UserDefined', lambda : custom_function()]],
'Service_distributions': [
['UserDefined', lambda : random()],
['UserDefined', lambda : custom_function()]],
'Number_of_servers': [1, 1],
'Transition_matrices': [[0.1, 0.1],
[0.1, 0.1]]
}
Q = ciw.Simulation(ciw.create_network(**params))
N1 = Q.transitive_nodes[0]
N2 = Q.transitive_nodes[1]
ciw.seed(5)
self.assertEqual(round(
N1.simulation.service_times[N1.id_number][0](), 2), 0.62)
self.assertEqual(round(
N1.simulation.service_times[N1.id_number][0](), 2), 0.74)
self.assertEqual(round(
N1.simulation.service_times[N1.id_number][0](), 2), 0.80)
self.assertEqual(round(
N1.simulation.service_times[N1.id_number][0](), 2), 0.94)
self.assertEqual(round(
N1.simulation.service_times[N1.id_number][0](), 2), 0.74)
self.assertEqual(round(
N2.simulation.service_times[N2.id_number][0](), 2), 0.46)
self.assertEqual(round(
N2.simulation.service_times[N2.id_number][0](), 2), 0.06)
self.assertEqual(round(
N2.simulation.service_times[N2.id_number][0](), 2), 0.93)
self.assertEqual(round(
N2.simulation.service_times[N2.id_number][0](), 2), 0.47)
self.assertEqual(round(
N2.simulation.service_times[N2.id_number][0](), 2), 1.30)
self.assertEqual(round(
N1.simulation.inter_arrival_times[N1.id_number][0](), 2), 0.90)
self.assertEqual(round(
N1.simulation.inter_arrival_times[N1.id_number][0](), 2), 0.11)
self.assertEqual(round(
N1.simulation.inter_arrival_times[N1.id_number][0](), 2), 0.47)
self.assertEqual(round(
N1.simulation.inter_arrival_times[N1.id_number][0](), 2), 0.25)
self.assertEqual(round(
N1.simulation.inter_arrival_times[N1.id_number][0](), 2), 0.54)
self.assertEqual(round(
N2.simulation.inter_arrival_times[N2.id_number][0](), 2), 0.29)
self.assertEqual(round(
N2.simulation.inter_arrival_times[N2.id_number][0](), 2), 0.03)
self.assertEqual(round(
N2.simulation.inter_arrival_times[N2.id_number][0](), 2), 0.43)
self.assertEqual(round(
N2.simulation.inter_arrival_times[N2.id_number][0](), 2), 0.56)
self.assertEqual(round(
N2.simulation.inter_arrival_times[N2.id_number][0](), 2), 0.46)
def test_have_event_method(self):
ciw.seed(1)
Q = ciw.Simulation(ciw.create_network(
'ciw/tests/testing_parameters/params.yml'))
N = ciw.ArrivalNode(Q)
self.assertEqual(Q.transitive_nodes[0].all_individuals, [])
self.assertEqual(Q.transitive_nodes[0].individuals, [[]])
self.assertEqual(Q.transitive_nodes[1].all_individuals, [])
self.assertEqual(Q.transitive_nodes[1].individuals, [[]])
self.assertEqual(Q.transitive_nodes[2].all_individuals, [])
self.assertEqual(Q.transitive_nodes[2].individuals, [[]])
self.assertEqual(Q.transitive_nodes[3].all_individuals, [])
self.assertEqual(Q.transitive_nodes[3].individuals, [[]])
self.assertEqual(round(N.next_event_date, 5), 0.00105)
self.assertEqual(N.next_node, 1)
N.have_event()
self.assertEqual([str(obj) for obj in Q.transitive_nodes[0].all_individuals], ['Individual 1'])
self.assertEqual([str(obj) for pr_cls in Q.transitive_nodes[0].individuals for obj in pr_cls], ['Individual 1'])
self.assertEqual(Q.transitive_nodes[1].all_individuals, [])
self.assertEqual(Q.transitive_nodes[1].individuals, [[]])
self.assertEqual(Q.transitive_nodes[2].all_individuals, [])
self.assertEqual(Q.transitive_nodes[2].individuals, [[]])
self.assertEqual(Q.transitive_nodes[3].all_individuals, [])
self.assertEqual(Q.transitive_nodes[3].individuals, [[]])
self.assertEqual(round(N.next_event_date, 5), 0.00518)
self.assertEqual(N.next_node, 3)
ciw.seed(12)
Q = ciw.Simulation(ciw.create_network(
'ciw/tests/testing_parameters/params.yml'))
N = ciw.ArrivalNode(Q)
self.assertEqual(Q.transitive_nodes[0].all_individuals, [])
self.assertEqual(Q.transitive_nodes[0].individuals, [[]])
self.assertEqual(Q.transitive_nodes[1].all_individuals, [])
self.assertEqual(Q.transitive_nodes[1].individuals, [[]])
self.assertEqual(Q.transitive_nodes[2].all_individuals, [])
self.assertEqual(Q.transitive_nodes[2].individuals, [[]])
self.assertEqual(Q.transitive_nodes[3].all_individuals, [])
self.assertEqual(Q.transitive_nodes[3].individuals, [[]])
self.assertEqual(round(N.next_event_date, 5), 0.01938)
self.assertEqual(N.next_node, 3)
N.have_event()
self.assertEqual(Q.transitive_nodes[0].all_individuals, [])
self.assertEqual(Q.transitive_nodes[0].individuals, [[]])
self.assertEqual(Q.transitive_nodes[1].all_individuals, [])
self.assertEqual(Q.transitive_nodes[1].individuals, [[]])
self.assertEqual([str(obj) for obj in Q.transitive_nodes[2].all_individuals], ['Individual 1'])
self.assertEqual([str(obj) for pr_cls in Q.transitive_nodes[2].individuals for obj in pr_cls], ['Individual 1'])
self.assertEqual(Q.transitive_nodes[3].all_individuals, [])
self.assertEqual(Q.transitive_nodes[3].individuals, [[]])
self.assertEqual(round(N.next_event_date, 5), 0.02021)
self.assertEqual(N.next_node, 2)
def test_prioritys_with_classchanges(self):
params = {
'Arrival_distributions': {'Class 0': [['Exponential', 0.5],
['Exponential', 0.5]],
'Class 1': [['Exponential', 0.5],
['Exponential', 0.5]]},
'Service_distributions': {'Class 0': [['Uniform', 0.9, 1.1],
['Uniform', 0.9, 1.1]],
'Class 1': [['Uniform', 0.9, 1.1],
['Uniform', 0.9, 1.1]]},
'Number_of_servers': [1, 1],
'Transition_matrices': {'Class 0': [[0.0, 1.0],
[1.0, 0.0]],
'Class 1': [[0.0, 1.0],
[1.0, 0.0]]},
'Priority_classes': {'Class 1': 0,
'Class 0': 1},
'Class_change_matrices': {'Node 1': [[0.0, 1.0],
[1.0, 0.0]],
'Node 2': [[0.0, 1.0],
[1.0, 0.0]]}
}
ciw.seed(1)
N = ciw.create_network(**params)
Q = ciw.Simulation(N)
Q.simulate_until_max_time(25)
recs = Q.get_all_records()
recs_cust1 = sorted([r for r in recs if r.id_number==1],
key=lambda r: r.arrival_date)
recs_cust2 = sorted([r for r in recs if r.id_number==2],
key=lambda r: r.arrival_date)
recs_cust3 = sorted([r for r in recs if r.id_number==3],
key=lambda r: r.arrival_date)
self.assertEqual([0, 1, 0, 1, 0],
[r.customer_class for r in recs_cust1])
self.assertEqual([1, 0, 1, 0, 1],
[r.customer_class for r in recs_cust2])
self.assertEqual([0, 1, 0, 1, 0],
[r.customer_class for r in recs_cust3])
self.assertEqual([1, 2, 1, 2, 1], [r.node for r in recs_cust1])
self.assertEqual([2, 1, 2, 1, 2], [r.node for r in recs_cust2])
self.assertEqual([1, 2, 1, 2, 1], [r.node for r in recs_cust3])
self.assertEqual(set([r.customer_class for r
in Q.nodes[1].individuals[0]]), set([1]))
self.assertEqual(set([r.customer_class for r
in Q.nodes[1].individuals[1]]), set([0]))
self.assertEqual(set([r.customer_class for r
in Q.nodes[2].individuals[0]]), set([1]))
self.assertEqual(set([r.customer_class for r
in Q.nodes[2].individuals[1]]), set([0]))
def test_no_arrivals_dist(self):
params = {
'Arrival_distributions': ['NoArrivals'],
'Service_distributions': [['Deterministic', 6.6]],
'Number_of_servers': [1],
'Transition_matrices': [[0.1]]
}
Q = ciw.Simulation(ciw.create_network(params))
Nna = Q.transitive_nodes[0]
ciw.seed(5)
self.assertEqual(Nna.simulation.inter_arrival_times[Nna.id_number][0](), float('Inf'))
def test_seedh(self, choices, lmbda, s, rm):
ciw.seed(s)
a1 = random.expovariate(lmbda)
b1 = nprandom.choice(choices)
c1 = random.random()
ciw.seed(s)
a2 = random.expovariate(lmbda)
b2 = nprandom.choice(choices)
c2 = random.random()
self.assertEqual(a1, a2)
self.assertEqual(b1, b2)
self.assertEqual(c1, c2)
def test_seed(self):
ciw.seed(5)
a1 = random.expovariate(5)
b1 = nprandom.choice([4, 5, 6, 1])
c1 = random.random()
ciw.seed(5)
a2 = random.expovariate(5)
b2 = nprandom.choice([4, 5, 6, 1])
c2 = random.random()
self.assertEqual(a1, a2)
self.assertEqual(b1, b2)
self.assertEqual(c1, c2)
def test_broken_timedependent_function_dist(self):
params = {
'Arrival_distributions': [
['TimeDependent', time_dependent_function_1]],
'Service_distributions': [
['TimeDependent', broken_td_func]],
'Number_of_servers': [1]
}
Q = ciw.Simulation(ciw.create_network(**params))
N = Q.transitive_nodes[0]
ciw.seed(5)
self.assertRaises(ValueError, N.simulation.service_times[N.id_number][0], 3.0)
self.assertRaises(ValueError, N.get_service_time, 0, 3.0)
def test_change_customer_class_method(self):
ciw.seed(14)
Q = ciw.Simulation(ciw.create_network(
'ciw/tests/testing_parameters/params_change_class.yml'))
N1 = Q.transitive_nodes[0]
ind = ciw.Individual(254, 0)
self.assertEqual(ind.customer_class, 0)
self.assertEqual(ind.previous_class, 0)
N1.change_customer_class(ind)
self.assertEqual(ind.customer_class, 1)
self.assertEqual(ind.previous_class, 0)
N1.change_customer_class(ind)
self.assertEqual(ind.customer_class, 1)
self.assertEqual(ind.previous_class, 1)
N1.change_customer_class(ind)
self.assertEqual(ind.customer_class, 1)
self.assertEqual(ind.previous_class, 1)
N1.change_customer_class(ind)
self.assertEqual(ind.customer_class, 0)
self.assertEqual(ind.previous_class, 1)
# Test for case of having priorities
ciw.seed(14)
parameters_dictionary = ciw.load_parameters(
'ciw/tests/testing_parameters/params_priorities.yml')
class_change_matrix = {'Node 1': [[.5, .5], [.25, .75]],
'Node 2': [[1, 0], [0, 1]]}
parameters_dictionary['Class_change_matrices'] = class_change_matrix
Q = ciw.Simulation(ciw.create_network(parameters_dictionary))
N1 = Q.transitive_nodes[0]
ind = ciw.Individual(254, 0)
self.assertEqual(ind.customer_class, 0)
self.assertEqual(ind.priority_class, 0)
self.assertEqual(ind.previous_class, 0)
N1.change_customer_class(ind)
self.assertEqual(ind.customer_class, 1)
self.assertEqual(ind.priority_class, 1)
self.assertEqual(ind.previous_class, 0)
N1.change_customer_class(ind)
self.assertEqual(ind.customer_class, 1)
self.assertEqual(ind.priority_class, 1)
self.assertEqual(ind.previous_class, 1)
N1.change_customer_class(ind)
self.assertEqual(ind.customer_class, 1)
self.assertEqual(ind.priority_class, 1)
self.assertEqual(ind.previous_class, 1)
N1.change_customer_class(ind)
self.assertEqual(ind.customer_class, 0)
self.assertEqual(ind.priority_class, 0)
self.assertEqual(ind.previous_class, 1)
def test_init_method(self):
ciw.seed(5)
Q = ciw.Simulation(ciw.create_network(
'ciw/tests/testing_parameters/params.yml'))
N = ciw.ArrivalNode(Q)
self.assertEqual(round(N.next_event_date, 5), 0.00440)
self.assertEqual(N.number_of_individuals, 0)
dates_dict = {1: {0: 0.2110410999, 1: 0.1415614623, 2: 0.3923690877},
2: {0: 0.1218825551, 1: 0.0044003133, 2: 0.2442775601},
3: {0: 0.0819463473, 1: 0.4135097542, 2: 0.7256307839},
4: {0: 0.1738823223, 1: 0.3988184145, 2: 0.2987813628}}
self.assertEqual({nd: {obs: round(N.event_dates_dict[nd][obs], 10)
for obs in N.event_dates_dict[nd]} for nd in N.event_dates_dict},
dates_dict)
