def sugiyama_example(sumo_binary=None): sumo_params = SumoParams(sim_step=0.1, sumo_binary="sumo-gui") if sumo_binary is not None: sumo_params.sumo_binary = sumo_binary vehicles = Vehicles() vehicles.add( veh_id="idm", acceleration_controller=(IDMController, {}), routing_controller=(ContinuousRouter, {}), num_vehicles=22) env_params = EnvParams(additional_params=ADDITIONAL_ENV_PARAMS) additional_net_params = ADDITIONAL_NET_PARAMS.copy() net_params = NetParams(additional_params=additional_net_params) initial_config = InitialConfig(bunching=20) scenario = LoopScenario( name="sugiyama", generator_class=CircleGenerator, vehicles=vehicles, net_params=net_params, initial_config=initial_config) env = AccelEnv(env_params, sumo_params, scenario) return SumoExperiment(env, scenario)
def figure_eight_example(sumo_binary=None): sumo_params = SumoParams(sumo_binary="sumo-gui") if sumo_binary is not None: sumo_params.sumo_binary = sumo_binary vehicles = Vehicles() vehicles.add(veh_id="idm", acceleration_controller=(IDMController, {}), lane_change_controller=(StaticLaneChanger, {}), routing_controller=(ContinuousRouter, {}), initial_speed=0, num_vehicles=14) env_params = EnvParams(additional_params=ADDITIONAL_ENV_PARAMS) additional_net_params = ADDITIONAL_NET_PARAMS.copy() net_params = NetParams(no_internal_links=False, additional_params=additional_net_params) scenario = Figure8Scenario(name="figure8", generator_class=Figure8Generator, vehicles=vehicles, net_params=net_params) env = AccelEnv(env_params, sumo_params, scenario) return SumoExperiment(env, scenario)
def start(): sumo_params = SumoParams(sim_step=0.1, sumo_binary="sumo") sumo_params.sumo_binary = 'sumo' vehicles = Vehicles() vehicles.add(veh_id="idm", acceleration_controller=(IDMController, {}), routing_controller=(ContinuousRouter, {}), num_vehicles=22) env_params = EnvParams(additional_params=ADDITIONAL_ENV_PARAMS) additional_net_params = ADDITIONAL_NET_PARAMS.copy() net_params = NetParams(additional_params=additional_net_params) initial_config = InitialConfig(bunching=20) scenario = LoopScenario(name="sugiyama", generator_class=CircleGenerator, vehicles=vehicles, net_params=net_params, initial_config=initial_config) env = AccelEnv(env_params, sumo_params, scenario) env._close()
def start(): """Start a environment object with ray.""" sumo_params = SumoParams(sim_step=0.1, render=False) vehicles = Vehicles() vehicles.add( veh_id="idm", acceleration_controller=(IDMController, {}), routing_controller=(ContinuousRouter, {}), num_vehicles=22) env_params = EnvParams(additional_params=ADDITIONAL_ENV_PARAMS) additional_net_params = ADDITIONAL_NET_PARAMS.copy() net_params = NetParams(additional_params=additional_net_params) initial_config = InitialConfig(bunching=20) scenario = LoopScenario( name="sugiyama", vehicles=vehicles, net_params=net_params, initial_config=initial_config) env = AccelEnv(env_params, sumo_params, scenario) env._close()
def minicity_example(render=None, save_render=None, sight_radius=None, pxpm=None, show_radius=None): """ Perform a simulation of vehicles on modified minicity of University of Delaware. Parameters ---------- render: bool, optional specifies whether to use the gui during execution Returns ------- exp: flow.core.experiment.Experiment A non-rl experiment demonstrating the performance of human-driven vehicles on the minicity scenario. """ sim_params = SumoParams(sim_step=0.25) # update sim_params values if provided as inputs sim_params.render = render or sim_params.render sim_params.save_render = save_render or sim_params.save_render sim_params.sight_radius = sight_radius or sim_params.sight_radius sim_params.pxpm = pxpm or sim_params.pxpm sim_params.show_radius = show_radius or sim_params.show_radius vehicles = VehicleParams() vehicles.add(veh_id="idm", acceleration_controller=(IDMController, {}), routing_controller=(MinicityRouter, {}), car_following_params=SumoCarFollowingParams(speed_mode=1, ), lane_change_params=SumoLaneChangeParams( lane_change_mode="no_lat_collide", ), initial_speed=0, num_vehicles=90) vehicles.add(veh_id="rl", acceleration_controller=(RLController, {}), routing_controller=(MinicityRouter, {}), car_following_params=SumoCarFollowingParams( speed_mode="obey_safe_speed", ), initial_speed=0, num_vehicles=10) env_params = EnvParams(additional_params=ADDITIONAL_ENV_PARAMS) net_params = NetParams(no_internal_links=False) initial_config = InitialConfig(spacing="random", min_gap=5) scenario = MiniCityScenario(name="minicity", vehicles=vehicles, initial_config=initial_config, net_params=net_params) env = AccelEnv(env_params, sim_params, scenario) return Experiment(env)
def grid_example(sumo_binary=None): inner_length = 300 long_length = 500 short_length = 300 n = 2 m = 3 num_cars_left = 20 num_cars_right = 20 num_cars_top = 20 num_cars_bot = 20 tot_cars = (num_cars_left + num_cars_right) * m \ + (num_cars_top + num_cars_bot) * n grid_array = { "short_length": short_length, "inner_length": inner_length, "long_length": long_length, "row_num": n, "col_num": m, "cars_left": num_cars_left, "cars_right": num_cars_right, "cars_top": num_cars_top, "cars_bot": num_cars_bot } sumo_params = SumoParams(sim_step=0.1, sumo_binary="sumo-gui") if sumo_binary is not None: sumo_params.sumo_binary = sumo_binary vehicles = Vehicles() vehicles.add(veh_id="human", routing_controller=(GridRouter, {}), num_vehicles=tot_cars) env_params = EnvParams(additional_params=ADDITIONAL_ENV_PARAMS) additional_net_params = { "grid_array": grid_array, "speed_limit": 35, "horizontal_lanes": 1, "vertical_lanes": 1, "traffic_lights": True } net_params = NetParams(no_internal_links=False, additional_params=additional_net_params) initial_config = InitialConfig() scenario = SimpleGridScenario(name="grid-intersection", generator_class=SimpleGridGenerator, vehicles=vehicles, net_params=net_params, initial_config=initial_config) env = AccelEnv(env_params, sumo_params, scenario) return SumoExperiment(env, scenario)
def highway_example(sumo_binary=None): """ Perform a simulation of vehicles on a highway. Parameters ---------- sumo_binary: bool, optional specifies whether to use sumo's gui during execution Returns ------- exp: flow.core.SumoExperiment type A non-rl experiment demonstrating the performance of human-driven vehicles on a figure eight. """ sumo_params = SumoParams(sumo_binary="sumo-gui") if sumo_binary is not None: sumo_params.sumo_binary = sumo_binary vehicles = Vehicles() vehicles.add(veh_id="human", acceleration_controller=(IDMController, {}), num_vehicles=20) vehicles.add(veh_id="human2", acceleration_controller=(IDMController, {}), num_vehicles=20) env_params = EnvParams(additional_params=ADDITIONAL_ENV_PARAMS) inflow = InFlows() inflow.add(veh_type="human", edge="highway", probability=0.25, departLane="free", departSpeed=20) inflow.add(veh_type="human2", edge="highway", probability=0.25, departLane="free", departSpeed=20) additional_net_params = ADDITIONAL_NET_PARAMS.copy() net_params = NetParams(in_flows=inflow, additional_params=additional_net_params) initial_config = InitialConfig(spacing="uniform", shuffle=True) scenario = HighwayScenario(name="highway", generator_class=HighwayGenerator, vehicles=vehicles, net_params=net_params, initial_config=initial_config) env = AccelEnv(env_params, sumo_params, scenario) return SumoExperiment(env, scenario)
def two_loops_merge_straight_example(sumo_binary=None): sumo_params = SumoParams(sim_step=0.1, emission_path="./data/", sumo_binary="sumo-gui") if sumo_binary is not None: sumo_params.sumo_binary = sumo_binary # note that the vehicles are added sequentially by the generator, # so place the merging vehicles after the vehicles in the ring vehicles = Vehicles() vehicles.add(veh_id="idm", acceleration_controller=(IDMController, {}), lane_change_controller=(SumoLaneChangeController, {}), routing_controller=(ContinuousRouter, {}), num_vehicles=7, sumo_car_following_params=SumoCarFollowingParams( minGap=0.0, tau=0.5), sumo_lc_params=SumoLaneChangeParams()) vehicles.add(veh_id="merge-idm", acceleration_controller=(IDMController, {}), lane_change_controller=(SumoLaneChangeController, {}), routing_controller=(ContinuousRouter, {}), num_vehicles=10, sumo_car_following_params=SumoCarFollowingParams( minGap=0.01, tau=0.5), sumo_lc_params=SumoLaneChangeParams()) env_params = EnvParams(additional_params=ADDITIONAL_ENV_PARAMS) additional_net_params = ADDITIONAL_NET_PARAMS.copy() additional_net_params["ring_radius"] = 50 additional_net_params["inner_lanes"] = 1 additional_net_params["outer_lanes"] = 1 additional_net_params["lane_length"] = 75 net_params = NetParams( no_internal_links=False, additional_params=additional_net_params ) initial_config = InitialConfig( x0=50, spacing="uniform", additional_params={"merge_bunching": 0} ) scenario = TwoLoopsOneMergingScenario( name="two-loop-one-merging", generator_class=TwoLoopOneMergingGenerator, vehicles=vehicles, net_params=net_params, initial_config=initial_config ) env = AccelEnv(env_params, sumo_params, scenario) return SumoExperiment(env, scenario)
def figure_eight_example(render=None): """ Perform a simulation of vehicles on a figure eight. Parameters ---------- render: bool, optional specifies whether to use the gui during execution Returns ------- exp: flow.core.experiment.Experiment A non-rl experiment demonstrating the performance of human-driven vehicles on a figure eight. """ sim_params = SumoParams(render=True) if render is not None: sim_params.render = render vehicles = VehicleParams() vehicles.add( veh_id="idm", acceleration_controller=(IDMController, {}), lane_change_controller=(StaticLaneChanger, {}), routing_controller=(ContinuousRouter, {}), car_following_params=SumoCarFollowingParams( speed_mode="obey_safe_speed", decel=1.5, ), initial_speed=0, num_vehicles=14) env_params = EnvParams(additional_params=ADDITIONAL_ENV_PARAMS) additional_net_params = ADDITIONAL_NET_PARAMS.copy() net_params = NetParams(additional_params=additional_net_params) scenario = Figure8Scenario( name="figure8", vehicles=vehicles, net_params=net_params) env = AccelEnv(env_params, sim_params, scenario) return Experiment(env)
def sugiyama_example(render=None): """ Perform a simulation of vehicles on a ring road. Parameters ---------- render : bool, optional specifies whether to use the gui during execution Returns ------- exp: flow.core.experiment.Experiment A non-rl experiment demonstrating the performance of human-driven vehicles on a ring road. """ sim_params = SumoParams(sim_step=0.1, render=True) if render is not None: sim_params.render = render vehicles = VehicleParams() vehicles.add( veh_id="idm", acceleration_controller=(IDMController, {}), routing_controller=(ContinuousRouter, {}), num_vehicles=22) env_params = EnvParams(additional_params=ADDITIONAL_ENV_PARAMS) additional_net_params = ADDITIONAL_NET_PARAMS.copy() net_params = NetParams(additional_params=additional_net_params) initial_config = InitialConfig(bunching=20) scenario = LoopScenario( name="sugiyama", vehicles=vehicles, net_params=net_params, initial_config=initial_config) env = AccelEnv(env_params, sim_params, scenario) return Experiment(env)
def highway_example(sumo_binary=None): sumo_params = SumoParams(sumo_binary="sumo-gui") if sumo_binary is not None: sumo_params.sumo_binary = sumo_binary vehicles = Vehicles() vehicles.add(veh_id="human", acceleration_controller=(IDMController, {}), num_vehicles=20) vehicles.add(veh_id="human2", acceleration_controller=(IDMController, {}), num_vehicles=20) env_params = EnvParams(additional_params=ADDITIONAL_ENV_PARAMS) inflow = InFlows() inflow.add(veh_type="human", edge="highway", probability=0.25, departLane="free", departSpeed=20) inflow.add(veh_type="human2", edge="highway", probability=0.25, departLane="free", departSpeed=20) additional_net_params = ADDITIONAL_NET_PARAMS.copy() net_params = NetParams(in_flows=inflow, additional_params=additional_net_params) initial_config = InitialConfig(spacing="uniform", shuffle=True) scenario = HighwayScenario(name="highway", generator_class=HighwayGenerator, vehicles=vehicles, net_params=net_params, initial_config=initial_config) env = AccelEnv(env_params, sumo_params, scenario) return SumoExperiment(env, scenario)
def figure_eight_example(render=None): """ Perform a simulation of vehicles on a figure eight. Parameters ---------- render: bool, optional specifies whether to use sumo's gui during execution Returns ------- exp: flow.core.SumoExperiment type A non-rl experiment demonstrating the performance of human-driven vehicles on a figure eight. """ sumo_params = SumoParams(render=True) if render is not None: sumo_params.render = render vehicles = Vehicles() vehicles.add(veh_id="idm", acceleration_controller=(IDMController, {}), lane_change_controller=(StaticLaneChanger, {}), routing_controller=(ContinuousRouter, {}), speed_mode="no_collide", initial_speed=0, num_vehicles=14) env_params = EnvParams(additional_params=ADDITIONAL_ENV_PARAMS) additional_net_params = ADDITIONAL_NET_PARAMS.copy() net_params = NetParams(no_internal_links=False, additional_params=additional_net_params) scenario = Figure8Scenario(name="figure8", generator_class=Figure8Generator, vehicles=vehicles, net_params=net_params) env = AccelEnv(env_params, sumo_params, scenario) return SumoExperiment(env, scenario)
def highway_exp_setup(sumo_params=None, vehicles=None, env_params=None, net_params=None, initial_config=None, traffic_lights=None): """ Create an environment and scenario pair for highway test experiments. Parameters ---------- sumo_params: SumoParams type sumo-related configuration parameters, defaults to a time step of 0.1s and no sumo-imposed failsafe on human or rl vehicles vehicles: Vehicles type vehicles to be placed in the network, default is one vehicles with an IDM acceleration controller and ContinuousRouter routing controller. env_params: EnvParams type environment-specific parameters, defaults to a environment with no failsafes, where other parameters do not matter for non-rl runs net_params: NetParams type network-specific configuration parameters, defaults to a single lane highway of length 100 m initial_config: InitialConfig type specifies starting positions of vehicles, defaults to evenly distributed vehicles across the length of the network traffic_lights: TrafficLights type traffic light signals, defaults to no traffic lights in the network """ logging.basicConfig(level=logging.WARNING) if sumo_params is None: # set default sumo_params configuration sumo_params = SumoParams(sim_step=0.1, render=False) if vehicles is None: # set default vehicles configuration vehicles = Vehicles() vehicles.add( veh_id="idm", acceleration_controller=(IDMController, {}), speed_mode="aggressive", routing_controller=(ContinuousRouter, {}), num_vehicles=1) if env_params is None: # set default env_params configuration additional_env_params = { "target_velocity": 8, "max_accel": 1, "max_decel": 1, "num_steps": 500 } env_params = EnvParams(additional_params=additional_env_params) if net_params is None: # set default net_params configuration additional_net_params = { "length": 100, "lanes": 1, "speed_limit": 30, "resolution": 40, "num_edges": 1 } net_params = NetParams(additional_params=additional_net_params) if initial_config is None: # set default initial_config configuration initial_config = InitialConfig() if traffic_lights is None: # set default to no traffic lights traffic_lights = TrafficLights() # create the scenario scenario = HighwayScenario( name="RingRoadTest", vehicles=vehicles, net_params=net_params, initial_config=initial_config, traffic_lights=traffic_lights) # create the environment env = AccelEnv( env_params=env_params, sumo_params=sumo_params, scenario=scenario) return env, scenario
def grid_example(render=None): """ Perform a simulation of vehicles on a grid. Parameters ---------- render: bool, optional specifies whether to use sumo's gui during execution Returns ------- exp: flow.core.SumoExperiment type A non-rl experiment demonstrating the performance of human-driven vehicles and balanced traffic lights on a grid. """ inner_length = 300 long_length = 500 short_length = 300 n = 2 m = 3 num_cars_left = 20 num_cars_right = 20 num_cars_top = 20 num_cars_bot = 20 tot_cars = (num_cars_left + num_cars_right) * m \ + (num_cars_top + num_cars_bot) * n grid_array = { "short_length": short_length, "inner_length": inner_length, "long_length": long_length, "row_num": n, "col_num": m, "cars_left": num_cars_left, "cars_right": num_cars_right, "cars_top": num_cars_top, "cars_bot": num_cars_bot } sumo_params = SumoParams(sim_step=0.1, render=True) if render is not None: sumo_params.render = render vehicles = Vehicles() vehicles.add(veh_id="human", routing_controller=(GridRouter, {}), num_vehicles=tot_cars) env_params = EnvParams(additional_params=ADDITIONAL_ENV_PARAMS) tl_logic = TrafficLights(baseline=False) phases = [{ "duration": "31", "minDur": "8", "maxDur": "45", "state": "GGGrrrGGGrrr" }, { "duration": "6", "minDur": "3", "maxDur": "6", "state": "yyyrrryyyrrr" }, { "duration": "31", "minDur": "8", "maxDur": "45", "state": "rrrGGGrrrGGG" }, { "duration": "6", "minDur": "3", "maxDur": "6", "state": "rrryyyrrryyy" }] tl_logic.add("center0", phases=phases, programID=1) tl_logic.add("center1", phases=phases, programID=1) tl_logic.add("center2", tls_type="actuated", phases=phases, programID=1) additional_net_params = { "grid_array": grid_array, "speed_limit": 35, "horizontal_lanes": 1, "vertical_lanes": 1 } net_params = NetParams(no_internal_links=False, additional_params=additional_net_params) initial_config = InitialConfig() scenario = SimpleGridScenario(name="grid-intersection", vehicles=vehicles, net_params=net_params, initial_config=initial_config, traffic_lights=tl_logic) env = AccelEnv(env_params, sumo_params, scenario) return SumoExperiment(env, scenario)
def grid_example(sumo_binary=None): inner_length = 300 long_length = 500 short_length = 300 n = 2 m = 3 num_cars_left = 20 num_cars_right = 20 num_cars_top = 20 num_cars_bot = 20 tot_cars = (num_cars_left + num_cars_right) * m \ + (num_cars_top + num_cars_bot) * n grid_array = { "short_length": short_length, "inner_length": inner_length, "long_length": long_length, "row_num": n, "col_num": m, "cars_left": num_cars_left, "cars_right": num_cars_right, "cars_top": num_cars_top, "cars_bot": num_cars_bot } sumo_params = SumoParams(sim_step=0.1, sumo_binary="sumo-gui") if sumo_binary is not None: sumo_params.sumo_binary = sumo_binary vehicles = Vehicles() vehicles.add(veh_id="human", routing_controller=(GridRouter, {}), num_vehicles=tot_cars) env_params = EnvParams(additional_params=ADDITIONAL_ENV_PARAMS) tl_logic = TrafficLights(baseline=False) phases = [{ "duration": "31", "minDur": "8", "maxDur": "45", "state": "GGGrrrGGGrrr" }, { "duration": "6", "minDur": "3", "maxDur": "6", "state": "yyyrrryyyrrr" }, { "duration": "31", "minDur": "8", "maxDur": "45", "state": "rrrGGGrrrGGG" }, { "duration": "6", "minDur": "3", "maxDur": "6", "state": "rrryyyrrryyy" }] tl_logic.add("center0", phases=phases, programID=1) tl_logic.add("center1", phases=phases, programID=1) tl_logic.add("center2", tls_type="actuated", phases=phases, programID=1) additional_net_params = { "grid_array": grid_array, "speed_limit": 35, "horizontal_lanes": 1, "vertical_lanes": 1 } net_params = NetParams(no_internal_links=False, additional_params=additional_net_params) initial_config = InitialConfig() scenario = SimpleGridScenario(name="grid-intersection", generator_class=SimpleGridGenerator, vehicles=vehicles, net_params=net_params, initial_config=initial_config, traffic_lights=tl_logic) env = AccelEnv(env_params, sumo_params, scenario) return SumoExperiment(env, scenario)
def loop_merge_example(render=None): """ Perform a simulation of vehicles on a loop merge. Parameters ---------- render : bool, optional specifies whether to use sumo's gui during execution Returns ------- exp: flow.core.SumoExperiment type A non-rl experiment demonstrating the performance of human-driven vehicles on a loop merge. """ sumo_params = SumoParams(sim_step=0.1, emission_path="./data/", render=True) if render is not None: sumo_params.render = render # note that the vehicles are added sequentially by the scenario, # so place the merging vehicles after the vehicles in the ring vehicles = Vehicles() vehicles.add(veh_id="idm", acceleration_controller=(IDMController, {}), lane_change_controller=(SumoLaneChangeController, {}), routing_controller=(ContinuousRouter, {}), num_vehicles=7, speed_mode="no_collide", sumo_car_following_params=SumoCarFollowingParams(minGap=0.0, tau=0.5), sumo_lc_params=SumoLaneChangeParams()) vehicles.add(veh_id="merge-idm", acceleration_controller=(IDMController, {}), lane_change_controller=(SumoLaneChangeController, {}), routing_controller=(ContinuousRouter, {}), num_vehicles=10, speed_mode="no_collide", sumo_car_following_params=SumoCarFollowingParams(minGap=0.01, tau=0.5), sumo_lc_params=SumoLaneChangeParams()) env_params = EnvParams(additional_params=ADDITIONAL_ENV_PARAMS) additional_net_params = ADDITIONAL_NET_PARAMS.copy() additional_net_params["ring_radius"] = 50 additional_net_params["inner_lanes"] = 1 additional_net_params["outer_lanes"] = 1 additional_net_params["lane_length"] = 75 net_params = NetParams(no_internal_links=False, additional_params=additional_net_params) initial_config = InitialConfig(x0=50, spacing="uniform", additional_params={"merge_bunching": 0}) scenario = TwoLoopsOneMergingScenario(name="two-loop-one-merging", vehicles=vehicles, net_params=net_params, initial_config=initial_config) env = AccelEnv(env_params, sumo_params, scenario) return SumoExperiment(env, scenario)
def minicity_example(render=None, save_render=None, sight_radius=None, pxpm=None, show_radius=None): """ Perform a simulation of vehicles on modified minicity of University of Delaware. Parameters ---------- render: bool, optional specifies whether to use sumo's gui during execution Returns ------- exp: flow.core.SumoExperiment type A non-rl experiment demonstrating the performance of human-driven vehicles on the minicity scenario. """ sumo_params = SumoParams(render=False) if render is not None: sumo_params.render = render if save_render is not None: sumo_params.save_render = save_render if sight_radius is not None: sumo_params.sight_radius = sight_radius if pxpm is not None: sumo_params.pxpm = pxpm if show_radius is not None: sumo_params.show_radius = show_radius vehicles = Vehicles() vehicles.add(veh_id="idm", acceleration_controller=(IDMController, {}), routing_controller=(MinicityRouter, {}), speed_mode=1, lane_change_mode="no_lat_collide", initial_speed=0, num_vehicles=20) vehicles.add(veh_id="rl", acceleration_controller=(RLController, {}), routing_controller=(MinicityRouter, {}), speed_mode="no_collide", initial_speed=0, num_vehicles=5) env_params = EnvParams(additional_params=ADDITIONAL_ENV_PARAMS) additional_net_params = ADDITIONAL_NET_PARAMS.copy() net_params = NetParams(no_internal_links=False, additional_params=additional_net_params) initial_config = InitialConfig(spacing="random", min_gap=5) scenario = MiniCityScenario(name="minicity", vehicles=vehicles, initial_config=initial_config, net_params=net_params) env = AccelEnv(env_params, sumo_params, scenario) return SumoExperiment(env, scenario)
def grid_example(render=None, use_inflows=False): """ Perform a simulation of vehicles on a grid. Parameters ---------- render: bool, optional specifies whether to use the gui during execution use_inflows : bool, optional set to True if you would like to run the experiment with inflows of vehicles from the edges, and False otherwise Returns ------- exp: flow.core.experiment.Experiment A non-rl experiment demonstrating the performance of human-driven vehicles and balanced traffic lights on a grid. """ v_enter = 10 inner_length = 300 long_length = 500 short_length = 300 n_rows = 2 n_columns = 3 num_cars_left = 20 num_cars_right = 20 num_cars_top = 20 num_cars_bot = 20 tot_cars = (num_cars_left + num_cars_right) * n_columns \ + (num_cars_top + num_cars_bot) * n_rows grid_array = { "short_length": short_length, "inner_length": inner_length, "long_length": long_length, "row_num": n_rows, "col_num": n_columns, "cars_left": num_cars_left, "cars_right": num_cars_right, "cars_top": num_cars_top, "cars_bot": num_cars_bot } sim_params = SumoParams(sim_step=0.1, render=True) if render is not None: sim_params.render = render vehicles = VehicleParams() vehicles.add( veh_id="human", routing_controller=(GridRouter, {}), car_following_params=SumoCarFollowingParams( min_gap=2.5, decel=7.5, # avoid collisions at emergency stops ), num_vehicles=tot_cars) env_params = EnvParams(additional_params=ADDITIONAL_ENV_PARAMS) tl_logic = TrafficLightParams(baseline=False) phases = [{ "duration": "31", "minDur": "8", "maxDur": "45", "state": "GrGrGrGrGrGr" }, { "duration": "6", "minDur": "3", "maxDur": "6", "state": "yryryryryryr" }, { "duration": "31", "minDur": "8", "maxDur": "45", "state": "rGrGrGrGrGrG" }, { "duration": "6", "minDur": "3", "maxDur": "6", "state": "ryryryryryry" }] tl_logic.add("center0", phases=phases, programID=1) tl_logic.add("center1", phases=phases, programID=1) tl_logic.add("center2", phases=phases, programID=1, tls_type="actuated") additional_net_params = { "grid_array": grid_array, "speed_limit": 35, "horizontal_lanes": 1, "vertical_lanes": 1 } if use_inflows: initial_config, net_params = get_flow_params( col_num=n_columns, row_num=n_rows, additional_net_params=additional_net_params) else: initial_config, net_params = get_non_flow_params( enter_speed=v_enter, add_net_params=additional_net_params) scenario = SimpleGridScenario(name="grid-intersection", vehicles=vehicles, net_params=net_params, initial_config=initial_config, traffic_lights=tl_logic) env = AccelEnv(env_params, sim_params, scenario) return Experiment(env)
def variable_lanes_exp_setup(sumo_params=None, vehicles=None, env_params=None, net_params=None, initial_config=None, traffic_lights=None): """ Creates an environment and scenario pair for a ring road network with different number of lanes in each edge. Used for test purposes. Parameters ---------- sumo_params: SumoParams type sumo-related configuration parameters, defaults to a time step of 0.1s and no sumo-imposed failsafe on human or rl vehicles vehicles: Vehicles type vehicles to be placed in the network, default is one vehicles with an IDM acceleration controller and ContinuousRouter routing controller. env_params: EnvParams type environment-specific parameters, defaults to a environment with no failsafes, where other parameters do not matter for non-rl runs net_params: NetParams type network-specific configuration parameters, defaults to a figure eight with a 30 m radius and "no_internal_links" set to False initial_config: InitialConfig type specifies starting positions of vehicles, defaults to evenly distributed vehicles across the length of the network traffic_lights: TrafficLights type traffic light signals, defaults to no traffic lights in the network """ logging.basicConfig(level=logging.WARNING) if sumo_params is None: # set default sumo_params configuration sumo_params = SumoParams(sim_step=0.1, sumo_binary="sumo") if vehicles is None: # set default vehicles configuration vehicles = Vehicles() vehicles.add( veh_id="idm", acceleration_controller=(IDMController, {}), speed_mode="aggressive", routing_controller=(ContinuousRouter, {}), num_vehicles=1) if env_params is None: # set default env_params configuration additional_env_params = { "target_velocity": 8, "max_accel": 1, "max_decel": 1, "num_steps": 500 } env_params = EnvParams(additional_params=additional_env_params) if net_params is None: # set default net_params configuration additional_net_params = { "length": 230, "lanes": 1, "speed_limit": 30, "resolution": 40 } net_params = NetParams(additional_params=additional_net_params) if initial_config is None: # set default initial_config configuration initial_config = InitialConfig() if traffic_lights is None: # set default to no traffic lights traffic_lights = TrafficLights() # create the scenario scenario = LoopScenario( name="VariableLaneRingRoadTest", generator_class=VariableLanesGenerator, vehicles=vehicles, net_params=net_params, initial_config=initial_config, traffic_lights=traffic_lights) # create the environment env = AccelEnv( env_params=env_params, sumo_params=sumo_params, scenario=scenario) return env, scenario
def setup_bottlenecks(sumo_params=None, vehicles=None, env_params=None, net_params=None, initial_config=None, traffic_lights=None, inflow=None, scaling=1): """ Create an environment and scenario pair for grid 1x1 test experiments. Sumo-related configuration parameters, defaults to a time step of 1s and no sumo-imposed failsafe on human or rl vehicles Parameters ---------- sumo_params: SumoParams type sumo-related configuration parameters, defaults to a time step of 0.1s and no sumo-imposed failsafe on human or rl vehicles vehicles: Vehicles type vehicles to be placed in the network, default is 5 vehicles per edge for a total of 20 vehicles with an IDM acceleration controller and GridRouter routing controller. env_params: EnvParams type environment-specific parameters, defaults to a environment with failsafes, where other parameters do not matter for non-rl runs net_params: NetParams type network-specific configuration parameters, defaults to a 1x1 grid which traffic lights on and "no_internal_links" set to False initial_config: InitialConfig type specifies starting positions of vehicles, defaults to evenly distributed vehicles across the length of the network traffic_lights: TrafficLights type specifies logic of any traffic lights added to the system """ if sumo_params is None: # set default sumo_params configuration sumo_params = SumoParams(sim_step=0.1, render=False) if vehicles is None: vehicles = Vehicles() vehicles.add(veh_id="human", speed_mode=25, lane_change_controller=(SumoLaneChangeController, {}), routing_controller=(ContinuousRouter, {}), lane_change_mode=1621, num_vehicles=1 * scaling) if env_params is None: additional_env_params = { "target_velocity": 40, "max_accel": 1, "max_decel": 1, "lane_change_duration": 5, "add_rl_if_exit": False, "disable_tb": True, "disable_ramp_metering": True } env_params = EnvParams(additional_params=additional_env_params) if inflow is None: inflow = InFlows() inflow.add(veh_type="human", edge="1", vehsPerHour=1000, departLane="random", departSpeed=10) if traffic_lights is None: traffic_lights = TrafficLights() if net_params is None: additional_net_params = {"scaling": scaling} net_params = NetParams(inflows=inflow, no_internal_links=False, additional_params=additional_net_params) if initial_config is None: initial_config = InitialConfig(spacing="random", min_gap=5, lanes_distribution=float("inf"), edges_distribution=["2", "3", "4", "5"]) scenario = BottleneckScenario(name="bay_bridge_toll", generator_class=BottleneckGenerator, vehicles=vehicles, net_params=net_params, initial_config=initial_config, traffic_lights=traffic_lights) # create the environment env = AccelEnv(env_params=env_params, sumo_params=sumo_params, scenario=scenario) return env, scenario
horizon=HORIZON, evaluate=True, # Set to True to evaluate traffic metrics additional_params={ "target_velocity": 20, "max_accel": 3, "max_decel": 3, }, ) initial_config = InitialConfig() net_params = NetParams( no_internal_links=False, additional_params=ADDITIONAL_NET_PARAMS, ) scenario = Figure8Scenario(name="figure_eight", generator_class=Figure8Generator, vehicles=vehicles, net_params=net_params, initial_config=initial_config) env = AccelEnv(env_params, sumo_params, scenario) exp = SumoExperiment(env, scenario) num_runs = 2 results = exp.run(num_runs, HORIZON) avg_speed = np.mean(results["mean_returns"]) print('The average speed across {} runs is {}'.format(num_runs, avg_speed))
def highway_ramps_example(render=None): """ Perform a simulation of vehicles on a highway section with ramps. Parameters ---------- render: bool, optional Specifies whether or not to use the GUI during the simulation. Returns ------- exp: flow.core.experiment.Experiment A non-RL experiment demonstrating the performance of human-driven vehicles on a highway section with on and off ramps. """ sim_params = SumoParams(render=True, emission_path="./data/", sim_step=0.2, restart_instance=True) if render is not None: sim_params.render = render vehicles = VehicleParams() vehicles.add( veh_id="human", acceleration_controller=(IDMController, { "noise": 0.2 }), car_following_params=SumoCarFollowingParams( speed_mode="obey_safe_speed", ), lane_change_params=SumoLaneChangeParams(lane_change_mode=1621)) env_params = EnvParams(additional_params=ADDITIONAL_ENV_PARAMS, sims_per_step=5, warmup_steps=0) inflows = InFlows() inflows.add(veh_type="human", edge="highway_0", vehs_per_hour=HIGHWAY_INFLOW_RATE, depart_lane="free", depart_speed="max", name="highway_flow") for i in range(len(additional_net_params["on_ramps_pos"])): inflows.add(veh_type="human", edge="on_ramp_{}".format(i), vehs_per_hour=ON_RAMPS_INFLOW_RATE, depart_lane="first", depart_speed="max", name="on_ramp_flow") net_params = NetParams(inflows=inflows, additional_params=additional_net_params) initial_config = InitialConfig(spacing="uniform", perturbation=5.0) scenario = HighwayRampsScenario(name="highway-ramp", vehicles=vehicles, net_params=net_params, initial_config=initial_config) env = AccelEnv(env_params, sim_params, scenario) return Experiment(env)
def grid_example(render=None): """ Perform a simulation of vehicles on a grid. Parameters ---------- render: bool, optional specifies whether to use the gui during execution Returns ------- exp: flow.core.experiment.Experiment A non-rl experiment demonstrating the performance of human-driven vehicles and balanced traffic lights on a grid. """ inner_length = 300 long_length = 500 short_length = 300 N_ROWS = 2 N_COLUMNS = 3 num_cars_left = 20 num_cars_right = 20 num_cars_top = 20 num_cars_bot = 20 tot_cars = (num_cars_left + num_cars_right) * N_COLUMNS \ + (num_cars_top + num_cars_bot) * N_ROWS grid_array = { "short_length": short_length, "inner_length": inner_length, "long_length": long_length, "row_num": N_ROWS, "col_num": N_COLUMNS, "cars_left": num_cars_left, "cars_right": num_cars_right, "cars_top": num_cars_top, "cars_bot": num_cars_bot } sim_params = AimsunParams(sim_step=0.5, render=True) if render is not None: sim_params.render = render vehicles = VehicleParams() vehicles.add(veh_id="human", num_vehicles=tot_cars) env_params = EnvParams(additional_params=ADDITIONAL_ENV_PARAMS) tl_logic = TrafficLightParams(baseline=False) phases = [{ "duration": "31", "minDur": "8", "maxDur": "45", "yellow": "3", "state": "GGGrrrGGGrrr" }, { "duration": "6", "minDur": "3", "maxDur": "6", "yellow": "3", "state": "yyyrrryyyrrr" }, { "duration": "31", "minDur": "8", "maxDur": "45", "yellow": "3", "state": "rrrGGGrrrGGG" }, { "duration": "6", "minDur": "3", "maxDur": "6", "yellow": "3", "state": "rrryyyrrryyy" }] tl_logic.add("center0", phases=phases, programID=1) tl_logic.add("center1", phases=phases, programID=1) tl_logic.add("center2", tls_type="actuated", phases=phases, programID=1) tl_logic.add("center3", phases=phases, programID=1) tl_logic.add("center4", phases=phases, programID=1) tl_logic.add("center5", tls_type="actuated", phases=phases, programID=1) additional_net_params = { "grid_array": grid_array, "speed_limit": 35, "horizontal_lanes": 1, "vertical_lanes": 1 } net_params = NetParams(additional_params=additional_net_params) initial_config = InitialConfig(spacing='custom') scenario = SimpleGridScenario(name="grid-intersection", vehicles=vehicles, net_params=net_params, initial_config=initial_config, traffic_lights=tl_logic) env = AccelEnv(env_params, sim_params, scenario, simulator='aimsun') return Experiment(env)
def setup_bottlenecks(sumo_params=None, vehicles=None, env_params=None, net_params=None, initial_config=None, traffic_lights=None, inflow=None, scaling=1): if sumo_params is None: # set default sumo_params configuration sumo_params = SumoParams(sim_step=0.1, sumo_binary="sumo") if vehicles is None: vehicles = Vehicles() vehicles.add( veh_id="human", speed_mode=25, lane_change_controller=(SumoLaneChangeController, {}), routing_controller=(ContinuousRouter, {}), lane_change_mode=1621, num_vehicles=1 * scaling) if env_params is None: additional_env_params = { "target_velocity": 40, "max_accel": 1, "max_decel": 1, "lane_change_duration": 5, "add_rl_if_exit": False, "disable_tb": True, "disable_ramp_metering": True } env_params = EnvParams(additional_params=additional_env_params) if inflow is None: inflow = InFlows() inflow.add( veh_type="human", edge="1", vehsPerHour=1000, departLane="random", departSpeed=10) if traffic_lights is None: traffic_lights = TrafficLights() if net_params is None: additional_net_params = {"scaling": scaling} net_params = NetParams( in_flows=inflow, no_internal_links=False, additional_params=additional_net_params) if initial_config is None: initial_config = InitialConfig( spacing="random", min_gap=5, lanes_distribution=float("inf"), edges_distribution=["2", "3", "4", "5"]) scenario = BottleneckScenario( name="bay_bridge_toll", generator_class=BottleneckGenerator, vehicles=vehicles, net_params=net_params, initial_config=initial_config, traffic_lights=traffic_lights) # create the environment env = AccelEnv( env_params=env_params, sumo_params=sumo_params, scenario=scenario) return env, scenario
def variable_lanes_exp_setup(sim_params=None, vehicles=None, env_params=None, net_params=None, initial_config=None, traffic_lights=None): """ Create an environment and scenario variable-lane ring road. Each edge in this scenario can have a different number of lanes. Used for test purposes. Parameters ---------- sim_params : flow.core.params.SumoParams sumo-related configuration parameters, defaults to a time step of 0.1s and no sumo-imposed failsafe on human or rl vehicles vehicles : Vehicles type vehicles to be placed in the network, default is one vehicles with an IDM acceleration controller and ContinuousRouter routing controller. env_params : flow.core.params.EnvParams environment-specific parameters, defaults to a environment with no failsafes, where other parameters do not matter for non-rl runs net_params : flow.core.params.NetParams network-specific configuration parameters, defaults to a figure eight with a 30 m radius initial_config : flow.core.params.InitialConfig specifies starting positions of vehicles, defaults to evenly distributed vehicles across the length of the network traffic_lights: flow.core.params.TrafficLightParams traffic light signals, defaults to no traffic lights in the network """ logging.basicConfig(level=logging.WARNING) if sim_params is None: # set default sim_params configuration sim_params = SumoParams(sim_step=0.1, render=False) if vehicles is None: # set default vehicles configuration vehicles = VehicleParams() vehicles.add(veh_id="idm", acceleration_controller=(IDMController, {}), car_following_params=SumoCarFollowingParams( speed_mode="aggressive", ), routing_controller=(ContinuousRouter, {}), num_vehicles=1) if env_params is None: # set default env_params configuration additional_env_params = { "target_velocity": 8, "max_accel": 1, "max_decel": 1, "sort_vehicles": False } env_params = EnvParams(additional_params=additional_env_params) if net_params is None: # set default net_params configuration additional_net_params = { "length": 230, "lanes": 1, "speed_limit": 30, "resolution": 40 } net_params = NetParams(additional_params=additional_net_params) if initial_config is None: # set default initial_config configuration initial_config = InitialConfig() if traffic_lights is None: # set default to no traffic lights traffic_lights = TrafficLightParams() # create the scenario scenario = VariableLanesScenario(name="VariableLaneRingRoadTest", vehicles=vehicles, net_params=net_params, initial_config=initial_config, traffic_lights=traffic_lights) # create the environment env = AccelEnv(env_params=env_params, sim_params=sim_params, scenario=scenario) # reset the environment env.reset() return env, scenario
def figure_eight_exp_setup(sumo_params=None, vehicles=None, env_params=None, net_params=None, initial_config=None, traffic_lights=None): """ Create an environment and scenario pair for figure eight test experiments. Parameters ---------- sumo_params : flow.core.params.SumoParams sumo-related configuration parameters, defaults to a time step of 0.1s and no sumo-imposed failsafe on human or rl vehicles vehicles : Vehicles type vehicles to be placed in the network, default is one vehicles with an IDM acceleration controller and ContinuousRouter routing controller. env_params : flow.core.params.EnvParams environment-specific parameters, defaults to a environment with no failsafes, where other parameters do not matter for non-rl runs net_params : flow.core.params.NetParams network-specific configuration parameters, defaults to a figure eight with a 30 m radius and "no_internal_links" set to False initial_config : flow.core.params.InitialConfig specifies starting positions of vehicles, defaults to evenly distributed vehicles across the length of the network traffic_lights: flow.core.params.TrafficLightParams traffic light signals, defaults to no traffic lights in the network """ logging.basicConfig(level=logging.WARNING) if sumo_params is None: # set default sumo_params configuration sumo_params = SumoParams(sim_step=0.1, render=False) if vehicles is None: # set default vehicles configuration vehicles = Vehicles() vehicles.add(veh_id="idm", acceleration_controller=(IDMController, {}), sumo_car_following_params=SumoCarFollowingParams( speed_mode="aggressive", ), routing_controller=(ContinuousRouter, {}), num_vehicles=1) if env_params is None: # set default env_params configuration additional_env_params = { "target_velocity": 8, "max_accel": 1, "max_decel": 1, "num_steps": 500 } env_params = EnvParams(additional_params=additional_env_params) if net_params is None: # set default net_params configuration additional_net_params = { "radius_ring": 30, "lanes": 1, "speed_limit": 30, "resolution": 40 } net_params = NetParams(no_internal_links=False, additional_params=additional_net_params) if initial_config is None: # set default initial_config configuration initial_config = InitialConfig(lanes_distribution=1) if traffic_lights is None: # set default to no traffic lights traffic_lights = TrafficLightParams() # create the scenario scenario = Figure8Scenario(name="RingRoadTest", vehicles=vehicles, net_params=net_params, initial_config=initial_config, traffic_lights=traffic_lights) # create the environment env = AccelEnv(env_params=env_params, sumo_params=sumo_params, scenario=scenario) return env, scenario
def figure_eight_baseline(num_runs, render=True): """Run script for all figure eight baselines. Parameters ---------- num_runs : int number of rollouts the performance of the environment is evaluated over render : bool, optional specifies whether to use sumo's gui during execution Returns ------- SumoExperiment class needed to run simulations """ # We place 1 autonomous vehicle and 13 human-driven vehicles in the network vehicles = Vehicles() vehicles.add(veh_id="human", acceleration_controller=(IDMController, { "noise": 0.2 }), routing_controller=(ContinuousRouter, {}), speed_mode="no_collide", num_vehicles=14) sumo_params = SumoParams( sim_step=0.1, render=render, ) env_params = EnvParams( horizon=HORIZON, evaluate=True, # Set to True to evaluate traffic metrics additional_params={ "target_velocity": 20, "max_accel": 3, "max_decel": 3, }, ) initial_config = InitialConfig() net_params = NetParams( no_internal_links=False, additional_params=ADDITIONAL_NET_PARAMS, ) scenario = Figure8Scenario(name="figure_eight", vehicles=vehicles, net_params=net_params, initial_config=initial_config) env = AccelEnv(env_params, sumo_params, scenario) exp = SumoExperiment(env, scenario) results = exp.run(num_runs, HORIZON) avg_speed = np.mean(results["mean_returns"]) return avg_speed
def triangle_scenario_example(highway_inflow, middle_length, emission_dir, render_=False): # create an empty vehicles object vehicles = VehicleParams() # add some vehicles to this object of type "human" vehicles.add(veh_id="human", acceleration_controller=(IDMController, {}), routing_controller=(ContinuousRouter, {}), car_following_params=SumoCarFollowingParams( speed_mode="obey_safe_speed", ), lane_change_params=SumoLaneChangeParams( lane_change_mode="strategic", ), num_vehicles=0) inflow = InFlows() inflow.add(veh_type="human", edge="inflow_highway_2", vehs_per_hour=highway_inflow, departSpeed=10, departLane="random") inflow.add(veh_type="human", edge="inflow_merge_2", vehs_per_hour=500, departSpeed=10, departLane="random") additional_net_params = { # length of the merge edge "merge_length": 100, # length of the highway leading to the merge "pre_merge_length": 200, # length of the highway past the merge "post_merge_length": 100, # number of lanes in the merge "merge_lanes": 2, # number of lanes in the highway "highway_lanes": 5, # max speed limit of the network "speed_limit": 30, } # we choose to make the main highway slightly longer additional_net_params["pre_merge_length"] = middle_length net_params = NetParams( inflows=inflow, # our inflows no_internal_links=False, additional_params=additional_net_params) sumo_params = SumoParams(render=render_, sim_step=0.2, emission_path=emission_dir) # '/Users/apple/Desktop/Berkeley/Repo/Flow/triange-data/' env_params = EnvParams(additional_params=ADDITIONAL_ENV_PARAMS) initial_config = InitialConfig(spacing="random", perturbation=1) scenario = TriangleMergeScenario(name="custom-triangle-merge-example", vehicles=vehicles, net_params=net_params, initial_config=initial_config, inflow_edge_len=middle_length) env = AccelEnv(env_params, sumo_params, scenario) return Experiment(env)