Merge pull request #182 from matsim-vsp/167-fix-vehicle-insertion-and-removal

Added WaitingList and Buffer to the Links (Like for MATSim)

Author: paulheinr

rust_qsim/assets/equil/equil-1-plan.xml

@@ -22,7 +22,7 @@
                     <attribute name="routingMode" class="java.lang.String">car</attribute>
                 </attributes>
                 <route type="links" start_link="1" end_link="20" trav_time="undefined" distance="25000.0"
-                       vehicleRefId="1_car">1 6 15 20
+                       vehicleRefId="1">1 6 15 20
                 </route>
             </leg>
             <activity type="w" link="20" x="3456.0" y="4242.0" max_dur="00:10:00">
@@ -32,7 +32,7 @@
                     <attribute name="routingMode" class="java.lang.String">car</attribute>
                 </attributes>
                 <route type="links" start_link="20" end_link="20" trav_time="undefined" distance="0.0"
-                       vehicleRefId="1_car">20
+                       vehicleRefId="1">20
                 </route>
             </leg>
             <activity type="w" link="20" x="10000.0" y="0.0" max_dur="03:30:00">
@@ -42,7 +42,7 @@
                     <attribute name="routingMode" class="java.lang.String">car</attribute>
                 </attributes>
                 <route type="links" start_link="20" end_link="1" trav_time="undefined" distance="65000.0"
-                       vehicleRefId="1_car">20 21 22 23 1
+                       vehicleRefId="1">20 21 22 23 1
                 </route>
             </leg>
             <activity type="h" link="1" x="-25000.0" y="0.0">

rust_qsim/assets/equil/equil-vehicles.xml

@@ -1,9 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
-<vehicleDefinitions xmlns="http://www.matsim.org/files/dtd" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-                    xsi:schemaLocation="http://www.matsim.org/files/dtd http://www.matsim.org/files/dtd/vehicleDefinitions_v1.0.xsd">
+<vehicleDefinitions xmlns="http://www.matsim.org/files/dtd" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.matsim.org/files/dtd http://www.matsim.org/files/dtd/vehicleDefinitions_v2.0.xsd">
     <vehicleType id="car">
-        <attributes>
-        </attributes>
         <description>abc</description>
         <length meter="9.5"/>
         <width meter="3.0"/>
@@ -13,9 +10,6 @@
         <flowEfficiencyFactor factor="1.5"/>
     </vehicleType>
     <vehicleType id="walk">
-        <attributes>
-            <attribute name="lod" class="java.lang.String">teleported</attribute>
-        </attributes>
         <description>This is a pair of shoes</description>
         <length meter="0.5"/>
         <width meter="1.0"/>

rust_qsim/src/generated/mod.rs

@@ -225,6 +225,12 @@ impl From<&str> for AttributeValue {
     }
 }
 
+impl From<f64> for AttributeValue {
+    fn from(value: f64) -> Self {
+        AttributeValue::new_double(value)
+    }
+}
+
 // we can't tag the enum as non-exhaustive because prost generates it. This is why the warning is manually disabled.
 #[allow(unreachable_patterns)]
 impl Serialize for AttributeValue {

rust_qsim/src/simulation/agents/agent.rs

@@ -68,16 +68,19 @@ impl SimulationAgentLogic for SimulationAgent {
     fn advance_plan(&mut self) {
         self.logic.advance_plan();
     }
-    fn wakeup_time(&self, now: u32) -> u32 {
-        self.logic.wakeup_time(now)
-    }
     fn state(&self) -> SimulationAgentState {
         self.logic.state()
     }
+    fn is_wanting_to_arrive_on_current_link(&self) -> bool {
+        self.logic.is_wanting_to_arrive_on_current_link()
+    }
     fn curr_link_id(&self) -> Option<&Id<Link>> {
         self.logic.curr_link_id()
     }
     fn peek_next_link_id(&self) -> Option<&Id<Link>> {
         self.logic.peek_next_link_id()
     }
+    fn wakeup_time(&self, now: u32) -> u32 {
+        self.logic.wakeup_time(now)
+    }
 }

rust_qsim/src/simulation/agents/agent_logic.rs

@@ -139,17 +139,6 @@ impl SimulationAgentLogic for PlanBasedSimulationLogic {
         );
     }
 
-    fn wakeup_time(&self, now: u32) -> u32 {
-        match self
-            .basic_agent_delegate
-            .plan_element_at(self.curr_plan_element)
-            .unwrap()
-        {
-            InternalPlanElement::Activity(a) => a.cmp_end_time(now),
-            InternalPlanElement::Leg(_) => panic!("Cannot wake up on a leg!"),
-        }
-    }
-
     fn state(&self) -> SimulationAgentState {
         match self.curr_plan_element % 2 {
             0 => SimulationAgentState::ACTIVITY,
@@ -158,6 +147,10 @@ impl SimulationAgentLogic for PlanBasedSimulationLogic {
         }
     }
 
+    fn is_wanting_to_arrive_on_current_link(&self) -> bool {
+        self.peek_next_link_id().is_none()
+    }
+
     fn curr_link_id(&self) -> Option<&Id<Link>> {
         if self.state() != SimulationAgentState::LEG {
             return None;
@@ -192,6 +185,17 @@ impl SimulationAgentLogic for PlanBasedSimulationLogic {
             .unwrap()
             .route_element_at(next_i)
     }
+
+    fn wakeup_time(&self, now: u32) -> u32 {
+        match self
+            .basic_agent_delegate
+            .plan_element_at(self.curr_plan_element)
+            .unwrap()
+        {
+            InternalPlanElement::Activity(a) => a.cmp_end_time(now),
+            InternalPlanElement::Leg(_) => panic!("Cannot wake up on a leg!"),
+        }
+    }
 }
 
 impl EndTime for PlanBasedSimulationLogic {
@@ -228,6 +232,22 @@ impl SimulationAgentLogic for AdaptivePlanBasedSimulationLogic {
         self.delegate.advance_plan();
     }
 
+    fn state(&self) -> SimulationAgentState {
+        self.delegate.state()
+    }
+
+    fn is_wanting_to_arrive_on_current_link(&self) -> bool {
+        self.delegate.is_wanting_to_arrive_on_current_link()
+    }
+
+    fn curr_link_id(&self) -> Option<&Id<Link>> {
+        self.delegate.curr_link_id()
+    }
+
+    fn peek_next_link_id(&self) -> Option<&Id<Link>> {
+        self.delegate.peek_next_link_id()
+    }
+
     fn wakeup_time(&self, now: u32) -> u32 {
         let mut end = self.delegate.curr_act().cmp_end_time(now);
         if let Some(l) = self.delegate.next_leg() {
@@ -240,18 +260,6 @@ impl SimulationAgentLogic for AdaptivePlanBasedSimulationLogic {
         }
         end
     }
-
-    fn state(&self) -> SimulationAgentState {
-        self.delegate.state()
-    }
-
-    fn curr_link_id(&self) -> Option<&Id<Link>> {
-        self.delegate.curr_link_id()
-    }
-
-    fn peek_next_link_id(&self) -> Option<&Id<Link>> {
-        self.delegate.peek_next_link_id()
-    }
 }
 
 impl EndTime for AdaptivePlanBasedSimulationLogic {

rust_qsim/src/simulation/agents/mod.rs

@@ -16,10 +16,13 @@ pub trait SimulationAgentLogic:
     fn curr_leg(&self) -> &InternalLeg;
     fn next_leg(&self) -> Option<&InternalLeg>;
     fn advance_plan(&mut self);
-    fn wakeup_time(&self, now: u32) -> u32;
     fn state(&self) -> SimulationAgentState;
+
+    // Having these functions here is not ideal. See https://github.com/matsim-vsp/parallel_qsim_rust/issues/203 for more details.
+    fn is_wanting_to_arrive_on_current_link(&self) -> bool;
     fn curr_link_id(&self) -> Option<&Id<Link>>;
     fn peek_next_link_id(&self) -> Option<&Id<Link>>;
+    fn wakeup_time(&self, now: u32) -> u32;
 }
 
 pub trait EnvironmentalEventObserver {
@@ -28,12 +31,12 @@ pub trait EnvironmentalEventObserver {
 
 #[non_exhaustive]
 pub enum AgentEvent<'a> {
-    // activity related events
+    // activity-related events
     ActivityStarted(),
     WokeUp(WokeUpEvent<'a>),
     ActivityFinished(),
 
-    // teleportation related events
+    // teleportation-related events
     TeleportationStarted(),
     TeleportationFinished(),
 

rust_qsim/src/simulation/config.rs

@@ -436,10 +436,15 @@ pub struct Simulation {
     pub start_time: u32,
     pub end_time: u32,
     pub sample_size: f32,
+    #[serde(default = "default_to_10")]
     pub stuck_threshold: u32,
     pub main_modes: Vec<String>,
 }
 
+fn default_to_10() -> u32 {
+    10
+}
+
 #[derive(Serialize, Deserialize, Clone, Copy, Debug)]
 pub struct ComputationalSetup {
     pub global_sync: bool,

rust_qsim/src/simulation/engines/leg_engine.rs

@@ -59,6 +59,15 @@ impl<C: SimCommunicator> LegEngine<C> {
         }
     }
 
+    /// Performs a sim step for the leg engine. Note that vehicles that leave a link and move to another link are always processed one time step later.
+    /// This is in line with the Java reference implementation. The reason is that the order is:
+    ///
+    /// 1. `move_nodes`
+    /// 2. `move_links`
+    ///
+    /// Let's say, a vehicle's earliest exit time is `x`. The `move_links` call puts it into the buffer
+    /// at time step `x` (assuming it is free), and the `move_nodes` call at time step `x+1` puts it onto the next link.
+    /// The corresponding LinkEnter and LinkLeave events have time step `x+1`
     #[instrument(level = "trace", skip(self, agents), fields(rank=self.net_message_broker.rank()))]
     pub(crate) fn do_step(
         &mut self,
@@ -70,14 +79,16 @@ impl<C: SimCommunicator> LegEngine<C> {
         }
 
         let teleported_vehicles = self.teleportation_engine.do_step(now);
-        let network_vehicles = self.network_engine.move_nodes(now);
+
+        self.network_engine.move_nodes(now);
+        let network_vehicles = self
+            .network_engine
+            .move_links(now, &mut self.net_message_broker);
 
         let mut agents = vec![];
         agents.extend(self.publish_end_events(now, network_vehicles, true));
         agents.extend(self.publish_end_events(now, teleported_vehicles, false));
 
-        self.network_engine
-            .move_links(now, &mut self.net_message_broker);
         let sync_messages = self.net_message_broker.send_recv(now);
 
         for mut msg in sync_messages {

rust_qsim/src/simulation/engines/network_engine.rs

@@ -29,23 +29,25 @@ impl NetworkEngine {
         self.network.send_veh_en_route(vehicle, events, now)
     }
 
-    pub(super) fn move_nodes(&mut self, now: u32) -> Vec<InternalVehicle> {
+    pub(super) fn move_nodes(&mut self, now: u32) {
         self.network.move_nodes(&mut self.comp_env, now)
     }
 
     pub(super) fn move_links<C: SimCommunicator>(
         &mut self,
         now: u32,
         net_message_broker: &mut NetMessageBroker<C>,
-    ) {
-        let (vehicles, storage_cap_updates) = self.network.move_links(now);
+    ) -> Vec<InternalVehicle> {
+        let move_links_result = self.network.move_links(&mut self.comp_env, now);
 
-        for veh in vehicles {
+        for veh in move_links_result.vehicles_exit_partition {
             net_message_broker.add_veh(veh, now);
         }
 
-        for cap in storage_cap_updates {
+        for cap in move_links_result.storage_cap_updates {
             net_message_broker.add_cap_update(cap, now);
         }
+
+        move_links_result.vehicles_end_leg
     }
 }

rust_qsim/src/simulation/events/mod.rs

@@ -325,6 +325,100 @@ impl EventTrait for LinkLeaveEvent {
     }
 }
 
+#[derive(Builder, Debug)]
+pub struct VehicleEntersTrafficEvent {
+    pub time: u32,
+    pub vehicle: Id<InternalVehicle>,
+    pub link: Id<Link>,
+    pub driver: Id<InternalPerson>,
+    pub mode: Id<String>,
+    #[builder(default = 1.0)]
+    pub relative_position_on_link: f64,
+    #[builder(default)]
+    pub attributes: InternalAttributes,
+}
+
+impl VehicleEntersTrafficEvent {
+    pub const TYPE: &'static str = "vehicle enters traffic";
+    pub fn from_proto_event(event: &MyEvent, time: u32) -> Self {
+        let attrs = InternalAttributes::from(&event.attributes);
+        assert!(event.r#type.eq(Self::TYPE));
+        VehicleEntersTrafficEventBuilder::default()
+            .time(time)
+            .vehicle(Id::create(&event.attributes["vehicle"].as_string()))
+            .link(Id::create(&event.attributes["link"].as_string()))
+            .driver(Id::create(&event.attributes["driver"].as_string()))
+            .mode(Id::create(&event.attributes["mode"].as_string()))
+            .relative_position_on_link(event.attributes["relative_position_on_link"].as_double())
+            .attributes(attrs)
+            .build()
+            .unwrap()
+    }
+}
+
+impl EventTrait for VehicleEntersTrafficEvent {
+    fn type_(&self) -> &'static str {
+        Self::TYPE
+    }
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+    fn time(&self) -> u32 {
+        self.time
+    }
+
+    fn attributes(&self) -> &InternalAttributes {
+        &self.attributes
+    }
+}
+
+#[derive(Builder, Debug)]
+pub struct VehicleLeavesTrafficEvent {
+    pub time: u32,
+    pub vehicle: Id<InternalVehicle>,
+    pub link: Id<Link>,
+    pub driver: Id<InternalPerson>,
+    pub mode: Id<String>,
+    #[builder(default = 1.0)]
+    pub relative_position_on_link: f64,
+    #[builder(default)]
+    pub attributes: InternalAttributes,
+}
+
+impl VehicleLeavesTrafficEvent {
+    pub const TYPE: &'static str = "vehicle leaves traffic";
+    pub fn from_proto_event(event: &MyEvent, time: u32) -> Self {
+        let attrs = InternalAttributes::from(&event.attributes);
+        assert!(event.r#type.eq(Self::TYPE));
+        VehicleLeavesTrafficEventBuilder::default()
+            .time(time)
+            .vehicle(Id::create(&event.attributes["vehicle"].as_string()))
+            .link(Id::create(&event.attributes["link"].as_string()))
+            .driver(Id::create(&event.attributes["driver"].as_string()))
+            .mode(Id::create(&event.attributes["mode"].as_string()))
+            .relative_position_on_link(event.attributes["relative_position_on_link"].as_double())
+            .attributes(attrs)
+            .build()
+            .unwrap()
+    }
+}
+
+impl EventTrait for VehicleLeavesTrafficEvent {
+    fn type_(&self) -> &'static str {
+        Self::TYPE
+    }
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+    fn time(&self) -> u32 {
+        self.time
+    }
+
+    fn attributes(&self) -> &InternalAttributes {
+        &self.attributes
+    }
+}
+
 #[derive(Builder, Debug)]
 pub struct PersonEntersVehicleEvent {
     pub time: u32,