def test_NullQueue_data_collection(self):
adj = {
0: {
1: {
'edge_type': 1
}
},
1: {
2: {
'edge_type': 2
},
3: {
'edge_type': 2
},
4: {
'edge_type': 2
}
}
}
g = qt.adjacency2graph(adj)
qcl = {1: qt.QueueServer, 2: qt.NullQueue}
qn = qt.QueueNetwork(g, q_classes=qcl)
qn.initialize(edges=(0, 1))
qn.start_collecting_data(edge_type=2)
qn.max_agents = 5000
qn.simulate(n=10000)
data = qn.get_queue_data()
# Data collected by NullQueues do not have departure and
# service start times in the data
self.assertFalse(data[:, (1, 2)].any())
def test_QueueNetwork_greedy_routing(self):
lam = np.random.randint(1, 10) + 0.0
rho = np.random.uniform(0.75, 1)
nSe = np.random.randint(1, 10)
mu = lam / (3 * rho * nSe)
def arr(t):
return t + np.random.exponential(1 / lam)
def ser(t):
return t + np.random.exponential(1 / mu)
def ser_id(t):
return t
adj = {
0: {1: {'edge_type': 1}},
1: {
2: {'edge_type': 2},
3: {'edge_type': 2},
4: {'edge_type': 2}
}
}
g = qt.adjacency2graph(adj)
qcl = {1: qt.QueueServer, 2: qt.QueueServer}
arg = {
1: {
'arrival_f': arr,
'service_f': ser_id,
'AgentFactory': qt.GreedyAgent
},
2: {
'service_f': ser,
'num_servers': nSe
}
}
qn = qt.QueueNetwork(g, q_classes=qcl, q_args=arg)
qn.initialize(edges=(0, 1))
qn.max_agents = 5000
num_events = 1000
ans = np.zeros(num_events, bool)
e01 = qn.g.edge_index[(0, 1)]
edg = qn.edge2queue[e01].edge
c = 0
while c < num_events:
qn.simulate(n=1)
if qn.next_event_description() == ('Departure', e01):
d0 = qn.edge2queue[e01]._departures[0].desired_destination(qn, edg)
a1 = np.argmin([qn.edge2queue[e].number_queued() for e in qn.out_edges[1]])
d1 = qn.out_edges[1][a1]
ans[c] = d0 == d1
c += 1
self.assertTrue(ans.all())
def test_QueueNetwork_greedy_routing(self):
lam = np.random.randint(1, 10) + 0.0
rho = np.random.uniform(0.75, 1)
nSe = np.random.randint(1, 10)
mu = lam / (3 * rho * nSe)
def arr(t):
return t + np.random.exponential(1 / lam)
def ser(t):
return t + np.random.exponential(1 / mu)
def ser_id(t):
return t
adj = {
0: {1: {'edge_type': 1}},
1: {
2: {'edge_type': 2},
3: {'edge_type': 2},
4: {'edge_type': 2}
}
}
g = qt.adjacency2graph(adj)
qcl = {1: qt.QueueServer, 2: qt.QueueServer}
arg = {
1: {
'arrival_f': arr,
'service_f': ser_id,
'AgentFactory': qt.GreedyAgent
},
2: {
'service_f': ser,
'num_servers': nSe
}
}
qn = qt.QueueNetwork(g, q_classes=qcl, q_args=arg)
qn.initialize(edges=(0, 1))
qn.max_agents = 5000
num_events = 1000
ans = np.zeros(num_events, bool)
e01 = qn.g.edge_index[(0, 1)]
edg = qn.edge2queue[e01].edge
c = 0
while c < num_events:
qn.simulate(n=1)
if qn.next_event_description() == ('Departure', e01):
d0 = qn.edge2queue[e01]._departures[0].desired_destination(qn, edg)
a1 = np.argmin([qn.edge2queue[e].number_queued() for e in qn.out_edges[1]])
d1 = qn.out_edges[1][a1]
ans[c] = d0 == d1
c += 1
self.assertTrue(ans.all())
def test_adjacency2graph_matrix_etype(self):
# Test adjacency argument using ndarrays work
adj = {0: {1: {}}, 1: {2: {}, 3: {}}, 2: {0: {}}, 3: {}}
ety = np.array([[0, 5, 0, 0], [0, 0, 9, 14], [0, 0, 0, 0],
[0, 0, 0, 0]])
g = qt.adjacency2graph(adj, edge_type=ety, adjust=1)
ans = qt.graph2dict(g)
self.assertEqual(ans, self.expected_response0)
def draw3():
adj = {0 : [1], 1: [2, 3], 3: [0]}
eTy = {0: {1: 1}, 1: {2: 2, 3: 4}, 3: {0: 1}}
g = qt.adjacency2graph(adj, edge_type=eTy)
ans = qt.graph2dict(g)
print(ans)
nx.draw_networkx(g)
plt.axis('off')
plt.show()
def test_adjacency2graph_matrix_adjacency(self):
# Test adjacency argument using ndarray work
adj = np.array([[0, 1, 0, 0], [0, 0, 1, 1], [1, 0, 0, 0], [0, 0, 0,
0]])
ety = {0: {1: 5}, 1: {2: 9, 3: 14}}
g = qt.adjacency2graph(adj, edge_type=ety, adjust=2)
ans = qt.graph2dict(g)
self.assertTrue(ans == self.expected_response1)
def test_adjacency2graph_matrix_etype(self):
# Test adjacency argument using ndarrays work
adj = {0: {1: {}}, 1: {2: {}, 3: {}}, 2: {0: {}}, 3: {}}
ety = np.array([[0, 5, 0, 0],
[0, 0, 9, 14],
[0, 0, 0, 0],
[0, 0, 0, 0]])
g = qt.adjacency2graph(adj, edge_type=ety, adjust=1)
ans = qt.graph2dict(g)
self.assertEqual(ans, self.expected_response0)
def test_adjacency2graph_matrix_adjacency(self):
# Test adjacency argument using ndarray work
adj = np.array([[0, 1, 0, 0],
[0, 0, 1, 1],
[1, 0, 0, 0],
[0, 0, 0, 0]])
ety = {0: {1: 5}, 1: {2: 9, 3: 14}}
g = qt.adjacency2graph(adj, edge_type=ety, adjust=2)
ans = qt.graph2dict(g)
self.assertTrue(ans == self.expected_response1)
def createQueueGraph(num_checkIns,num_pollBooths,checkIn_rate,polling_rate,precinctPop):
#Create graph adjacent graph nodes
adja_list = {0:[1],1:[k for k in range(2,2+num_checkIns)]}
for k in range(2,2+num_checkIns):
adja_list.update({k:[l for l in range(2+num_checkIns,2+num_checkIns+num_pollBooths)]})
#Create graph edges, of type 1, 2, or 3, depending on the type of queue
edge_list = {0: {1:1}, 1:{k: 2 for k in range(2, 2+num_checkIns)}}
for k in range(2,2+num_checkIns):
edge_list.update({k:{l: 3 for l in range(2+num_checkIns,2+num_checkIns+num_pollBooths)}})
#Generate graph
g = qt.adjacency2graph(adjacency=adja_list, edge_type=edge_list)
return g
def draw2():
adj1 = {
0: {1: {}},
1: {2: {},
3: {}},
3: {0: {}}}
eTy = {0: {1: 1}, 1: {2: 2, 3: 4}, 3: {0: 1}}
# A loop will be added to vertex 2
g = qt.adjacency2graph(adj1, edge_type=eTy)
ans = qt.graph2dict(g)
print(ans)
nx.draw_networkx(g)
plt.axis('off')
plt.show()
def test_NullQueue_data_collection(self):
adj = {
0: {1: {'edge_type': 1}},
1: {2: {'edge_type': 2},
3: {'edge_type': 2},
4: {'edge_type': 2}}
}
g = qt.adjacency2graph(adj)
qcl = {1: qt.QueueServer, 2: qt.NullQueue}
qn = qt.QueueNetwork(g, q_classes=qcl)
qn.initialize(edges=(0, 1))
qn.start_collecting_data(edge_type=2)
qn.max_agents = 5000
qn.simulate(n=10000)
data = qn.get_queue_data()
# Data collected by NullQueues do not have departure and
# service start times in the data
self.assertFalse(data[:, (1, 2)].any())
def test_QueueNetwork_add_arrival(self):
adj = {0: [1], 1: [2, 3]}
g = qt.adjacency2graph(adj)
qn = qt.QueueNetwork(g)
mat = qt.generate_transition_matrix(g)
qn.set_transitions(mat)
qn.initialize(edges=(0, 1))
qn.start_collecting_data(edge=[(1, 2), (1, 3)])
qn.simulate(150000)
data = qn.get_queue_data(edge=[(1, 2), (1, 3)])
e0, e1 = qn.out_edges[1]
p0 = np.sum(data[:, 5] == e0, dtype=float) / data.shape[0]
p1 = np.sum(data[:, 5] == e1, dtype=float) / data.shape[0]
trans = qn.transitions(False)
self.assertAlmostEqual(trans[1][2], p0, 2)
self.assertAlmostEqual(trans[1][3], p1, 2)
def test_QueueNetwork_add_arrival(self):
adj = {0: [1], 1: [2, 3]}
g = qt.adjacency2graph(adj)
qn = qt.QueueNetwork(g)
mat = qt.generate_transition_matrix(g)
qn.set_transitions(mat)
qn.initialize(edges=(0, 1))
qn.start_collecting_data(edge=[(1, 2), (1, 3)])
qn.simulate(150000)
data = qn.get_queue_data(edge=[(1, 2), (1, 3)])
e0, e1 = qn.out_edges[1]
p0 = np.sum(data[:, 5] == e0, dtype=float) / data.shape[0]
p1 = np.sum(data[:, 5] == e1, dtype=float) / data.shape[0]
trans = qn.transitions(False)
self.assertAlmostEqual(trans[1][2], p0, 2)
self.assertAlmostEqual(trans[1][3], p1, 2)
def simulation(adja_list,edge_list,matrix_seed,graph_seed):
s = matrix_seed
ss = graph_seed
g = qt.adjacency2graph(adjacency=adja_list, edge_type=edge_list)
qn = qt.QueueNetwork(g=g, q_classes=q_classes, q_args=q_args, seed=ss, blocking='BAS')
# mat = create_mat(g,s)
# qn.set_transitions(mat)
# print(qn.transitions(True))
# mat = {0: {1: 1.0}, 1: {2: 0.0, 3: 1.0, 4: 0.0},
# 2: {5: 1.0}, 3: {5: 0.0, 6: 0.0, 7: 1.0}, 4: {6: 1.0},
# 5: {7: 1.0}, 6: {7: 1.0}, 7: {8: 1.0}, 8: {8: 1.0}}
# qn.set_transitions(mat)
"""
mat = qt.generate_transition_matrix(g, seed=96)
qn.set_transitions(mat)
"""
# qn.draw(fname="sim.png", figsize=(12, 3), bbox_inches='tight')
# plt.show()
qn.initialize(edge_type=1)
qn.clear_data()
qn.start_collecting_data(edge_type=1)
qn.start_collecting_data(edge_type=2)
qn.start_collecting_data(edge_type=3)
qn.start_collecting_data(edge_type=4)
qn.start_collecting_data(edge_type=5)
qn.start_collecting_data(edge_type=6)
qn.start_collecting_data(edge_type=7)
qn.start_collecting_data(edge_type=8)
qn.start_collecting_data(edge_type=9)
qn.start_collecting_data(edge_type=10)
qn.start_collecting_data(edge_type=11)
qn.start_collecting_data(edge_type=12)
qn.simulate(t=100)
"""
len(data2), means the total job in server 2
"""
np.set_printoptions(suppress=True)
data1 = qn.get_queue_data(edge_type=1)
data2 = qn.get_queue_data(edge_type=2)
data3 = qn.get_queue_data(edge_type=3)
data4 = qn.get_queue_data(edge_type=4)
data5 = qn.get_queue_data(edge_type=5)
data6 = qn.get_queue_data(edge_type=6)
data7 = qn.get_queue_data(edge_type=7)
data8 = qn.get_queue_data(edge_type=8)
data9 = qn.get_queue_data(edge_type=9)
data10 = qn.get_queue_data(edge_type=10)
data11 = qn.get_queue_data(edge_type=11)
data12 = qn.get_queue_data(edge_type=12)
dataa1 = qn.get_agent_data(edge_type=1,return_header=False)
dataa12 = qn.get_agent_data(edge_type=12,return_header=False)
total_job_num = len(data1)
job_pool = 0
each_total_job = [] # a list with each server's total job
each_thoughtput = [] # a list with each server's throught
# print("==========edge_type=1================")
# print(data1)
# print("==========edge_type=2================")
# print(data2)
# print("==========edge_type=3================")
# print(data3)
# print("==========edge_type=4================")
# print(data4)
# print("==========edge_type=5================")
# print(data5)
# print("==========edge_type=6================")
# print(data6)
# print("==========edge_type=7================")
# print(data7)
# print("==========edge_type=8================")
# print(data8)
# print("==========edge_type=9================")
# print(data9)
# print("==========edge_type=10================")
# print(data10)
# print("==========edge_type11================")
# print(data11)
# print("==========edge_type=12================")
# print(data12)
# print("totol job of server1: ", len(data1))
# print("totol job of server2: ", len(data2))
# print("totol job of server3: ", len(data3))
# print("totol job of server4: ", len(data4))
# print("totol job of server5: ", len(data5))
# print("totol job of server6: ", len(data6))
# print("totol job of server7: ", len(data7))
# print("totol job of server8: ", len(data8))
# print("totol job of server9: ", len(data9))
# print("totol job of server10: ", len(data10))
# print("totol job of server11: ", len(data11))
# print("totol job of server12: ", len(data12),"\n")
# each_total_job.append(len(data1))
# each_total_job.append(len(data2))
# each_total_job.append(len(data3))
# each_total_job.append(len(data4))
# each_total_job.append(len(data5))
# each_total_job.append(len(data6))
# each_total_job.append(len(data7))
# each_total_job.append(len(data8))
# each_total_job.append(len(data9))
# each_total_job.append(len(data10))
# each_total_job.append(len(data11))
# each_total_job.append(len(data12))
for i in range(len(data1)):
if data1[i][2] != 0.:
job_pool = job_pool +1
each_thoughtput.append(job_pool)
# print("TOTAL NUMBER OF JOBS IN THIS SIMULATION: ",job_pool)
counter = 0
for i in range(len(data2)):
if data2[i][2] != 0.:
counter = counter +1
each_thoughtput.append(counter)
# print("through put of server2: ",counter)
counter = 0
for i in range(len(data3)):
if data3[i][2] != 0.:
counter = counter +1
each_thoughtput.append(counter)
# print("through put of server3: ",counter)
counter = 0
for i in range(len(data4)):
if data4[i][2] != 0.:
counter = counter +1
each_thoughtput.append(counter)
# print("through put of server4: ",counter)
counter = 0
for i in range(len(data5)):
if data5[i][2] != 0.:
counter = counter +1
each_thoughtput.append(counter)
# print("through put of server5: ",counter)
counter = 0
for i in range(len(data6)):
if data6[i][2] != 0.:
counter = counter +1
each_thoughtput.append(counter)
# print("through put of server6: ",counter)
counter = 0
for i in range(len(data7)):
if data7[i][2] != 0.:
counter = counter +1
each_thoughtput.append(counter)
# print("through put of server7: ",counter)
counter = 0
for i in range(len(data8)):
if data8[i][2] != 0.:
counter = counter +1
each_thoughtput.append(counter)
# print("through put of server8: ",counter)
counter = 0
for i in range(len(data9)):
if data9[i][2] != 0.:
counter = counter +1
each_thoughtput.append(counter)
# print("through put of server9: ",counter)
counter = 0
for i in range(len(data10)):
if data10[i][2] != 0.:
counter = counter +1
each_thoughtput.append(counter)
# print("through put of server9: ",counter)
counter = 0
for i in range(len(data11)):
if data11[i][2] != 0.:
counter = counter +1
each_thoughtput.append(counter)
# print("through put of server11: ",counter)
container = len(data12)
each_thoughtput.append(container)
# print("CONTAINER HAS RECIEVED: ",container,"\n")
# data_caculate(each_total_job,each_thoughtput)
drop = delay_and_drop_caculate(dataa1,dataa12,(job_pool-container))
# save_data1(data1)
print("total job in container: ",container)
print("compared with the container ","the drop rate of this simulation: ", drop/container,"\n")
print("the transition matrix is: ", qn.transitions(False))
def test_graph2dict(self):
adj = generate_adjacency()
g1 = qt.adjacency2graph(adj, adjust=2)
aj1 = qt.graph2dict(g1)
g2 = qt.adjacency2graph(aj1, adjust=2)
self.assertTrue(nx.is_isomorphic(g1, g2))
def test_adjacency2graph_errors(self):
with self.assertRaises(TypeError):
qt.adjacency2graph([])
q_args = {
1: {
"num_servers": 1000,
"arrival_f": lambda t: t + np.random.exponential(500),
"service_f": lambda t: t,
"AgentFactory": qt.ResourceAgent,
"qbuffer": 1000,
"active_cap": np.infty
},
2: {
"num_servers": np.infty,
"service_f": lambda t: t + np.random.exponential(1)
}
}
net = qt.QueueNetwork(g=qt.adjacency2graph(adjacency=adj_list,
edge_type=edg_list),
q_classes=q_cls,
q_args=q_args,
seed=66)
net.initialize(edges=(0, 1))
print(net.num_events)
# net.animate(t=horizon,
# figsize=(5, 5),
# filename='plots/qt_animation/test.mp4',
# frames=1000,
# fps=30,
# writer='ffmpeg',
# vertex_size=30)
net.start_collecting_data()
for _ in range(1000):
net._simulate_next_event(slow=False)
def test_adjacency2graph_errors(self):
with self.assertRaises(TypeError):
qt.adjacency2graph([])
def simulation(adja_list, edge_list, matrix_seed, graph_seed):
s = matrix_seed
ss = graph_seed
g = qt.adjacency2graph(adjacency=adja_list, edge_type=edge_list)
qn = qt.QueueNetwork(g=g,
q_classes=q_classes,
q_args=q_args,
seed=ss,
blocking='BAS')
# mat = create_mat(g,s)
# qn.set_transitions(mat)
"""
mat = qt.generate_transition_matrix(g, seed=96)
qn.set_transitions(mat)
"""
qn.draw(fname="sim.png", figsize=(12, 3), bbox_inches='tight')
# plt.show()
qn.initialize(edge_type=1)
qn.clear_data()
qn.start_collecting_data(edge_type=1)
qn.start_collecting_data(edge_type=2)
qn.start_collecting_data(edge_type=3)
qn.start_collecting_data(edge_type=4)
qn.start_collecting_data(edge_type=5)
qn.start_collecting_data(edge_type=6)
qn.start_collecting_data(edge_type=7)
qn.start_collecting_data(edge_type=8)
qn.start_collecting_data(edge_type=9)
qn.start_collecting_data(edge_type=10)
qn.start_collecting_data(edge_type=11)
qn.start_collecting_data(edge_type=12)
qn.simulate(t=0.3)
"""
len(data2), means the total job in server 2
"""
np.set_printoptions(suppress=True)
data1 = qn.get_queue_data(edge_type=1)
data2 = qn.get_queue_data(edge_type=2)
data3 = qn.get_queue_data(edge_type=3)
data4 = qn.get_queue_data(edge_type=4)
data5 = qn.get_queue_data(edge_type=5)
data6 = qn.get_queue_data(edge_type=6)
data7 = qn.get_queue_data(edge_type=7)
data8 = qn.get_queue_data(edge_type=8)
data9 = qn.get_queue_data(edge_type=9)
data10 = qn.get_queue_data(edge_type=10)
data11 = qn.get_queue_data(edge_type=11)
data12 = qn.get_queue_data(edge_type=12)
dataa1 = qn.get_agent_data(edge_type=1)
dataa2 = qn.get_agent_data(edge_type=2)
dataa3 = qn.get_agent_data(edge_type=3)
dataa4 = qn.get_agent_data(edge_type=4)
dataa5 = qn.get_agent_data(edge_type=5)
dataa6 = qn.get_agent_data(edge_type=6)
dataa7 = qn.get_agent_data(edge_type=7)
dataa8 = qn.get_agent_data(edge_type=8)
dataa9 = qn.get_agent_data(edge_type=9)
dataa10 = qn.get_agent_data(edge_type=10)
dataa11 = qn.get_agent_data(edge_type=11)
dataa12 = qn.get_agent_data(edge_type=12)
total_job_num = len(data1)
job_pool = 0
each_total_job = [] # a list with each server's total job
each_thoughtput = [] # a list with each server's throught
print("==========edge_type=1================")
print(data1)
print("==========edge_type=2================")
print(data2)
print("==========edge_type=3================")
print(data3)
print("==========edge_type=4================")
print(data4)
print("==========edge_type=5================")
print(data5)
print("==========edge_type=6================")
print(data6)
print("==========edge_type=7================")
print(data7)
print("==========edge_type=8================")
print(data8)
print("==========edge_type=9================")
print(data9)
print("==========edge_type=10================")
print(data10)
print("==========edge_type11================")
print(data11)
print("==========edge_type=12================")
print(data12)
print("totol job of server1: ", len(data1))
print("totol job of server2: ", len(data2))
print("totol job of server3: ", len(data3))
print("totol job of server4: ", len(data4))
print("totol job of server5: ", len(data5))
print("totol job of server6: ", len(data6))
print("totol job of server7: ", len(data7))
print("totol job of server8: ", len(data8))
print("totol job of server9: ", len(data9))
print("totol job of server10: ", len(data10))
print("totol job of server11: ", len(data11))
print("totol job of server12: ", len(data12), "\n")
print("==========agent=1================")
print(dataa1)
print("==========agent=2================")
print(dataa2)
print("==========agent=3================")
print(dataa3)
print("==========agent=4================")
print(dataa4)
print("==========agent=5================")
print(dataa5)
print("==========agent=6================")
print(dataa6)
print("==========agent=7================")
print(dataa7)
print("==========agent=8================")
print(dataa8)
print("==========agent=9================")
print(dataa9)
print("==========agent=10================")
print(dataa10)
print("==========agent11================")
print(dataa11)
print("==========agent=12================")
print(dataa12)
each_total_job.append(len(data1))
each_total_job.append(len(data2))
each_total_job.append(len(data3))
each_total_job.append(len(data4))
each_total_job.append(len(data5))
each_total_job.append(len(data6))
each_total_job.append(len(data7))
each_total_job.append(len(data8))
each_total_job.append(len(data9))
each_total_job.append(len(data10))
each_total_job.append(len(data11))
each_total_job.append(len(data12))
for i in range(len(data1)):
if data1[i][2] != 0.:
job_pool = job_pool + 1
each_thoughtput.append(job_pool)
print("TOTAL NUMBER OF JOBS IN THIS SIMULATION: ", job_pool)
counter = 0
for i in range(len(data2)):
if data2[i][2] != 0.:
counter = counter + 1
each_thoughtput.append(counter)
print("through put of server2: ", counter)
counter = 0
for i in range(len(data3)):
if data3[i][2] != 0.:
counter = counter + 1
each_thoughtput.append(counter)
print("through put of server3: ", counter)
counter = 0
for i in range(len(data4)):
if data4[i][2] != 0.:
counter = counter + 1
each_thoughtput.append(counter)
print("through put of server4: ", counter)
counter = 0
for i in range(len(data5)):
if data5[i][2] != 0.:
counter = counter + 1
each_thoughtput.append(counter)
print("through put of server5: ", counter)
counter = 0
for i in range(len(data6)):
if data6[i][2] != 0.:
counter = counter + 1
each_thoughtput.append(counter)
print("through put of server6: ", counter)
counter = 0
for i in range(len(data7)):
if data7[i][2] != 0.:
counter = counter + 1
each_thoughtput.append(counter)
print("through put of server7: ", counter)
counter = 0
for i in range(len(data8)):
if data8[i][2] != 0.:
counter = counter + 1
each_thoughtput.append(counter)
print("through put of server8: ", counter)
counter = 0
for i in range(len(data9)):
if data9[i][2] != 0.:
counter = counter + 1
each_thoughtput.append(counter)
print("through put of server9: ", counter)
counter = 0
for i in range(len(data10)):
if data10[i][2] != 0.:
counter = counter + 1
each_thoughtput.append(counter)
print("through put of server9: ", counter)
counter = 0
for i in range(len(data11)):
if data11[i][2] != 0.:
counter = counter + 1
each_thoughtput.append(counter)
print("through put of server11: ", counter)
container = len(data12)
each_thoughtput.append(container)
print("CONTAINER HAS RECIEVED: ", container, "\n")
print("the through put of the map / the total number of jobs in map: ",
container / job_pool, "\n")
data_caculate(each_total_job, each_thoughtput)
# edge_list = {0: {1:1,2:1,4:1}, 1: {0:1,3:1}, 2: {0:1,5:1,6:1}, 3:{1:1,4:1,8:1},
# 4:{0:1,3:1,6:1,9:1}, 5:{2:1,7:1}, 6:{2:1,4:1,7:1,10:1}, 7:{5:1,6:1,11:1},
# 8:{3:1,9:1,12:1}, 9:{4:1,8:1,10:1,13:1,14:1}, 10:{6:1,9:1,11:1,14:1},
# 11:{7:1,10:1,15:1}, 12:{8:1,13:1}, 13:{9:1,12:1,14:1}, 14:{9:1,10:1,13:1,15:1},
# 15:{11:1,14:1}}
# adja_list = {0: [1], 1: [2,3,4], 2:[5,6] }
# edge_list = {0: {1:1}, 1: {2:2,3:2,4:2}, 2: {5:3,6:3}}
# adja_list = {0: [1,2,3], 1: [2, 4], 2:[1,3,4],3:[2, 4] }
# edge_list = {0: {1:1, 2:1, 3:1}, 1: {2:2 ,4:3}, 2: {1:2,3:2,4:3}, 3: {2:2 ,4:3}}
adja_list = {0: [1], 1: [2, 3]}
edge_list = {0: {1: 1}, 1: {2: 2, 3: 3}}
g = qt.adjacency2graph(adjacency=adja_list, edge_type=edge_list)
qn = qt.QueueNetwork(g=g, q_classes=q_classes, q_args=q_args, seed=13)
qn.draw(fname="sim.png", figsize=(12, 3), bbox_inches='tight')
pos = nx.spring_layout(g)
nx.draw_networkx_nodes(g,
pos,
node_color='green',
edge_color='orange',
alpha=0.6)
nx.draw_networkx_edges(g,
pos,
node_color='green',
edge_color='orange',
alpha=0.6)
nx.draw_networkx_labels(g, pos)
import functools
import numpy as np
import queueing_tool as qt
# Make an adjacency list
adja_list = {0: {1: {}}, 1: {k: {} for k in range(2, 22)}}
# Make an object that has the same dimensions as your adjacency list that
# specifies the type of queue along each edge.
edge_list = {0: {1: 1}, 1: {k: 2 for k in range(2, 22)}}
# Creates a networkx directed graph using the adjacency list and edge list
g = qt.adjacency2graph(adjacency=adja_list, edge_type=edge_list)
# Make a mapping between the edge types and the queue classes that sit on each
# edge. Do not use 0 as a key, it's used to map to NullQueues.
q_classes = {0: qt.NullQueue, 1: qt.QueueServer, 2: qt.QueueServer}
# Define the parameters for each of the queues
def rate(t):
return 25 + 350 * np.sin(np.pi * t / 2)**2
def ser_f(t):
return t + np.random.exponential(0.2 / 2.5)
def identity(t):
def simulation(adja_list, edge_list, matrix_seed, graph_seed):
s = matrix_seed
ss = graph_seed
g = qt.adjacency2graph(adjacency=adja_list, edge_type=edge_list)
qn = qt.QueueNetwork(g=g,
q_classes=q_classes,
q_args=q_args,
seed=ss,
blocking='BAS')
# mat = data_pool_trans_matrix
# mat = np.asarray(mat)
# print("gogogoogogoogogo")
# print(mat)
# qn.set_transitions(mat)
if data_pool_trans_matrix is not None:
mat = renew_transition_matrix_2nd()
print(mat)
qn.set_transitions(mat)
else:
pass
# print(qn.transitions(True))
"""
mat = qt.generate_transition_matrix(g, seed=96)
qn.set_transitions(mat)
"""
# qn.draw(fname="sim.png", figsize=(12, 3), bbox_inches='tight')
# plt.show()
qn.initialize(edge_type=1)
qn.clear_data()
qn.start_collecting_data(edge_type=1)
qn.start_collecting_data(edge_type=2)
qn.start_collecting_data(edge_type=3)
qn.start_collecting_data(edge_type=4)
qn.start_collecting_data(edge_type=5)
qn.start_collecting_data(edge_type=6)
qn.start_collecting_data(edge_type=7)
qn.start_collecting_data(edge_type=8)
qn.start_collecting_data(edge_type=9)
qn.start_collecting_data(edge_type=10)
qn.start_collecting_data(edge_type=11)
qn.start_collecting_data(edge_type=12)
qn.simulate(t=100)
"""
len(data2), means the total job in server 2
"""
np.set_printoptions(suppress=True)
data1 = qn.get_queue_data(edge_type=1)
data2 = qn.get_queue_data(edge_type=2)
data3 = qn.get_queue_data(edge_type=3)
data4 = qn.get_queue_data(edge_type=4)
data5 = qn.get_queue_data(edge_type=5)
data6 = qn.get_queue_data(edge_type=6)
data7 = qn.get_queue_data(edge_type=7)
data8 = qn.get_queue_data(edge_type=8)
data9 = qn.get_queue_data(edge_type=9)
data10 = qn.get_queue_data(edge_type=10)
data11 = qn.get_queue_data(edge_type=11)
data12 = qn.get_queue_data(edge_type=12)
dataa1 = qn.get_agent_data(edge_type=1, return_header=False)
dataa12 = qn.get_agent_data(edge_type=12, return_header=False)
"""
========> 重要資料作業區 <============
"""
total_job_num = len(data1)
job_pool = 0
each_total_job = [] # a list with each server's total job
each_thoughtput = [] # a list with each server's throughtput
"""
========> 重要資料作業區 <============
"""
# print("==========edge_type=1================")
# print(data1)
# print("==========edge_type=2================")
# print(data2)
# print("==========edge_type=3================")
# print(data3)
# print("==========edge_type=4================")
# print(data4)
# print("==========edge_type=5================")
# print(data5)
# print("==========edge_type=6================")
# print(data6)
# print("==========edge_type=7================")
# print(data7)
# print("==========edge_type=8================")
# print(data8)
# print("==========edge_type=9================")
# print(data9)
# print("==========edge_type=10================")
# print(data10)
# print("==========edge_type11================")
# print(data11)
# print("==========edge_type=12================")
# print(data12)
# print("totol job of server1: ", len(data1))
# print("totol job of server2: ", len(data2))
# print("totol job of server3: ", len(data3))
# print("totol job of server4: ", len(data4))
# print("totol job of server5: ", len(data5))
# print("totol job of server6: ", len(data6))
# print("totol job of server7: ", len(data7))
# print("totol job of server8: ", len(data8))
# print("totol job of server9: ", len(data9))
# print("totol job of server10: ", len(data10))
# print("totol job of server11: ", len(data11))
# print("totol job of server12: ", len(data12),"\n")
# each_total_job.append(len(data1))
# each_total_job.append(len(data2))
# each_total_job.append(len(data3))
# each_total_job.append(len(data4))
# each_total_job.append(len(data5))
# each_total_job.append(len(data6))
# each_total_job.append(len(data7))
# each_total_job.append(len(data8))
# each_total_job.append(len(data9))
# each_total_job.append(len(data10))
# each_total_job.append(len(data11))
# each_total_job.append(len(data12))
for i in range(len(data1)):
if data1[i][2] != 0.:
job_pool = job_pool + 1
each_thoughtput.append(job_pool)
# print("TOTAL NUMBER OF JOBS IN THIS SIMULATION: ",job_pool)
# counter = 0
# for i in range(len(data2)):
# if data2[i][2] != 0.:
# counter = counter +1
# each_thoughtput.append(counter)
# # print("through put of server2: ",counter)
# counter = 0
# for i in range(len(data3)):
# if data3[i][2] != 0.:
# counter = counter +1
# each_thoughtput.append(counter)
# # print("through put of server3: ",counter)
# counter = 0
# for i in range(len(data4)):
# if data4[i][2] != 0.:
# counter = counter +1
# each_thoughtput.append(counter)
# # print("through put of server4: ",counter)
# counter = 0
# for i in range(len(data5)):
# if data5[i][2] != 0.:
# counter = counter +1
# each_thoughtput.append(counter)
# # print("through put of server5: ",counter)
# counter = 0
# for i in range(len(data6)):
# if data6[i][2] != 0.:
# counter = counter +1
# each_thoughtput.append(counter)
# # print("through put of server6: ",counter)
# counter = 0
# for i in range(len(data7)):
# if data7[i][2] != 0.:
# counter = counter +1
# each_thoughtput.append(counter)
# # print("through put of server7: ",counter)
# counter = 0
# for i in range(len(data8)):
# if data8[i][2] != 0.:
# counter = counter +1
# each_thoughtput.append(counter)
# # print("through put of server8: ",counter)
# counter = 0
# for i in range(len(data9)):
# if data9[i][2] != 0.:
# counter = counter +1
# each_thoughtput.append(counter)
# # print("through put of server9: ",counter)
# counter = 0
# for i in range(len(data10)):
# if data10[i][2] != 0.:
# counter = counter +1
# each_thoughtput.append(counter)
# # print("through put of server9: ",counter)
# counter = 0
# for i in range(len(data11)):
# if data11[i][2] != 0.:
# counter = counter +1
# each_thoughtput.append(counter)
# # print("through put of server11: ",counter)
container = len(data12)
each_thoughtput.append(container)
# print("CONTAINER HAS RECIEVED: ",container,"\n")
"""
========> 重要資料作業區 <============
"""
# server_delay = {}
server_delay["server2"] = particular_server_delay(data2)
server_delay["server3"] = particular_server_delay(data3)
server_delay["server4"] = particular_server_delay(data4)
server_delay["server5"] = particular_server_delay(data5)
server_delay["server6"] = particular_server_delay(data6)
server_delay["server7"] = particular_server_delay(data7)
server_delay["server8"] = particular_server_delay(data8)
server_delay["server9"] = particular_server_delay(data9)
server_delay["server10"] = particular_server_delay(data10)
server_delay["server11"] = particular_server_delay(data11)
# server_delayy = []
# server_delayy.append(particular_server_delay(data2))
# server_delayy.append(particular_server_delay(data3))
# server_delayy.append(particular_server_delay(data4))
# server_delayy.append(particular_server_delay(data5))
# server_delayy.append(particular_server_delay(data6))
# server_delayy.append(particular_server_delay(data7))
# server_delayy.append(particular_server_delay(data8))
# server_delayy.append(particular_server_delay(data9))
# server_delayy.append(particular_server_delay(data10))
# server_delayy.append(particular_server_delay(data11))
# debug(each_total_job,each_thoughtput) # for reward
drop = delay_and_drop_caculate(dataa1, dataa12,
(job_pool - container)) # for drop rate
# check_distributtion(data1)
print("total job in container: ", container)
print("compared with the container ",
"the drop rate of this simulation: ", drop / container, "\n")
improve_data(server_delay)
# print(improve_data(server_delayy))
"""
data = q.fetch_data()
s0[k] = np.std(data[:,1] - data[:, 0] )
w0 = np.hstack((w0, data[:,1] - data[:, 0] ) )
q.clear()
# """
# The queueing network definition
adjacency = {
0: {1: {'edge_type': 1} },
1: {k: {'edge_type': 2} for k in range(2, 2 + nc) }
}
# edge_type = {0: {1: 1}, 1: {k: 2 for k in range(2, 22)}}
g = qt.adjacency2graph(adjacency)
qclass = {1: qt.QueueServer, 2: qt.QueueServer }
qargs = {1: {'nServers': 1, 'deactive_t': h,
'arrival_f': arr,
'service_f': lambda t: t,
'AgentClass': qt.GreedyAgent},
2: {'nServers': 1,
'service_f': ser} }
qn = qt.QueueNetwork(adjacency, q_classes=qclass, q_args=qargs)
w1 = np.array([] )
s1 = np.zeros(N)
for k in range(N) :
qn.start_collecting_data(eType=2)
def simulation(adja_list, edge_list, matrix_seed, graph_seed):
# adja_list = {0: [1,2,3], 1: [4],2 :[4,5,6],3:[5],4:[6],5:[6],6:[7]}
# edge_list = {0: {1:1,2:1,3:1}, 1: {4:2}, 2:{4:3,6:4,5:5}, 3:{5:6}, 4:{6:7},5:{6:8},6:{7:9}}
s = matrix_seed
ss = graph_seed
g = qt.adjacency2graph(adjacency=adja_list, edge_type=edge_list)
qn = qt.QueueNetwork(g=g,
q_classes=q_classes,
q_args=q_args,
seed=ss,
blocking='BAS')
# mat = create_mat(g,s)
# qn.set_transitions(mat)
"""
mat = qt.generate_transition_matrix(g, seed=96)
qn.set_transitions(mat)
"""
qn.draw(fname="sim.png", figsize=(12, 3), bbox_inches='tight')
# plt.show()
qn.initialize(edge_type=1)
qn.clear_data()
qn.start_collecting_data(edge_type=1)
qn.start_collecting_data(edge_type=2)
qn.start_collecting_data(edge_type=3)
qn.start_collecting_data(edge_type=4)
qn.start_collecting_data(edge_type=5)
qn.start_collecting_data(edge_type=6)
qn.start_collecting_data(edge_type=7)
qn.start_collecting_data(edge_type=8)
qn.start_collecting_data(edge_type=9)
qn.simulate(t=0.2)
np.set_printoptions(suppress=True)
data1 = qn.get_queue_data(edge_type=1)
data2 = qn.get_queue_data(edge_type=2)
data3 = qn.get_queue_data(edge_type=3)
data4 = qn.get_queue_data(edge_type=4)
data5 = qn.get_queue_data(edge_type=5)
data6 = qn.get_queue_data(edge_type=6)
data7 = qn.get_queue_data(edge_type=7)
data8 = qn.get_queue_data(edge_type=8)
data9 = qn.get_queue_data(edge_type=9)
print("==========edge_type=1================")
print(data1)
print("==========edge_type=2================")
# print(data2)
# print("==========edge_type=3================")
# print(data3)
# print("==========edge_type=4================")
# print(data4)
# print("==========edge_type=5================")
# print(data5)
# print("==========edge_type=6================")
# print(data6)
# print("==========edge_type=7================")
# print(data7)
# print("==========edge_type=8================")
# print(data8)
# print("==========edge_type=9================")
# print(data9,"\n")
print("totol job of server1: ", len(data1))
print("totol job of server2: ", len(data2))
print("totol job of server3: ", len(data3))
print("totol job of server4: ", len(data4))
print("totol job of server5: ", len(data5))
print("totol job of server6: ", len(data6))
print("totol job of server7: ", len(data7))
print("totol job of server8: ", len(data8))
print("totol job of server9: ", len(data9), "\n")
through_put = 0
total_job_num = len(data1)
counter = 0
for i in range(len(data4)):
if data4[i][2] != 0.:
counter = counter + 1
through_put = through_put + counter
print("through put of server4: ", counter)
counter = 0
for i in range(len(data7)):
if data7[i][2] != 0.:
counter = counter + 1
through_put = through_put + counter
print("through put of server7: ", counter)
counter = 0
for i in range(len(data8)):
if data8[i][2] != 0.:
counter = counter + 1
through_put = through_put + counter
print("through put of server8: ", counter, "\n")
print(
"the through put of server4,7,8 is equal to the total number of job in server 9:",
through_put)
print("the through put of the map / the total number of jobs in map: ",
through_put / total_job_num)
def test_graph2dict(self):
adj = generate_adjacency()
g1 = qt.adjacency2graph(adj, adjust=2)
aj1 = qt.graph2dict(g1)
g2 = qt.adjacency2graph(aj1, adjust=2)
self.assertTrue(nx.is_isomorphic(g1, g2))