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 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 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)
