def __init__(self,
env_params,
sim_params,
network=None,
simulator='traci',
scenario=None):
"""Initialize the environment class.
Parameters
----------
env_params : flow.core.params.EnvParams
see flow/core/params.py
sim_params : flow.core.params.SimParams
see flow/core/params.py
network : flow.networks.Network
see flow/networks/base.py
simulator : str
the simulator used, one of {'traci', 'aimsun'}. Defaults to 'traci'
Raises
------
flow.utils.exceptions.FatalFlowError
if the render mode is not set to a valid value
"""
self.env_params = env_params
if scenario is not None:
deprecated_attribute(self, "scenario", "network")
self.network = scenario if scenario is not None else network
self.net_params = self.network.net_params
self.initial_config = self.network.initial_config
self.sim_params = deepcopy(sim_params)
# check whether we should be rendering
self.should_render = self.sim_params.render
self.sim_params.render = False
time_stamp = ''.join(str(time.time()).split('.'))
if os.environ.get("TEST_FLAG", 0):
# 1.0 works with stress_test_start 10k times
time.sleep(1.0 * int(time_stamp[-6:]) / 1e6)
# FIXME: this is sumo-specific
self.sim_params.port = sumolib.miscutils.getFreeSocketPort()
# time_counter: number of steps taken since the start of a rollout
self.time_counter = 0
# step_counter: number of total steps taken
self.step_counter = 0
# initial_state:
self.initial_state = {}
self.state = None
self.obs_var_labels = []
# simulation step size
self.sim_step = sim_params.sim_step
# the simulator used by this environment
self.simulator = simulator
# create the Flow kernel
self.k = Kernel(simulator=self.simulator, sim_params=self.sim_params)
# use the network class's network parameters to generate the necessary
# network components within the network kernel
self.k.network.generate_network(self.network)
# initial the vehicles kernel using the VehicleParams object
self.k.vehicle.initialize(deepcopy(self.network.vehicles))
# initialize the simulation using the simulation kernel. This will use
# the network kernel as an input in order to determine what network
# needs to be simulated.
kernel_api = self.k.simulation.start_simulation(
network=self.k.network, sim_params=self.sim_params)
# pass the kernel api to the kernel and it's subclasses
self.k.pass_api(kernel_api)
# the available_routes variable contains a dictionary of routes
# vehicles can traverse; to be used when routes need to be chosen
# dynamically
self.available_routes = self.k.network.rts
# store the initial vehicle ids
self.initial_ids = deepcopy(self.network.vehicles.ids)
# store the initial state of the vehicles kernel (needed for restarting
# the simulation)
self.k.vehicle.kernel_api = None
self.k.vehicle.master_kernel = None
self.initial_vehicles = deepcopy(self.k.vehicle)
self.k.vehicle.kernel_api = self.k.kernel_api
self.k.vehicle.master_kernel = self.k
self.setup_initial_state()
# use pyglet to render the simulation
if self.sim_params.render in ['gray', 'dgray', 'rgb', 'drgb']:
save_render = self.sim_params.save_render
sight_radius = self.sim_params.sight_radius
pxpm = self.sim_params.pxpm
show_radius = self.sim_params.show_radius
# get network polygons
network = []
# FIXME: add to network kernel instead of hack
for lane_id in self.k.kernel_api.lane.getIDList():
_lane_poly = self.k.kernel_api.lane.getShape(lane_id)
lane_poly = [i for pt in _lane_poly for i in pt]
network.append(lane_poly)
# instantiate a pyglet renderer
self.renderer = Renderer(network,
self.sim_params.render,
save_render,
sight_radius=sight_radius,
pxpm=pxpm,
show_radius=show_radius)
# render a frame
self.render(reset=True)
elif self.sim_params.render in [True, False]:
# default to sumo-gui (if True) or sumo (if False)
if (self.sim_params.render is
True) and self.sim_params.save_render:
self.path = os.path.expanduser(
'~') + '/flow_rendering/' + self.network.name
os.makedirs(self.path, exist_ok=True)
else:
raise FatalFlowError('Mode %s is not supported!' %
self.sim_params.render)
atexit.register(self.terminate)
def __init__(
self,
speed_mode='right_of_way',
accel=2.6,
decel=4.5,
sigma=0.5,
tau=1.0, # past 1 at sim_step=0.1 you no longer see waves
min_gap=2.5,
max_speed=30,
speed_factor=1.0,
speed_dev=0.1,
impatience=0.5,
car_follow_model="IDM",
**kwargs):
"""Instantiate SumoCarFollowingParams."""
# check for deprecations (minGap)
if "minGap" in kwargs:
deprecated_attribute(self, "minGap", "min_gap")
min_gap = kwargs["minGap"]
# check for deprecations (maxSpeed)
if "maxSpeed" in kwargs:
deprecated_attribute(self, "maxSpeed", "max_speed")
max_speed = kwargs["maxSpeed"]
# check for deprecations (speedFactor)
if "speedFactor" in kwargs:
deprecated_attribute(self, "speedFactor", "speed_factor")
speed_factor = kwargs["speedFactor"]
# check for deprecations (speedDev)
if "speedDev" in kwargs:
deprecated_attribute(self, "speedDev", "speed_dev")
speed_dev = kwargs["speedDev"]
# check for deprecations (carFollowModel)
if "carFollowModel" in kwargs:
deprecated_attribute(self, "carFollowModel", "car_follow_model")
car_follow_model = kwargs["carFollowModel"]
# create a controller_params dict with all the specified parameters
self.controller_params = {
"accel": accel,
"decel": decel,
"sigma": sigma,
"tau": tau,
"minGap": min_gap,
"maxSpeed": max_speed,
"speedFactor": speed_factor,
"speedDev": speed_dev,
"impatience": impatience,
"carFollowModel": car_follow_model,
}
# adjust the speed mode value
if isinstance(speed_mode, str) and speed_mode in SPEED_MODES:
speed_mode = SPEED_MODES[speed_mode]
elif not (isinstance(speed_mode, int)
or isinstance(speed_mode, float)):
logging.error("Setting speed mode of to default.")
speed_mode = SPEED_MODES["obey_safe_speed"]
self.speed_mode = speed_mode
def __init__(self,
lane_change_mode="no_lc_safe",
model="LC2013",
lc_strategic=1.0,
lc_cooperative=1.0,
lc_speed_gain=1.0,
lc_keep_right=1.0,
lc_look_ahead_left=2.0,
lc_speed_gain_right=1.0,
lc_sublane=1.0,
lc_pushy=0,
lc_pushy_gap=0.6,
lc_assertive=1,
lc_accel_lat=1.0,
**kwargs):
"""Instantiate SumoLaneChangeParams."""
# check for deprecations (lcStrategic)
if "lcStrategic" in kwargs:
deprecated_attribute(self, "lcStrategic", "lc_strategic")
lc_strategic = kwargs["lcStrategic"]
# check for deprecations (lcCooperative)
if "lcCooperative" in kwargs:
deprecated_attribute(self, "lcCooperative", "lc_cooperative")
lc_cooperative = kwargs["lcCooperative"]
# check for deprecations (lcSpeedGain)
if "lcSpeedGain" in kwargs:
deprecated_attribute(self, "lcSpeedGain", "lc_speed_gain")
lc_speed_gain = kwargs["lcSpeedGain"]
# check for deprecations (lcKeepRight)
if "lcKeepRight" in kwargs:
deprecated_attribute(self, "lcKeepRight", "lc_keep_right")
lc_keep_right = kwargs["lcKeepRight"]
# check for deprecations (lcLookaheadLeft)
if "lcLookaheadLeft" in kwargs:
deprecated_attribute(self, "lcLookaheadLeft", "lc_look_ahead_left")
lc_look_ahead_left = kwargs["lcLookaheadLeft"]
# check for deprecations (lcSpeedGainRight)
if "lcSpeedGainRight" in kwargs:
deprecated_attribute(self, "lcSpeedGainRight",
"lc_speed_gain_right")
lc_speed_gain_right = kwargs["lcSpeedGainRight"]
# check for deprecations (lcSublane)
if "lcSublane" in kwargs:
deprecated_attribute(self, "lcSublane", "lc_sublane")
lc_sublane = kwargs["lcSublane"]
# check for deprecations (lcPushy)
if "lcPushy" in kwargs:
deprecated_attribute(self, "lcPushy", "lc_pushy")
lc_pushy = kwargs["lcPushy"]
# check for deprecations (lcPushyGap)
if "lcPushyGap" in kwargs:
deprecated_attribute(self, "lcPushyGap", "lc_pushy_gap")
lc_pushy_gap = kwargs["lcPushyGap"]
# check for deprecations (lcAssertive)
if "lcAssertive" in kwargs:
deprecated_attribute(self, "lcAssertive", "lc_assertive")
lc_assertive = kwargs["lcAssertive"]
# check for deprecations (lcAccelLat)
if "lcAccelLat" in kwargs:
deprecated_attribute(self, "lcAccelLat", "lc_accel_lat")
lc_accel_lat = kwargs["lcAccelLat"]
# check for valid model
if model not in ["LC2013", "SL2015"]:
logging.error("Invalid lane change model! Defaulting to LC2013")
model = "LC2013"
if model == "LC2013":
self.controller_params = {
"laneChangeModel": model,
"lcStrategic": str(lc_strategic),
"lcCooperative": str(lc_cooperative),
"lcSpeedGain": str(lc_speed_gain),
"lcKeepRight": str(lc_keep_right),
# "lcLookaheadLeft": str(lc_look_ahead_left),
# "lcSpeedGainRight": str(lcSpeedGainRight)
}
elif model == "SL2015":
self.controller_params = {
"laneChangeModel": model,
"lcStrategic": str(lc_strategic),
"lcCooperative": str(lc_cooperative),
"lcSpeedGain": str(lc_speed_gain),
"lcKeepRight": str(lc_keep_right),
"lcLookaheadLeft": str(lc_look_ahead_left),
"lcSpeedGainRight": str(lc_speed_gain_right),
"lcSublane": str(lc_sublane),
"lcPushy": str(lc_pushy),
"lcPushyGap": str(lc_pushy_gap),
"lcAssertive": str(lc_assertive),
"lcAccelLat": str(lc_accel_lat)
}
# adjust the lane change mode value
if isinstance(lane_change_mode, str) and lane_change_mode in LC_MODES:
lane_change_mode = LC_MODES[lane_change_mode]
elif not (isinstance(lane_change_mode, int)
or isinstance(lane_change_mode, float)):
logging.error("Setting lane change mode to default.")
lane_change_mode = LC_MODES["no_lc_safe"]
self.lane_change_mode = lane_change_mode
def deprecate(old, new):
deprecated_attribute(self, old, new)
new_val = kwargs[old]
del kwargs[old]
return new_val
def __init__(self,
env_params,
sim_params,
network=None,
simulator='traci',
scenario=None):
"""Initialize the environment class.
Parameters
----------
env_params : flow.core.params.EnvParams
see flow/core/params.py
sim_params : flow.core.params.SimParams
see flow/core/params.py
network : flow.networks.Network
see flow/networks/base.py
simulator : str
the simulator used, one of {'traci', 'aimsun'}. Defaults to 'traci'
Raises
------
flow.utils.exceptions.FatalFlowError
if the render mode is not set to a valid valuefor _ in range(self.env_params.sims_per_step):
self.time_counter += 1
self.step_counter += 1
# perform acceleration actions for controlled human-driven vehicles
if len(self.k.vehicle.get_controlled_ids()) > 0:
accel = []
for veh_id in self.k.vehicle.get_controlled_ids():
action = self.k.vehicle.get_acc_controller(
veh_id).get_action(self)
accel.append(action)
if self.k.vehicle.get_edge(veh_id)[0] == ":":
if self.k.vehicle.get_speed(veh_id) <= 0.00000001:
print(self.time_counter,'veh_id:',veh_id,'its leader:',self.k.vehicle.get_leader(veh_id),'headway to leader:',self.k.vehicle.get_headway(veh_id),'action:',action,'speed:',self.k.vehicle.get_speed(veh_id))
#if self.k.vehicle.get_leader(self.k.vehicle.get_leader(veh_id))==veh_id:
# break
self.k.vehicle.apply_acceleration(
self.k.vehicle.get_controlled_ids(), accel)
# perform lane change actions for controlled human-driven vehicles
if len(self.k.vehicle.get_controlled_lc_ids()) > 0:
direction = []
for veh_id in self.k.vehicle.get_controlled_lc_ids():
target_lane = self.k.vehicle.get_lane_changing_controller(
veh_id).get_action(self)
direction.append(target_lane)
self.k.vehicle.apply_lane_change(
self.k.vehicle.get_controlled_lc_ids(),
direction=direction)
# perform (optionally) routing actions for all vehicles in the
# network, including RL and SUMO-controlled vehicles
routing_ids = []
routing_actions = []
for veh_id in self.k.vehicle.get_ids():
if self.k.vehicle.get_routing_controller(veh_id) \
is not None:
routing_ids.append(veh_id)
route_contr = self.k.vehicle.get_routing_controller(
veh_id)
routing_actions.append(route_contr.choose_route(self))
self.k.vehicle.choose_routes(routing_ids, routing_actions)
self.apply_rl_actions(rl_actions)
#self.additional_command()
# advance the simulation in the simulator by one step
"""
self.process_seeds_file = None
self.env_params = env_params
self.time_with_no_vehicles = 0
if scenario is not None:
deprecated_attribute(self, "scenario", "network")
self.network = scenario if scenario is not None else network
self.net_params = self.network.net_params
self.initial_config = self.network.initial_config
self.sim_params = sim_params
time_stamp = ''.join(str(time.time()).split('.'))
if os.environ.get("TEST_FLAG", 0):
# 1.0 works with stress_test_start 10k times
time.sleep(1.0 * int(time_stamp[-6:]) / 1e6)
# FIXME: this is sumo-specific
self.sim_params.port = sumolib.miscutils.getFreeSocketPort()
# time_counter: number of steps taken since the start of a rollout
self.time_counter = 0
# step_counter: number of total steps taken
self.step_counter = 0
# initial_state:
self.initial_state = {}
self.state = None
self.obs_var_labels = []
# simulation step size
self.sim_step = sim_params.sim_step
# the simulator used by this environment
self.simulator = simulator
# create the Flow kernel
self.k = Kernel(simulator=self.simulator, sim_params=sim_params)
# use the network class's network parameters to generate the necessary
# network components within the network kernel
self.k.network.generate_network(self.network)
# initial the vehicles kernel using the VehicleParams object
self.k.vehicle.initialize(deepcopy(self.network.vehicles))
# initialize the simulation using the simulation kernel. This will use
# the network kernel as an input in order to determine what network
# needs to be simulated.
kernel_api = self.k.simulation.start_simulation(network=self.k.network,
sim_params=sim_params)
# pass the kernel api to the kernel and it's subclasses
self.k.pass_api(kernel_api)
# the available_routes variable contains a dictionary of routes
# vehicles can traverse; to be used when routes need to be chosen
# dynamically
self.available_routes = self.k.network.rts
# store the initial vehicle ids
self.initial_ids = deepcopy(self.network.vehicles.ids)
# store the initial state of the vehicles kernel (needed for restarting
# the simulation)
self.k.vehicle.kernel_api = None
self.k.vehicle.master_kernel = None
self.initial_vehicles = deepcopy(self.k.vehicle)
self.k.vehicle.kernel_api = self.k.kernel_api
self.k.vehicle.master_kernel = self.k
self.setup_initial_state()
# use pyglet to render the simulation
if self.sim_params.render in ['gray', 'dgray', 'rgb', 'drgb']:
save_render = self.sim_params.save_render
sight_radius = self.sim_params.sight_radius
pxpm = self.sim_params.pxpm
show_radius = self.sim_params.show_radius
# get network polygons
network = []
# FIXME: add to network kernel instead of hack
for lane_id in self.k.kernel_api.lane.getIDList():
_lane_poly = self.k.kernel_api.lane.getShape(lane_id)
lane_poly = [i for pt in _lane_poly for i in pt]
network.append(lane_poly)
# instantiate a pyglet renderer
self.renderer = Renderer(network,
self.sim_params.render,
save_render,
sight_radius=sight_radius,
pxpm=pxpm,
show_radius=show_radius)
# render a frame
self.render(reset=True)
elif self.sim_params.render in [True, False]:
pass # default to sumo-gui (if True) or sumo (if False)
else:
raise FatalFlowError('Mode %s is not supported!' %
self.sim_params.render)
atexit.register(self.terminate)
