From eaaa005b27210ada1cfde2079a4baa5fd47b28ca Mon Sep 17 00:00:00 2001 From: Lance Rogers Date: Fri, 12 Jun 2015 09:44:35 -0400 Subject: [PATCH 01/30] Getting started --- cars.py | 27 +++++++++++++++++++++++++++ road.py | 12 ++++++++++++ simulation.py | 4 ++++ 3 files changed, 43 insertions(+) create mode 100644 cars.py create mode 100644 road.py create mode 100644 simulation.py diff --git a/cars.py b/cars.py new file mode 100644 index 0000000..b3790fa --- /dev/null +++ b/cars.py @@ -0,0 +1,27 @@ +class Car: + + def __init__(self): + self.max_speed = 33 # speed in m / s + self.speed = 0 # m / s + self.length = 5 # in meters + pass + + def min_distance_between_car(self): + pass + + def speed_conversion(self): + pass + + def accelerate(self): + # accelerate 2 m/s \ + # increase speed + pass + + def current_location(self): + # cars location on road + pass + + def slow(self): + # cars have a 10% chance of randomly deselerating + pass + diff --git a/road.py b/road.py new file mode 100644 index 0000000..cb84192 --- /dev/null +++ b/road.py @@ -0,0 +1,12 @@ +class Road: + + def __init__(self): + self.length = 1 # length in km + pass + + @property + def length_m(self): + # converts length of road from km to meters + length_in_meters = self.length * 10**3 + return length_in_meters + diff --git a/simulation.py b/simulation.py new file mode 100644 index 0000000..de30352 --- /dev/null +++ b/simulation.py @@ -0,0 +1,4 @@ +class Sim: + + def __init__(self): + pass From 5730422bd759745c571fd0fc69fd7378348ef40e Mon Sep 17 00:00:00 2001 From: Lance Rogers Date: Fri, 12 Jun 2015 17:35:50 -0400 Subject: [PATCH 02/30] Figured out how to track location --- simulation.py | 27 +++++++++++++++++++++++++-- 1 file changed, 25 insertions(+), 2 deletions(-) diff --git a/simulation.py b/simulation.py index de30352..31ea11d 100644 --- a/simulation.py +++ b/simulation.py @@ -1,4 +1,27 @@ -class Sim: +from road import Road - def __init__(self): + +class Simulation: + + def __init__(self, road): + self.cars_count = 30 + self.road_state = road.road_state + + def cars_on_road(self): pass + + def loop(self): + # keep regenerating the road + pass + + + + + +road = Road() + +sim = Simulation(road) + +sim.road_state[456] = 1 + +print(sim.road_state) \ No newline at end of file From 78cc5bc223e95dc558bd5420480ae3b9be6ffa22 Mon Sep 17 00:00:00 2001 From: Lance Rogers Date: Fri, 12 Jun 2015 19:13:16 -0400 Subject: [PATCH 03/30] slowly coming along --- cars.py | 35 +++++++++++++++++++---------------- road.py | 22 +++++++++++++--------- simulation.py | 17 ++++++++++++++--- 3 files changed, 46 insertions(+), 28 deletions(-) diff --git a/cars.py b/cars.py index b3790fa..76f1a08 100644 --- a/cars.py +++ b/cars.py @@ -1,27 +1,30 @@ class Car: - def __init__(self): - self.max_speed = 33 # speed in m / s - self.speed = 0 # m / s - self.length = 5 # in meters - pass + def __init__(self, position, speed=0, length=5, max_speed=33 ): + self.max_speed = max_speed # speed in m / s + self.speed = speed # m / s + self.length = length # in meters + self.position = position def min_distance_between_car(self): + # location >= int(speed) in meters from car in front of it + # if another car is too close, car will match that cars speed + # pass - - def speed_conversion(self): - pass - def accelerate(self): - # accelerate 2 m/s \ + # accelerate 2 m/s # increase speed - pass - def current_location(self): - # cars location on road pass - def slow(self): - # cars have a 10% chance of randomly deselerating - pass + def decelerate(self): + self.speed = self.speed -2 + return self.speed + +car = Car(456) + +car.speed = 20 +car.decelerate() +car.decelerate() +print(car.position) \ No newline at end of file diff --git a/road.py b/road.py index cb84192..5bbe329 100644 --- a/road.py +++ b/road.py @@ -1,12 +1,16 @@ -class Road: +import numpy as np +from cars import Car +class Road: + # road is only one lane so their only needs to be a linear def __init__(self): - self.length = 1 # length in km - pass - - @property - def length_m(self): - # converts length of road from km to meters - length_in_meters = self.length * 10**3 - return length_in_meters + self.length = 1000 # length in meters + self.road_state = np.zeros(self.length, int) + + + + + + + diff --git a/simulation.py b/simulation.py index 31ea11d..9a4ba4b 100644 --- a/simulation.py +++ b/simulation.py @@ -1,17 +1,27 @@ from road import Road +# cars take a location argument randomly generate cars locations that are all 33 away from each other class Simulation: - def __init__(self, road): - self.cars_count = 30 + def __init__(self, road, cars_count=30): + self.cars_count = cars_count self.road_state = road.road_state + self.time = 3600 # time in seconds def cars_on_road(self): pass - def loop(self): + def update(self): + # while time is greater than zero continue # keep regenerating the road + # keep updating the road as the cards move + # you need a way to keep track of time (speed = index on road_state) + # meters(which are the index values of road_state) + pass + + def rand_slow(self): + # cars have a 10% chance of randomly slowing down by 2 m/s pass @@ -23,5 +33,6 @@ def loop(self): sim = Simulation(road) sim.road_state[456] = 1 +sim.road_state[454] = 1 print(sim.road_state) \ No newline at end of file From 5ccccf0ed79b039ac8f3cf11c6f3e119a10f587c Mon Sep 17 00:00:00 2001 From: Lance Rogers Date: Fri, 12 Jun 2015 20:00:38 -0400 Subject: [PATCH 04/30] slowly coming along --- cars.py | 21 ++++++++------------- simulation.py | 14 ++++++++++++-- 2 files changed, 20 insertions(+), 15 deletions(-) diff --git a/cars.py b/cars.py index 76f1a08..6e083b4 100644 --- a/cars.py +++ b/cars.py @@ -6,16 +6,11 @@ def __init__(self, position, speed=0, length=5, max_speed=33 ): self.length = length # in meters self.position = position - def min_distance_between_car(self): - # location >= int(speed) in meters from car in front of it - # if another car is too close, car will match that cars speed - # - pass + def accelerate(self): # accelerate 2 m/s - # increase speed - - pass + self.speed = self.speed + 2 + return self.speed def decelerate(self): self.speed = self.speed -2 @@ -23,8 +18,8 @@ def decelerate(self): car = Car(456) -car.speed = 20 - -car.decelerate() -car.decelerate() -print(car.position) \ No newline at end of file +car.speed=20 +car.accelerate() +car.accelerate() +car.accelerate() +print(car.speed) \ No newline at end of file diff --git a/simulation.py b/simulation.py index 9a4ba4b..752792b 100644 --- a/simulation.py +++ b/simulation.py @@ -1,15 +1,17 @@ from road import Road +from cars import Car -# cars take a location argument randomly generate cars locations that are all 33 away from each other +# cars take a position argument randomly generate cars locations that are all 33 away from each other class Simulation: def __init__(self, road, cars_count=30): self.cars_count = cars_count self.road_state = road.road_state + self.cars_on_road = [] # contains all the cars on the road self.time = 3600 # time in seconds - def cars_on_road(self): + def car_factory(self): pass def update(self): @@ -20,6 +22,14 @@ def update(self): # meters(which are the index values of road_state) pass + def min_distance_between_car(self): + # location >= int(speed) in meters from car in front of it + # if another car is too close, car will match that cars speed + min_distance = car.speed + car.position + if min_distance != 0: + pass + + def rand_slow(self): # cars have a 10% chance of randomly slowing down by 2 m/s pass From 9c4eb49c14c3192d025f415c6fc599ff3311ff89 Mon Sep 17 00:00:00 2001 From: Lance Rogers Date: Fri, 12 Jun 2015 20:05:08 -0400 Subject: [PATCH 05/30] slowly coming along --- cars.py | 9 ++++++--- road.py | 3 +-- simulation.py | 1 + 3 files changed, 8 insertions(+), 5 deletions(-) diff --git a/cars.py b/cars.py index 6e083b4..1cfeb35 100644 --- a/cars.py +++ b/cars.py @@ -6,7 +6,6 @@ def __init__(self, position, speed=0, length=5, max_speed=33 ): self.length = length # in meters self.position = position - def accelerate(self): # accelerate 2 m/s self.speed = self.speed + 2 @@ -16,10 +15,14 @@ def decelerate(self): self.speed = self.speed -2 return self.speed -car = Car(456) + + + + +car = Car(100) car.speed=20 car.accelerate() car.accelerate() car.accelerate() -print(car.speed) \ No newline at end of file +print(car.position) \ No newline at end of file diff --git a/road.py b/road.py index 5bbe329..e4573bd 100644 --- a/road.py +++ b/road.py @@ -1,8 +1,7 @@ import numpy as np -from cars import Car class Road: - # road is only one lane so their only needs to be a linear + # road is only one lane so there only needs to be a one dimensional array def __init__(self): self.length = 1000 # length in meters self.road_state = np.zeros(self.length, int) diff --git a/simulation.py b/simulation.py index 752792b..8b6b5f7 100644 --- a/simulation.py +++ b/simulation.py @@ -2,6 +2,7 @@ from cars import Car # cars take a position argument randomly generate cars locations that are all 33 away from each other +# simulation takes a road argument class Simulation: From efebb2b6ab3943d8b0efeea9f0a0be50a3325ad2 Mon Sep 17 00:00:00 2001 From: Lance Rogers Date: Fri, 12 Jun 2015 20:33:24 -0400 Subject: [PATCH 06/30] slowly coming along --- road.py | 4 ++-- simulation.py | 14 +++++++++----- 2 files changed, 11 insertions(+), 7 deletions(-) diff --git a/road.py b/road.py index e4573bd..547faf6 100644 --- a/road.py +++ b/road.py @@ -2,8 +2,8 @@ class Road: # road is only one lane so there only needs to be a one dimensional array - def __init__(self): - self.length = 1000 # length in meters + def __init__(self, length=1000): + self.length = length # length in meters self.road_state = np.zeros(self.length, int) diff --git a/simulation.py b/simulation.py index 8b6b5f7..f1bf383 100644 --- a/simulation.py +++ b/simulation.py @@ -1,5 +1,6 @@ from road import Road from cars import Car +import numpy as np # cars take a position argument randomly generate cars locations that are all 33 away from each other # simulation takes a road argument @@ -13,11 +14,15 @@ def __init__(self, road, cars_count=30): self.time = 3600 # time in seconds def car_factory(self): + # start_p = 0 + # add 33 to start_p for every car produced in a run + # for item in self.road_state: + # if item in pass def update(self): # while time is greater than zero continue - # keep regenerating the road + # keep regenerating the road with every generation of the road self.time -2 # keep updating the road as the cards move # you need a way to keep track of time (speed = index on road_state) # meters(which are the index values of road_state) @@ -38,12 +43,11 @@ def rand_slow(self): - road = Road() sim = Simulation(road) -sim.road_state[456] = 1 -sim.road_state[454] = 1 +car = Car(456) + -print(sim.road_state) \ No newline at end of file +print(car) \ No newline at end of file From f8097d22d661f5d9e4ddc7984ac28435d0160788 Mon Sep 17 00:00:00 2001 From: Lance Rogers Date: Sat, 13 Jun 2015 00:10:51 -0400 Subject: [PATCH 07/30] slowly coming along --- simulation.py | 19 ++++++++++--------- 1 file changed, 10 insertions(+), 9 deletions(-) diff --git a/simulation.py b/simulation.py index f1bf383..2308add 100644 --- a/simulation.py +++ b/simulation.py @@ -5,7 +5,7 @@ # cars take a position argument randomly generate cars locations that are all 33 away from each other # simulation takes a road argument -class Simulation: +class Sim: def __init__(self, road, cars_count=30): self.cars_count = cars_count @@ -28,13 +28,15 @@ def update(self): # meters(which are the index values of road_state) pass - def min_distance_between_car(self): + def min_distance_between_car(self, car): # location >= int(speed) in meters from car in front of it # if another car is too close, car will match that cars speed min_distance = car.speed + car.position - if min_distance != 0: - pass - + if self.road_state[car.position:min_distance] != 0: + car.decelerate() + elif self.road_state[car.position:min_distance] == 0: + car.accelerate() + return car.speed def rand_slow(self): # cars have a 10% chance of randomly slowing down by 2 m/s @@ -45,9 +47,8 @@ def rand_slow(self): road = Road() -sim = Simulation(road) +sim = Sim(road) car = Car(456) - - -print(car) \ No newline at end of file +sim.road_state[23:23 + 5] = 1 +print(sim.road_state) \ No newline at end of file From c7c664a37f65b7f6665198fb2e1fc094ff999387 Mon Sep 17 00:00:00 2001 From: Lance Rogers Date: Sat, 13 Jun 2015 00:58:46 -0400 Subject: [PATCH 08/30] done until the morning --- cars.py | 15 ++++++++------- 1 file changed, 8 insertions(+), 7 deletions(-) diff --git a/cars.py b/cars.py index 1cfeb35..a214e56 100644 --- a/cars.py +++ b/cars.py @@ -1,3 +1,5 @@ +import random + class Car: def __init__(self, position, speed=0, length=5, max_speed=33 ): @@ -12,17 +14,16 @@ def accelerate(self): return self.speed def decelerate(self): - self.speed = self.speed -2 + self.speed = self.speed - 2 return self.speed + def rand_slow(self): + # cars have a 10% chance of randomly slowing down by 2 m/s + if random.random() <= .1: + self.decelerate() + return self.speed -car = Car(100) -car.speed=20 -car.accelerate() -car.accelerate() -car.accelerate() -print(car.position) \ No newline at end of file From 640a7e0c2ac681ebd3a8c6024c530d876832acfc Mon Sep 17 00:00:00 2001 From: Lance Rogers Date: Sat, 13 Jun 2015 15:36:13 -0400 Subject: [PATCH 09/30] almost finished with simulation file --- simulation.py | 15 ++++++++------- 1 file changed, 8 insertions(+), 7 deletions(-) diff --git a/simulation.py b/simulation.py index 2308add..0c1418a 100644 --- a/simulation.py +++ b/simulation.py @@ -15,10 +15,13 @@ def __init__(self, road, cars_count=30): def car_factory(self): # start_p = 0 - # add 33 to start_p for every car produced in a run + # add 33 to start_position for every car produced in a run # for item in self.road_state: - # if item in - pass + init_location = 0 + for num in range(self.cars_count): + init_location = init_location + 33 + f_car = Car(init_location) # you need to pas in a position from road state + self.cars_on_road.append(f_car) def update(self): # while time is greater than zero continue @@ -26,7 +29,7 @@ def update(self): # keep updating the road as the cards move # you need a way to keep track of time (speed = index on road_state) # meters(which are the index values of road_state) - pass + def min_distance_between_car(self, car): # location >= int(speed) in meters from car in front of it @@ -38,9 +41,7 @@ def min_distance_between_car(self, car): car.accelerate() return car.speed - def rand_slow(self): - # cars have a 10% chance of randomly slowing down by 2 m/s - pass + From b059be2f6ab2fe55bb52b28498573630cd4c9497 Mon Sep 17 00:00:00 2001 From: Lance Rogers Date: Sat, 13 Jun 2015 16:55:59 -0400 Subject: [PATCH 10/30] commiting to have cars file with min_distance_function in it --- cars.py | 39 +++++++++++++++++++++++++++++++-------- 1 file changed, 31 insertions(+), 8 deletions(-) diff --git a/cars.py b/cars.py index a214e56..610802f 100644 --- a/cars.py +++ b/cars.py @@ -1,29 +1,52 @@ import random +from road import Road class Car: - def __init__(self, position, speed=0, length=5, max_speed=33 ): + def __init__(self, start_position, speed=0, length=5, max_speed=33, road=Road() ): self.max_speed = max_speed # speed in m / s self.speed = speed # m / s self.length = length # in meters - self.position = position + self.position = start_position + self.road = road def accelerate(self): # accelerate 2 m/s - self.speed = self.speed + 2 - return self.speed + if self.speed < self.max_speed: + self.speed = self.speed + 2 + def decelerate(self): - self.speed = self.speed - 2 - return self.speed + if self.speed > 1: + self.speed = self.speed - 2 def rand_slow(self): # cars have a 10% chance of randomly slowing down by 2 m/s - if random.random() <= .1: + if random.random() <= .1 and self.speed > 2: + self.decelerate() + + def move_car(self, position): + end_of_world = self.position + self.speed + if end_of_world <= self.road.length: + self.position = self.position + pass + + def min_distance_between_car(self): + # location >= int(speed) in meters from car in front of it + # if another car is too close, car will match that cars speed + min_distance = self.speed + self.position + if self.road.road_state[car.position:min_distance] != 0: self.decelerate() - return self.speed + elif self.road.road_state[car.position:min_distance] == 0: + self.accelerate() + + + + +car = Car(4) +print(car.position) \ No newline at end of file From 3d53b58c4b32fdb2e090072cd4640ca8aec3dd35 Mon Sep 17 00:00:00 2001 From: Lance Rogers Date: Sat, 13 Jun 2015 17:04:48 -0400 Subject: [PATCH 11/30] cars now has a move function --- cars.py | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/cars.py b/cars.py index 610802f..17b60d2 100644 --- a/cars.py +++ b/cars.py @@ -7,7 +7,8 @@ def __init__(self, start_position, speed=0, length=5, max_speed=33, road=Road() self.max_speed = max_speed # speed in m / s self.speed = speed # m / s self.length = length # in meters - self.position = start_position + self.start_position = start_position + self.position = self.start_position self.road = road def accelerate(self): @@ -29,8 +30,9 @@ def move_car(self, position): end_of_world = self.position + self.speed if end_of_world <= self.road.length: self.position = self.position - pass - + elif end_of_world >= self.road.length: + self.position = self.start_position + def min_distance_between_car(self): # location >= int(speed) in meters from car in front of it # if another car is too close, car will match that cars speed From f6cd30db87f69a24102783a762b2ac0e7e695335 Mon Sep 17 00:00:00 2001 From: Lance Rogers Date: Sat, 13 Jun 2015 21:07:20 -0400 Subject: [PATCH 12/30] almost have the simulation done --- cars.py | 29 ++++++++--------------------- simulation.py | 47 +++++++++++++++++++++++++++++------------------ 2 files changed, 37 insertions(+), 39 deletions(-) diff --git a/cars.py b/cars.py index 17b60d2..d9842a1 100644 --- a/cars.py +++ b/cars.py @@ -7,8 +7,7 @@ def __init__(self, start_position, speed=0, length=5, max_speed=33, road=Road() self.max_speed = max_speed # speed in m / s self.speed = speed # m / s self.length = length # in meters - self.start_position = start_position - self.position = self.start_position + self.position = start_position self.road = road def accelerate(self): @@ -16,9 +15,8 @@ def accelerate(self): if self.speed < self.max_speed: self.speed = self.speed + 2 - def decelerate(self): - if self.speed > 1: + if self.speed > 2: self.speed = self.speed - 2 def rand_slow(self): @@ -26,21 +24,12 @@ def rand_slow(self): if random.random() <= .1 and self.speed > 2: self.decelerate() - def move_car(self, position): - end_of_world = self.position + self.speed - if end_of_world <= self.road.length: - self.position = self.position - elif end_of_world >= self.road.length: - self.position = self.start_position - - def min_distance_between_car(self): - # location >= int(speed) in meters from car in front of it - # if another car is too close, car will match that cars speed - min_distance = self.speed + self.position - if self.road.road_state[car.position:min_distance] != 0: - self.decelerate() - elif self.road.road_state[car.position:min_distance] == 0: - self.accelerate() + def car_loop(self, position): + new_point = self.position + self.speed + if new_point <= self.road.length: + self.position = new_point + elif new_point >= self.road.length: + self.position = self.position - self.road.length @@ -49,6 +38,4 @@ def min_distance_between_car(self): -car = Car(4) -print(car.position) \ No newline at end of file diff --git a/simulation.py b/simulation.py index 0c1418a..d881e7d 100644 --- a/simulation.py +++ b/simulation.py @@ -1,8 +1,7 @@ from road import Road from cars import Car -import numpy as np -# cars take a position argument randomly generate cars locations that are all 33 away from each other +# cars take a position argument # simulation takes a road argument class Sim: @@ -14,42 +13,54 @@ def __init__(self, road, cars_count=30): self.time = 3600 # time in seconds def car_factory(self): - # start_p = 0 - # add 33 to start_position for every car produced in a run - # for item in self.road_state: + # * after initial code is finished come back here and design the simulation to + # * account for car length init_location = 0 for num in range(self.cars_count): init_location = init_location + 33 - f_car = Car(init_location) # you need to pas in a position from road state + f_car = Car(init_location) # you need to pass in a position from road state self.cars_on_road.append(f_car) - def update(self): - # while time is greater than zero continue - # keep regenerating the road with every generation of the road self.time -2 - # keep updating the road as the cards move - # you need a way to keep track of time (speed = index on road_state) - # meters(which are the index values of road_state) + def update_road_state(self): + # updates the current state of the road i.e.(changes the index position of cars from 0 to 1 + updated_state = self.road_state + for vehicle in self.cars_on_road: + updated_state[vehicle.position] = 1 + def update_speed(self): + # updates the vehicles on the roads speed + for vehicle in self.cars_on_road: + vehicle.speed = self.min_distance_between_car(vehicle) def min_distance_between_car(self, car): # location >= int(speed) in meters from car in front of it # if another car is too close, car will match that cars speed + car.car_loop(car.position) min_distance = car.speed + car.position if self.road_state[car.position:min_distance] != 0: car.decelerate() + car.rand_slow() elif self.road_state[car.position:min_distance] == 0: car.accelerate() - return car.speed + car.rand_slow() + def traffic(self): + self.update_road_state() + list_of_road_states + while self.time > 0: + self.update_road_state() + self. + self.time -= 1 + def main(self): + self.car_factory() + self.update_road_state() + pass + + -road = Road() -sim = Sim(road) -car = Car(456) -sim.road_state[23:23 + 5] = 1 -print(sim.road_state) \ No newline at end of file From 9e651f74243258d1158fe9a09a8b3509b16ef2b8 Mon Sep 17 00:00:00 2001 From: Lance Rogers Date: Sat, 13 Jun 2015 23:49:13 -0400 Subject: [PATCH 13/30] almost have the simulation done, still debugging..... --- simulation.py | 43 +++++++++++++++++++++++-------------------- 1 file changed, 23 insertions(+), 20 deletions(-) diff --git a/simulation.py b/simulation.py index d881e7d..7803f6f 100644 --- a/simulation.py +++ b/simulation.py @@ -6,7 +6,7 @@ class Sim: - def __init__(self, road, cars_count=30): + def __init__(self, road=Road(), cars_count=30): self.cars_count = cars_count self.road_state = road.road_state self.cars_on_road = [] # contains all the cars on the road @@ -29,38 +29,41 @@ def update_road_state(self): def update_speed(self): # updates the vehicles on the roads speed - for vehicle in self.cars_on_road: - vehicle.speed = self.min_distance_between_car(vehicle) + # bug is here fix it!!!!!!!! update speed cant use min_distance_between_car() + # I think update_speed() is unnecessary + for x in self.cars_on_road: x.speed = self.min_distance_between_car(x) - def min_distance_between_car(self, car): + def min_distance_between_car(self, object): # location >= int(speed) in meters from car in front of it # if another car is too close, car will match that cars speed - car.car_loop(car.position) - min_distance = car.speed + car.position - if self.road_state[car.position:min_distance] != 0: - car.decelerate() - car.rand_slow() - elif self.road_state[car.position:min_distance] == 0: - car.accelerate() - car.rand_slow() + min_distance = object.speed + object.position + if self.road_state[object.position:min_distance] != 0: + object.decelerate() + object.rand_slow() + object.car_loop() + elif self.road_state[object.position:min_distance] == 0: + object.accelerate() + object.rand_slow() + object.car_loop() def traffic(self): self.update_road_state() - list_of_road_states + list_of_road_states = [] while self.time > 0: + self.update_speed() self.update_road_state() - self. self.time -= 1 - - + list_of_road_states.append(self.road_state) + return list_of_road_states def main(self): self.car_factory() - self.update_road_state() - pass - - + self.traffic() +sim = Sim() +sim.car_factory() +x = [index.speed for index in sim.cars_on_road] +print(sim.traffic()) \ No newline at end of file From f26fc9b40e2b93787a17771c5ae545373770cee1 Mon Sep 17 00:00:00 2001 From: Lance Rogers Date: Sat, 13 Jun 2015 23:49:49 -0400 Subject: [PATCH 14/30] almost have the simulation done, still debugging..... --- cars.py | 14 +++++--------- 1 file changed, 5 insertions(+), 9 deletions(-) diff --git a/cars.py b/cars.py index d9842a1..f123445 100644 --- a/cars.py +++ b/cars.py @@ -3,9 +3,9 @@ class Car: - def __init__(self, start_position, speed=0, length=5, max_speed=33, road=Road() ): + def __init__(self, start_position, length=5, max_speed=33, road=Road() ): self.max_speed = max_speed # speed in m / s - self.speed = speed # m / s + self.speed = 0 # m / s self.length = length # in meters self.position = start_position self.road = road @@ -13,18 +13,18 @@ def __init__(self, start_position, speed=0, length=5, max_speed=33, road=Road() def accelerate(self): # accelerate 2 m/s if self.speed < self.max_speed: - self.speed = self.speed + 2 + self.speed += 2 def decelerate(self): if self.speed > 2: - self.speed = self.speed - 2 + self.speed -= 2 def rand_slow(self): # cars have a 10% chance of randomly slowing down by 2 m/s if random.random() <= .1 and self.speed > 2: self.decelerate() - def car_loop(self, position): + def car_loop(self): new_point = self.position + self.speed if new_point <= self.road.length: self.position = new_point @@ -35,7 +35,3 @@ def car_loop(self, position): - - - - From a18386016cb9eec24d5e6a8d3355b166f0761152 Mon Sep 17 00:00:00 2001 From: Lance Rogers Date: Sun, 14 Jun 2015 10:46:41 -0400 Subject: [PATCH 15/30] almost have the simulation done, still debugging..... --- cars.py | 7 +++++-- simulation.py | 29 ++++++++++++++++++----------- 2 files changed, 23 insertions(+), 13 deletions(-) diff --git a/cars.py b/cars.py index f123445..7da5c6f 100644 --- a/cars.py +++ b/cars.py @@ -14,22 +14,25 @@ def accelerate(self): # accelerate 2 m/s if self.speed < self.max_speed: self.speed += 2 + self.move() def decelerate(self): if self.speed > 2: self.speed -= 2 + self.move() def rand_slow(self): # cars have a 10% chance of randomly slowing down by 2 m/s if random.random() <= .1 and self.speed > 2: self.decelerate() + self.move() - def car_loop(self): + def move(self): new_point = self.position + self.speed if new_point <= self.road.length: self.position = new_point elif new_point >= self.road.length: - self.position = self.position - self.road.length + self.position = new_point - self.road.length diff --git a/simulation.py b/simulation.py index 7803f6f..308e708 100644 --- a/simulation.py +++ b/simulation.py @@ -11,6 +11,7 @@ def __init__(self, road=Road(), cars_count=30): self.road_state = road.road_state self.cars_on_road = [] # contains all the cars on the road self.time = 3600 # time in seconds + self.list_of_road_states = [] def car_factory(self): # * after initial code is finished come back here and design the simulation to @@ -26,35 +27,40 @@ def update_road_state(self): updated_state = self.road_state for vehicle in self.cars_on_road: updated_state[vehicle.position] = 1 + self.road_state = updated_state + return self.road_state def update_speed(self): # updates the vehicles on the roads speed # bug is here fix it!!!!!!!! update speed cant use min_distance_between_car() # I think update_speed() is unnecessary - for x in self.cars_on_road: x.speed = self.min_distance_between_car(x) + for car in self.cars_on_road: + self.min_distance_between_car(car) + def min_distance_between_car(self, object): # location >= int(speed) in meters from car in front of it # if another car is too close, car will match that cars speed min_distance = object.speed + object.position - if self.road_state[object.position:min_distance] != 0: + if self.road_state[object.position:min_distance] is not 0: object.decelerate() object.rand_slow() - object.car_loop() - elif self.road_state[object.position:min_distance] == 0: + elif self.road_state[object.position:min_distance] is 0 or object.speed < object.max_speed: object.accelerate() object.rand_slow() - object.car_loop() + return object + def traffic(self): self.update_road_state() - list_of_road_states = [] + while self.time > 0: - self.update_speed() self.update_road_state() + self.update_speed() self.time -= 1 - list_of_road_states.append(self.road_state) - return list_of_road_states + self.list_of_road_states.append(self.update_road_state()) + return self.list_of_road_states + def main(self): self.car_factory() @@ -63,7 +69,8 @@ def main(self): sim = Sim() sim.car_factory() -x = [index.speed for index in sim.cars_on_road] - +sim.traffic() +x = sim.cars_on_road +m = [a.position for a in x] print(sim.traffic()) \ No newline at end of file From f2e9000723d8b747b97ef2d101587c80d3782f22 Mon Sep 17 00:00:00 2001 From: Lance Rogers Date: Sun, 14 Jun 2015 10:48:21 -0400 Subject: [PATCH 16/30] the dubgging method may come in hand --- simulation.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/simulation.py b/simulation.py index 308e708..1a2a974 100644 --- a/simulation.py +++ b/simulation.py @@ -73,4 +73,4 @@ def main(self): x = sim.cars_on_road m = [a.position for a in x] -print(sim.traffic()) \ No newline at end of file +print(sim.list_of_road_states[1]) \ No newline at end of file From 735df974c148c8cee7160a271dc61a120ea0cec9 Mon Sep 17 00:00:00 2001 From: Lance Rogers Date: Sun, 14 Jun 2015 11:56:16 -0400 Subject: [PATCH 17/30] all files now work, now to figure out what data i need to keep track of and how to plot that data --- simulation.py | 17 ++++------------- 1 file changed, 4 insertions(+), 13 deletions(-) diff --git a/simulation.py b/simulation.py index 1a2a974..b2999d8 100644 --- a/simulation.py +++ b/simulation.py @@ -26,13 +26,12 @@ def update_road_state(self): # updates the current state of the road i.e.(changes the index position of cars from 0 to 1 updated_state = self.road_state for vehicle in self.cars_on_road: - updated_state[vehicle.position] = 1 + updated_state[vehicle.position:vehicle.position + vehicle.length] = 1 self.road_state = updated_state - return self.road_state + return self.road_state def update_speed(self): - # updates the vehicles on the roads speed - # bug is here fix it!!!!!!!! update speed cant use min_distance_between_car() + # updates the vehicles on the road's speed # I think update_speed() is unnecessary for car in self.cars_on_road: self.min_distance_between_car(car) @@ -59,18 +58,10 @@ def traffic(self): self.update_speed() self.time -= 1 self.list_of_road_states.append(self.update_road_state()) - return self.list_of_road_states + def main(self): self.car_factory() self.traffic() -sim = Sim() - -sim.car_factory() -sim.traffic() -x = sim.cars_on_road -m = [a.position for a in x] - -print(sim.list_of_road_states[1]) \ No newline at end of file From 62d52936b5187696954e2199c6c86dd43bbf630d Mon Sep 17 00:00:00 2001 From: Lance Rogers Date: Sun, 14 Jun 2015 12:30:34 -0400 Subject: [PATCH 18/30] all files now work, now to figure out what data i need to keep track of and how to plot that data --- cars.py | 7 +------ road.py | 10 +--------- simulation.py | 7 +------ 3 files changed, 3 insertions(+), 21 deletions(-) diff --git a/cars.py b/cars.py index 7da5c6f..5de0f9c 100644 --- a/cars.py +++ b/cars.py @@ -32,9 +32,4 @@ def move(self): if new_point <= self.road.length: self.position = new_point elif new_point >= self.road.length: - self.position = new_point - self.road.length - - - - - + self.position = new_point - self.road.length \ No newline at end of file diff --git a/road.py b/road.py index 547faf6..3a0f868 100644 --- a/road.py +++ b/road.py @@ -4,12 +4,4 @@ class Road: # road is only one lane so there only needs to be a one dimensional array def __init__(self, length=1000): self.length = length # length in meters - self.road_state = np.zeros(self.length, int) - - - - - - - - + self.road_state = np.zeros(self.length, int) \ No newline at end of file diff --git a/simulation.py b/simulation.py index b2999d8..5827245 100644 --- a/simulation.py +++ b/simulation.py @@ -36,7 +36,6 @@ def update_speed(self): for car in self.cars_on_road: self.min_distance_between_car(car) - def min_distance_between_car(self, object): # location >= int(speed) in meters from car in front of it # if another car is too close, car will match that cars speed @@ -49,7 +48,6 @@ def min_distance_between_car(self, object): object.rand_slow() return object - def traffic(self): self.update_road_state() @@ -59,9 +57,6 @@ def traffic(self): self.time -= 1 self.list_of_road_states.append(self.update_road_state()) - - def main(self): self.car_factory() - self.traffic() - + self.traffic() \ No newline at end of file From bd86d220fb6bb4ae45ae38fcadd969c3d5c9a845 Mon Sep 17 00:00:00 2001 From: Lance Rogers Date: Sun, 14 Jun 2015 14:25:19 -0400 Subject: [PATCH 19/30] so i have a working simulation and it generates a list of data points, as tuples. (speed, position) now time to figure out how to be able to correspond it to the time --- cars.py | 7 +++---- simulation.py | 44 +++++++++++++++++++------------------------- 2 files changed, 22 insertions(+), 29 deletions(-) diff --git a/cars.py b/cars.py index 5de0f9c..fd711e6 100644 --- a/cars.py +++ b/cars.py @@ -8,28 +8,27 @@ def __init__(self, start_position, length=5, max_speed=33, road=Road() ): self.speed = 0 # m / s self.length = length # in meters self.position = start_position + self.pre_pos = 0 self.road = road def accelerate(self): # accelerate 2 m/s if self.speed < self.max_speed: self.speed += 2 - self.move() def decelerate(self): if self.speed > 2: self.speed -= 2 - self.move() def rand_slow(self): # cars have a 10% chance of randomly slowing down by 2 m/s if random.random() <= .1 and self.speed > 2: self.decelerate() - self.move() def move(self): new_point = self.position + self.speed + self.pre_pos = self.position if new_point <= self.road.length: self.position = new_point elif new_point >= self.road.length: - self.position = new_point - self.road.length \ No newline at end of file + self.position = new_point - self.road.length diff --git a/simulation.py b/simulation.py index 5827245..e857f14 100644 --- a/simulation.py +++ b/simulation.py @@ -11,7 +11,7 @@ def __init__(self, road=Road(), cars_count=30): self.road_state = road.road_state self.cars_on_road = [] # contains all the cars on the road self.time = 3600 # time in seconds - self.list_of_road_states = [] + self.vehicle_data = [] def car_factory(self): # * after initial code is finished come back here and design the simulation to @@ -22,41 +22,35 @@ def car_factory(self): f_car = Car(init_location) # you need to pass in a position from road state self.cars_on_road.append(f_car) - def update_road_state(self): + def update(self, vehicle): # updates the current state of the road i.e.(changes the index position of cars from 0 to 1 - updated_state = self.road_state - for vehicle in self.cars_on_road: - updated_state[vehicle.position:vehicle.position + vehicle.length] = 1 - self.road_state = updated_state - return self.road_state - - def update_speed(self): - # updates the vehicles on the road's speed - # I think update_speed() is unnecessary - for car in self.cars_on_road: - self.min_distance_between_car(car) + self.road_state[vehicle.pre_pos:vehicle.pre_pos + vehicle.speed] = 0 + self.road_state[vehicle.position:vehicle.position + vehicle.length] = 1 + self.min_distance_between_car(vehicle) + def min_distance_between_car(self, object): # location >= int(speed) in meters from car in front of it # if another car is too close, car will match that cars speed min_distance = object.speed + object.position - if self.road_state[object.position:min_distance] is not 0: - object.decelerate() - object.rand_slow() - elif self.road_state[object.position:min_distance] is 0 or object.speed < object.max_speed: + if self.road_state[object.position:min_distance] is 0 or object.speed < object.max_speed: object.accelerate() - object.rand_slow() - return object + elif self.road_state[object.position:min_distance] is not 0: + object.decelerate() - def traffic(self): - self.update_road_state() + def traffic(self): while self.time > 0: - self.update_road_state() - self.update_speed() + for vehicle in self.cars_on_road: + self.vehicle_data.append((vehicle.speed, vehicle.position)) + vehicle.rand_slow() + self.min_distance_between_car(vehicle) + vehicle.move() + self.update(vehicle) self.time -= 1 - self.list_of_road_states.append(self.update_road_state()) def main(self): self.car_factory() - self.traffic() \ No newline at end of file + self.traffic() + + From 1a0e908d136306e5bfd1615f4cea306a0f9f12b3 Mon Sep 17 00:00:00 2001 From: Lance Rogers Date: Sun, 14 Jun 2015 14:29:53 -0400 Subject: [PATCH 20/30] now have the (speed, postion) tuples stored in a seperate list for each second --- simulation.py | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-) diff --git a/simulation.py b/simulation.py index e857f14..350ccd1 100644 --- a/simulation.py +++ b/simulation.py @@ -41,12 +41,14 @@ def min_distance_between_car(self, object): def traffic(self): while self.time > 0: + pre_data_list = [] for vehicle in self.cars_on_road: - self.vehicle_data.append((vehicle.speed, vehicle.position)) + pre_data_list.append((vehicle.speed, vehicle.position)) vehicle.rand_slow() self.min_distance_between_car(vehicle) vehicle.move() self.update(vehicle) + self.vehicle_data.append(pre_data_list) self.time -= 1 def main(self): @@ -54,3 +56,8 @@ def main(self): self.traffic() +sim = Sim() + +sim.main() + +print(sim.vehicle_data) \ No newline at end of file From 1d07c64c8e8aa0a20e76b5f355b94e00b4e120f7 Mon Sep 17 00:00:00 2001 From: Lance Rogers Date: Sun, 14 Jun 2015 14:30:57 -0400 Subject: [PATCH 21/30] now have the (speed, postion) tuples stored in a seperate list for each second. Time to start ipython notebook. --- simulation.py | 6 ------ 1 file changed, 6 deletions(-) diff --git a/simulation.py b/simulation.py index 350ccd1..361f4ef 100644 --- a/simulation.py +++ b/simulation.py @@ -55,9 +55,3 @@ def main(self): self.car_factory() self.traffic() - -sim = Sim() - -sim.main() - -print(sim.vehicle_data) \ No newline at end of file From daa219aa969a9761a78092a68b59cadfac095c0b Mon Sep 17 00:00:00 2001 From: Lance Rogers Date: Sun, 14 Jun 2015 17:02:39 -0400 Subject: [PATCH 22/30] added collisions function --- simulation.py | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/simulation.py b/simulation.py index 361f4ef..fa8bdf1 100644 --- a/simulation.py +++ b/simulation.py @@ -12,6 +12,7 @@ def __init__(self, road=Road(), cars_count=30): self.cars_on_road = [] # contains all the cars on the road self.time = 3600 # time in seconds self.vehicle_data = [] + self.collisions = 0 def car_factory(self): # * after initial code is finished come back here and design the simulation to @@ -51,6 +52,14 @@ def traffic(self): self.vehicle_data.append(pre_data_list) self.time -= 1 + + def collisions(self): + for i in self.vehicle_data: + for index in i: + if index.count(1) > 1: + self.collisions += 1 + + def main(self): self.car_factory() self.traffic() From 5fbdafd55846e5feaeaa80dba3af71693aa03a2b Mon Sep 17 00:00:00 2001 From: Lance Rogers Date: Sun, 14 Jun 2015 17:34:45 -0400 Subject: [PATCH 23/30] working on my graph --- .idea/.name | 1 + .idea/misc.xml | 14 + .idea/modules.xml | 8 + .idea/traffic-simulation.iml | 16 + .idea/vcs.xml | 6 + .idea/workspace.xml | 696 ++++++++++++++++++ .../Traffic Simulation Plots-checkpoint.ipynb | 6 + Traffic Simulation Plots.ipynb | 94 +++ simulation.py | 20 +- 9 files changed, 845 insertions(+), 16 deletions(-) create mode 100644 .idea/.name create mode 100644 .idea/misc.xml create mode 100644 .idea/modules.xml create mode 100644 .idea/traffic-simulation.iml create mode 100644 .idea/vcs.xml create mode 100644 .idea/workspace.xml create mode 100644 .ipynb_checkpoints/Traffic Simulation Plots-checkpoint.ipynb create mode 100644 Traffic Simulation Plots.ipynb diff --git a/.idea/.name b/.idea/.name new file mode 100644 index 0000000..9b1c5e1 --- /dev/null +++ b/.idea/.name @@ -0,0 +1 @@ +traffic-simulation \ No newline at end of file diff --git a/.idea/misc.xml b/.idea/misc.xml new file mode 100644 index 0000000..21109db --- /dev/null +++ b/.idea/misc.xml @@ -0,0 +1,14 @@ + + + + + + + + + + + + + + \ No newline at end of file diff --git a/.idea/modules.xml b/.idea/modules.xml new file mode 100644 index 0000000..25ff64a --- /dev/null +++ b/.idea/modules.xml @@ -0,0 +1,8 @@ + + + + + + + + \ No newline at end of file diff --git a/.idea/traffic-simulation.iml b/.idea/traffic-simulation.iml new file mode 100644 index 0000000..dddbc23 --- /dev/null +++ b/.idea/traffic-simulation.iml @@ -0,0 +1,16 @@ + + + + + + + + + + + \ No newline at end of file diff --git a/.idea/vcs.xml b/.idea/vcs.xml new file mode 100644 index 0000000..94a25f7 --- /dev/null +++ b/.idea/vcs.xml @@ -0,0 +1,6 @@ + + + + + + \ No newline at end of file diff --git a/.idea/workspace.xml b/.idea/workspace.xml new file mode 100644 index 0000000..060794d --- /dev/null +++ b/.idea/workspace.xml @@ -0,0 +1,696 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + true + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + true + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1434113433382 + + + 1434116675477 + + + 1434144950039 + + + 1434150796784 + + + 1434153638242 + + + 1434153908682 + + + 1434155604866 + + + 1434168651393 + + + 1434171526488 + + + 1434224173455 + + + 1434228959580 + + + 1434229488350 + + + 1434244040194 + + + 1434253753084 + + + 1434253789888 + + + 1434293201706 + + + 1434293301916 + + + 1434297376282 + + + 1434299434223 + + + 1434306319512 + + + 1434306593213 + + + 1434306657915 + + + 1434315759989 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/.ipynb_checkpoints/Traffic Simulation Plots-checkpoint.ipynb b/.ipynb_checkpoints/Traffic Simulation Plots-checkpoint.ipynb new file mode 100644 index 0000000..286dcb3 --- /dev/null +++ b/.ipynb_checkpoints/Traffic Simulation Plots-checkpoint.ipynb @@ -0,0 +1,6 @@ +{ + "cells": [], + "metadata": {}, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/Traffic Simulation Plots.ipynb b/Traffic Simulation Plots.ipynb new file mode 100644 index 0000000..4c340ee --- /dev/null +++ b/Traffic Simulation Plots.ipynb @@ -0,0 +1,94 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "import random\n", + "import math\n", + "import statistics\n", + "import matplotlib.pyplot as plt\n", + "from simulation import Sim\n", + "from itertools import count" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "%matplotlib inline" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "sim = Sim()\n", + "sim.main()\n", + "\n", + "data = sim.vehicle_data\n", + "crashs = [x for x in data if x.count(1) > 1]\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "\n", + "x = [x for x,y in data ]\n", + "y = [y for x, y]\n", + "colors = blue\n", + "\n", + "\n", + "plt.scatter(x, y, s=1, c=colors, alpha=0.5)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.4.2" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/simulation.py b/simulation.py index fa8bdf1..74fbf1a 100644 --- a/simulation.py +++ b/simulation.py @@ -22,14 +22,13 @@ def car_factory(self): init_location = init_location + 33 f_car = Car(init_location) # you need to pass in a position from road state self.cars_on_road.append(f_car) - + def update(self, vehicle): # updates the current state of the road i.e.(changes the index position of cars from 0 to 1 self.road_state[vehicle.pre_pos:vehicle.pre_pos + vehicle.speed] = 0 self.road_state[vehicle.position:vehicle.position + vehicle.length] = 1 self.min_distance_between_car(vehicle) - - + def min_distance_between_car(self, object): # location >= int(speed) in meters from car in front of it # if another car is too close, car will match that cars speed @@ -39,27 +38,16 @@ def min_distance_between_car(self, object): elif self.road_state[object.position:min_distance] is not 0: object.decelerate() - def traffic(self): while self.time > 0: - pre_data_list = [] for vehicle in self.cars_on_road: - pre_data_list.append((vehicle.speed, vehicle.position)) + self.vehicle_data.append((vehicle.speed, vehicle.position)) vehicle.rand_slow() self.min_distance_between_car(vehicle) vehicle.move() self.update(vehicle) - self.vehicle_data.append(pre_data_list) self.time -= 1 - - - def collisions(self): - for i in self.vehicle_data: - for index in i: - if index.count(1) > 1: - self.collisions += 1 - - + def main(self): self.car_factory() self.traffic() From 1c60337d95eccff7240aa3e479bb2e9797b40137 Mon Sep 17 00:00:00 2001 From: Lance Rogers Date: Sun, 14 Jun 2015 19:33:10 -0400 Subject: [PATCH 24/30] .....eh --- .../Traffic Simulation Plots-checkpoint.ipynb | 104 +++++++++++++++++- Traffic Simulation Plots.ipynb | 55 ++++++--- simulation.py | 7 +- 3 files changed, 150 insertions(+), 16 deletions(-) diff --git a/.ipynb_checkpoints/Traffic Simulation Plots-checkpoint.ipynb b/.ipynb_checkpoints/Traffic Simulation Plots-checkpoint.ipynb index 286dcb3..7f0f80a 100644 --- a/.ipynb_checkpoints/Traffic Simulation Plots-checkpoint.ipynb +++ b/.ipynb_checkpoints/Traffic Simulation Plots-checkpoint.ipynb @@ -1,6 +1,106 @@ { - "cells": [], - "metadata": {}, + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "import random\n", + "import math\n", + "import statistics\n", + "import matplotlib.pyplot as plt\n", + "from simulation import Sim\n", + "from itertools import count" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "%matplotlib inline" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "meta_data = [Sim().main() for _ in range(200)]\n", + "def annoy(meta_data):\n", + " x_list = []\n", + " y_list = []\n", + " for data in meta_data: \n", + " x_list = x_list + [x for x,y in data]\n", + " y_list = y_list + [y for x,y in data]\n", + " return x_list, y_list\n", + "x, y = annoy(meta_data)\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXkAAAEACAYAAABWLgY0AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nRK5CYII=\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "plt.scatter(x, y, s=1, c=\"blue\", alpha=0.5)\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.4.2" + } + }, "nbformat": 4, "nbformat_minor": 0 } diff --git a/Traffic Simulation Plots.ipynb b/Traffic Simulation Plots.ipynb index 4c340ee..aa2c734 100644 --- a/Traffic Simulation Plots.ipynb +++ b/Traffic Simulation Plots.ipynb @@ -29,34 +29,63 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 7, "metadata": { "collapsed": false }, - "outputs": [], + "outputs": [ + { + "ename": "KeyboardInterrupt", + "evalue": "", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mmeta_data\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0mSim\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmain\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0m_\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m200\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 2\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mannoy\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmeta_data\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[0mx_list\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[0my_list\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mdata\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mmeta_data\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m(.0)\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mmeta_data\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0mSim\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmain\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0m_\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m200\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 2\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mannoy\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmeta_data\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[0mx_list\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[0my_list\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mdata\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mmeta_data\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/Users/lancerogers/homework/traffic_simulation/traffic-simulation/simulation.py\u001b[0m in \u001b[0;36mmain\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 55\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 56\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcar_factory\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 57\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtraffic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 58\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvehicle_data\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 59\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/Users/lancerogers/homework/traffic_simulation/traffic-simulation/simulation.py\u001b[0m in \u001b[0;36mtraffic\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 47\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmin_distance_between_car\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mvehicle\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 48\u001b[0m \u001b[0mvehicle\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmove\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 49\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mupdate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mvehicle\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 50\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtick\u001b[0m \u001b[0;34m+=\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 51\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtime\u001b[0m \u001b[0;34m-=\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/Users/lancerogers/homework/traffic_simulation/traffic-simulation/simulation.py\u001b[0m in \u001b[0;36mupdate\u001b[0;34m(self, vehicle)\u001b[0m\n\u001b[1;32m 27\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mupdate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvehicle\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 28\u001b[0m \u001b[0;31m# updates the current state of the road i.e.(changes the index position of cars from 0 to 1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 29\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mroad_state\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mvehicle\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpre_pos\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0mvehicle\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpre_pos\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mvehicle\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mspeed\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 30\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mroad_state\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mvehicle\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mposition\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0mvehicle\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mposition\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mvehicle\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlength\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 31\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmin_distance_between_car\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mvehicle\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mKeyboardInterrupt\u001b[0m: " + ] + } + ], "source": [ - "sim = Sim()\n", - "sim.main()\n", + "meta_data = [Sim().main() for _ in range(200)]\n", + "def annoy(meta_data):\n", + " x_list = []\n", + " y_list = []\n", + " for data in meta_data: \n", + " x_list = x_list + [x for x,y in data]\n", + " y_list = y_list + [y for x,y in data]\n", + " return x_list, y_list\n", + "x, y = annoy(meta_data)\n", "\n", - "data = sim.vehicle_data\n", - "crashs = [x for x in data if x.count(1) > 1]\n" + "print(x)" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "metadata": { "collapsed": false }, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXkAAAEACAYAAABWLgY0AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nRK5CYII=\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "\n", - "x = [x for x,y in data ]\n", - "y = [y for x, y]\n", - "colors = blue\n", - "\n", + "plt.scatter(x, y, s=1, c=\"blue\", alpha=0.5)\n", "\n", - "plt.scatter(x, y, s=1, c=colors, alpha=0.5)\n", "plt.show()" ] }, diff --git a/simulation.py b/simulation.py index 74fbf1a..3af8942 100644 --- a/simulation.py +++ b/simulation.py @@ -11,6 +11,7 @@ def __init__(self, road=Road(), cars_count=30): self.road_state = road.road_state self.cars_on_road = [] # contains all the cars on the road self.time = 3600 # time in seconds + self.tick = 1 self.vehicle_data = [] self.collisions = 0 @@ -41,14 +42,18 @@ def min_distance_between_car(self, object): def traffic(self): while self.time > 0: for vehicle in self.cars_on_road: - self.vehicle_data.append((vehicle.speed, vehicle.position)) + self.vehicle_data.append((vehicle.position, vehicle.speed)) vehicle.rand_slow() self.min_distance_between_car(vehicle) vehicle.move() self.update(vehicle) + self.tick += 1 self.time -= 1 + + def main(self): self.car_factory() self.traffic() + return self.vehicle_data From 2313c8907cef733eab2f6c6d776b04ec9fba0da6 Mon Sep 17 00:00:00 2001 From: Lance Rogers Date: Sun, 14 Jun 2015 20:03:51 -0400 Subject: [PATCH 25/30] I think I got something --- .../Traffic Simulation Plots-checkpoint.ipynb | 28 +++++++---- Traffic Simulation Plots.ipynb | 49 ++++++++----------- simulation.py | 5 +- 3 files changed, 41 insertions(+), 41 deletions(-) diff --git a/.ipynb_checkpoints/Traffic Simulation Plots-checkpoint.ipynb b/.ipynb_checkpoints/Traffic Simulation Plots-checkpoint.ipynb index 7f0f80a..3b2d123 100644 --- a/.ipynb_checkpoints/Traffic Simulation Plots-checkpoint.ipynb +++ b/.ipynb_checkpoints/Traffic Simulation Plots-checkpoint.ipynb @@ -2,15 +2,13 @@ "cells": [ { "cell_type": "code", - "execution_count": 1, + "execution_count": 11, "metadata": { "collapsed": true }, "outputs": [], "source": [ "import random\n", - "import math\n", - "import statistics\n", "import matplotlib.pyplot as plt\n", "from simulation import Sim\n", "from itertools import count" @@ -18,7 +16,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 12, "metadata": { "collapsed": true }, @@ -29,13 +27,13 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 13, "metadata": { "collapsed": false }, "outputs": [], "source": [ - "meta_data = [Sim().main() for _ in range(200)]\n", + "meta_data = [Sim().main() for _ in range(1000)]\n", "def annoy(meta_data):\n", " x_list = []\n", " y_list = []\n", @@ -49,16 +47,16 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 15, "metadata": { "collapsed": false }, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXkAAAEACAYAAABWLgY0AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nRK5CYII=\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZEAAAEZCAYAAABWwhjiAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nOJVxI+I4juNUxo2I4ziOU5n/D/+Kuj4q/AMgAAAAAElFTkSuQmCC\n", "text/plain": [ - "" + "" ] }, "metadata": {}, @@ -66,12 +64,22 @@ } ], "source": [ - "\n", + "plt.xlabel(\"Speed * 10^1 in m/s\")\n", + "plt.ylabel(\"Distance\")\n", + "plt.title(\"Traffic Flow on 1 km Road\")\n", "plt.scatter(x, y, s=1, c=\"blue\", alpha=0.5)\n", "\n", "plt.show()" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Findings\n", + "#### By looking at the data, I have come to the conclussion that the optimal speed limit for this road is between 72 kmh and 80 kmh." + ] + }, { "cell_type": "code", "execution_count": null, diff --git a/Traffic Simulation Plots.ipynb b/Traffic Simulation Plots.ipynb index aa2c734..3b2d123 100644 --- a/Traffic Simulation Plots.ipynb +++ b/Traffic Simulation Plots.ipynb @@ -2,15 +2,13 @@ "cells": [ { "cell_type": "code", - "execution_count": 1, + "execution_count": 11, "metadata": { "collapsed": true }, "outputs": [], "source": [ "import random\n", - "import math\n", - "import statistics\n", "import matplotlib.pyplot as plt\n", "from simulation import Sim\n", "from itertools import count" @@ -18,7 +16,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 12, "metadata": { "collapsed": true }, @@ -29,29 +27,13 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 13, "metadata": { "collapsed": false }, - "outputs": [ - { - "ename": "KeyboardInterrupt", - "evalue": "", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mmeta_data\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0mSim\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmain\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0m_\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m200\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 2\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mannoy\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmeta_data\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[0mx_list\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[0my_list\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mdata\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mmeta_data\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m(.0)\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mmeta_data\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0mSim\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmain\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0m_\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m200\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 2\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mannoy\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmeta_data\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[0mx_list\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[0my_list\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mdata\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mmeta_data\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/Users/lancerogers/homework/traffic_simulation/traffic-simulation/simulation.py\u001b[0m in \u001b[0;36mmain\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 55\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 56\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcar_factory\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 57\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtraffic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 58\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvehicle_data\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 59\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/Users/lancerogers/homework/traffic_simulation/traffic-simulation/simulation.py\u001b[0m in \u001b[0;36mtraffic\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 47\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmin_distance_between_car\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mvehicle\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 48\u001b[0m \u001b[0mvehicle\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmove\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 49\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mupdate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mvehicle\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 50\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtick\u001b[0m \u001b[0;34m+=\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 51\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtime\u001b[0m \u001b[0;34m-=\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/Users/lancerogers/homework/traffic_simulation/traffic-simulation/simulation.py\u001b[0m in \u001b[0;36mupdate\u001b[0;34m(self, vehicle)\u001b[0m\n\u001b[1;32m 27\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mupdate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvehicle\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 28\u001b[0m \u001b[0;31m# updates the current state of the road i.e.(changes the index position of cars from 0 to 1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 29\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mroad_state\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mvehicle\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpre_pos\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0mvehicle\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpre_pos\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mvehicle\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mspeed\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 30\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mroad_state\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mvehicle\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mposition\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0mvehicle\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mposition\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mvehicle\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlength\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 31\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmin_distance_between_car\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mvehicle\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;31mKeyboardInterrupt\u001b[0m: " - ] - } - ], + "outputs": [], "source": [ - "meta_data = [Sim().main() for _ in range(200)]\n", + "meta_data = [Sim().main() for _ in range(1000)]\n", "def annoy(meta_data):\n", " x_list = []\n", " y_list = []\n", @@ -60,22 +42,21 @@ " y_list = y_list + [y for x,y in data]\n", " return x_list, y_list\n", "x, y = annoy(meta_data)\n", - "\n", - "print(x)" + "\n" ] }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 15, "metadata": { "collapsed": false }, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXkAAAEACAYAAABWLgY0AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nRK5CYII=\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZEAAAEZCAYAAABWwhjiAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nOJVxI+I4juNUxo2I4ziOU5n/D/+Kuj4q/AMgAAAAAElFTkSuQmCC\n", "text/plain": [ - "" + "" ] }, "metadata": {}, @@ -83,12 +64,22 @@ } ], "source": [ - "\n", + "plt.xlabel(\"Speed * 10^1 in m/s\")\n", + "plt.ylabel(\"Distance\")\n", + "plt.title(\"Traffic Flow on 1 km Road\")\n", "plt.scatter(x, y, s=1, c=\"blue\", alpha=0.5)\n", "\n", "plt.show()" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Findings\n", + "#### By looking at the data, I have come to the conclussion that the optimal speed limit for this road is between 72 kmh and 80 kmh." + ] + }, { "cell_type": "code", "execution_count": null, diff --git a/simulation.py b/simulation.py index 3af8942..1ba6c33 100644 --- a/simulation.py +++ b/simulation.py @@ -10,7 +10,7 @@ def __init__(self, road=Road(), cars_count=30): self.cars_count = cars_count self.road_state = road.road_state self.cars_on_road = [] # contains all the cars on the road - self.time = 3600 # time in seconds + self.time = 60 # time in seconds self.tick = 1 self.vehicle_data = [] self.collisions = 0 @@ -22,6 +22,7 @@ def car_factory(self): for num in range(self.cars_count): init_location = init_location + 33 f_car = Car(init_location) # you need to pass in a position from road state + f_car.rand_slow() self.cars_on_road.append(f_car) def update(self, vehicle): @@ -42,7 +43,7 @@ def min_distance_between_car(self, object): def traffic(self): while self.time > 0: for vehicle in self.cars_on_road: - self.vehicle_data.append((vehicle.position, vehicle.speed)) + self.vehicle_data.append((vehicle.speed / self.tick, vehicle.position )) vehicle.rand_slow() self.min_distance_between_car(vehicle) vehicle.move() From f1bc2fbbe43dfb310a6dcdc03591f6e5bc4bfef4 Mon Sep 17 00:00:00 2001 From: Lance Rogers Date: Sun, 14 Jun 2015 21:44:31 -0400 Subject: [PATCH 26/30] I think this passes the requirments of normal --- .../Traffic Simulation Plots-checkpoint.ipynb | 12 ++++++------ Traffic Simulation Plots.ipynb | 12 ++++++------ 2 files changed, 12 insertions(+), 12 deletions(-) diff --git a/.ipynb_checkpoints/Traffic Simulation Plots-checkpoint.ipynb b/.ipynb_checkpoints/Traffic Simulation Plots-checkpoint.ipynb index 3b2d123..a92d776 100644 --- a/.ipynb_checkpoints/Traffic Simulation Plots-checkpoint.ipynb +++ b/.ipynb_checkpoints/Traffic Simulation Plots-checkpoint.ipynb @@ -27,13 +27,13 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 16, "metadata": { "collapsed": false }, "outputs": [], "source": [ - "meta_data = [Sim().main() for _ in range(1000)]\n", + "meta_data = [Sim().main() for _ in range(10000)]\n", "def annoy(meta_data):\n", " x_list = []\n", " y_list = []\n", @@ -47,16 +47,16 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 17, "metadata": { "collapsed": false }, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZEAAAEZCAYAAABWwhjiAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nOJVxI+I4juNUxo2I4ziOU5n/D/+Kuj4q/AMgAAAAAElFTkSuQmCC\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZEAAAEZCAYAAABWwhjiAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", "text/plain": [ - "" + "" ] }, "metadata": {}, @@ -77,7 +77,7 @@ "metadata": {}, "source": [ "## Findings\n", - "#### By looking at the data, I have come to the conclussion that the optimal speed limit for this road is between 72 kmh and 80 kmh." + "#### By looking at the data, I have come to the conclussion that the optimal speed limit for this road is between 72 kmh and 80 kmh. In normal mode" ] }, { diff --git a/Traffic Simulation Plots.ipynb b/Traffic Simulation Plots.ipynb index 3b2d123..a92d776 100644 --- a/Traffic Simulation Plots.ipynb +++ b/Traffic Simulation Plots.ipynb @@ -27,13 +27,13 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 16, "metadata": { "collapsed": false }, "outputs": [], "source": [ - "meta_data = [Sim().main() for _ in range(1000)]\n", + "meta_data = [Sim().main() for _ in range(10000)]\n", "def annoy(meta_data):\n", " x_list = []\n", " y_list = []\n", @@ -47,16 +47,16 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 17, "metadata": { "collapsed": false }, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZEAAAEZCAYAAABWwhjiAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nOJVxI+I4juNUxo2I4ziOU5n/D/+Kuj4q/AMgAAAAAElFTkSuQmCC\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZEAAAEZCAYAAABWwhjiAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", "text/plain": [ - "" + "" ] }, "metadata": {}, @@ -77,7 +77,7 @@ "metadata": {}, "source": [ "## Findings\n", - "#### By looking at the data, I have come to the conclussion that the optimal speed limit for this road is between 72 kmh and 80 kmh." + "#### By looking at the data, I have come to the conclussion that the optimal speed limit for this road is between 72 kmh and 80 kmh. In normal mode" ] }, { From 72ed5f23e24704ff2f870fe49570af47263271a0 Mon Sep 17 00:00:00 2001 From: Lance Rogers Date: Mon, 15 Jun 2015 13:43:27 -0400 Subject: [PATCH 27/30] I now have the simulation adjusting for speed of values in front, I think... Also the graph is for distance and time. --- .idea/workspace.xml | 65 ++++++++++++++----- .../Traffic Simulation Plots-checkpoint.ipynb | 46 ++++++++----- Traffic Simulation Plots.ipynb | 46 ++++++++----- cars.py | 1 + simulation.py | 16 ++++- 5 files changed, 121 insertions(+), 53 deletions(-) diff --git a/.idea/workspace.xml b/.idea/workspace.xml index 060794d..d208571 100644 --- a/.idea/workspace.xml +++ b/.idea/workspace.xml @@ -1,7 +1,11 @@ - + + + + + @@ -44,8 +48,8 @@ - - + + @@ -87,10 +91,9 @@ - @@ -519,29 +522,29 @@ - - + + - - + - + - + + - - + + @@ -561,9 +564,9 @@ - - + + @@ -636,6 +639,34 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -684,8 +715,8 @@ - - + + diff --git a/.ipynb_checkpoints/Traffic Simulation Plots-checkpoint.ipynb b/.ipynb_checkpoints/Traffic Simulation Plots-checkpoint.ipynb index a92d776..fbae210 100644 --- a/.ipynb_checkpoints/Traffic Simulation Plots-checkpoint.ipynb +++ b/.ipynb_checkpoints/Traffic Simulation Plots-checkpoint.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 11, + "execution_count": 1, "metadata": { "collapsed": true }, @@ -16,7 +16,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 2, "metadata": { "collapsed": true }, @@ -27,13 +27,13 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 3, "metadata": { "collapsed": false }, "outputs": [], "source": [ - "meta_data = [Sim().main() for _ in range(10000)]\n", + "meta_data = [Sim().main() for _ in range(1)]\n", "def annoy(meta_data):\n", " x_list = []\n", " y_list = []\n", @@ -42,21 +42,23 @@ " y_list = y_list + [y for x,y in data]\n", " return x_list, y_list\n", "x, y = annoy(meta_data)\n", + "#sim = Sim()\n", + "\n", "\n" ] }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 4, "metadata": { "collapsed": false }, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZEAAAEZCAYAAABWwhjiAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAY8AAAEZCAYAAABvpam5AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nVx6O4zhONK48HMdxnGhceTiO4zjR/H8Quv0jtFfepgAAAABJRU5ErkJggg==\n", "text/plain": [ - "" + "" ] }, "metadata": {}, @@ -64,21 +66,31 @@ } ], "source": [ - "plt.xlabel(\"Speed * 10^1 in m/s\")\n", - "plt.ylabel(\"Distance\")\n", + "plt.xlabel(\"Time in Seconds\")\n", + "plt.ylabel(\"Locations\")\n", "plt.title(\"Traffic Flow on 1 km Road\")\n", - "plt.scatter(x, y, s=1, c=\"blue\", alpha=0.5)\n", + "plt.scatter(x, y, s=1, c=\"red\", marker=\"|\")\n", "\n", - "plt.show()" + "plt.show() " ] }, { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Findings\n", - "#### By looking at the data, I have come to the conclussion that the optimal speed limit for this road is between 72 kmh and 80 kmh. In normal mode" - ] + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [] }, { "cell_type": "code", diff --git a/Traffic Simulation Plots.ipynb b/Traffic Simulation Plots.ipynb index a92d776..fbae210 100644 --- a/Traffic Simulation Plots.ipynb +++ b/Traffic Simulation Plots.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 11, + "execution_count": 1, "metadata": { "collapsed": true }, @@ -16,7 +16,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 2, "metadata": { "collapsed": true }, @@ -27,13 +27,13 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 3, "metadata": { "collapsed": false }, "outputs": [], "source": [ - "meta_data = [Sim().main() for _ in range(10000)]\n", + "meta_data = [Sim().main() for _ in range(1)]\n", "def annoy(meta_data):\n", " x_list = []\n", " y_list = []\n", @@ -42,21 +42,23 @@ " y_list = y_list + [y for x,y in data]\n", " return x_list, y_list\n", "x, y = annoy(meta_data)\n", + "#sim = Sim()\n", + "\n", "\n" ] }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 4, "metadata": { "collapsed": false }, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZEAAAEZCAYAAABWwhjiAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAY8AAAEZCAYAAABvpam5AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nVx6O4zhONK48HMdxnGhceTiO4zjR/H8Quv0jtFfepgAAAABJRU5ErkJggg==\n", "text/plain": [ - "" + "" ] }, "metadata": {}, @@ -64,21 +66,31 @@ } ], "source": [ - "plt.xlabel(\"Speed * 10^1 in m/s\")\n", - "plt.ylabel(\"Distance\")\n", + "plt.xlabel(\"Time in Seconds\")\n", + "plt.ylabel(\"Locations\")\n", "plt.title(\"Traffic Flow on 1 km Road\")\n", - "plt.scatter(x, y, s=1, c=\"blue\", alpha=0.5)\n", + "plt.scatter(x, y, s=1, c=\"red\", marker=\"|\")\n", "\n", - "plt.show()" + "plt.show() " ] }, { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Findings\n", - "#### By looking at the data, I have come to the conclussion that the optimal speed limit for this road is between 72 kmh and 80 kmh. In normal mode" - ] + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [] }, { "cell_type": "code", diff --git a/cars.py b/cars.py index fd711e6..2f7896c 100644 --- a/cars.py +++ b/cars.py @@ -10,6 +10,7 @@ def __init__(self, start_position, length=5, max_speed=33, road=Road() ): self.position = start_position self.pre_pos = 0 self.road = road + self.index_position = 0 def accelerate(self): # accelerate 2 m/s diff --git a/simulation.py b/simulation.py index 1ba6c33..2f38303 100644 --- a/simulation.py +++ b/simulation.py @@ -13,17 +13,21 @@ def __init__(self, road=Road(), cars_count=30): self.time = 60 # time in seconds self.tick = 1 self.vehicle_data = [] + self.speed_data = [] self.collisions = 0 def car_factory(self): # * after initial code is finished come back here and design the simulation to # * account for car length init_location = 0 + my_location = 0 for num in range(self.cars_count): init_location = init_location + 33 f_car = Car(init_location) # you need to pass in a position from road state + f_car.index_position = my_location f_car.rand_slow() self.cars_on_road.append(f_car) + my_location += 1 def update(self, vehicle): # updates the current state of the road i.e.(changes the index position of cars from 0 to 1 @@ -38,16 +42,24 @@ def min_distance_between_car(self, object): if self.road_state[object.position:min_distance] is 0 or object.speed < object.max_speed: object.accelerate() elif self.road_state[object.position:min_distance] is not 0: - object.decelerate() + if object.index_position + 1 < self.cars_count: + new_speed = self.cars_on_road[object.index_position + 1].speed + object.speed = new_speed + elif object.index_position + 1 > self.cars_count: + new_speed = self.cars_on_road[object.index_position -1].speed + object.speed = new_speed def traffic(self): while self.time > 0: + #temp_data = [] for vehicle in self.cars_on_road: - self.vehicle_data.append((vehicle.speed / self.tick, vehicle.position )) + self.vehicle_data.append((self.tick, vehicle.position )) vehicle.rand_slow() self.min_distance_between_car(vehicle) vehicle.move() self.update(vehicle) + self.speed_data.append(vehicle.speed) + #self.vehicle_data.append(temp_data) self.tick += 1 self.time -= 1 From d96cfd376848721d07115de45fc2db2d2e81366c Mon Sep 17 00:00:00 2001 From: Lance Rogers Date: Mon, 15 Jun 2015 17:16:53 -0400 Subject: [PATCH 28/30] Car now matches car in fronts speed if min_distance isnt met --- .idea/workspace.xml | 80 ++++++++++++++----- .../Traffic Simulation Plots-checkpoint.ipynb | 53 +++++++----- Traffic Simulation Plots.ipynb | 53 +++++++----- cars.py | 2 +- simulation.py | 19 ++--- 5 files changed, 132 insertions(+), 75 deletions(-) diff --git a/.idea/workspace.xml b/.idea/workspace.xml index d208571..c7a72f1 100644 --- a/.idea/workspace.xml +++ b/.idea/workspace.xml @@ -4,7 +4,9 @@ + + @@ -18,7 +20,7 @@ - + - @@ -118,7 +120,6 @@ - @@ -139,6 +140,7 @@ + @@ -522,29 +524,29 @@ - - + + - + - + + + - - + - - + @@ -564,11 +566,19 @@ - - + + + + + + @@ -602,15 +612,43 @@ -