update current speed in all segments

ruth/data/map.py

@@ -103,6 +103,9 @@ def name(self):
         """Name of the map."""
         return self.border.name + "_" + self.download_date.replace(":", "-")
 
+    def edges(self):
+        return self.current_network.edges()
+
     def get_travel_time(self, node_from: int, node_to: int, speed_kph: SpeedKph):
         return float('inf') if speed_kph == 0 else float(
             self.segment_lengths[(node_from, node_to)]) * 3.6 / float(speed_kph)
@@ -115,14 +118,17 @@ def init_current_speeds(self):
         nx.set_edge_attributes(self.current_network, values=speeds, name="current_speed")
         nx.set_edge_attributes(self.current_network, values=travel_times, name="current_travel_time")
 
-    def update_current_speeds(self, segment_ids, speeds: List[SpeedKph]):
+    def update_current_speeds(self, gv_speeds: List[SpeedKph]):
+        max_speeds = nx.get_edge_attributes(self.current_network, name='speed_kph')
+
         new_speeds = {}
         new_travel_times = {}
-        for (node_from, node_to), speed in zip(segment_ids, speeds):
-            max_speed = self.get_current_max_speed(node_from, node_to)
-            speed = speed if speed < max_speed else max_speed
-            new_speeds[(node_from, node_to)] = speed
-            new_travel_times[(node_from, node_to)] = self.get_travel_time(node_from, node_to, speed)
+        for (node_ids, max_speed), gv_speed in zip(max_speeds.items(), gv_speeds):
+            node_from, node_to = node_ids
+            gv_speed = gv_speed if gv_speed < max_speed else max_speed
+            new_speeds[(node_from, node_to)] = gv_speed
+            new_travel_times[(node_from, node_to)] = self.get_travel_time(node_from, node_to, gv_speed)
+
         nx.set_edge_attributes(self.current_network, values=new_speeds, name='current_speed')
         nx.set_edge_attributes(self.current_network, values=new_travel_times, name='current_travel_time')
 

ruth/simulator/singlenode.py

@@ -64,7 +64,6 @@ def simulate(
 
         step = self.sim.number_of_steps
         last_map_update = self.current_offset
-        segments_changed_speed = set()
 
         while self.current_offset is not None:
             step_start_dt = datetime.now()
@@ -76,11 +75,10 @@ def simulate(
                 self.sim.routing_map.update_temporary_max_speeds(self.sim.setting.departure_time + self.current_offset)
                 if self.current_offset - last_map_update >= self.sim.setting.map_update_freq_s:
                     new_speeds = [self.sim.global_view.get_segment_speed(node_from, node_to)
-                                  for node_from, node_to in segments_changed_speed]
-                    self.sim.routing_map.update_current_speeds(segments_changed_speed, new_speeds)
+                                  for node_from, node_to in self.sim.routing_map.edges()]
+                    self.sim.routing_map.update_current_speeds(new_speeds)
                     alternatives_provider.load_map(self.sim.routing_map)
 
-                    segments_changed_speed = set()
                     last_map_update = self.current_offset
 
             with timer_set.get("allowed_vehicles"):
@@ -112,15 +110,8 @@ def simulate(
                     vehicle.update_followup_route(route)
 
             with timer_set.get("advance_vehicle"):
-                for vehicle in vehicles_to_be_moved:
-                    segments_changed_speed.add((vehicle.current_node, vehicle.next_node))
-
                 fcds = self.advance_vehicles(vehicles_to_be_moved.copy(), offset)
 
-                for vehicle in vehicles_to_be_moved:
-                    if vehicle.active:
-                        segments_changed_speed.add((vehicle.current_node, vehicle.next_node))
-
             with timer_set.get("update"):
                 self.sim.update(fcds)
 

ruth/vehicle.py

@@ -73,6 +73,9 @@ def __setstate__(self, state):
         self.__dict__.update(state)
         self.__post_init__(None)
 
+    def __eq__(self, other):
+        return self.id == other.id
+
     @property
     def next_routing_od_nodes(self) -> Tuple[int, int]:
         return self.next_routing_start.node, self.dest_node