def test_num_runs(self): # run the experiment for 1 run and collect the last position of all # vehicles env, _, flow_params = ring_road_exp_setup() flow_params['sim'].render = False flow_params['env'].horizon = 10 exp = Experiment(flow_params) exp.env = env exp.run(num_runs=1) vel1 = [exp.env.k.vehicle.get_speed(exp.env.k.vehicle.get_ids())] # run the experiment for 2 runs and collect the last position of all # vehicles env, _, flow_params = ring_road_exp_setup() flow_params['sim'].render = False flow_params['env'].horizon = 10 exp = Experiment(flow_params) exp.env = env exp.run(num_runs=2) vel2 = [exp.env.k.vehicle.get_speed(exp.env.k.vehicle.get_ids())] # check that the final position is the same in both instances np.testing.assert_array_almost_equal(vel1, vel2)
def setUp_failsafe(self, vehicles): additional_env_params = { "target_velocity": 8, "max_accel": 3, "max_decel": 3, "sort_vehicles": False } env_params = EnvParams(additional_params=additional_env_params) additional_net_params = { "length": 100, "lanes": 1, "speed_limit": 30, "resolution": 40 } net_params = NetParams(additional_params=additional_net_params) initial_config = InitialConfig(bunching=10) # create the environment and scenario classes for a ring road env, scenario = ring_road_exp_setup( vehicles=vehicles, env_params=env_params, net_params=net_params, initial_config=initial_config) # instantiate an experiment class self.exp = Experiment(env)
def test_convert_to_csv(self): dir_path = os.path.dirname(os.path.realpath(__file__)) sim_params = SumoParams(emission_path="{}/".format(dir_path)) env, scenario = ring_road_exp_setup(sim_params=sim_params) exp = Experiment(env) exp.run(num_runs=1, num_steps=10, convert_to_csv=True) time.sleep(0.1) # check that both the emission xml and csv files exist self.assertTrue( os.path.isfile(dir_path + "/{}-emission.xml".format(scenario.name))) self.assertTrue( os.path.isfile(dir_path + "/{}-emission.csv".format(scenario.name))) time.sleep(0.1) # delete the files os.remove( os.path.expanduser(dir_path + "/{}-emission.xml".format(scenario.name))) os.remove( os.path.expanduser(dir_path + "/{}-emission.csv".format(scenario.name)))
class TestItRuns(unittest.TestCase): """ Tests the set_state function """ def setUp(self): vehicles = Vehicles() vehicles.add( veh_id="idm", acceleration_controller=(IDMController, {}), routing_controller=(GridRouter, {}), sumo_car_following_params=SumoCarFollowingParams( min_gap=2.5, tau=1.1), num_vehicles=16) env, scenario = grid_mxn_exp_setup( row_num=1, col_num=3, vehicles=vehicles) self.exp = Experiment(env) def tearDown(self): # free data used by the class self.exp = None def test_it_runs(self): self.exp.run(5, 50)
class TestItRuns(unittest.TestCase): """ Tests the set_state function """ def setUp(self): vehicles = VehicleParams() vehicles.add(veh_id="idm", acceleration_controller=(IDMController, {}), routing_controller=(GridRouter, {}), car_following_params=SumoCarFollowingParams(min_gap=2.5, tau=1.1), num_vehicles=16) _, _, flow_params = traffic_light_grid_mxn_exp_setup(row_num=1, col_num=3, vehicles=vehicles) flow_params['env'].horizon = 50 self.exp = Experiment(flow_params) def tearDown(self): # free data used by the class self.exp = None def test_it_runs(self): self.exp.run(5)
def test_rl_actions(self): def rl_actions(*_): return [1] # actions are always an acceleration of 1 for one veh # create an environment using AccelEnv with 1 RL vehicle vehicles = VehicleParams() vehicles.add( veh_id="rl", acceleration_controller=(RLController, {}), routing_controller=(ContinuousRouter, {}), car_following_params=SumoCarFollowingParams( speed_mode="aggressive", ), num_vehicles=1) env, _ = ring_road_exp_setup(vehicles=vehicles) exp = Experiment(env=env) exp.run(1, 10, rl_actions=rl_actions) # check that the acceleration of the RL vehicle was that specified by # the rl_actions method self.assertAlmostEqual(exp.env.k.vehicle.get_speed("rl_0"), 1, places=1)
class TestLoopMerges(unittest.TestCase): """ Tests the loop_merges scenario and environment. """ def setUp(self): # create the environment and scenario classes for a ring road self.env, scenario = two_loops_one_merging_exp_setup() # instantiate an experiment class self.exp = Experiment(self.env) def tearDown(self): # terminate the traci instance try: self.env.terminate() except FileNotFoundError: pass # free up used memory self.env = None self.exp = None def test_it_runs(self): """ Tests that the loop merges experiment runs, and vehicles do not exit the network. """ self.exp.run(1, 10) def test_gen_custom_start_pos(self): """ Tests that vehicle with the prefix "merge" are in the merge_in lane, and all other vehicles are in the ring road. """ # reset the environment to ensure all vehicles are at their starting # positions self.env.reset() ids = self.env.k.vehicle.get_ids() # collect the starting edges of all vehicles merge_starting_edges = [] other_starting_edges = [] for veh_id in ids: if veh_id[:5] == "merge": merge_starting_edges.append( self.env.k.vehicle.get_edge(veh_id)) else: other_starting_edges.append( self.env.k.vehicle.get_edge(veh_id)) # ensure that all vehicles are starting in the edges they should be in expected_merge_starting_edges = ["right", "top", "bottom"] self.assertTrue( all(starting_edge in expected_merge_starting_edges for starting_edge in merge_starting_edges)) self.assertTrue( all(starting_edge not in expected_merge_starting_edges for starting_edge in other_starting_edges))
def test_collide_inflows(self): """Tests collisions in the presence of inflows.""" # create the environment and network classes for a ring road sim_params = SumoParams(sim_step=1, render=False) total_vehicles = 0 vehicles = VehicleParams() vehicles.add( veh_id="idm", acceleration_controller=(SimCarFollowingController, {}), routing_controller=(GridRouter, {}), car_following_params=SumoCarFollowingParams( tau=0.1, carFollowModel="Krauss", minGap=2.5, speed_mode=0b00000, ), num_vehicles=total_vehicles) grid_array = { "short_length": 100, "inner_length": 100, "long_length": 100, "row_num": 1, "col_num": 1, "cars_left": 0, "cars_right": 0, "cars_top": 0, "cars_bot": 0 } additional_net_params = { "speed_limit": 35, "grid_array": grid_array, "horizontal_lanes": 1, "vertical_lanes": 1 } inflows = InFlows() inflows.add(veh_type="idm", edge="bot0_0", vehs_per_hour=1000) inflows.add(veh_type="idm", edge="top0_1", vehs_per_hour=1000) inflows.add(veh_type="idm", edge="left1_0", vehs_per_hour=1000) inflows.add(veh_type="idm", edge="right0_0", vehs_per_hour=1000) net_params = NetParams( inflows=inflows, additional_params=additional_net_params) env, _ = traffic_light_grid_mxn_exp_setup( row_num=1, col_num=1, sim_params=sim_params, vehicles=vehicles, net_params=net_params) # go through the env and set all the lights to green for i in range(env.rows * env.cols): env.k.traffic_light.set_state( node_id='center' + str(i), state="gggggggggggg") # instantiate an experiment class exp = Experiment(env) exp.run(50, 50)
def merge_baseline(num_runs, render=True): """Run script for all merge baselines. Parameters ---------- num_runs : int number of rollouts the performance of the environment is evaluated over render: bool, optional specifies whether to use the gui during execution Returns ------- flow.core.experiment.Experiment class needed to run simulations """ sim_params = flow_params['sim'] env_params = flow_params['env'] # modify the rendering to match what is requested sim_params.render = render # set the evaluation flag to True env_params.evaluate = True flow_params['env'].horizon = env_params.horizon exp = Experiment(flow_params) results = exp.run(num_runs) avg_speed = np.mean(results['mean_returns']) return avg_speed
def setUp(self): # create the environment and network classes for a ring road env, _, flow_params = ring_road_exp_setup() flow_params['sim'].render = False flow_params['env'].horizon = 10 # instantiate an experiment class self.exp = Experiment(flow_params) self.exp.env = env
class TestIndividualLights(unittest.TestCase): """ Tests the functionality of the the TrafficLightParams class in allowing for customization of specific nodes """ def setUp(self): tl_logic = TrafficLightParams(baseline=False) phases = [{ "duration": "31", "minDur": "8", "maxDur": "45", "state": "GrGr" }, { "duration": "6", "minDur": "3", "maxDur": "6", "state": "yryr" }, { "duration": "31", "minDur": "8", "maxDur": "45", "state": "rGrG" }, { "duration": "6", "minDur": "3", "maxDur": "6", "state": "ryry" }] tl_logic.add("center0", phases=phases, programID=1) tl_logic.add("center1", phases=phases, programID=1, offset=1) tl_logic.add("center2", tls_type="actuated", phases=phases, programID=1) tl_logic.add("center3", tls_type="actuated", phases=phases, programID=1, maxGap=3.0, detectorGap=0.8, showDetectors=True, file="testindividuallights.xml", freq=100) _, _, flow_params = traffic_light_grid_mxn_exp_setup(row_num=1, col_num=4, tl_logic=tl_logic) flow_params['env'].horizon = 50 self.exp = Experiment(flow_params) def tearDown(self): # free data used by the class self.exp = None def test_it_runs(self): self.exp.run(5)
def run_experiment(parameters): additional_net_params = parameters["additional_net_params"] flow_rate = parameters["flow_rate"] name = parameters["name"] vehicle_types = parameters["vehicle_types"] vehicle_speeds = parameters["vehicle_speeds"] lane_change_modes = parameters["lane_change_modes"] experiment_len = parameters["experiment_len"] emission_path = parameters["emission_path"] inflow_c = Inflow(flow_rate=flow_rate, vehicle_types=vehicle_types) inflow = inflow_c.create_inflow() net_params = NetParams(additional_params=additional_net_params, inflows=inflow) initial_config = InitialConfig(spacing="random", perturbation=1, edges_distribution=["edge4"]) traffic_lights = TrafficLightParams() sim_params = SumoParams(sim_step=1, render=True, emission_path=emission_path, restart_instance=True, overtake_right=True) env_params = EnvParams(additional_params=ADDITIONAL_ENV_PARAMS) vehicle_c = Vehicles(vehicle_types=vehicle_types, vehicle_speeds=vehicle_speeds, lane_change_modes=lane_change_modes) vehicles = vehicle_c.create_vehicles() flow_params = dict(exp_tag=name, env_name=AccelEnv, network=HighwayNetwork, simulator='traci', sim=sim_params, env=env_params, net=net_params, veh=vehicles, initial=initial_config, tls=traffic_lights) # number of time steps flow_params['env'].horizon = experiment_len exp = Experiment(flow_params) # run the sumo simulation _ = exp.run(1, convert_to_csv=True) emission_location = os.path.join(exp.env.sim_params.emission_path, exp.env.network.name) print(emission_location + '-emission.xml')
def run_scenario(render=False, emissions=None,#"/home/mesto/flow/data/", output=output_path, step=0.1, duration=1000, flow_rate=2800, car_following_model=IDMController, speed=30 ): env_params = EnvParams() initial_config = InitialConfig() vehicles = VehicleParams() sim_params = SumoParams(render=render, sim_step=step, emission_path=emissions) vehicles = VehicleParams() inflow = InFlows() #Parameters for the network. #Template( net: file path for the sumo network. rou: path to the routes xml file #vtype: path to vehicle types xml. #e1det: Requires modified traci simulation python file. Points to where detector definitions are stored #location that output will be saved. Also requires modified traci.py net_params = NetParams(inflows=inflow, template= { "net" : net_path, "rou" : route_path, "vtype": vtype_path, "e1Det": detector_path, "output": output }, no_internal_links=False) initial_config = InitialConfig( edges_distribution=[starting_edge]) scenario = Custom_Scenario( name="template", net_params=net_params, initial_config=initial_config, vehicles=vehicles ) #The following determines which lanes vehicles spawn in. By default they spawn in rightmost lane #possibles are: int (number of lane), free (which lane is open), best, random for key in scenario.template_vehicles: scenario.template_vehicles[key]['departLane'] = 'free' env = myEnv( env_params=env_params, sim_params=sim_params, scenario=scenario ) env.setSpeed(speed) exp = Experiment(env=env) _ = exp.run(1, duration)
def run_simulation(flow_params): # make the horizon small and set render to False flow_params['sim'].render = False flow_params['env'].horizon = 5 # create an experiment object exp = Experiment(flow_params) # run the experiment for one run exp.run(1)
def merge_baseline(num_runs, render=True): """Run script for all merge baselines. Parameters ---------- num_runs : int number of rollouts the performance of the environment is evaluated over render: bool, optional specifies whether to use the gui during execution Returns ------- flow.core.experiment.Experiment class needed to run simulations """ exp_tag = flow_params['exp_tag'] sim_params = flow_params['sim'] vehicles = flow_params['veh'] env_params = flow_params['env'] net_params = flow_params['net'] initial_config = flow_params.get('initial', InitialConfig()) traffic_lights = flow_params.get('tls', TrafficLightParams()) # modify the rendering to match what is requested sim_params.render = render # set the evaluation flag to True env_params.evaluate = True # import the scenario class module = __import__('flow.scenarios', fromlist=[flow_params['scenario']]) scenario_class = getattr(module, flow_params['scenario']) # create the scenario object scenario = scenario_class(name=exp_tag, vehicles=vehicles, net_params=net_params, initial_config=initial_config, traffic_lights=traffic_lights) # import the environment class module = __import__('flow.envs', fromlist=[flow_params['env_name']]) env_class = getattr(module, flow_params['env_name']) # create the environment object env = env_class(env_params, sim_params, scenario) exp = Experiment(env) results = exp.run(num_runs, env_params.horizon) avg_speed = np.mean(results['mean_returns']) return avg_speed
def test_collide(self): """Tests collisions in the absence of inflows.""" # create the environment and scenario classes for a ring road sim_params = SumoParams(sim_step=1, render=False) total_vehicles = 20 vehicles = VehicleParams() vehicles.add( veh_id="idm", acceleration_controller=(SimCarFollowingController, {}), routing_controller=(GridRouter, {}), car_following_params=SumoCarFollowingParams( tau=0.1, carFollowModel="Krauss", minGap=2.5, speed_mode=0b00000, ), num_vehicles=total_vehicles) grid_array = { "short_length": 100, "inner_length": 100, "long_length": 100, "row_num": 1, "col_num": 1, "cars_left": int(total_vehicles / 4), "cars_right": int(total_vehicles / 4), "cars_top": int(total_vehicles / 4), "cars_bot": int(total_vehicles / 4) } additional_net_params = { "speed_limit": 35, "grid_array": grid_array, "horizontal_lanes": 1, "vertical_lanes": 1 } net_params = NetParams( no_internal_links=False, additional_params=additional_net_params) self.env, self.scenario = grid_mxn_exp_setup( row_num=1, col_num=1, sim_params=sim_params, vehicles=vehicles, net_params=net_params) # go through the env and set all the lights to green for i in range(self.env.rows * self.env.cols): self.env.traci_connection.trafficlight.setRedYellowGreenState( 'center' + str(i), "gggggggggggg") # instantiate an experiment class self.exp = Experiment(self.env) self.exp.run(50, 50)
def merge_baseline(num_runs): """Run script for all merge baselines. Parameters ---------- num_runs : int number of rollouts the performance of the environment is evaluated over flow_params : dict the flow meta-parameters describing the structure of a benchmark. Must be one of the merge flow_params Returns ------- flow.core.experiment.Experiment class needed to run simulations """ exp_tag = flow_params['exp_tag'] sim_params = flow_params['sim'] vehicles = flow_params['veh'] env_params = flow_params['env'] net_params = flow_params['net'] initial_config = flow_params.get('initial', InitialConfig()) traffic_lights = flow_params.get('tls', TrafficLightParams()) # set the evaluation flag to True env_params.evaluate = True # import the scenario class module = __import__('flow.scenarios', fromlist=[flow_params['scenario']]) scenario_class = getattr(module, flow_params['scenario']) # create the scenario object scenario = scenario_class(name=exp_tag, vehicles=vehicles, net_params=net_params, initial_config=initial_config, traffic_lights=traffic_lights) # import the environment class module = __import__('flow.envs', fromlist=[flow_params['env_name']]) env_class = getattr(module, flow_params['env_name']) # create the environment object env = env_class(env_params, sim_params, scenario) exp = Experiment(env) results = exp.run(num_runs, env_params.horizon, convert_to_csv=True) avg_speed = np.mean(results['mean_returns']) return avg_speed
def bottleneck1_baseline(num_runs, render=True): """Run script for the bottleneck1 baseline. Parameters ---------- num_runs : int number of rollouts the performance of the environment is evaluated over render: str, optional specifies whether to use the gui during execution Returns ------- flow.core.experiment.Experiment class needed to run simulations """ sim_params = flow_params['sim'] env_params = flow_params['env'] net_params = flow_params['net'] # we want no autonomous vehicles in the simulation vehicles = VehicleParams() vehicles.add(veh_id='human', car_following_params=SumoCarFollowingParams(speed_mode=9, ), routing_controller=(ContinuousRouter, {}), lane_change_params=SumoLaneChangeParams( lane_change_mode=1621, ), num_vehicles=1 * SCALING) # only include human vehicles in inflows flow_rate = 2300 * SCALING inflow = InFlows() inflow.add(veh_type='human', edge='1', vehs_per_hour=flow_rate, departLane='random', departSpeed=10) net_params.inflows = inflow # modify the rendering to match what is requested sim_params.render = render # set the evaluation flag to True env_params.evaluate = True flow_params['env'].horizon = env_params.horizon exp = Experiment(flow_params) results = exp.run(num_runs) return np.mean(results['returns']), np.std(results['returns'])
def setUp(self): vehicles = Vehicles() vehicles.add( veh_id="idm", acceleration_controller=(IDMController, {}), routing_controller=(GridRouter, {}), sumo_car_following_params=SumoCarFollowingParams( min_gap=2.5, tau=1.1), num_vehicles=16) env, scenario = grid_mxn_exp_setup( row_num=1, col_num=3, vehicles=vehicles) self.exp = Experiment(env)
def setUp(self): vehicles = VehicleParams() vehicles.add(veh_id="idm", acceleration_controller=(IDMController, {}), routing_controller=(GridRouter, {}), car_following_params=SumoCarFollowingParams(min_gap=2.5, tau=1.1), num_vehicles=16) _, _, flow_params = traffic_light_grid_mxn_exp_setup(row_num=1, col_num=3, vehicles=vehicles) flow_params['env'].horizon = 50 self.exp = Experiment(flow_params)
def setUp(self): # create the environment and scenario classes for a grid network self.env, _ = grid_mxn_exp_setup(row_num=2, col_num=2) self.env.reset() # instantiate an experiment class self.exp = Experiment(self.env)
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 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 = AimsunParams(sim_step=0.5, render=False, emission_path='data') if render is not None: sim_params.render = render vehicles = VehicleParams() vehicles.add(veh_id="human", acceleration_controller=(IDMController, {}), num_vehicles=14) env_params = EnvParams() net_params = NetParams(additional_params=ADDITIONAL_NET_PARAMS.copy()) scenario = Figure8Scenario(name="figure8", vehicles=vehicles, net_params=net_params) env = TestEnv(env_params, sim_params, scenario, simulator='aimsun') return Experiment(env)
def setUp(self): # create the environment and network classes for a traffic light grid network self.env, _ = traffic_light_grid_mxn_exp_setup(row_num=2, col_num=2) self.env.reset() # instantiate an experiment class self.exp = Experiment(self.env)
def setUp(self): # create the environment and scenario classes for a ring road self.env, self.scenario = grid_mxn_exp_setup() self.env.reset() # instantiate an experiment class self.exp = Experiment(self.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 setUp(self): tl_logic = TrafficLightParams(baseline=False) phases = [{ "duration": "31", "minDur": "8", "maxDur": "45", "state": "GrGr" }, { "duration": "6", "minDur": "3", "maxDur": "6", "state": "yryr" }, { "duration": "31", "minDur": "8", "maxDur": "45", "state": "rGrG" }, { "duration": "6", "minDur": "3", "maxDur": "6", "state": "ryry" }] tl_logic.add("center0", phases=phases, programID=1) tl_logic.add("center1", phases=phases, programID=1, offset=1) tl_logic.add("center2", tls_type="actuated", phases=phases, programID=1) tl_logic.add("center3", tls_type="actuated", phases=phases, programID=1, maxGap=3.0, detectorGap=0.8, showDetectors=True, file="testindividuallights.xml", freq=100) _, _, flow_params = traffic_light_grid_mxn_exp_setup(row_num=1, col_num=4, tl_logic=tl_logic) flow_params['env'].horizon = 50 self.exp = Experiment(flow_params)
def main(): env = GetTrafficLightEnv() act = deepq.learn(env, network='mlp', total_timesteps=0, load_path="tls_model.pkl") reward = 0 iterations = 1 exp = Experiment(getFlowParamsForTls()) ## This is the RL agent that is using the trained model that we saved from train_tls file rl_agent = lambda state: act(state[None])[0] ## This is the static agent that switches the light every 20s static_agent = static_rl_actions # Passing the appropriate lambda among static and rl, you can perform the experiment exp.run(10, rl_agent, convert_to_csv=True)
def setUp(self): tl_logic = TrafficLightParams(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, offset=1) tl_logic.add("center2", tls_type="actuated", phases=phases, programID=1) tl_logic.add("center3", tls_type="actuated", phases=phases, programID=1, maxGap=3.0, detectorGap=0.8, showDetectors=True, file="testindividuallights.xml", freq=100) env, scenario = grid_mxn_exp_setup(row_num=1, col_num=4, tl_logic=tl_logic) self.exp = Experiment(env)
def highway_example(render=None): """ Perform a simulation of vehicles on a highway. 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="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) network = HighwayNetwork(name="highway", vehicles=vehicles, net_params=net_params, initial_config=initial_config) env = LaneChangeAccelEnv(env_params, sim_params, network) return Experiment(env)