Add several accelerations to custom output

flow/controllers/base_controller.py

@@ -34,7 +34,7 @@ class BaseController:
     delay : int
         delay in applying the action (time)
     fail_safe : str
-        Should be either "instantaneous" or "safe_velocity"
+        Should be "instantaneous", "safe_velocity", "feasible_accel", or "all"
     noise : double
         variance of the gaussian from which to sample a noisy acceleration
     """
@@ -75,8 +75,12 @@ def get_action(self, env):
         time step.
 
         This method also augments the controller with the desired level of
-        stochastic noise, and utlizes the "instantaneous" or "safe_velocity"
-        failsafes if requested.
+        stochastic noise, and utlizes the "instantaneous", "safe_velocity",
+        "feasible_accel", or "all" failsafes if requested. The "all" failsafe
+        performs all three failsafes with this order:
+        1) "safe_velocity",
+        2) "feasible_accel",
+        3) "instantaneous".
 
         Parameters
         ----------
@@ -88,8 +92,11 @@ def get_action(self, env):
         float
             the modified form of the acceleration
         """
-        # clear the current stored accel_without_noise of this vehicle None
-        env.k.vehicle.update_accel_without_noise(self.veh_id, None)
+        # clear the current stored accel_no_noise_no_failsafe of this vehicle None
+        env.k.vehicle.update_accel_no_noise_no_failsafe(self.veh_id, None)
+        env.k.vehicle.update_accel_no_noise_with_failsafe(self.veh_id, None)
+        env.k.vehicle.update_accel_with_noise_no_failsafe(self.veh_id, None)
+        env.k.vehicle.update_accel_with_noise_with_failsafe(self.veh_id, None)
 
         # this is to avoid abrupt decelerations when a vehicle has just entered
         # a network and it's data is still not subscribed
@@ -110,23 +117,38 @@ def get_action(self, env):
 
         # store the acceleration without noise to each vehicle
         # run fail safe if requested
-        accel_without_noise = accel
+        env.k.vehicle.update_accel_no_noise_no_failsafe(self.veh_id, accel)
+        accel_no_noise_with_failsafe = accel
         if self.fail_safe == 'instantaneous':
-            accel_without_noise = self.get_safe_action_instantaneous(env, accel_without_noise)
+            accel_no_noise_with_failsafe = self.get_safe_action_instantaneous(env, accel)
         elif self.fail_safe == 'safe_velocity':
-            accel_without_noise = self.get_safe_velocity_action(env, accel_without_noise)
-        env.k.vehicle.update_accel_without_noise(self.veh_id, accel_without_noise)
+            accel_no_noise_with_failsafe = self.get_safe_velocity_action(env, accel)
+        elif self.fail_safe == 'feasible_accel':
+            accel_no_noise_with_failsafe = self.get_feasible_action(accel)
+        elif self.fail_safe == 'all':
+            accel_no_noise_with_failsafe = self.get_safe_velocity_action(env, accel)
+            accel_no_noise_with_failsafe = self.get_feasible_action(accel_no_noise_with_failsafe)
+            accel_no_noise_with_failsafe = self.get_safe_action_instantaneous(env, accel_no_noise_with_failsafe)
+
+        env.k.vehicle.update_accel_no_noise_with_failsafe(self.veh_id, accel_no_noise_with_failsafe)
 
         # add noise to the accelerations, if requested
         if self.accel_noise > 0:
             accel += np.sqrt(env.sim_step) * np.random.normal(0, self.accel_noise)
+        env.k.vehicle.update_accel_with_noise_no_failsafe(self.veh_id, accel)
 
         # run the fail-safes, if requested
         if self.fail_safe == 'instantaneous':
             accel = self.get_safe_action_instantaneous(env, accel)
         elif self.fail_safe == 'safe_velocity':
             accel = self.get_safe_velocity_action(env, accel)
-
+        elif self.fail_safe == 'feasible_accel':
+            accel = self.get_feasible_action(accel)
+        elif self.fail_safe == 'all':
+            accel = self.get_safe_velocity_action(env, accel)
+            accel = self.get_feasible_action(accel)
+            accel = self.get_safe_action_instantaneous(env, accel)
+        env.k.vehicle.update_accel_with_noise_with_failsafe(self.veh_id, accel)
         return accel
 
     def get_safe_action_instantaneous(self, env, action):
@@ -172,6 +194,12 @@ def get_safe_action_instantaneous(self, env, action):
                 # if the vehicle will crash into the vehicle ahead of it in the
                 # next time step (assuming the vehicle ahead of it is not
                 # moving), then stop immediately
+                print(
+                    "=====================================\n"
+                    "Vehicle {} is about to crash. Instantaneous acceleration "
+                    "clipping applied.\n"
+                    "=====================================".format(self.veh_id))
+
                 return -this_vel / sim_step
             else:
                 # if the vehicle is not in danger of crashing, continue with
@@ -233,8 +261,8 @@ def safe_velocity(self, env):
         Returns
         -------
         float
-            maximum safe velocity given a maximum deceleration and delay in
-            performing the breaking action
+            maximum safe velocity given a maximum deceleration, delay in
+            performing the breaking action, and speed limit
         """
         lead_id = env.k.vehicle.get_leader(self.veh_id)
         lead_vel = env.k.vehicle.get_speed(lead_id)
@@ -245,4 +273,54 @@ def safe_velocity(self, env):
 
         v_safe = 2 * h / env.sim_step + dv - this_vel * (2 * self.delay)
 
+        # check for speed limit
+        this_edge = env.k.vehicle.get_edge(self.veh_id)
+        edge_speed_limit = env.k.network.speed_limit(this_edge)
+
+        if v_safe > edge_speed_limit:
+            v_safe = edge_speed_limit
+            print(
+                "=====================================\n"
+                "Speed of vehicle {} is greater than speed limit. Safe "
+                "velocity clipping applied.\n"
+                "=====================================".format(self.veh_id))
+
         return v_safe
+
+    def get_feasible_action(self, action):
+        """Perform the "feasible_accel" failsafe action.
+
+        Checks if the computed acceleration would put us above maximum
+        acceleration or deceleration. If it would, output the acceleration
+        equal to maximum acceleration or deceleration.
+
+        Parameters
+        ----------
+        action : float
+            requested acceleration action
+
+        Returns
+        -------
+        float
+            the requested action clipped by the feasible acceleration or
+            deceleration.
+        """
+        if action > self.max_accel:
+            action = self.max_accel
+
+            print(
+                "=====================================\n"
+                "Acceleration of vehicle {} is greater than the max "
+                "acceleration. Feasible acceleration clipping applied.\n"
+                "=====================================".format(self.veh_id))
+
+        if action < -self.max_deaccel:
+            action = -self.max_deaccel
+
+            print(
+                "=====================================\n"
+                "Deceleration of vehicle {} is greater than the max "
+                "deceleration. Feasible acceleration clipping applied.\n"
+                "=====================================".format(self.veh_id))
+
+        return action

flow/core/kernel/vehicle/base.py

@@ -124,6 +124,23 @@ def remove(self, veh_id):
     def apply_acceleration(self, veh_id, acc):
         """Apply the acceleration requested by a vehicle in the simulator.
 
+        In SUMO, this function applies slowDown method which applies smoothing.
+
+        Parameters
+        ----------
+        veh_id : str or list of str
+            list of vehicle identifiers
+        acc : float or array_like
+            requested accelerations from the vehicles
+        """
+        raise NotImplementedError
+
+    def apply_acceleration_not_smooth(self, veh_id, acc):
+        """Apply the acceleration requested by a vehicle in the simulator.
+
+        In SUMO, this function applies setSpeed method which doesn't apply
+        smoothing.
+
         Parameters
         ----------
         veh_id : str or list of str
@@ -693,16 +710,40 @@ def get_accel(self, veh_id):
         """Return the acceleration of vehicle with veh_id."""
         raise NotImplementedError
 
-    def update_accel_without_noise(self, veh_id, accel_without_noise):
-        """Update stored acceleration without noise of vehicle with veh_id."""
+    def update_accel_no_noise_no_failsafe(self, veh_id, accel_no_noise_no_failsafe):
+        """Update stored acceleration without noise without failsafe of vehicle with veh_id."""
+        raise NotImplementedError
+
+    def update_accel_no_noise_with_failsafe(self, veh_id, accel_no_noise_with_failsafe):
+        """Update stored acceleration without noise with failsafe of vehicle with veh_id."""
+        raise NotImplementedError
+
+    def update_accel_with_noise_no_failsafe(self, veh_id, accel_with_noise_no_failsafe):
+        """Update stored acceleration with noise without failsafe of vehicle with veh_id."""
+        raise NotImplementedError
+
+    def update_accel_with_noise_with_failsafe(self, veh_id, accel_with_noise_with_failsafe):
+        """Update stored acceleration with noise with failsafe of vehicle with veh_id."""
         raise NotImplementedError
 
     def get_2d_position(self, veh_id, error=-1001):
         """Return (x, y) position of vehicle with veh_id."""
         raise NotImplementedError
 
-    def get_accel_without_noise(self, veh_id):
-        """Return the acceleration without noise of vehicle with veh_id."""
+    def get_accel_no_noise_no_failsafe(self, veh_id):
+        """Return the acceleration without noise without failsafe of vehicle with veh_id."""
+        raise NotImplementedError
+
+    def get_accel_no_noise_with_failsafe(self, veh_id):
+        """Return the acceleration without noise with failsafe of vehicle with veh_id."""
+        raise NotImplementedError
+
+    def get_accel_with_noise_no_failsafe(self, veh_id):
+        """Return the acceleration with noise without failsafe of vehicle with veh_id."""
+        raise NotImplementedError
+
+    def get_accel_with_noise_with_failsafe(self, veh_id):
+        """Return the acceleration with noise with failsafe of vehicle with veh_id."""
         raise NotImplementedError
 
     def get_realized_accel(self, veh_id):

flow/core/kernel/vehicle/traci.py

@@ -113,7 +113,6 @@ def initialize(self, vehicles):
                 self.__vehicles[veh_id] = dict()
                 self.__vehicles[veh_id]['type'] = typ['veh_id']
                 self.__vehicles[veh_id]['initial_speed'] = typ['initial_speed']
-                self.__vehicles[veh_id]["accel_without_noise"] = None
                 self.num_vehicles += 1
                 if typ['acceleration_controller'][0] == RLController:
                     self.num_rl_vehicles += 1
@@ -952,7 +951,7 @@ def _prev_edge_followers(self, veh_id, edge_dict, lane, num_edges):
 
     def apply_acceleration(self, veh_ids, acc):
         """See parent class."""
-        # to hand the case of a single vehicle
+        # to handle the case of a single vehicle
         if type(veh_ids) == str:
             veh_ids = [veh_ids]
             acc = [acc]
@@ -964,6 +963,20 @@ def apply_acceleration(self, veh_ids, acc):
                 next_vel = max([this_vel + acc[i] * self.sim_step, 0])
                 self.kernel_api.vehicle.slowDown(vid, next_vel, 1e-3)
 
+    def apply_acceleration_not_smooth(self, veh_ids, acc):
+        """See parent class."""
+        # to handle the case of a single vehicle
+        if type(veh_ids) == str:
+            veh_ids = [veh_ids]
+            acc = [acc]
+
+        for i, vid in enumerate(veh_ids):
+            if acc[i] is not None and vid in self.get_ids():
+                self.__vehicles[vid]["accel"] = acc[i]
+                this_vel = self.get_speed(vid)
+                next_vel = max([this_vel + acc[i] * self.sim_step, 0])
+                self.kernel_api.vehicle.setSpeed(vid, next_vel)
+
     def apply_lane_change(self, veh_ids, direction):
         """See parent class."""
         # to hand the case of a single vehicle
@@ -1130,15 +1143,45 @@ def get_accel(self, veh_id):
             self.__vehicles[veh_id]["accel"] = None
         return self.__vehicles[veh_id]["accel"]
 
-    def update_accel_without_noise(self, veh_id, accel_without_noise):
+    def update_accel_no_noise_no_failsafe(self, veh_id, accel_no_noise_no_failsafe):
+        """See parent class."""
+        self.__vehicles[veh_id]["accel_no_noise_no_failsafe"] = accel_no_noise_no_failsafe
+
+    def update_accel_no_noise_with_failsafe(self, veh_id, accel_no_noise_with_failsafe):
+        """See parent class."""
+        self.__vehicles[veh_id]["accel_no_noise_with_failsafe"] = accel_no_noise_with_failsafe
+
+    def update_accel_with_noise_no_failsafe(self, veh_id, accel_with_noise_no_failsafe):
+        """See parent class."""
+        self.__vehicles[veh_id]["accel_with_noise_no_failsafe"] = accel_with_noise_no_failsafe
+
+    def update_accel_with_noise_with_failsafe(self, veh_id, accel_with_noise_with_failsafe):
+        """See parent class."""
+        self.__vehicles[veh_id]["accel_with_noise_with_failsafe"] = accel_with_noise_with_failsafe
+
+    def get_accel_no_noise_no_failsafe(self, veh_id):
+        """See parent class."""
+        if "accel_no_noise_no_failsafe" not in self.__vehicles[veh_id]:
+            self.__vehicles[veh_id]["accel_no_noise_no_failsafe"] = None
+        return self.__vehicles[veh_id]["accel_no_noise_no_failsafe"]
+
+    def get_accel_no_noise_with_failsafe(self, veh_id):
+        """See parent class."""
+        if "accel_no_noise_with_failsafe" not in self.__vehicles[veh_id]:
+            self.__vehicles[veh_id]["accel_no_noise_with_failsafe"] = None
+        return self.__vehicles[veh_id]["accel_no_noise_with_failsafe"]
+
+    def get_accel_with_noise_no_failsafe(self, veh_id):
         """See parent class."""
-        self.__vehicles[veh_id]["accel_without_noise"] = accel_without_noise
+        if "accel_with_noise_no_failsafe" not in self.__vehicles[veh_id]:
+            self.__vehicles[veh_id]["accel_with_noise_no_failsafe"] = None
+        return self.__vehicles[veh_id]["accel_with_noise_no_failsafe"]
 
-    def get_accel_without_noise(self, veh_id):
+    def get_accel_with_noise_with_failsafe(self, veh_id):
         """See parent class."""
-        if "accel_without_noise" not in self.__vehicles[veh_id]:
-            self.__vehicles[veh_id]["accel_without_noise"] = None
-        return self.__vehicles[veh_id]["accel_without_noise"]
+        if "accel_with_noise_with_failsafe" not in self.__vehicles[veh_id]:
+            self.__vehicles[veh_id]["accel_with_noise_with_failsafe"] = None
+        return self.__vehicles[veh_id]["accel_with_noise_with_failsafe"]
 
     def get_realized_accel(self, veh_id):
         """See parent class."""

flow/data_pipeline/data_pipeline.py

@@ -94,13 +94,18 @@ def get_extra_info(veh_kernel, extra_info, veh_ids):
         extra_info["time_step"].append(veh_kernel.get_timestep(vid) / 1000)
         extra_info["id"].append(vid)
         extra_info["headway"].append(veh_kernel.get_headway(vid))
-        extra_info["acceleration"].append(veh_kernel.get_accel(vid))
+        extra_info["target_accel_with_noise_with_failsafe"].append(veh_kernel.get_accel(vid))
         extra_info["leader_id"].append(veh_kernel.get_leader(vid))
         extra_info["follower_id"].append(veh_kernel.get_follower(vid))
         extra_info["leader_rel_speed"].append(veh_kernel.get_speed(
             veh_kernel.get_leader(vid)) - veh_kernel.get_speed(vid))
-        extra_info["accel_without_noise"].append(veh_kernel.get_accel_without_noise(vid))
-        extra_info["realilzed_accel"].append(veh_kernel.get_realized_accel(vid))
+        extra_info["target_accel_no_noise_no_failsafe"].append(
+            veh_kernel.get_accel_no_noise_no_failsafe(vid))
+        extra_info["target_accel_with_noise_no_failsafe"].append(
+            veh_kernel.get_accel_with_noise_no_failsafe(vid))
+        extra_info["target_accel_no_noise_with_failsafe"].append(
+            veh_kernel.get_accel_no_noise_with_failsafe(vid))
+        extra_info["realized_accel"].append(veh_kernel.get_realized_accel(vid))
         extra_info["road_grade"].append(veh_kernel.get_road_grade(vid))
         position = veh_kernel.get_2d_position(vid)
         extra_info["x"].append(position[0])

flow/data_pipeline/query.py

@@ -53,7 +53,7 @@ class QueryStrings(Enum):
                 id,
                 time_step,
                 speed,
-                acceleration,
+                target_accel_with_noise_with_failsafe AS acceleration,
                 road_grade,
                 source_id
             FROM trajectory_table
@@ -71,7 +71,7 @@ class QueryStrings(Enum):
                 id,
                 time_step,
                 speed,
-                accel_without_noise AS acceleration,
+                target_accel_no_noise_with_failsafe AS acceleration,
                 road_grade,
                 source_id
             FROM trajectory_table
@@ -88,7 +88,7 @@ class QueryStrings(Enum):
             SELECT
                 id,
                 time_step,
-                accel_without_noise,
+                target_accel_no_noise_with_failsafe,
                 road_grade,
                 source_id,
                 time_step - LAG(time_step, 1)
@@ -103,8 +103,8 @@ class QueryStrings(Enum):
             SELECT
                 id,
                 time_step,
-                prev_speed + accel_without_noise * sim_step AS speed,
-                accel_without_noise AS acceleration,
+                prev_speed + target_accel_no_noise_with_failsafe * sim_step AS speed,
+                target_accel_no_noise_with_failsafe AS acceleration,
                 road_grade,
                 source_id
             FROM lagged_timestep