def motivation_number_runs():
# 2. Simulating with identified simulation length, getting a reasonable number of runs.
# Using simulation_length = 1500, and discarding the first 100 items as the system takes this time to warm-up
run_sizes = [i for i in range(0, 10)]
graph_type = 'Highway'
sim_time_stats = []
for run_size in run_sizes:
# sim_time_stats.append[]
for i in range(run_size):
system = run_simulation(seed=None,
end_time=1500,
stats_step_size=50,
graph_type=graph_type,
tow_truck_mode=True)
sim_time_stats[-1].append(system.time_statistics[-1])
key = 'Average number of incidents'
plot = plt.figure()
plt.ylabel(key)
plt.xlabel('Simulation Time')
for idx, val in enumerate(run_sizes):
run_time = run_sizes[idx]
for run in sim_time_stats:
for stat_tuple in run:
plt.plot([stat_tuple[0]], [stat_tuple[1][key]], 'o')
plt.show()
def motivation_simulation_length():
# 1. Simulating for identifying a final simulation time
# Using number of runs = 5
graph_type = 'Highway' # Toy1, Toy2, Highway
# number_of_runs = 1
number_of_runs = 5
end_times = [i for i in range(51, 1600, 100)]
# end_times = [150, 300, 450]
# print(end_times)
sim_time_stats = [[] for i in range(len(end_times))]
for i, ival in enumerate(end_times):
for j in range(number_of_runs):
system = run_simulation(simulation_id=str(ival) + '-' + str(j),
seed=None,
end_time=ival,
stats_step_size=50,
graph_type=graph_type,
tow_truck_mode=True,
warm_up=100)
sim_time_stats[i].append(
(system.time_statistics['time'], system.final_statistics))
# keys = ['number_of_ghost_cars_at_time', 'number_of_route_cars_at_time', 'number_of_current_incidents', 'Average number of incidents']
# keys = ['number_of_current_incidents', 'Average number of incidents']
keys = ['average_number_of_incidents']
#
for key in keys:
plot = plt.figure()
plt.ylabel(key)
plt.xlabel('Simulation Time')
for idx, end_time in enumerate(end_times):
for sim_time_stat in sim_time_stats[idx]:
plt.plot(end_time, sim_time_stat[1][key], 'bo')
plt.show()
def test_no_obs():
robot = Robot(1, -2, utils.to_radians(-60))
ball = Ball(0, 0, 0, 0)
result = main.run_simulation(robot,
ball, [],
simulation_delay=1000,
enable_detection=False,
drawable_obs_avoidance=True)
assert result
def test_no_obs2():
robot = Robot(constants.x_start, constants.y_start, constants.theta_start)
ball = Ball(constants.WINDOW_CORNERS[2] - 1,
constants.WINDOW_CORNERS[3] - 1, 0, 0)
result = main.run_simulation(robot,
ball, [],
simulation_delay=1000,
enable_detection=False)
assert result
def stats_of_edges_served_by_tow_trucks():
graph_type = 'Highway'
edge_numbers = [0 for i in range(100)]
for i in range(run_size):
system = run_simulation('EdgesServed-',
seed=100 + i,
end_time=1600,
stats_step_size=50,
graph_type=graph_type,
tow_truck_mode=True,
warm_up=100)
print(system.
final_statistics['number_of_times_edges_served_by_tow_trucks'])
edge_numbers = list(
map(
sum,
zip(
edge_numbers, system.final_statistics[
'number_of_times_edges_served_by_tow_trucks'])))
edge_numbers = [i / run_size for i in edge_numbers]
print(edge_numbers)
# edge_numbers = system.final_statistics['number_of_times_edges_served_by_tow_trucks']
# edge_numbers = [0, 1, 0, 4, 5, 5, 1, 5, 4, 9, 3, 10, 6, 2, 4, 2, 5, 2, 3, 4, 6, 5, 4, 1, 6, 9, 5, 2, 9, 3, 5, 8, 6, 2, 2, 2, 4, 4, 3, 6, 2, 5, 1, 1, 4, 1, 2, 2, 2, 3, 3, 1, 3, 5, 2, 2, 3, 9, 8, 3, 3, 3, 4, 6, 0, 6, 3, 1, 4, 7, 5, 3, 2, 1, 3, 3, 2, 5, 3, 1, 4, 3, 4, 10, 2, 6, 3, 3, 2, 4, 1, 4, 7, 3, 2, 3, 1, 3, 1, 0]
# graph, route_path = util.build_highway_graph()
edge_num_dict = dict()
for key, val in enumerate(edge_numbers):
edge_num_dict[key] = val
sorted_edge_nums = sorted(edge_num_dict.items(),
key=lambda kv: (kv[1], kv[0]),
reverse=True)[0:15]
print(sorted_edge_nums)
x = []
y = []
for edge in sorted_edge_nums:
edge_id = edge[0]
source_node = system.graph.edges[edge_id].source_id
target_node = system.graph.edges[edge_id].target_id
x.append(util.city_names[source_node] + '-' +
util.city_names[target_node])
y.append(edge[1])
plot = plt.figure()
plt.xlabel('Highway link')
plt.ylabel('Numbers of times reached by tow trucks')
# plt.plot(incidents_x, incidents_y, 'bo')
plt.bar(x, y)
plt.xticks(x, x, rotation='vertical')
plt.subplots_adjust(bottom=0.40)
# plt.margins(0.2)
# bottom, top = plt.ylim()
# plt.ylim(bottom=0, top=top)
# plt.xticks(incidents_x, incidents_x)
plt.show()
def execute_plot(self):
result = run_simulation(self.compile_profile(),
self.param['Generations'].get(),
self.param['Rounds'].get())
self.fig.clear()
x_axis = result.pop('gens')
self.f = self.fig.add_subplot(111)
for strat in result:
self.f.plot(x_axis, result[strat], label=strat)
self.set_graph_params()
self.f.legend()
self.canvas.show()
def test_vshyvost():
for seed in seeds:
print(seed)
constants.RANDOM_SEED = seed
ball = Ball.create_randomized()
obstacles = main._generate_obstacles(cnt=constants.OBSTACLES_COUNT)
robot = Robot(constants.x_start, constants.y_start,
constants.theta_start)
result = main.run_simulation(robot,
ball,
obstacles,
enable_detection=True)
assert result
def sim_runs():
seed = int(time.time())
with open(result_file, 'w') as fo:
fo.write('Time_Steps,4_Door,2_Door,1_Door,1_Door,1_Door,1_Door\n')
# 313 is the y coordinate for bottom row of cells on Armstead south sidewalk,
# given in person sized cell coordinates.
# The range for the x coordinates is 77 - 413, inclusive
# The x coordinate for spring south sidewalk is 76, the y range is 314 - 493, inclusive
# The x coordinate for west peachtree south sidewalk is 414, the y range is 314 - 493, inclusive # was 323
for pos in door_pos:
temp_list = [[
list(coord_list[pos[0]]),
list(coord_list[pos[0]]),
list(coord_list[pos[0]]),
list(coord_list[pos[0]])
], [list(coord_list[pos[1]]),
list(coord_list[pos[1]])], [list(coord_list[pos[2]])],
[list(coord_list[pos[3]])], [list(coord_list[pos[4]])],
[list(coord_list[pos[5]])]]
door_coords = temp_list
#setup locations for 4 door and 2 door, they will always be next to each other
coord = 0 if door_coords[0][0][2] else 1
for i in range(1, 4):
door_coords[0][i][coord] = door_coords[0][i - 1][coord] + 2
door_coords[0][i][coord ^ 1] = door_coords[0][i - 1][coord ^ 1]
coord = 0 if door_coords[1][0][2] else 1
door_coords[1][1][coord] = door_coords[1][0][coord] + 2
door_coords[1][1][coord ^ 1] = door_coords[1][0][coord ^ 1]
#print door_coords
#for i in xrange(7):
# for doorlist in door_coords[1:]:
# coord = 0 if doorlist[0][2] else 1
# for door in doorlist:
# door[coord] += 20
# run simulations
result = main.run_simulation(door_coords, seed)
with open('timestep_results.csv', 'a') as fo:
fo.write('%d,%d,%d,%d,%d,%d,%d\n' %
(result, pos[0], pos[1], pos[2], pos[3], pos[4], pos[5]))
def test_static_obs():
robot = Robot(constants.x_start, constants.y_start, constants.theta_start)
ball = Ball(constants.WINDOW_CORNERS[2] - 1,
constants.WINDOW_CORNERS[3] - 1, 0, 0)
obstacles = [
MovingObstacle(ball.x - 0.5, ball.y - 0.5, 0, 0)
# MovingObstacle.create_randomized(),
]
result = main.run_simulation(robot,
ball,
obstacles,
simulation_delay=1000,
enable_detection=True,
drawable_obs_avoidance=True)
assert result
def test_static_hist():
# robot = Robot(constants.x_start, constants.y_start + 1, 1.75)
robot = Robot(constants.x_start, constants.y_start, 1.75)
ball = Ball(constants.WINDOW_CORNERS[2] - 1,
constants.WINDOW_CORNERS[3] - 1, 0, 0)
obstacles = [
# MovingObstacle(constants.x_start + 0.8, constants.y_start + 1.8, 0, 0),
MovingObstacle(constants.x_start + 0.4, constants.y_start + 0.4, 0, 0)
# MovingObstacle.create_randomized(),
]
result = main.run_simulation(robot,
ball,
obstacles,
simulation_delay=1000,
enable_detection=True,
drawable_obs_avoidance=True)
assert result
def motivation_simulation_length():
# 1. Simulating for identifying a final simulation time
# Using number of runs = 5
graph_type = 'Highway' # Toy1, Toy2, Highway
# number_of_runs = 1
number_of_runs = 5
end_times = [i for i in range(100, 1600, 100)]
# end_times = [100, 150, 200]
# print(end_times)
sim_time_stats = [[] for i in range(len(end_times))]
for i, ival in enumerate(end_times):
for j in range(number_of_runs):
system = run_simulation(simulation_id=str(ival) + '-' + str(j),
seed=20 + i + j,
end_time=ival,
stats_step_size=50,
graph_type=graph_type,
tow_truck_mode=False,
warm_up=100)
# system = run_simulation(simulation_id=str(ival) + '-' + str(j), seed=20+i+j, end_time=ival, stats_step_size=50, graph_type=graph_type, tow_truck_mode=False)
sim_time_stats[i].append(system.final_statistics)
# keys = ['number_of_ghost_cars_at_time', 'number_of_route_cars_at_time', 'number_of_current_incidents', 'Average number of incidents']
# keys = ['number_of_current_incidents', 'Average number of incidents']
keys = ['average_number_of_incidents']
for key in keys:
plot = plt.figure()
plt.ylabel(key)
plt.xlabel('Simulation Time')
# i = 0
for idx, end_time in enumerate(end_times):
for sim_time_stat in sim_time_stats[idx]:
# i+=1
plt.plot(end_time, sim_time_stat[key], 'bo')
print(i)
# left, right = plt.xlim()
# plt.xlim(100, right)
bottom, top = plt.ylim()
plt.ylim(0, top)
plt.show()
def motivation_number_tow_trucks():
graph_type = 'Highway' # Toy1, Toy2, Highway
# number_of_runs = 1
number_of_runs = 20
tow_truck_numbers = [i for i in range(1, 26)]
# tow_truck_numbers = [1, 6, 11, 16]
# end_times = [150, 300, 450]
# print(end_times)
sim_time_stats = [[] for i in range(len(tow_truck_numbers))]
for i, ival in enumerate(tow_truck_numbers):
for j in range(number_of_runs):
system = run_simulation(simulation_id=str('tow_truck_number-') +
str(ival) + '-' + str(j),
seed=None,
end_time=1600,
stats_step_size=50,
graph_type=graph_type,
tow_truck_mode=True,
warm_up=100,
number_of_tow_trucks=ival)
sim_time_stats[i].append(
(str(ival) + str(j), system.final_statistics))
# keys = ['number_of_ghost_cars_at_time', 'number_of_route_cars_at_time', 'number_of_current_incidents', 'Average number of incidents']
# keys = ['number_of_current_incidents', 'Average number of incidents']
keys = ['average_number_of_incidents']
for key in keys:
plot = plt.figure()
# plt.ylim()
plt.xticks([i for i in range(1, 40, 5)], [i for i in range(1, 40, 5)])
plt.ylabel(key)
plt.xlabel('Number of tow trucks')
for idx, tow_truck_number in enumerate(tow_truck_numbers):
for sim_time_stat in sim_time_stats[idx]:
plt.plot(tow_truck_number, sim_time_stat[1][key], 'bo')
bottom, top = plt.ylim()
plt.xlim(0, 25)
plt.ylim(0, top)
plt.show()
def motivation_number_runs():
# 2. Simulating with identified simulation length, getting a reasonable number of runs.
# Using simulation_length = 1500, and discarding the first 100 items as the system takes this time to warm-up
run_sizes = [i for i in range(1, 50)]
graph_type = 'Highway'
run_size_stats = [[] for i in range(len(run_sizes))]
trial_per_run_size = 5
# sim_time_stats.append[]
# for run_size in run_sizes:
for index, run_size in enumerate(run_sizes):
for trial in range(trial_per_run_size):
values = []
for run in range(run_size):
system = run_simulation('Run-' + str(run_size) + '-' +
str(trial),
seed=run_size + run + trial,
end_time=1600,
stats_step_size=50,
graph_type=graph_type,
tow_truck_mode=False,
warm_up=100)
values.append(
system.final_statistics['average_number_of_incidents'])
run_size_stats[index].append(mean(values))
key = 'average_number_of_incidents'
plot = plt.figure()
plt.ylabel('Average number of Incidents')
plt.xlabel('Run Size')
for idx, run_size in enumerate(run_sizes):
for value in run_size_stats[idx]:
print('Run_size', run_size)
print(value)
plt.plot([run_size], value, 'bo')
plt.show()
import os
if "LA_EXIT_ON_COMPLETE" in os.environ:
from main import run_simulation
run_simulation(os.environ['LA_INFILE'], os.environ['LA_OUTFILE'])
import sys
sys.exit()
if "LA_IS_SIMULATION" in os.environ:
from main import run_simulation
if os.environ["LA_WITH_GUI"] == "YES":
try:
from matplotlib import pyplot as plt
from IPython import get_ipython
get_ipython().magic("matplotlib")
except:
print(
"Matplotlib imported. To run matplotlib interractively with ipython, run the command \n\n>>> %matplotlib"
)
from mirage import lens_analysis as la
from mirage.util import *
from mirage.parameters import *
import mirage
#Import general things
from astropy import units as u
import numpy as np
import math
# A few ipython things to manipulate the environment
import numpy as np
import matplotlib.pyplot as plt
from main import run_simulation
from utils import get_args
if __name__ == "__main__":
args = get_args()
args.no_plot = True
args.no_print = True
errs = []
acc_ws = np.linspace(0, 1.0, 101)
for acc_w in acc_ws:
args.filter_acc_weight = acc_w
errs.append(run_simulation(args))
title = "Error vs. Accelerometer Weight"
plt.figure(title)
plt.title(title)
plt.plot(acc_ws, errs)
plt.xlabel("Accel. Weight")
plt.ylabel("Mean Abs. Err. (rad)")
plt.show()
def test_first_example(self):
input_array = '12345678'
phases = 4
result_expected = '01029498'
result_actual = main.run_simulation(input_array, phases)[0:8]
self.assertEqual(result_actual, result_expected)
def variance_of_performance_measures_with_tow_trucks():
# tow_truck_numbers = [5, 10, 15, 16, 20]
tow_truck_numbers = [i for i in range(1, 26)]
# tow_truck_numbers = [20, 30]
run_size_int = 5
travel_x = []
travel_y = []
delays_x = []
delays_y = []
num_delays_x = []
num_delays_y = []
incidents_x = []
incidents_y = []
for tow_truck_number in tow_truck_numbers:
travel_times_list = []
number_delays_list = []
delay_times_list = []
average_number_of_incidents = []
for run in range(run_size_int):
graph_type = 'Highway'
system = run_simulation('Variance-' + str(tow_truck_number) +
str('-') + str(run),
seed=40 + tow_truck_number + run,
end_time=1600,
stats_step_size=50,
graph_type=graph_type,
tow_truck_mode=True,
warm_up=100,
number_of_tow_trucks=tow_truck_number)
travel_times_list.append(
mean(system.final_statistics['route_travel_times']))
delay_times_list.append(
mean(system.final_statistics['route_delay_times']))
number_delays_list.append(
mean(system.final_statistics['route_number_delays']))
average_number_of_incidents.append(
system.final_statistics['average_number_of_incidents'])
travel_y += travel_times_list
travel_x += [tow_truck_number for i in range(run_size_int)]
delays_y += delay_times_list
delays_x += [tow_truck_number for i in range(run_size_int)]
num_delays_y += number_delays_list
num_delays_x += [tow_truck_number for i in range(run_size_int)]
incidents_y += average_number_of_incidents
incidents_x += [tow_truck_number for i in range(run_size_int)]
print('Average travel times -', travel_y)
print('Average delay times -', delays_y)
print('Number of delays -', num_delays_y)
print('Average number of incidents -', incidents_y)
print('Tow truck numbers -', incidents_x)
plot = plt.figure()
plt.xlabel('Number of tow trucks')
plt.ylabel('Average route travel time')
plt.plot(travel_x, travel_y, 'bo')
# bottom, top = plt.ylim()
# plt.ylim(bottom=0, top=top)
plt.xticks(incidents_x, incidents_x)
plt.show()
plot = plt.figure()
plt.xlabel('Number of tow trucks')
plt.ylabel('Average delay time')
plt.plot(delays_x, delays_y, 'bo')
# bottom, top = plt.ylim()
# plt.ylim(bottom=0, top=top)
plt.xticks(incidents_x, incidents_x)
plt.show()
plot = plt.figure()
plt.xlabel('Number of tow trucks')
plt.ylabel('Average number of delays')
plt.plot(num_delays_x, num_delays_y, 'bo')
bottom, top = plt.ylim()
plt.ylim(bottom=0, top=top)
plt.xticks(incidents_x, incidents_x)
plt.show()
plot = plt.figure()
plt.xlabel('Number of tow trucks')
plt.ylabel('Numbers of incidents (With tow trucks)')
plt.plot(incidents_x, incidents_y, 'bo')
bottom, top = plt.ylim()
plt.ylim(bottom=0, top=top)
plt.xticks(incidents_x, incidents_x)
plt.show()
def test_fourth_example(self):
input_array = '69317163492948606335995924319873'
phases = 100
result_expected = '52432133'
result_actual = main.run_simulation(input_array, phases)[0:8]
self.assertEqual(result_actual, result_expected)
def test_third_example(self):
input_array = '19617804207202209144916044189917'
phases = 100
result_expected = '73745418'
result_actual = main.run_simulation(input_array, phases)[0:8]
self.assertEqual(result_actual, result_expected)
from main import run_simulation
color_map = ['g', 'y', 'r', 'b', 'm', 'k']
# green not infected
# yellow newly_infected
# red - infected
# blue recovered
# purple immune
plt.figure(figsize=(10, 10))
# number of nodes
# generate graph
# return animation_bc_sir, ba, len(animation_bc_sir)
color_rules, G, size = run_simulation(
'rc',
0,
0,
0.1,
)
# generating input frames here, since my data is too big
# its important that the frames go as input and is not generated
# on the fly
colors = list()
count = 0
for x in range(size):
frame_colors = list()
length = len(color_rules[x])
for i in range(length):
node_color = color_map[color_rules[x][i]]
node_color = color.to_hex(node_color)
frame_colors.append(node_color)
import main
from system import System
DISPLAY = False
SYSTEM = System(DISPLAY)
for i in range(2):
main.run_simulation(SYSTEM=SYSTEM, DISPLAY=DISPLAY)
def perf_measure_3():
# For incidents: distribution of the number of incidents in the whole network, at any
# arbitrary epoch. This is similar to the previous question, but now for the fraction of time
# that exactly k incidents are taking place simultaneously in the network
graph_type = 'Highway'
system = run_simulation('Measure-3-vis',
seed=40,
end_time=1600,
stats_step_size=50,
graph_type=graph_type,
tow_truck_mode=False,
warm_up=100)
times_fraction_per_number_of_incidents = system.final_statistics[
'time_spent_per_current_number_of_incidents']
# rounded_times = [round(i) for i in times_fraction_per_number_of_incidents]
# print(rounded_times)
# counts_number_delays = Counter(number_delays_list)
# list_of_number_delays = []
# for i in range(max(number_delays_list) + 1):
# list_of_number_delays.append(counts_number_delays[i])
print('Counts of time spent per number of incidents',
times_fraction_per_number_of_incidents)
print('len', len(times_fraction_per_number_of_incidents))
min_non_zero_incidents = 0
max_non_zero_incidents = len(times_fraction_per_number_of_incidents)
i = 0
while i < len(times_fraction_per_number_of_incidents
) and times_fraction_per_number_of_incidents[i] == 0:
min_non_zero_incidents += 1
i += 1
i = len(times_fraction_per_number_of_incidents) - 1
while i > 0 and times_fraction_per_number_of_incidents[i] == 0:
max_non_zero_incidents -= 1
i -= 1
print('max_non_zero_incidents', max_non_zero_incidents)
print('min_non_zero_incidents', min_non_zero_incidents)
plot = plt.figure()
plt.xlabel('Numbers of incidents')
plt.ylabel('Fraction of time spent')
plt.xlim(min_non_zero_incidents - 1, max_non_zero_incidents)
plt.bar([i for i in range(len(times_fraction_per_number_of_incidents))], [
j / sum(times_fraction_per_number_of_incidents)
for j in times_fraction_per_number_of_incidents
])
plt.show()
average_number_of_incidents = []
# CI calculation
for i in range(run_size):
system = run_simulation('Measure-3' + str(i),
seed=i,
end_time=1600,
stats_step_size=50,
graph_type=graph_type,
tow_truck_mode=False,
warm_up=100)
print('Run -', i)
average_number_of_incidents.append(
system.final_statistics['average_number_of_incidents'])
mean_number_of_incidents = sum(average_number_of_incidents) / len(
average_number_of_incidents)
std_number_of_incidents = std(average_number_of_incidents)
print('Mean of Number of Incidents -', mean_number_of_incidents)
print('Standard Deviation of Number of Incidents -',
std_number_of_incidents)
halfwidth_number_of_incidents = ci(std_number_of_incidents, run_size)
print('Halfwidth of Number of Incidents -', halfwidth_number_of_incidents)
print('Range - ', mean_number_of_incidents - halfwidth_number_of_incidents,
mean_number_of_incidents + halfwidth_number_of_incidents)
def perf_measure_2():
# 2. For the network: distribution of the number of delayed vehicles at any arbitrary epoch.
# Formulated differently, we would like to see a table where you simulate for k = 0; 1; 2; : : :
# the fraction of time that exactly k vehicles are being delayed (consider it as being stuck
# in a traffic jam).
# Note that, in order to determine the second performance measure (number of
# delayed vehicles in the network), it actually matters how many vehicles are driving in the
# whole network. So now you need to add random vehicles in the network that drive between
# the highway junctions. This part does not have to be implemented very realistically. You
# may even assume that vehicles enter the network randomly at each of the nodes, travel one
# link, and then leave the network again. For these vehicles, no origin-destination routing is
# required. Only vehicles travelling from A to B have a fixed route. Our advice is to keep
# it simple: do not introduce too many model parameters, like number of vehicles per hour
# travelling on each link. You are allowed to assume that this rate is equal for all links.
graph_type = 'Highway'
system = run_simulation('Measure-2-vis',
seed=40,
end_time=1600,
stats_step_size=50,
graph_type=graph_type,
tow_truck_mode=False,
warm_up=100)
times_delayed_per_number_of_cars = system.final_statistics[
'time_spent_delayed_per_current_number_of_all_cars']
# print('Time spent per number of delayed cars', times_delayed_per_number_of_cars)
print('len', len(times_delayed_per_number_of_cars))
data = [(i, times_delayed_per_number_of_cars[i])
for i in range(len(times_delayed_per_number_of_cars))]
x, y, bin_width = group_into_bins(data)
print('x', x)
print('y', y)
print('len(y)', len(y))
min_non_zero_delayed_cars = 0
max_non_zero_delayed_cars = len(y) - 1
# comparison = 0
i = 0
while i < len(y) and y[i] == 0:
min_non_zero_delayed_cars += 1
i += 1
# i = x[i+1]
i = len(y) - 1
while i > 0 and y[i] == 0:
max_non_zero_delayed_cars -= 1
i -= 1
print('max_non_zero_delayed_cars', max_non_zero_delayed_cars)
print('min_non_zero_delayed_cars', min_non_zero_delayed_cars)
plt.xlabel('Numbers of delayed cars (with Tow Trucks)')
plt.ylabel('Fraction of time spent')
plt.xlim(x[min_non_zero_delayed_cars] - 1, x[max_non_zero_delayed_cars])
plt.bar(x, [j / sum(y) for j in y], width=bin_width * 0.8)
plt.show()
average_number_of_delayed_cars = []
# CI calculation
for i in range(run_size):
system = run_simulation('Measure-2' + str(i),
seed=i,
end_time=1600,
stats_step_size=50,
graph_type=graph_type,
tow_truck_mode=False,
warm_up=100)
print('Run -', i)
average_number_of_delayed_cars.append(
system.final_statistics['average_time_of_delay_of_all_cars'])
mean_number_of_delayed_cars = sum(average_number_of_delayed_cars) / len(
average_number_of_delayed_cars)
std_number_of_delayed_cars = std(average_number_of_delayed_cars)
print('Mean of Delayed Cars -', mean_number_of_delayed_cars)
print('Standard Deviation of Delayed Cars -', std_number_of_delayed_cars)
halfwidth_number_of_delayed_cars = ci(std_number_of_delayed_cars, run_size)
print('Halfwidth of Delayed Cars -', halfwidth_number_of_delayed_cars)
print('Range - ',
mean_number_of_delayed_cars - halfwidth_number_of_delayed_cars,
mean_number_of_delayed_cars + halfwidth_number_of_delayed_cars)
def test_run_simulation_for_t0_gives_t4():
assert run_simulation(t0, True, 4) == t4
def prev_timestep(self):
t_prev = int(self.TimeLabel.text()[2:]) - 1
t_prev = t_prev if t_prev > 0 else 0
state = self.reader.get_specific_timestep(t_prev - 1)
self._show(state)
state = self.reader.get_next_timestep()
self._show(state)
def stop(self):
self.stop_autoplay = True
def auto_play(self):
self.stop_autoplay = False
self.reader.reset()
for state in self.reader:
self._show(state)
sleep(0.5)
if self.stop_autoplay:
break
if __name__ == "__main__":
import sys
run_simulation()
app = QtWidgets.QApplication(sys.argv)
MainWindow = QtWidgets.QMainWindow()
ui = Ui_MainWindow()
ui.setupUi(MainWindow)
MainWindow.show()
sys.exit(app.exec_())
def test_second_example(self):
input_array = '80871224585914546619083218645595'
phases = 100
result_expected = '24176176'
result_actual = main.run_simulation(input_array, phases)[0:8]
self.assertEqual(result_actual, result_expected)
def perf_measure_1():
# 1. For individual vehicles: distribution of the travel time (mean, standard deviation, plot
# a histogram). Indicate which part of the travel time is caused by the delay. Present
# results on the number of incidents they encounter on average (again: mean, standard
# deviation, distribution).
# Travel time on the route between A to B
# Probability of minutes of time taken for the travel along the route. Ghost cars not necessary, or included.
graph_type = 'Highway'
system = run_simulation('Measure-1',
seed=30,
end_time=1600,
stats_step_size=50,
graph_type=graph_type,
tow_truck_mode=False,
warm_up=100)
travel_times_list = system.final_statistics['route_travel_times']
delay_times_list = system.final_statistics['route_delay_times']
number_delays_list = system.final_statistics['route_number_delays']
print('Travel Times List for Route Cars')
print(travel_times_list)
print(len(travel_times_list))
# Graph 1
rounded_travel_times_list = [round(i) for i in travel_times_list]
max_travel_time = max(rounded_travel_times_list)
counts_travel_times = Counter(rounded_travel_times_list)
list_of_times = []
print('Rounded Travel Times List', rounded_travel_times_list)
for i in range(int(max_travel_time) + 1):
list_of_times.append(counts_travel_times[i])
print(list_of_times) # Must be X-axis
print('Count of travel times -', list_of_times)
plot = plt.figure()
plt.ylabel('Probability')
plt.xlabel('Total Travel Time')
plt.xlim(50, max_travel_time)
plt.plot([i for i in range(len(list_of_times))],
[j / sum(list_of_times) for j in list_of_times])
plt.show()
# Graph 2
rounded_delay_times_list = [round(i) for i in delay_times_list]
max_delay_time = max(rounded_delay_times_list)
counts_delay_times = Counter(rounded_delay_times_list)
list_of_delay_times = []
print('Rounded Delay Times List', rounded_delay_times_list)
for i in range(1, int(max_delay_time) + 1):
list_of_delay_times.append(counts_delay_times[i])
print(list_of_delay_times) # Must be X-axis
print('Count of delay times -', list_of_delay_times)
plot = plt.figure()
plt.ylabel('Probability')
plt.xlabel('Total Delay Time')
plt.xlim(1, max_delay_time)
plt.plot([i for i in range(len(list_of_delay_times))],
[j / sum(list_of_delay_times) for j in list_of_delay_times])
plt.show()
# Graph 3
# Showing the distribution of the number of incidents in a single route travel
print(number_delays_list)
counts_number_delays = Counter(number_delays_list)
list_of_number_delays = []
for i in range(max(number_delays_list) + 1):
list_of_number_delays.append(counts_number_delays[i])
print('Counts of number of delays', list_of_number_delays)
plot = plt.figure()
plt.xlabel('Numbers of incidents')
plt.ylabel('Probability')
# plt.xlim(1, max_delay_time)
plt.bar([i for i in range(len(list_of_number_delays))],
[j / sum(list_of_number_delays) for j in list_of_number_delays])
plt.show()
# CI calculation
travel_times_list = []
delay_times_list = []
number_delays_list = []
for i in range(run_size):
system = run_simulation('Measure-1',
seed=None,
end_time=1600,
stats_step_size=50,
graph_type=graph_type,
tow_truck_mode=False,
warm_up=100)
travel_times_list += system.final_statistics['route_travel_times']
delay_times_list += system.final_statistics['route_delay_times']
number_delays_list += system.final_statistics['route_number_delays']
print('\n')
print('Number of Route Travel Times - ', len(travel_times_list))
mean_route_travel_time = sum(travel_times_list) / len(travel_times_list)
std_route_travel_time = std(travel_times_list)
print('Mean of Route Travel Time -', mean_route_travel_time)
print('Standard Deviation of Route Travel Time -', std_route_travel_time)
halfwidth_route_travel_time = ci(std_route_travel_time, run_size)
print('Halfwidth of Route Travel Time -', halfwidth_route_travel_time)
print('Range - ', mean_route_travel_time - halfwidth_route_travel_time,
mean_route_travel_time + halfwidth_route_travel_time)
# Also do CI calculation
print('\n')
print('Number of Delay Travel Times - ', len(delay_times_list))
mean_delay_time = sum(delay_times_list) / len(delay_times_list)
std_delay_time = std(delay_times_list)
print('Mean of Delay Travel Time -', mean_delay_time)
print('Standard Deviation of Delay Travel Time -', std_delay_time)
halfwidth_delay_time = ci(std_delay_time, run_size)
print('Halfwidth of Delay Travel Time -', halfwidth_delay_time)
print('Range - ', mean_delay_time - halfwidth_delay_time,
mean_delay_time + halfwidth_delay_time)
print('\n')
print('Number of Delays - ', len(number_delays_list))
mean_delay_number = sum(number_delays_list) / len(number_delays_list)
std_delay_number = std(number_delays_list)
print('Mean of Delay Travel Time -', mean_delay_number)
print('Standard Deviation of Delay Travel Time -', std_delay_number)
halfwidth_delay_number = ci(std_delay_number, run_size)
print('Halfwidth of Delay Travel Time -', halfwidth_delay_number)
print('Range - ', mean_delay_number - halfwidth_delay_number,
mean_delay_number + halfwidth_delay_number)
import main
print("Starting test 0!")
main.run_simulation('test0_FAST.json')
main.run_simulation('test0_RENO.json')
print("Starting test1!")
main.run_simulation('test1_FAST.json')
main.run_simulation('test1_RENO.json')
print("Starting test2!")
main.run_simulation('test2_FAST.json')
main.run_simulation('test2_RENO.json')
print("Starting test3!")
main.run_simulation('test3.json')
print("Starting test4!")
main.run_simulation('test4.json')
print("Starting test5!")
main.run_simulation('test5_FAST.json')
