Init

Author: Grufoony

src/dsf/mobility/RoadDynamics.hpp

@@ -501,11 +501,13 @@ namespace dsf::mobility {
     std::optional<Id> previousNodeId = std::nullopt;
     std::set<Id> forbiddenTurns;
     double speedCurrent = 1.0;
+    double stationaryWeightCurrent = 1.0;
     if (pAgent->streetId().has_value()) {
       auto const& pStreetCurrent{this->graph().edge(pAgent->streetId().value())};
       previousNodeId = pStreetCurrent->source();
       forbiddenTurns = pStreetCurrent->forbiddenTurns();
       speedCurrent = pStreetCurrent->maxSpeed();
+      stationaryWeightCurrent = pStreetCurrent->stationaryWeight();
     }
 
     // Get path targets for non-random agents
@@ -551,7 +553,9 @@ namespace dsf::mobility {
 
       // Calculate base probability
       auto const speedNext{pStreetOut->maxSpeed()};
-      double probability = speedCurrent * speedNext;
+      double const stationaryWeightNext = pStreetOut->stationaryWeight();
+      auto const weightRatio{stationaryWeightNext / stationaryWeightCurrent}; // SQRT (p_i / p_j)
+      double probability = speedCurrent * speedNext * std::sqrt(weightRatio);
 
       // Apply error probability for non-random agents
       if (this->m_errorProbability.has_value() && !pathTargets.empty()) {

src/dsf/mobility/RoadNetwork.cpp

@@ -841,6 +841,21 @@ namespace dsf::mobility {
     addEdge<Street>(std::move(street));
   }
 
+  void RoadNetwork::setStreetStationaryWeights(std::unordered_map<Id, double> const& weights) {
+    std::for_each(DSF_EXECUTION m_edges.cbegin(),
+                  m_edges.cend(),
+                  [this](auto const& pair) {
+                    auto const streetId = pair.first;
+                    auto& pStreet = edge(pair.second);
+                    auto it = weights.find(streetId);
+                    if (it != weights.end()) {
+                      pStreet->setStationaryWeight(it->second);
+                    } else {
+                      pStreet->setStationaryWeight(1.0);
+                    }
+                  });
+  }
+
   const std::unique_ptr<Street>* RoadNetwork::street(Id source, Id destination) const {
     // Get the iterator at id m_cantorPairingHashing(source, destination)
     try {

src/dsf/mobility/RoadNetwork.hpp

@@ -185,6 +185,8 @@ namespace dsf::mobility {
                (is_street_v<std::remove_reference_t<Tn>> && ...)
     void addStreets(T1&& street, Tn&&... streets);
 
+    void setStreetStationaryWeights(std::unordered_map<Id, double> const& streetWeights);
+
     /// @brief Get a street from the graph
     /// @param source The source node
     /// @param destination The destination node

src/dsf/mobility/Street.hpp

@@ -50,6 +50,7 @@ namespace dsf::mobility {
     std::vector<Direction> m_laneMapping;
     // std::unordered_map<Id, double> m_transitionProbabilities;
     std::optional<Counter> m_counter;
+    double m_stationaryWeight{1.0};
 
   public:
     /// @brief Construct a new Street object
@@ -90,6 +91,11 @@ namespace dsf::mobility {
     //     std::unordered_map<Id, double> const& transitionProbabilities) {
     //   m_transitionProbabilities = transitionProbabilities;
     // };
+    /// @brief Set the street's stationary weight
+    /// @param weight The street's stationary weight
+    inline void setStationaryWeight(double const weight) {
+      m_stationaryWeight = weight;
+    }
     /// @brief Enable a coil (dsf::Counter sensor) on the street
     /// @param name The name of the counter (default is "Coil_<street_id>")
     void enableCounter(std::string name = std::string());
@@ -117,7 +123,9 @@ namespace dsf::mobility {
     /// @brief Check if the street is full
     /// @return bool, True if the street is full, false otherwise
     inline bool isFull() const final { return this->nAgents() == this->m_capacity; }
-
+    /// @brief Get the street's stationary weight
+    /// @return double The street's stationary weight
+    inline auto stationaryWeight() const noexcept { return m_stationaryWeight; }
     // inline auto const& transitionProbabilities() const {
     //   return m_transitionProbabilities;
     // }