def cross_road_experiment(render=None): """ Parameters & Returns: tutorials/tutorial05_networks.ipynb """ vehicles = get_vehicle_params(TTCController, { "a": 2.0, "ttc_threshold": 4.5 }) env_params = EnvParams( warmup_steps=150, additional_params=ADDITIONAL_ENV_PARAMS, ) net_params = get_net_params(inflow_probability=0.3) sumo_params = SumoParams(render=True, emission_path="./emission/", summary_path="./emission/", tripinfo_path="./emission/", sim_step=0.1, restart_instance=True) if render is not None: sumo_params.render = render initial_config = get_initial_config() network = CrossRoadNetwork(name="cross_road_network", vehicles=vehicles, net_params=net_params, initial_config=initial_config) env = CrossRoadAccelEnv(env_params, sumo_params, network) return Experiment(env)
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 highway_example(render=None): """ Perform a simulation of vehicles on a highway. 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="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_0", probability=0.25, departLane="free", departSpeed=20) inflow.add(veh_type="human2", edge="highway_0", probability=0.25, departLane="free", departSpeed=20) additional_net_params = ADDITIONAL_NET_PARAMS.copy() net_params = NetParams(inflows=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 followerstopper_example(render=None): """Perform a simulation of vehicles on a ring road. In this simulation, one vehicle is automated, and switches from human-driving to begins to automated vehicles after the time specified in AUTOMATED_TIME. 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='automated', acceleration_controller=(FollowerStopper, { 'v_des': 4.15 }), car_following_params=SumoCarFollowingParams(accel=1), routing_controller=(ContinuousRouter, {}), num_vehicles=1) vehicles.add(veh_id='human', acceleration_controller=(IDMController, { 'noise': 0.2 }), routing_controller=(ContinuousRouter, {}), num_vehicles=21) env_params = EnvParams( additional_params={'automated_time': AUTOMATED_TIME}) additional_net_params = ADDITIONAL_NET_PARAMS.copy() additional_net_params['length'] = LENGTH net_params = NetParams(additional_params=additional_net_params) initial_config = InitialConfig() scenario = LoopScenario(name='sugiyama', vehicles=vehicles, net_params=net_params, initial_config=initial_config) env = ControllerEnv(env_params, sim_params, scenario) return Experiment(env)
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 sumo's gui during execution Returns ------- exp: flow.core.Experiment type A non-rl experiment demonstrating the performance of human-driven vehicles on a ring road. """ sumo_params = SumoParams(sim_step=SUMO_STEP, render=True) if render is not None: sumo_params.render = render vehicles = VehicleParams() vehicles.add(veh_id="idm", acceleration_controller=(IDMController, { "noise": 0.2 }), routing_controller=(ContinuousRouter, {}), num_vehicles=8) # in sugiyama taken from .../flow/scenarios/loop/loop_accel.py env_params = EnvParams(additional_params=ADDITIONAL_ENV_PARAMS) # in sugiyama taken from .../flow/scenarios/loop.py 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) 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 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 ring_perturbation(render=None): sim_params = SumoParams(sim_step=0.1, render=True, restart_instance=True) if render is not None: sim_params.render = render # Setup vehicle types vehicles = VehicleParams() vehicles.add(veh_id="human", acceleration_controller=(IDMController, { "noise": 0.2 }), car_following_params=SumoCarFollowingParams( speed_mode="obey_safe_speed", ), routing_controller=(ContinuousRouter, {}), num_vehicles=50) # For debugging only vehicles.add(veh_id="rl", acceleration_controller=(RLController, {}), car_following_params=SumoCarFollowingParams( speed_mode="obey_safe_speed", ), routing_controller=(ContinuousRouter, {}), num_vehicles=5) # Set parameters for the network additional_net_params = ADDITIONAL_NET_PARAMS.copy() additional_net_params["length"] = 1400 additional_net_params["speed_limit"] = 30 net_params = NetParams(additional_params=additional_net_params) # Setup the scenario initial_config = InitialConfig(shuffle=True) scenario = RingScenario(name='testing', vehicles=vehicles, net_params=net_params, initial_config=initial_config) # Setup the environment env_params = EnvParams(additional_params=PERTURB_ENV_PARAMS) env = PerturbingRingEnv(env_params, sim_params, scenario) return Experiment(env)
def cross_road_experiment(render=None): """ Parameters & Returns: tutorials/tutorial05_networks.ipynb """ vehicles = get_vehicle_params(PRMController, { "t_c": 6.0, "d_s": 55.0, "lambda_a": 1, "r_go": 0.1, "max_accel": 2.0, "max_deaccel": 4.5, "desire_v": 20.0, "d_nudge": 10.0, "discount": 0.2, "debug": False, }) env_params = EnvParams( warmup_steps=150, additional_params=ADDITIONAL_ENV_PARAMS, ) net_params = get_net_params(inflow_probability=0.3) sumo_params = SumoParams( render=True, emission_path="./emission/", summary_path="./emission/", tripinfo_path="./emission/", sim_step=0.1, restart_instance=True ) if render is not None: sumo_params.render = render initial_config = get_initial_config() network = CrossRoadNetwork( name="cross_road_network", vehicles=vehicles, net_params=net_params, initial_config=initial_config ) env = CrossRoadAccelEnv(env_params, sumo_params, network) return Experiment(env)
def bay_bridge_example(render=None, use_inflows=False, use_traffic_lights=False): """ Perform a simulation of vehicles on the Oakland-San Francisco Bay Bridge. Parameters ---------- render: bool, optional specifies whether to use the gui during execution use_inflows: bool, optional whether to activate inflows from the peripheries of the network use_traffic_lights: bool, optional whether to activate the traffic lights in the network Returns ------- exp: flow.core.experiment.Experiment A non-rl experiment demonstrating the performance of human-driven vehicles simulated by sumo on the Bay Bridge. """ sim_params = SumoParams(sim_step=0.6, overtake_right=True) if render is not None: sim_params.render = render car_following_params = SumoCarFollowingParams( speedDev=0.2, speed_mode="all_checks", ) lane_change_params = SumoLaneChangeParams( lc_assertive=20, lc_pushy=0.8, lc_speed_gain=4.0, model="LC2013", lane_change_mode="no_lat_collide", # lcKeepRight=0.8 ) vehicles = VehicleParams() vehicles.add( veh_id="human", acceleration_controller=(SimCarFollowingController, {}), routing_controller=(BayBridgeRouter, {}), car_following_params=car_following_params, lane_change_params=lane_change_params, num_vehicles=1400) additional_env_params = {} env_params = EnvParams(additional_params=additional_env_params) traffic_lights = TrafficLightParams() inflow = InFlows() if use_inflows: # south inflow.add( veh_type="human", edge="183343422", vehsPerHour=528, departLane="0", departSpeed=20) inflow.add( veh_type="human", edge="183343422", vehsPerHour=864, departLane="1", departSpeed=20) inflow.add( veh_type="human", edge="183343422", vehsPerHour=600, departLane="2", departSpeed=20) inflow.add( veh_type="human", edge="393649534", probability=0.1, departLane="0", departSpeed=20) # no data for this # west inflow.add( veh_type="human", edge="11189946", vehsPerHour=1752, departLane="0", departSpeed=20) inflow.add( veh_type="human", edge="11189946", vehsPerHour=2136, departLane="1", departSpeed=20) inflow.add( veh_type="human", edge="11189946", vehsPerHour=576, departLane="2", departSpeed=20) # north inflow.add( veh_type="human", edge="28413687#0", vehsPerHour=2880, departLane="0", departSpeed=20) inflow.add( veh_type="human", edge="28413687#0", vehsPerHour=2328, departLane="1", departSpeed=20) inflow.add( veh_type="human", edge="28413687#0", vehsPerHour=3060, departLane="2", departSpeed=20) inflow.add( veh_type="human", edge="11198593", probability=0.1, departLane="0", departSpeed=20) # no data for this inflow.add( veh_type="human", edge="11197889", probability=0.1, departLane="0", departSpeed=20) # no data for this # midway through bridge inflow.add( veh_type="human", edge="35536683", probability=0.1, departLane="0", departSpeed=20) # no data for this net_params = NetParams(inflows=inflow) net_params.template = TEMPLATE # download the template from AWS if use_traffic_lights: my_url = "https://s3-us-west-1.amazonaws.com/flow.netfiles/" \ "bay_bridge_TL_all_green.net.xml" else: my_url = "https://s3-us-west-1.amazonaws.com/flow.netfiles/" \ "bay_bridge_junction_fix.net.xml" my_file = urllib.request.urlopen(my_url) data_to_write = my_file.read() with open( os.path.join(os.path.dirname(os.path.abspath(__file__)), TEMPLATE), "wb+") as f: f.write(data_to_write) initial_config = InitialConfig( spacing="uniform", min_gap=15, edges_distribution=EDGES_DISTRIBUTION.copy()) network = BayBridgeNetwork( name="bay_bridge", vehicles=vehicles, traffic_lights=traffic_lights, net_params=net_params, initial_config=initial_config) env = BayBridgeEnv(env_params, sim_params, network) return Experiment(env)
def traffic_light_grid_example(render=None, use_inflows=False): """ Perform a simulation of vehicles on a traffic light 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 traffic light 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) network = TrafficLightGridNetwork(name="grid-intersection", vehicles=vehicles, net_params=net_params, initial_config=initial_config, traffic_lights=tl_logic) env = AccelEnv(env_params, sim_params, network) return Experiment(env)
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 dissipating_waves(render=None): sim_params = SumoParams(sim_step=0.1, render=True, restart_instance=True) if render is not None: sim_params.render = render # Setup vehicle types vehicles = VehicleParams() vehicles.add(veh_id="human", acceleration_controller=(IDMController, { "noise": 0.2 }), car_following_params=SumoCarFollowingParams( speed_mode="obey_safe_speed", ), num_vehicles=5) vehicles.add(veh_id="rl", acceleration_controller=(RLController, {}), car_following_params=SumoCarFollowingParams( speed_mode="obey_safe_speed", ), num_vehicles=0) # Vehicles are introduced from both sides of merge, with RL vehicles entering # from the highway portion as well inflow = InFlows() inflow.add(veh_type="human", edge="inflow_highway", vehs_per_hour=(1 - RL_PENETRATION) * FLOW_RATE, depart_lane="free", depart_speed=10) inflow.add(veh_type="rl", edge="inflow_highway", vehs_per_hour=RL_PENETRATION * FLOW_RATE, depart_lane="free", depart_speed=10) inflow.add(veh_type="human", edge="inflow_merge", vehs_per_hour=100, depart_lane="free", depart_speed=7.5) # Set parameters for the network additional_net_params = ADDITIONAL_NET_PARAMS.copy() additional_net_params["pre_merge_length"] = 500 additional_net_params["post_merge_length"] = 200 additional_net_params["merge_lanes"] = 1 additional_net_params["highway_lanes"] = 1 net_params = NetParams(inflows=inflow, additional_params=additional_net_params) # Setup the scenario initial_config = InitialConfig() scenario = MergeScenario(name='testing', vehicles=vehicles, net_params=net_params, initial_config=initial_config) # Setup the environment env_params = EnvParams(additional_params=ADDITIONAL_ENV_PARAMS) env = MergePOEnv(env_params, sim_params, scenario) return Experiment(env)
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 merge_example(render=None): """ Perform a simulation of vehicles on a merge. 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 merge. """ sim_params = SumoParams( render=True, emission_path=osp.abspath(osp.join(osp.dirname(__file__), 'data')), sim_step=0.2, restart_instance=False) 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", ), num_vehicles=5) env_params = EnvParams( additional_params=ADDITIONAL_ENV_PARAMS, sims_per_step=5, warmup_steps=0) inflow = InFlows() inflow.add( veh_type="human", edge="inflow_highway", vehs_per_hour=FLOW_RATE, departLane="free", departSpeed=10) inflow.add( veh_type="human", edge="inflow_merge", vehs_per_hour=100, departLane="free", departSpeed=7.5) additional_net_params = ADDITIONAL_NET_PARAMS.copy() additional_net_params["merge_lanes"] = 1 additional_net_params["highway_lanes"] = 1 additional_net_params["pre_merge_length"] = 500 net_params = NetParams( inflows=inflow, no_internal_links=False, additional_params=additional_net_params) initial_config = InitialConfig(spacing="uniform", perturbation=5.0) scenario = MergeScenario( name="merge-baseline", vehicles=vehicles, net_params=net_params, initial_config=initial_config) env = WaveAttenuationMergePOEnv(env_params, sim_params, scenario) return Experiment(env)
def merge_example(render=None): """ Perform a simulation of vehicles on a 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 merge. """ sumo_params = SumoParams( render=True, emission_path="./data/", sim_step=0.2, restart_instance=False, lateral_resolution=0.2, ) if render is not None: sumo_params.render = render vehicles = Vehicles() vehicles.add( veh_id="1", acceleration_controller=( IDMController, { # "noise": 0.2 }), routing_controller=(WeaveRouter, {}), speed_mode="all_checks", lane_change_mode="strategic", num_vehicles=5) vehicles.add( veh_id="2", acceleration_controller=( IDMController, { # "noise": 0.2 }), routing_controller=(WeaveRouter, {}), speed_mode="all_checks", lane_change_mode="strategic", num_vehicles=5) vehicles.add( veh_id="3", acceleration_controller=( IDMController, { # "noise": 0.2 }), routing_controller=(WeaveRouter, {}), speed_mode="all_checks", lane_change_mode="strategic", num_vehicles=5) vehicles.add( veh_id="4", acceleration_controller=( IDMController, { # "noise": 0.2 }), routing_controller=(WeaveRouter, {}), speed_mode="all_checks", lane_change_mode="strategic", num_vehicles=5) env_params = EnvParams(additional_params=ADDITIONAL_ENV_PARAMS, sims_per_step=5, warmup_steps=0) inflow = InFlows() inflow.add( veh_type="1", edge="inflow_highway", vehs_per_hour=FLOW_RATE * 0.6, # TODO: change departLane="free", departSpeed=10) inflow.add( veh_type="2", edge="inflow_highway", vehs_per_hour=FLOW_RATE * 0.4, # TODO: change departLane="free", departSpeed=10) inflow.add( veh_type="3", edge="inflow_merge", vehs_per_hour=FLOW_RATE * 0.3, # TODO: change departLane="free", departSpeed=7.5) inflow.add( veh_type="4", edge="inflow_merge", vehs_per_hour=FLOW_RATE * 0.1, # TODO: change departLane="free", departSpeed=7.5) additional_net_params = ADDITIONAL_NET_PARAMS.copy() additional_net_params["merge_lanes"] = 1 additional_net_params["diverge_lanes"] = 1 additional_net_params["highway_lanes"] = 2 additional_net_params["pre_merge_length"] = 300 additional_net_params["post_merge_length"] = 200 additional_net_params["post_diverge_length"] = 400 additional_net_params["merge_length"] = 100 additional_net_params["diverge_length"] = 200 net_params = NetParams(inflows=inflow, no_internal_links=False, additional_params=additional_net_params) initial_config = InitialConfig(spacing="uniform", perturbation=5.0) scenario = EntryExitScenario(name="merge-baseline", vehicles=vehicles, net_params=net_params, initial_config=initial_config) env = WaveAttenuationMergePOEnv(env_params, sumo_params, scenario) return SumoExperiment(env, scenario)
def bay_bridge_toll_example(render=None, use_traffic_lights=False): """Perform a simulation of the toll portion of the Bay Bridge. This consists of the toll booth and sections of the road leading up to it. Parameters ---------- render : bool, optional specifies whether to use the gui during execution use_traffic_lights: bool, optional whether to activate the traffic lights in the scenario Note ---- Unlike the bay_bridge_example, inflows are always activated here. """ sim_params = SumoParams(sim_step=0.4, overtake_right=True) if render is not None: sim_params.render = render car_following_params = SumoCarFollowingParams( speedDev=0.2, speed_mode="all_checks", ) lane_change_params = SumoLaneChangeParams( model="LC2013", lcCooperative=0.2, lcSpeedGain=15, lane_change_mode="no_lat_collide", ) vehicles = VehicleParams() vehicles.add(veh_id="human", acceleration_controller=(SimCarFollowingController, {}), routing_controller=(BayBridgeRouter, {}), car_following_params=car_following_params, lane_change_params=lane_change_params, num_vehicles=50) additional_env_params = {} env_params = EnvParams(additional_params=additional_env_params) inflow = InFlows() inflow.add(veh_type="human", edge="393649534", probability=0.2, departLane="random", departSpeed=10) inflow.add(veh_type="human", edge="4757680", probability=0.2, departLane="random", departSpeed=10) inflow.add(veh_type="human", edge="32661316", probability=0.2, departLane="random", departSpeed=10) inflow.add(veh_type="human", edge="90077193#0", vehs_per_hour=2000, departLane="random", departSpeed=10) net_params = NetParams(inflows=inflow, no_internal_links=False, template=TEMPLATE) # download the template from AWS if use_traffic_lights: my_url = "https://s3-us-west-1.amazonaws.com/flow.netfiles/" \ "bay_bridge_TL_all_green.net.xml" else: my_url = "https://s3-us-west-1.amazonaws.com/flow.netfiles/" \ "bay_bridge_junction_fix.net.xml" my_file = urllib.request.urlopen(my_url) data_to_write = my_file.read() with open( os.path.join(os.path.dirname(os.path.abspath(__file__)), TEMPLATE), "wb+") as f: f.write(data_to_write) initial_config = InitialConfig( spacing="uniform", # "random", min_gap=15, edges_distribution=EDGES_DISTRIBUTION.copy()) scenario = BayBridgeTollScenario(name="bay_bridge_toll", vehicles=vehicles, net_params=net_params, initial_config=initial_config) env = BayBridgeEnv(env_params, sim_params, scenario) return Experiment(env)
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 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 da_yuan_example(render=None, use_inflows=True): """ Perform a simulation of vehicles on a traffic light 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 traffic light grid. """ v_enter = 10 sim_params = SumoParams(sim_step=0.05, 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=6) env_params = EnvParams(additional_params=ADDITIONAL_ENV_PARAMS) tl_logic = TrafficLightParams(baseline=False) phases = [{ "duration": "31", "minDur": "8", "maxDur": "45", "state": "rrGGGG" }, { "duration": "6", "minDur": "3", "maxDur": "6", "state": "rryyyy" }, { "duration": "31", "minDur": "8", "maxDur": "45", "state": "GGrrrr" }, { "duration": "6", "minDur": "3", "maxDur": "6", "state": "yyrrrr" }] tl_logic.add("inner0", phases=phases, programID=1) tl_logic.add("inner1", phases=phases, programID=1) tl_logic.add("inner2", phases=phases, programID=1, tls_type="actuated") tl_logic.add("inner3", phases=phases, programID=1, tls_type="actuated") additional_net_params = { "speed_limit": 35, "horizontal_lanes": 1, "vertical_lanes": 1 } if use_inflows: initial_config, net_params = get_flow_params( additional_net_params=additional_net_params) else: initial_config, net_params = get_non_flow_params(enter_speed=v_enter) network = DaYuanNetwork(name="grid-intersection", vehicles=vehicles, net_params=net_params, initial_config=initial_config, traffic_lights=tl_logic) env = AccelEnv(env_params, sim_params, network) return Experiment(env)