Add possibility to normalize nExitingAgents on nLanes

Author: Grufoony

src/dsm/dsm.hpp

@@ -6,7 +6,7 @@
 
 static constexpr uint8_t DSM_VERSION_MAJOR = 2;
 static constexpr uint8_t DSM_VERSION_MINOR = 6;
-static constexpr uint8_t DSM_VERSION_PATCH = 7;
+static constexpr uint8_t DSM_VERSION_PATCH = 8;
 
 static auto const DSM_VERSION =
     std::format("{}.{}.{}", DSM_VERSION_MAJOR, DSM_VERSION_MINOR, DSM_VERSION_PATCH);

src/dsm/headers/Road.hpp

@@ -69,7 +69,7 @@ namespace dsm {
 
     virtual int nAgents() const = 0;
     virtual int nMovingAgents() const = 0;
-    virtual int nExitingAgents(Direction direction) const = 0;
+    virtual double nExitingAgents(Direction direction, bool normalizeOnNLanes) const = 0;
     virtual double density(bool normalized = false) const = 0;
   };
 }  // namespace dsm

src/dsm/headers/Street.hpp

@@ -115,8 +115,10 @@ namespace dsm {
     int nMovingAgents() const override;
     /// @brief Get the number of agents on all queues for a given direction
     /// @param direction The direction of the agents (default is ANY)
-    /// @return int The number of agents on all queues for a given direction
-    int nExitingAgents(Direction direction = Direction::ANY) const;
+    /// @param normalizeOnNLanes If true, the number of agents is normalized by the number of lanes
+    /// @return double The number of agents on all queues for a given direction
+    double nExitingAgents(Direction direction = Direction::ANY,
+                          bool normalizeOnNLanes = false) const;
 
     inline std::vector<Direction> const& laneMapping() const { return m_laneMapping; }
 

src/dsm/sources/Street.cpp

@@ -105,21 +105,38 @@ namespace dsm {
   }
 
   int Street::nMovingAgents() const { return m_movingAgents.size(); }
-  int Street::nExitingAgents(Direction direction) const {
-    int nAgents{0};
+  double Street::nExitingAgents(Direction direction, bool normalizeOnNLanes) const {
+    double nAgents{0.};
+    int n{0};
     for (auto i{0}; i < m_nLanes; ++i) {
       if (direction == Direction::ANY) {
         nAgents += m_exitQueues[i].size();
+        ++n;
       } else if (m_laneMapping[i] == direction) {
         nAgents += m_exitQueues[i].size();
       } else if (m_laneMapping[i] == Direction::RIGHTANDSTRAIGHT &&
                  (direction == Direction::RIGHT || direction == Direction::STRAIGHT)) {
         nAgents += m_exitQueues[i].size();
+        ++n;
       } else if (m_laneMapping[i] == Direction::LEFTANDSTRAIGHT &&
                  (direction == Direction::LEFT || direction == Direction::STRAIGHT)) {
         nAgents += m_exitQueues[i].size();
+        ++n;
+      } else if (direction == Direction::RIGHTANDSTRAIGHT &&
+                 (m_laneMapping[i] == Direction::RIGHT ||
+                  m_laneMapping[i] == Direction::STRAIGHT)) {
+        nAgents += m_exitQueues[i].size();
+        ++n;
+      } else if (direction == Direction::LEFTANDSTRAIGHT &&
+                 (m_laneMapping[i] == Direction::LEFT ||
+                  m_laneMapping[i] == Direction::STRAIGHT)) {
+        nAgents += m_exitQueues[i].size();
+        ++n;
       }
     }
+    if (normalizeOnNLanes) {
+      n > 1 ? nAgents /= n : nAgents;
+    }
     return nAgents;
   }
 

test/Test_dynamics.cpp

@@ -749,6 +749,8 @@ TEST_CASE("FirstOrderDynamics") {
         dynamics.evolve(false);  // Counter 3
         THEN("The agents are still") {
           CHECK_EQ(dynamics.graph().edge(1)->nExitingAgents(), 2);
+          CHECK_EQ(dynamics.graph().edge(1)->nExitingAgents(Direction::ANY, true),
+                   doctest::Approx(0.666667));
           CHECK_EQ(dynamics.graph().edge(1)->nExitingAgents(Direction::RIGHT), 0);
           CHECK_EQ(dynamics.graph().edge(1)->nExitingAgents(Direction::STRAIGHT), 1);
           CHECK_EQ(dynamics.graph().edge(1)->nExitingAgents(Direction::LEFT), 1);