def start_simulation(Env, sim_number, gui=False, _seed=None, setting_obj=None, dir_name=None, main_env=None, new_players=False): #testpath = "./../map/london-seg4/data/london-seg4.sumocfg") if gui: traci.start(["sumo-gui", "-c", Settings.sumo_config]) else: traci.start(["sumo", "-c", Settings.sumo_config]) env = Env(sim_number=sim_number, _seed=_seed, setting_obj=setting_obj, main_env=main_env, new_players=new_players) my_vis = Visualize(env) while True: traci.simulationStep() traci.addStepListener(env) if gui: my_vis.show() #this is for visualization of the path if env.break_condition: break #env.reward_to_json(os.path.join(dir_name, f"{sim_number}")) print("veh succesffuly arrived ", env.sim_env.success_veh) traci.close() #env.post_process.to_csv() return env.post_process, env
def run(): STEP = 0 plexe = Plexe() traci.addStepListener(plexe) StepLength = 0.1 topology = {} while STEP < 3600: traci.simulationStep() STEP += StepLength print(STEP) if (int(STEP * 10) % 50 == 0) and STEP >= 300: Vehicles_0 = traci.lane.getLastStepVehicleIDs("4_0") Vehicles_1 = traci.lane.getLastStepVehicleIDs("4_1") #Vehicles_2 = traci.lane.getLastStepVehicleIDs("a1i_1_2") #Vehicles_3 = traci.lane.getLastStepVehicleIDs("a1i_1_3") for lane in [Vehicles_0, Vehicles_1]: #Vehicles_2,Vehicles_3]: position_result, lane_result = sort_lane(lane) platooning_members = find_sequence(lane_result) print("&&&&&&&", platooning_members) platoon_forming(plexe, platooning_members, topology) print("topology", topology) print("&&&&&&&", platooning_members) if int(STEP * 10) % 50 == 0: try: platoon_die(plexe, topology) except: pass #print("######") traci.close() sys.stdout.flush()
def main(demo_mode, real_engine, setter=None): # used to randomly color the vehicles random.seed(1) start_sumo("cfg/freeway.sumo.cfg", False) plexe = Plexe() traci.addStepListener(plexe) step = 0 while running(demo_mode, step, 6000): # when reaching 60 seconds, reset the simulation when in demo_mode if demo_mode and step == 6000: start_sumo("cfg/freeway.sumo.cfg", True) step = 0 random.seed(1) traci.simulationStep() if step == 1: add_vehicles(plexe, N_VEHICLES, 150, real_engine) add_vehicle(plexe, "v0", 140, 1, 25, "passenger") add_vehicle(plexe, "v1", 250, 0, 20, "passenger2") traci.gui.trackVehicle("View #0", LEADER) traci.gui.setZoom("View #0", 50000) if real_engine and setter is not None: # if we are running with the dashboard, update its values tracked_id = traci.gui.getTrackedVehicle("View #0") if tracked_id != "": ed = plexe.get_engine_data(tracked_id) vd = plexe.get_vehicle_data(tracked_id) setter(ed[RPM], ed[GEAR], vd.speed, vd.acceleration) step += 1 traci.close()
def start_simulation(Env, sim_number, gui=False, _seed=None): if gui: traci.start(["sumo-gui", "-c", Settings.sumo_config]) else: traci.start(["sumo", "-c", Settings.sumo_config]) env = Env(sim_number=sim_number, _seed=_seed) my_vis = Visualize(env) while True: traci.simulationStep() traci.addStepListener(env) if gui: my_vis.show() #this is for visualization of the path if env.break_condition: break print("veh succesffuly arrived ", env.sim_env.success_veh) traci.close() env.post_process.to_csv() return env.sim_env
def run(): STEP = 0 plexe = Plexe() traci.addStepListener(plexe) StepLength = 0.01 topology = {} while STEP < 400: traci.simulationStep() STEP += StepLength if int(STEP * 100) % 500 == 0: Vehicles_0 = traci.lane.getLastStepVehicleIDs("a1i_1_0") #Vehicles_1 = traci.lane.getLastStepVehicleIDs("a1i_1_1") #Vehicles_2 = traci.lane.getLastStepVehicleIDs("a1i_1_2") #Vehicles_3 = traci.lane.getLastStepVehicleIDs("a1i_1_3") #for lane in [Vehicles_0,Vehicles_1,Vehicles_2,Vehicles_3]: for lane in [Vehicles_0]: position_result, lane_result = sort_lane(lane) platooning_members = find_sequence(lane_result) print("&&&&&&&", platooning_members) platoon_forming(plexe, platooning_members, topology) print("topology", topology) print("&&&&&&&", platooning_members) if int(STEP * 100) % 500 == 0: platoon_die(plexe, topology) #print("######") if STEP >= 20 and WRITE_EXCEL and int(STEP * 100) % 10 == 0: currentIDList = traci.vehicle.getIDList() print('999') write_excel(STEP, worksheet, begin_step, RouteList, vehicle_store, currentIDList) workbook.close() traci.close() sys.stdout.flush()
def main(demo_mode, real_engine, setter=None): # used to randomly color the vehicles random.seed(1) start_sumo("cfg/freeway.sumo.cfg", False) plexe = Plexe() traci.addStepListener(plexe) step = 0 state = GOING_TO_POSITION while running(demo_mode, step, 6000): # when reaching 60 seconds, reset the simulation when in demo_mode if demo_mode and step == 6000: start_sumo("cfg/freeway.sumo.cfg", True) step = 0 state = GOING_TO_POSITION random.seed(1) traci.simulationStep() if step == 0: # create vehicles and track the joiner topology = add_vehicles(plexe, N_VEHICLES, real_engine) traci.gui.trackVehicle("View #0", JOINER) traci.gui.setZoom("View #0", 20000) if step % 10 == 1: # simulate vehicle communication every 100 ms communicate(plexe, topology) if step == 100: # at 1 second, let the joiner get closer to the platoon topology = get_in_position(plexe, JOINER, FRONT_JOIN, topology) if state == GOING_TO_POSITION and step > 0: # when the distance of the joiner is small enough, let the others # open a gap to let the joiner enter the platoon if get_distance(plexe, JOINER, FRONT_JOIN) < JOIN_DISTANCE + 1: state = OPENING_GAP topology = open_gap(plexe, BEHIND_JOIN, JOINER, topology, N_VEHICLES) if state == OPENING_GAP: # when the gap is large enough, complete the maneuver if get_distance(plexe, BEHIND_JOIN, FRONT_JOIN) > \ 2 * JOIN_DISTANCE + 2: state = COMPLETED plexe.set_fixed_lane(JOINER, 0, safe=False) plexe.set_active_controller(JOINER, CACC) plexe.set_path_cacc_parameters(JOINER, distance=DISTANCE) plexe.set_active_controller(BEHIND_JOIN, CACC) plexe.set_path_cacc_parameters(BEHIND_JOIN, distance=DISTANCE) topology = reset_leader(BEHIND_JOIN, topology, N_VEHICLES) if real_engine and setter is not None: # if we are running with the dashboard, update its values tracked_id = traci.gui.getTrackedVehicle("View #0") if tracked_id != "": ed = plexe.get_engine_data(tracked_id) vd = plexe.get_vehicle_data(tracked_id) setter(ed[RPM], ed[GEAR], vd.speed, vd.acceleration) step += 1 traci.close()
def main(demo_mode, real_engine, setter=None): # used to randomly color the vehicles random.seed(1) start_sumo("cfg/freeway.sumo.cfg", False) plexe = Plexe() traci.addStepListener(plexe) step = 0 state = GOING_TO_POSITION while running(demo_mode, step, 6000):
def load(config_filename): ''' Load the config from file and create a Platoon Manager ''' global _mgr _config.load(config_filename) _mgr = _platoonmanager.PlatoonManager() if _useStepListener: # For SUMO version >= 0.30 traci.addStepListener(_mgr)
def run_simulation(api: Dragometer, fileName: str, names: list, gaps: list, has_slipstream_device: list, track: int, use_gui: False): """ :param names: The names of the vehicles, ordered from the first to the last. :param gaps: The initial inter-vehicle gaps. The first is the gap between the first and the second vehicle. :param has_slipstream_device: Whether to equip each vehicles with the slipstream device. """ assert len(names) >= 2 assert len(gaps) == len(names) - 1 assert len(names) == len(has_slipstream_device) if True in has_slipstream_device: assert has_slipstream_device[names.index(track)] start_sumo("cfg/freeway.sumo.cfg", False, use_gui) plexe = Plexe() traci.addStepListener(plexe) outfile = open(fileName, "w") writer = csv.DictWriter(outfile, fieldnames=fieldnames) writer.writeheader() step = 0 while running(False, step, 4000): traci.simulationStep() if step == 0: add_vehicles(plexe, names, gaps, has_slipstream_device) if use_gui: traci.gui.trackVehicle("View #0", 'v0') traci.gui.setZoom("View #0", 100000) else: # The example uses only a vehicle type, called "car" # (see cfg/freeway.rou.xml), which has a drag coefficient of 0.24 cd = 0.24 if True in has_slipstream_device: cd = traci.vehicle.getParameter( track, 'device.slipstream.actualDragCoefficient') charge = traci.vehicle.getParameter( track, 'device.battery.actualBatteryCapacity') if api is not None: if True not in has_slipstream_device: api.plot('1', step, float(cd), subplotIndex=0) api.plot('2', step, float(charge), subplotIndex=0) else: api.plot('1', step, float(cd), subplotIndex=1) api.plot('2', step, float(charge), subplotIndex=1) energy = traci.vehicle.getParameter( track, 'device.battery.energyConsumed') data = plexe.get_vehicle_data(track) radar = plexe.get_radar_data(track) log_data(writer, 1, step, data[ACCELERATION], data[SPEED], radar[RADAR_DISTANCE], cd, charge, energy) step += 1 traci.close()
def main(demo_mode, real_engine, setter=None): start_sumo("cfg/freeway.sumo.cfg", False) plexe = Plexe() traci.addStepListener(plexe) step = 0 state_left = None state_right = None random.seed(1) while running(demo_mode, step, 6000): if demo_mode and step == 6000: start_sumo("cfg/freeway.sumo.cfg", True) step = 0 random.seed(1) traci.simulationStep() if step == 1: add_platooning_vehicle(plexe, "p0", 150, 0, 25, 5, real_engine) add_vehicle(plexe, "v0", 140, 1, 25, "passenger") add_vehicle(plexe, "v1", 250, 0, 20, "passenger2") traci.gui.trackVehicle("View #0", "p0") traci.gui.setZoom("View #0", 50000) plexe.set_active_controller("p0", ACC) plexe.set_cc_desired_speed("p0", 25) traci.vehicle.setSpeedMode("p0", 0) if step > 1: state = traci.vehicle.getLaneChangeState("p0", 1)[0] if state_left != state: state_left = state str_status = get_status(state) print("Step %d, vehicle p0. Lane change status (LEFT ): %s" % (step, str_status)) state = traci.vehicle.getLaneChangeState("p0", -1)[0] if state_right != state: state_right = state str_status = get_status(state) print("Step %d, vehicle p0. Lane change status (RIGHT): %s" % (step, str_status)) if real_engine and setter is not None: # if we are running with the dashboard, update its values tracked_id = traci.gui.getTrackedVehicle("View #0") if tracked_id != "": ed = plexe.get_engine_data(tracked_id) vd = plexe.get_vehicle_data(tracked_id) setter(ed[RPM], ed[GEAR], vd.speed, vd.acceleration) step += 1 traci.close()
def main(demo_mode, real_engine, setter=None): # used to randomly color the vehicles random.seed(1) start_sumo("cfg/intersection/intersection.sumo.cfg", False) plexe = Plexe() traci.addStepListener(plexe) step = 0 topology = dict() min_dist = 1e6 # newly added split feature compared with brakedemo.py split = False
def start_simulation(): n_step = 0 env = EnvironmentListener() while True: traci.simulationStep() traci.addStepListener(env) n_step += 1 traci.close()
def main(demo_mode, real_engine, setter=None): # used to randomly color the vehicles random.seed(1) start_sumo("cfg/freeway.sumo.cfg", False) plexe = Plexe() traci.addStepListener(plexe) step = 0 topology = dict() min_dist = 1e6 while running(demo_mode, step, 1500): # when reaching 60 seconds, reset the simulation when in demo_mode if demo_mode and step == 1500: print("Min dist: %f" % min_dist) start_sumo("cfg/freeway.sumo.cfg", True) step = 0 random.seed(1) traci.simulationStep() if step == 0: # create vehicles and track the braking vehicle topology = add_vehicles(plexe, 8, 1, real_engine) traci.gui.trackVehicle("View #0", BRAKING_VEHICLE) traci.gui.setZoom("View #0", 20000) if step % 10 == 1: # simulate vehicle communication every 100 ms communicate(plexe, topology) if real_engine and setter is not None: # if we are running with the dashboard, update its values tracked_id = traci.gui.getTrackedVehicle("View #0") if tracked_id != "": ed = plexe.get_engine_data(tracked_id) vd = plexe.get_vehicle_data(tracked_id) setter(ed[RPM], ed[GEAR], vd.speed, vd.acceleration) if step == 500: plexe.set_fixed_acceleration(BRAKING_VEHICLE, True, -6) if step > 1: radar = plexe.get_radar_data("v.0.1") if radar[RADAR_DISTANCE] < min_dist: min_dist = radar[RADAR_DISTANCE] step += 1 traci.close()
def main(demo_mode, real_engine, setter=None): # used to randomly color the vehicles # 具体着色是在 utils module 的 add_platooning_vehicle 函数中实现的 random.seed(1) # 运行 SUMO 的配置文件,后边的参数 False / True 表示 SUMO server 是否已经在运行了。 # 若为 False,则打开 SUMO 并加载配置文件 # 若为 True,则重新加载配置文件 # freeway.sumo.cfg 中仿真步长为 0.01s start_sumo("cfg/freeway.sumo.cfg", False) # 以下设置可以使得每次 traci.simulationStep() 之后都调用一次 plexe plexe = Plexe() traci.addStepListener(plexe) step = 0 topology = dict() min_dist = 1e6
def load(config_filename): ''' Load the config from file and create a Platoon Manager ''' global _mgr, _mgr_listenerID simpla._config.load(config_filename) _mgr = simpla._platoonmanager.PlatoonManager() if _useStepListener: # For SUMO version >= 0.30 _mgr_listenerID = traci.addStepListener(_mgr)
def main(demo_mode, real_engine, setter=None): # used to randomly color the vehicles random.seed(1) gui = True start_sumo("cfg/freeway.sumo.cfg", False, gui=gui) plexe = Plexe() traci.addStepListener(plexe) step = 0 while running(demo_mode, step, 6000): # when reaching 60 seconds, reset the simulation when in demo_mode if demo_mode and step == 6000: start_sumo("cfg/freeway.sumo.cfg", True, gui=gui) step = 0 random.seed(1) traci.simulationStep() if step == 0: # create vehicles and track the joiner add_vehicles(plexe, N_VEHICLES, real_engine) if gui: traci.gui.trackVehicle("View #0", LEADER) traci.gui.setZoom("View #0", 20000) if step >= 1: if step % 10 == 0: time = step / 100.0 speed = SPEED + AMP * math.sin(2 * math.pi * FREQ * time) plexe.set_cc_desired_speed(LEADER, speed) if real_engine and setter is not None: # if we are running with the dashboard, update its values tracked_id = traci.gui.getTrackedVehicle("View #0") if tracked_id != "": ed = plexe.get_engine_data(tracked_id) vd = plexe.get_vehicle_data(tracked_id) setter(ed[RPM], ed[GEAR], vd.speed, vd.acceleration) step += 1 traci.close()
def main(demo_mode, real_engine=True, setter=None): random.seed(1) start_sumo("cfg/freeway.sumo.cfg", False) step = 0 plexe = Plexe() traci.addStepListener(plexe) while running(demo_mode, step, 4000): # when reaching 60 seconds, reset the simulation when in demo_mode if demo_mode and step == 4000: start_sumo("cfg/freeway.sumo.cfg", True) step = 0 random.seed(1) traci.simulationStep() if step == 0: # create vehicles and track one of them add_vehicles(plexe) traci.gui.trackVehicle("View #0", VEHICLES[TRACK]) traci.gui.setZoom("View #0", 20000) if step == 100: # at 1 second let them accelerate as much as they can for vid in VEHICLES: plexe.set_fixed_acceleration(vid, True, 20) # in the dashboard, show the engine information about the vehicle # being tracked tracked_id = traci.gui.getTrackedVehicle("View #0") if setter is not None and tracked_id != "": ed = plexe.get_engine_data(tracked_id) vd = plexe.get_vehicle_data(tracked_id) setter(ed[RPM], ed[GEAR], vd.speed, vd.acceleration) step += 1 traci.close()
def openGap(vehID, desiredGap, desiredSpeedDiff, maximumDecel, duration): ''' openGap(string, float>0, float>0, float>0, float>0) vehID - ID of the vehicle to be controlled desiredGap - gap that shall be established desiredSpeedDiff - rate at which the gap is open if possible maximumDecel - maximal deceleration at which the desiredSpeedDiff is tried to be approximated duration - The period for which the gap control should be active This methods adds a controller for the opening of a gap in front of the given vehicle. The controller stays active for a period of the given duration. If a leader is closer than the desiredGap, the controller tries to establish the desiredGap by inducing the given speedDifference, while not braking harder than maximumDecel. An object of the class GapCreator is created to manage the vehicle state and is added to traci as a stepListener. ''' global _activeGapControllers if DEBUG_GAP_CONTROL: print("openGap()") # Check type error errorMsg = None if desiredGap <= 0: errorMsg = "simpla.openGap(): Parameter desiredGap has to be a positive float (given value = %s)." % desiredGap elif desiredSpeedDiff <= 0: errorMsg = "simpla.openGap(): Parameter desiredSpeedDiff has to be a positive float (given value = %s)." % ( desiredSpeedDiff) elif maximumDecel <= 0: errorMsg = "simpla.openGap(): Parameter maximumDecel has to be a positive float (given value = %s)." % ( maximumDecel) elif duration <= 0: errorMsg = "simpla.openGap(): Parameter duration has to be a positive float (given value = %s)." % duration if errorMsg is not None: raise SimplaException(errorMsg) # remove any previous controller attached to the vehicle removeGapController(vehID) gc = GapController(vehID, desiredGap, desiredSpeedDiff, maximumDecel, duration) listenerID = traci.addStepListener(gc) _activeGapControllers[vehID] = listenerID if DEBUG_GAP_CONTROL: print("Active controllers: %s." % (_activeGapControllers))
def run_algorithm(): listener = traffic_analyzer.WaitingTimeListener() traci.addStepListener(listener) #Density for all incoming roads density = {} density["west"] = 0 density["north"] = 0 density["east"] = 0 density["south"] = 0 #Time needed for cars on incoming roads to pass through time = {} time["west"] = 0 time["north"] = 0 time["east"] = 0 time["south"] = 0 yellow = False yellow_timer = 0 green_timer = GREEN_TIME green_time = GREEN_TIME max_density = 0 max_density_edge = "west" step = 0 waiting_time = 0 waiting_time2 = 0 vehicle_amount = 0 while traci.simulation.getMinExpectedNumber() > 0: traci.simulationStep() step += 1 if step == 600: waiting_time = traffic_analyzer.getWaitingTimes() waiting_time2 = traffic_analyzer.getSquaredWaitingTimes() vehicle_amount = traffic_analyzer.getVehicleAmount() #Switching between roads if yellow: if yellow_timer < YELLOW_TIME: yellow_timer += 1 else: yellow_timer = 0 yellow = False if max_density_edge == "west" or max_density_edge == "east": traci.trafficlight.setRedYellowGreenState( "intersection", WE_GREEN_STATE) else: traci.trafficlight.setRedYellowGreenState( "intersection", NS_GREEN_STATE) #Light is green elif green_timer < green_time: green_timer += 1 #Determine which road that should get green light else: green_timer = 0 #Set current green road's values to 0 if max_density_edge == "west" or max_density_edge == "east": density["west"] = 0 density["east"] = 0 time["west"] = 0 time["east"] = 0 else: density["north"] = 0 density["south"] = 0 time["north"] = 0 time["south"] = 0 previous_edge = max_density_edge max_density = 0 #Get highest density for edge in density: if density[edge] > max_density: max_density = density[edge] max_density_edge = edge #All roads have been taken, recalculate values if max_density == 0: density["west"], time[ "west"] = traffic_analyzer.getDensityAndTimeOnEdge( "west_right") density["north"], time[ "north"] = traffic_analyzer.getDensityAndTimeOnEdge( "north_down") density["east"], time[ "east"] = traffic_analyzer.getDensityAndTimeOnEdge( "east_left") density["south"], time[ "south"] = traffic_analyzer.getDensityAndTimeOnEdge( "south_up") #Get highest density, again for edge in density: if density[edge] > max_density: max_density = density[edge] max_density_edge = edge if max_density_edge == "west" or max_density_edge == "east": green_time = min(max(time["west"], time["east"]), GREEN_TIME) if previous_edge != "west" and previous_edge != "east": yellow = True traci.trafficlight.setRedYellowGreenState( "intersection", NS_YELLOW_STATE) else: green_time = min(max(time["north"], time["south"]), GREEN_TIME) if previous_edge != "north" and previous_edge != "south": yellow = True traci.trafficlight.setRedYellowGreenState( "intersection", WE_YELLOW_STATE) waiting_time = traffic_analyzer.getWaitingTimes() - waiting_time waiting_time2 = traffic_analyzer.getSquaredWaitingTimes() - waiting_time2 vehicle_amount = traffic_analyzer.getVehicleAmount() - vehicle_amount print("Average waiting time: " + str(float(waiting_time) / vehicle_amount)) print("Average squared waiting time: " + str(float(waiting_time2) / vehicle_amount)) traci.close() sys.stdout.flush() traffic_analyzer.reset() return float(waiting_time) / vehicle_amount, float( waiting_time2) / vehicle_amount
def main(): seeds = [4, 5, 6, 7, 8, 9, 10, 11] modes = [E_GREEDY, UCB1, BAYES_UCB, THOMPSON_SAMPLING, HEINOVSKI] glossary = [] for seed in seeds: for mode in modes: try: Globals.mode = mode Globals.seed = seed random.seed(seed) sleep(0.5) utils.start_sumo("cfg/freeway.sumo.cfg", False, gui=True) # used to randomly color the vehicles plexe = Plexe() traci.addStepListener(plexe) step = 0 counter = [0, 0, 0, 0, 0, 0] happiness_change_monitor_vehicle = [] happiness_change_monitor_platoon = [] spawn_timer = 40 spawn_threshold = random.randint(200, 300) vehicleInfos = {} platoonUtils.registry(vehicleInfos, plexe) Monitoring.registry(vehicleInfos) createUtils.registry(vehicleInfos) PlatooningAlgorithms.registry(vehicleInfos, plexe) neighbor_table = [[] for i in range(500)] spawning_list = [] spawnable_list = [] # Reset simulation afer 6 Minutes. while step <= 60002: try: traci.simulationStep() except: print(sys.exc_info()[0]) """ ############################################################################ Setup Vehicles ############################################################################ """ all_vehicles = list(traci.vehicle.getIDList()) vehicles = list(all_vehicles) spawn_timer += 1 # Generating cars every second (100 timesteps) if spawn_timer >= spawn_threshold and len( vehicles) < AMOUNT_RANDOM_CARS: spawn_timer = 0 if len(spawnable_list) == 0: car_id = "v.%d" % counter[CAR] counter[CAR] += 1 else: car_id = spawnable_list.pop(0) if len(spawning_list) != 0: spawnable_list.append(spawning_list.pop(0)) # 0 - 3 Start # 4 - 6 1. Entry # 7 - 8 2. Entry # 9 3. Entry spawn_threshold = random.randint(200, 300) if step < 17000: vroute = random.randint(0, 3) elif step < 34000: vroute = random.randint(0, 6) spawn_threshold /= 1.5 elif step < 51000: vroute = random.randint(0, 8) spawn_threshold /= 2 if MODE == START_TO_END_SCENARIO: createUtils.add_vehicle(plexe, car_id, 0, vroute=3) else: createUtils.add_vehicle(plexe, car_id, 0, vroute=vroute) """ ############################################################################ Simulate ############################################################################ """ # for every existing car, do the following actions every 100 ms if hundred_ms_times(2, step): """ ############################################################################ Removing Routine at the End of a Car's Route ############################################################################ """ for car in all_vehicles: if car in vehicleInfos: if plexe.get_distance_to_end( car) < 10 or plexe.get_crashed( car) or 0 < vehicleInfos[ car].get_speed() < 0.5: if vehicleInfos[car].is_in_platoon(): platoonUtils.remove_platoon_member(car) pos_relative = int( vehicleInfos[car]. get_neighbor_table_pos()) if car in neighbor_table[pos_relative]: neighbor_table[pos_relative].remove( car) if plexe.get_crashed( car ) or 0 < vehicleInfos[car].get_speed() < 1: counter[CRASH] += 1 traci.vehicle.remove(car) spawning_list.append(car) vehicleInfos.pop(car) if car not in vehicleInfos: vehicles.remove(car) """ ############################################################################ Update Neighbor Table ############################################################################ """ for car in vehicles: pos_relative = int( math.floor( plexe.get_vehicle_data(car)[POS_X] / RADAR_DISTANCE)) pos_relative_old = int( vehicleInfos[car].get_neighbor_table_pos()) if pos_relative_old is not pos_relative: if car in neighbor_table[pos_relative_old]: neighbor_table[pos_relative_old].remove( car) neighbor_table[pos_relative].append(car) vehicleInfos[car].set_neighbor_table_pos( pos_relative) """ ############################################################################ Update Neighbors ############################################################################ """ for car in vehicles: state = vehicleInfos[car].get_state() position = vehicleInfos[ car].get_neighbor_table_pos() # add all vehicles in the specific neighbor_table area to the neighbors list if position == 0: neighbors = neighbor_table[ position] + neighbor_table[position + 1] else: neighbors = neighbor_table[ position - 1] + neighbor_table[ position] + neighbor_table[position + 1] # The current car is not a neighbor of itself if car in neighbors: neighbors.remove(car) vehicleInfos[car].set_neighbors(neighbors) """ ############################################################################ Happiness Update and Algorithms ############################################################################ """ if (state == SINGLE_CAR or (state == PLATOON and not Globals.mode == HEINOVSKI)) \ and hundred_ms_times(10, step): neighbor = PlatooningAlgorithms.processing_neighbor_search( car, neighbors) else: neighbor = None """ ############################################################################ Perform State Actions ############################################################################ """ """ ############################################################################ State = NEW_SPAWNED ############################################################################ """ if state == NEW_SPAWNED: vehicleInfos[car].set_current_speed_factor( vehicleInfos[car].get_desired_speed_factor( )) if vehicleInfos[car].get_road_id() in EDGES: vehicleInfos[car].set_state(SINGLE_CAR) if DEBUG_CREATE: print(car + " start speed: " + str( vehicleInfos[car].get_speed()) + " start speed factor: " + str(vehicleInfos[car]. get_desired_speed_factor())) print(car + " switches to Single Car State") elif state == SINGLE_CAR: """ ############################################################################ State = SINGLE_CAR ############################################################################ """ platoonUtils.fix_speed_factor(car) if platoonUtils.take_next_exit(car): if DEBUG_REMOVE_MEMBER: print(car + ": " + str( plexe.get_distance_to_end(car)) + " m distance to end") vehicleInfos[car].set_state(NO_PLATOONING) elif neighbor is not None and hundred_ms_times( 10, step): if not platoonUtils.cars_in_between(car, neighbor, neighbors) \ and len(vehicleInfos[neighbor].get_platoon_members()) < MAX_PLATOON_SIZE: last_member = vehicleInfos[ neighbor].get_platoon_members()[-1] lane_difference = abs( vehicleInfos[car].get_lane_id() - vehicleInfos[neighbor].get_lane_id( )) # It is only possible to join a platoon, if car is behind the last member of the # existing platoon. if platoonUtils.get_distance(car, last_member) \ > (lane_difference + 1) * JOINING_MINIMAL_DISTANCE: vehicleInfos[car].set_state( PREPARE_JOINING) vehicleInfos[ car].set_desired_platoon_leader( neighbor) vehicleInfos[neighbor].set_joiner() elif state == PREPARE_JOINING: """ ############################################################################ State = PREPARE_JOINING ############################################################################ """ # For monitoring purpose only desired_leader = vehicleInfos[ car].get_desired_platoon_leader() members = vehicleInfos[ desired_leader].get_platoon_members() member_happiness_list = {} for member in members: member_happiness_list[ member] = PlatooningAlgorithms.calc_new_happiness( member, desired_leader) platoonUtils.prepare_joining(car, neighbors) # For monitoring purpose only if not vehicleInfos[car].get_state( ) == PREPARE_JOINING and vehicleInfos[ car].is_from_another_platoon(): if vehicleInfos[car].get_state( ) == NO_PLATOONING: counter[CHANGE_ABORT] += 1 # Monitoring happiness change of single car leader = vehicleInfos[ car].get_platoon_leader() new_happiness = PlatooningAlgorithms.calc_new_happiness( car, leader) happiness_difference = vehicleInfos[ car].get_old_happiness( ) - new_happiness happiness_change_monitor_vehicle.append( (car, happiness_difference, step)) # Monitoring happiness change of joined platoon if change was successful. if leader == desired_leader: members = vehicleInfos[ leader].get_platoon_members() happiness_difference = 0 for member in members: if member in member_happiness_list: new_happiness = PlatooningAlgorithms.calc_new_happiness( member, leader) happiness_difference += ( member_happiness_list[ member] - new_happiness) happiness_change_monitor_platoon.append( (leader, happiness_difference, step)) vehicleInfos[ car].reset_from_another_platoon() elif state == JOINING_PROCESS: """ ############################################################################ State = JOINING_PROCESS ############################################################################ """ platoonUtils.joining_process(car) # This routine checks, whether the car wants to leave the highway soon. # If that is the case, the car will leave its platoon. leader = vehicleInfos[car].get_platoon_leader() if platoonUtils.take_next_exit( car) or platoonUtils.cars_in_between( car, leader, neighbors): if DEBUG_REMOVE_MEMBER: print(car + ": " + str( plexe.get_distance_to_end(car)) + " m distance to end") vehicleInfos[car].set_state( LEAVING_PROCESS) elif state == PLATOON: """ ############################################################################ State = PLATOON ############################################################################ """ # DEBUG: Platoon desired / real speed if DEBUG_PRINT_PLATOON_DESIRED_REAL_SPEED and vehicleInfos[ car].is_leader(): print( str(car) + ": DesiredSpeed: " + str(vehicleInfos[car]. get_desired_speed()) + " isSpeed: " + str(vehicleInfos[car].get_speed())) members = vehicleInfos[ car].get_platoon_members() for member in members[1::]: print("member: " + str(member) + ": DesiredSpeed: " + str(vehicleInfos[member]. get_desired_speed()) + " isSpeed: " + str(vehicleInfos[member]. get_speed())) print( "----------------------------------------------------------------------" ) if DEBUG_PLATOON_MERGING_ALLOWED and hundred_ms_times(10, step) \ and Globals.mode != HEINOVSKI: if platoonUtils.check_merging( car, neighbor, neighbors): counter[MERGE] += 1 if vehicleInfos[car].is_leader(): platoonUtils.handle_auto_lane_change_in_platoon( car) else: # if not vehicleInfos[car].is_leader() leader = vehicleInfos[ car].get_platoon_leader() if vehicleInfos[leader].get_state() == PLATOON \ and not vehicleInfos[car].on_same_lane_with_leader() \ and vehicleInfos[car].get_road_id() == vehicleInfos[leader].get_road_id(): # Checks, if a platooned car is on the wrong lane and handles the situation. platoonUtils.check_emergency_platoon_quit( car, leader) if vehicleInfos[car].get_state( ) == PLATOON and hundred_ms_times(10, step): # This routine checks, whether the car wants to leave the highway soon. if platoonUtils.take_next_exit(car): if DEBUG_REMOVE_MEMBER: print(car + ": " + str( plexe.get_distance_to_end(car)) + " m distance to end") vehicleInfos[car].set_state( LEAVING_PROCESS) # This routine checks, whether better platoons are available. if not vehicleInfos[car].has_joiner(): if platoonUtils.handle_platoon_changing( car, neighbor, neighbors): leader = vehicleInfos[ car].get_platoon_leader() old_happiness = PlatooningAlgorithms.calc_new_happiness( car, leader) counter[CHANGE] += 1 vehicleInfos[ car].set_from_another_platoon( ) vehicleInfos[ car].set_old_happiness( old_happiness) elif state == MERGING: """ ############################################################################ State = MERGING ############################################################################ """ if vehicleInfos[car].is_leader(): leader_front = vehicleInfos[ car].get_desired_platoon_leader() members = vehicleInfos[ car].get_platoon_members() # Platoon is out of range, abort. if platoonUtils.get_distance( car, leader_front) > RADAR_DISTANCE: counter[MERGE_ABORT] += 1 for member in members: vehicleInfos[member].set_state( PLATOON) elif not platoonUtils.cars_in_between( members[-1], leader_front, neighbors): platoonUtils.merge_platoons(car) elif state == LEAVING_PROCESS: """ ############################################################################ State = LEAVING_PROCESS ############################################################################ """ platoonUtils.prepare_for_remove(car) elif state == LEFT: """ ############################################################################ State = LEFT ############################################################################ """ platoonUtils.remove_platoon_member(car) elif state == NO_PLATOONING: """ ############################################################################ State = NO_PLATOONING ############################################################################ """ # Adjust speed factor to desired after leaving a platoon. if platoonUtils.take_next_exit( car ) and vehicleInfos[car].get_lane_id() != 0: vehicleInfos[car].set_current_speed_factor( 0.5) else: platoonUtils.fix_speed_factor(car) if not platoonUtils.take_next_exit(car): if vehicleInfos[car].get_counter() >= 20: vehicleInfos[car].set_state(SINGLE_CAR) if DEBUG_PLATOON_SWITCH: print( car + " is reset into SINGLE CAR STATE" ) vehicleInfos[car].reset_counter() else: vehicleInfos[car].inc_counter() """ ############################################################################ Monitoring ############################################################################ """ if half_second(step): Monitoring.observe(step) step += 1 except: print(sys.exc_info()) print("Simulation " + str(seed) + " stops at step " + str(step)) Monitoring.write_info(counter, step) Monitoring.write_happiness_change(happiness_change_monitor_vehicle, "vehicle") Monitoring.write_happiness_change(happiness_change_monitor_platoon, "platoon") traci.close() glossary.append((seed, mode, step)) Monitoring.writeGlossary(glossary)
print("\nEmergency breaking required...") self.emergencyBreak = True # MAIN PROGRAM print("Starting the TraCI server...") traci.start(sumoCmd) print("Subscribing to vehicle data...") traci.vehicle.subscribe("veh0", (tc.VAR_COLOR, tc.VAR_SPEED, tc.VAR_ACCELERATION, tc.VAR_POSITION, tc.VAR_LANE_ID, tc.VAR_LANEPOSITION)) traci.vehicle.subscribe("veh1", (tc.VAR_COLOR, tc.VAR_SPEED, tc.VAR_ACCELERATION, tc.VAR_POSITION, tc.VAR_LANE_ID, tc.VAR_LANEPOSITION)) traci.vehicle.subscribe("veh2", (tc.VAR_COLOR, tc.VAR_SPEED, tc.VAR_ACCELERATION, tc.VAR_POSITION, tc.VAR_LANE_ID, tc.VAR_LANEPOSITION)) print("Constructing a StateListener...") stateListener = StateListener(["veh0", "veh1", "veh2"]) traci.addStepListener(stateListener) # disable speed control by SUMO traci.vehicle.setSpeedMode("veh0",0) # set the desired speed and the time to reach that speed traci.vehicle.slowDown("veh0",1,3) step = 0 while step < 20: # advance the simulation print("\nsimulation step: %i" % step) traci.simulationStep() step += 1 # if emergency breaking or a collision occurs stop the simulation if stateListener.emergencyBreak or stateListener.collision: break
def run_algorithm(not_trained): wait_listener = traffic_analyzer.WaitingTimeListener() traci.addStepListener(wait_listener) delayListener = traffic_analyzer.DelayListener() traci.addStepListener(delayListener) queueListener = traffic_analyzer.QueueListener() traci.addStepListener(queueListener) #Reinforcement Learning Q = np.zeros([6, 6, 6, 6, 7, 2]) try: Q = np.load('q.npy') print("Q matrix loaded") except: pass # Set learning parameters lr = .8 y = .95 # switched = False yellow = False yellow_time = 0 green_time = 0 green_time_at_switch = 0 west_east = True traci.trafficlight.setRedYellowGreenState("intersection", WE_GREEN_STATE) state = [0, 0, 0, 0, 0] previous_state = state action = 0 previous_waiting_times = 0 step = 0 waiting_time = 0 waiting_time2 = 0 vehicle_amount = 0 while traci.simulation.getMinExpectedNumber() > 0: traci.simulationStep() step += 1 if step == 600: waiting_time = traffic_analyzer.getWaitingTimes() waiting_time2 = traffic_analyzer.getSquaredWaitingTimes() vehicle_amount = traffic_analyzer.getVehicleAmount() if yellow: if yellow_time < YELLOW_TIME: yellow_time += 1 else: yellow_time = 0 yellow = False if west_east: west_east = False traci.trafficlight.setRedYellowGreenState( "intersection", NS_GREEN_STATE) else: west_east = True traci.trafficlight.setRedYellowGreenState( "intersection", WE_GREEN_STATE) else: if green_time < 10: green_time += 1 elif not switched: #Reinforcement learning #Get state q_w, q_n, q_e, q_s, p_t = sensorValues( traffic_analyzer.queue_lengths["west"], traffic_analyzer.queue_lengths["north"], traffic_analyzer.queue_lengths["east"], traffic_analyzer.queue_lengths["south"], green_time) state = [q_w, q_n, q_e, q_s, p_t] #Get reward waiting_times = traffic_analyzer.getDelay() r = waiting_times - previous_waiting_times previous_waiting_times = waiting_times #Update Q-Table with new knowledge Q[previous_state[0], previous_state[1], previous_state[2], previous_state[3], previous_state[4], action] = Q[ previous_state[0], previous_state[1], previous_state[2], previous_state[3], previous_state[4], action] + lr * ( r + y * np.min(Q[state[0], state[1], state[2], state[3], state[4], :]) - Q[previous_state[0], previous_state[1], previous_state[2], previous_state[3], previous_state[4], action]) #Get action and execute it explore = 0.1 if not_trained: explore += (7800 - step) / 7800 if explore > 1: explore = 1 action = None if random.uniform(0, 1) > explore: action = np.argmin(Q[state[0], state[1], state[2], state[3], state[4], :]) else: action = random.randint(0, 1) if action == 1 and not west_east: switched = True GREEN_TIME = green_time + 10 elif action == 0 and west_east: switched = True GREEN_TIME = green_time + 10 previous_state = state green_time += 1 elif switched: if green_time < GREEN_TIME: green_time += 1 else: green_time = 0 switched = False yellow = True if west_east: traci.trafficlight.setRedYellowGreenState( "intersection", WE_YELLOW_STATE) else: traci.trafficlight.setRedYellowGreenState( "intersection", NS_YELLOW_STATE) waiting_time = traffic_analyzer.getWaitingTimes() - waiting_time waiting_time2 = traffic_analyzer.getSquaredWaitingTimes() - waiting_time2 vehicle_amount = traffic_analyzer.getVehicleAmount() - vehicle_amount np.save('q.npy', Q) print("Q matrix stored") print("Average waiting time: " + str(float(waiting_time) / vehicle_amount)) print("Average squared waiting time: " + str(float(waiting_time2) / vehicle_amount)) traci.close() sys.stdout.flush() traffic_analyzer.reset() return float(waiting_time) / vehicle_amount, float( waiting_time2) / vehicle_amount
def run_algorithm(gt): GREEN_TIME = gt green = 0 yellow = 0 west_east = True yellow_phase = False listener = traffic_analyzer.WaitingTimeListener() traci.addStepListener(listener) step = 0 waiting_time = 0 waiting_time2 = 0 vehicle_amount = 0 while traci.simulation.getMinExpectedNumber() > 0: traci.simulationStep() step += 1 if step == 600: waiting_time = traffic_analyzer.getWaitingTimes() waiting_time2 = traffic_analyzer.getSquaredWaitingTimes() vehicle_amount = traffic_analyzer.getVehicleAmount() #Increment time for the different phases if yellow_phase: yellow += 1 #Time maximized, switch state if yellow > YELLOW_TIME: yellow = 0 yellow_phase = False if west_east: traci.trafficlight.setRedYellowGreenState( "intersection", NS_GREEN_STATE) west_east = False else: traci.trafficlight.setRedYellowGreenState( "intersection", WE_GREEN_STATE) west_east = True else: green += 1 #Time maximized, switch state if green > GREEN_TIME: green = 0 yellow_phase = True if west_east: traci.trafficlight.setRedYellowGreenState( "intersection", WE_YELLOW_STATE) else: traci.trafficlight.setRedYellowGreenState( "intersection", NS_YELLOW_STATE) waiting_time = traffic_analyzer.getWaitingTimes() - waiting_time waiting_time2 = traffic_analyzer.getSquaredWaitingTimes() - waiting_time2 vehicle_amount = traffic_analyzer.getVehicleAmount() - vehicle_amount print("Average waiting time: " + str(float(waiting_time) / vehicle_amount)) print("Average squared waiting time: " + str(float(waiting_time2) / vehicle_amount)) traci.close() sys.stdout.flush() traffic_analyzer.reset() return float(waiting_time) / vehicle_amount, float( waiting_time2) / vehicle_amount
def runSimulation(): '''runSimulation(CarsInSimulation) -> none''' while traci.simulation.getMinExpectedNumber() > 0: traci.simulationStep() traci.close() def setUpSimulation(): sumoBinary = checkBinary("sumo") sumoCmd = [sumoBinary, "-c", "data/first.sumocfg"] traci.start(sumoCmd) if __name__ == "__main__": setUpSimulation() sl_evaluator = EvaluatorStepListener(Evaluator()) alpha = ConstantFunction(0) epsilon = ConstantFunction(.1) discount = .5 q_learning = RLAgentQLearning(epsilon, alpha, discount) state = IntersectionState("C") controller = RlTlController(state, q_learning) #controller = DoNothingTlController() sl_controller = TrafficControllerStepListener(controller) traci.addStepListener(sl_evaluator) traci.addStepListener(sl_controller) runSimulation() sl_evaluator.print_results()
def main(demo_mode, real_engine, setter=None): # used to randomly color the vehicles random.seed(1) start_sumo("cfg/jiangxinzhou.sumo.cfg", False) plexe = Plexe() traci.addStepListener(plexe) step = 0 redlight_stop = 0 topology_0 = dict() platoons_num = 1 car_num = [26] leader = [0] state_2_flag = [0] redlight_stop = [0] judge_flag = [0] special_stop_flag = [0] color = [(255, 255, 255, 255), (255, 255, 0, 255), (0, 255, 255, 255), (255, 0, 255, 255), (255, 255, 255, 255), (255, 255, 0, 255), (0, 255, 255, 255), (255, 0, 255, 255), (255, 255, 255, 255), (255, 255, 0, 255), (0, 255, 255, 255), (255, 0, 255, 255)] special_judge_flag = [0] while running(demo_mode, step, 500000): # when reaching 60 seconds, reset the simulation when in demo_mode if demo_mode and step == 500000: start_sumo("cfg/jiangxinzhou.sumo.cfg", True) step = 0 random.seed(1) traci.simulationStep() if step == 0: # create vehicles and track the braking vehicle distance_0 = 5 speed_0 = 25 car_num_0 = car_num[0] platoons_num_0 = 1 position_0 = 1000 topology_0 = add_vehicles(plexe, car_num_0, platoons_num_0, "vtypeauto", "platoon_route_0", position_0, speed_0, distance_0, real_engine) traci.gui.trackVehicle("View #0", "v.0.0") # traci.vehicle.highlight("v.0.0", color=(255,255,0,255), size=-1, alphaMax=-1, duration=-1, type=0) # traci.gui.trackVehicle("View #1", "v.0.1") traci.gui.setZoom("View #0", 700) # traci.gui.setOffset("View #0",5078.44,6332.91) # acf = traci.gui.getZoom(viewID='View #0') # print (acf) if step % 10 == 1: # simulate vehicle communication every 100 ms communicate(plexe, topology_0) # print (topology_0) if step > 10: # print(platoons_num) for i in range(platoons_num): # print(i) num_temp = int(leader[i]) leader_id = "v.0.%d" % num_temp # for size_cycle in range (0,100): traci.vehicle.highlight(leader_id, color[i], size=50, alphaMax=-1, duration=-1, type=0) # print (leader_id) nextTLS, current_phase, left_distance, absolute_time = getnext_trafficlightandphace( leader_id) if ((left_distance >= RANGE - 1) and (left_distance < RANGE)): judge_flag[i] = 1 else: judge_flag[i] = 0 if left_distance <= 0.5: state_2_flag[i] = 0 special_stop_flag[i] = 0 # print (left_distance,state_2_flag[i],special_stop_flag[i]) leader_data = plexe.get_vehicle_data(leader_id) if (nextTLS != "none" and judge_flag[i] == 1): time_left = absolute_time - traci.simulation.getTime() pass_num = int( math.floor((leader_data.speed * time_left - RANGE) / (LENGTH + DISTANCE))) state = judge_state(plexe, car_num[i], pass_num) # if i==0: # print (pass_num,state) if ((state == 0 and current_phase == 'g') or (current_phase == 'r')) and special_stop_flag[i] == 0: # plexe.set_cc_desired_speed(leader_id, 0) # plexe.set_active_controller(leader_id, 3) decel = leader_data.speed**2 / (2 * (left_distance - 10)) plexe.set_fixed_acceleration("v.0.%d" % int(leader[i]), True, -decel) redlight_stop[i] = 1 # ALL_PASS = 1 # elif state == 1 and current_phase == 'g': # continue # PART_PASS = 2 elif state == 2 and current_phase == 'g' and state_2_flag[ i] == 0: new_platoon_leader = "v.0.%d" % (int(leader[i]) + pass_num) for j in range((int(leader[i]) + pass_num) + 1, (int(leader[i]) + car_num[i])): # temporarily change the leader topology_0["v.0.%d" % j]["leader"] = new_platoon_leader traci.vehicle.setColor("v.0.%d" % j, color[platoons_num]) # the front vehicle if the vehicle opening the gap is the joiner plexe.set_active_controller(new_platoon_leader, ACC) traci.vehicle.setColor(new_platoon_leader, color[platoons_num]) plexe.set_path_cacc_parameters(new_platoon_leader, distance=100) topology_0[new_platoon_leader] = {} leader.append(int(leader[i]) + pass_num) car_num.append(car_num[i] - pass_num) platoons_num = platoons_num + 1 car_num[i] = pass_num redlight_stop.append(1) state_2_flag[i] = 1 state_2_flag.append(0) judge_flag.append(0) special_judge_flag[i] = 1 special_judge_flag.append(0) # must stop after separated special_stop_flag.append(1) leader_data_temp = plexe.get_vehicle_data( "v.0.%d" % int(leader[platoons_num - 1])) nextTLS, current_phase, left_distance, absolute_time = getnext_trafficlightandphace( "v.0.%d" % int(leader[platoons_num - 1])) decel = leader_data_temp.speed**2 / ( 2 * (left_distance - 10)) plexe.set_fixed_acceleration( "v.0.%d" % int(leader[platoons_num - 1]), True, -decel) # plexe.set_cc_desired_speed("v.0.%d" % int(leader[i+1]), 0) # plexe.set_active_controller("v.0.%d" % int(leader[platoons_num-1]), FAKED_CACC) # traci.gui.trackVehicle("View #0", "v.0.%d" % int(leader[i+1])) # if i>=1: # print(i, leader_id, leader, car_num,special_stop_flag,state_2_flag) # print (redlight_stop,current_phase) if redlight_stop[i] == 1 and current_phase != 'r' and int( leader_data.speed) <= 1: plexe.set_fixed_acceleration(leader_id, False, 0) plexe.set_cc_desired_speed(leader_id, 25) plexe.set_active_controller(leader_id, ACC) plexe.set_path_cacc_parameters(leader_id, distance=DISTANCE) redlight_stop[i] = 0 if real_engine and setter is not None: # if we are running with the dashboard, update its values tracked_id = traci.gui.getTrackedVehicle("View #0") if tracked_id != "": ed = plexe.get_engine_data(tracked_id) vd = plexe.get_vehicle_data(tracked_id) setter(ed[RPM], ed[GEAR], vd.speed, vd.acceleration) step += 1 traci.close()
else: sumoBinary = "/usr/share/sumo/bin/sumo-gui" # passing the "--start" option to tell sumo-gui to begin without waiting for the play button to be pressed sumoCmd = [sumoBinary, "-c", "/home/thomasrw/j/jconfig", "--start"] simplaConfig = "/home/thomasrw/j/mysimpla.cfg.xml" #simplaConfig2 = "/home/thomasrw/Model/mysimpla2.cfg.xml" traci.start(sumoCmd) #simpla.load(simplaConfig) #calling config.load() and platoonmanger() explicitly exposes the platoon manager variable allowing listeners # to be specified by platoon manager simpla._config.load(simplaConfig) ##mgr = simpla._platoonmanager.PlatoonManager() mgr = _platoonmanager2.PlatoonManager2() mgr_id = traci.addStepListener(mgr) #print(str(mgr.getMaxSize())) #mgr.setMaxSize(50) #print(str(mgr.getMaxSize())) #simpla.load(simplaConfig2) start = time.time() run() end = time.time() total = end - start print("time taken is: " + str(total))