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)
