Add a check for Delay boundaries

Author: Grufoony

examples/slow_charge_rb.cpp

@@ -120,7 +120,7 @@ int main(int argc, char** argv) {
 
   std::cout << "Creating dynamics...\n";
 
-  Dynamics dynamics{graph, SEED};
+  Dynamics dynamics{graph, SEED, 0.95};
   Unit n{0};
   {
     std::vector<Unit> destinationNodes;
@@ -138,7 +138,6 @@ int main(int argc, char** argv) {
   dynamics.setMaxFlowPercentage(0.7707);
   // dynamics.setForcePriorities(true);
   dynamics.setSpeedFluctuationSTD(0.1);
-  dynamics.setMinSpeedRateo(0.95);
 
   std::cout << "Done." << std::endl;
   std::cout << "Running simulation...\n";

examples/slow_charge_tl.cpp

@@ -216,7 +216,7 @@ int main(int argc, char** argv) {
 
   std::cout << "Creating dynamics...\n";
 
-  Dynamics dynamics{graph, SEED};
+  Dynamics dynamics{graph, SEED, 0.95};
   Unit n{0};
   {
     std::vector<Unit> destinationNodes;
@@ -234,7 +234,6 @@ int main(int argc, char** argv) {
   // dynamics.setMaxFlowPercentage(0.69);
   // dynamics.setForcePriorities(false);
   dynamics.setSpeedFluctuationSTD(0.1);
-  dynamics.setMinSpeedRateo(0.95);
   if (OPTIMIZE)
     dynamics.setDataUpdatePeriod(30);  // Store data every 30 time steps
 

examples/stalingrado.cpp

@@ -82,8 +82,7 @@ int main() {
   std::cout << "Streets: " << graph.nEdges() << '\n';
 
   // Create the dynamics
-  Dynamics dynamics{graph, 69};
-  dynamics.setMinSpeedRateo(0.95);
+  Dynamics dynamics{graph, 69, 0.95};
   dynamics.setSpeedFluctuationSTD(0.2);
   Itinerary itinerary{0, 4};
   dynamics.addItinerary(itinerary);

src/dsm/headers/FirstOrderDynamics.hpp

@@ -6,13 +6,15 @@ namespace dsm {
   template <typename delay_t>
     requires(std::unsigned_integral<delay_t>)
   class FirstOrderDynamics : public RoadDynamics<delay_t> {
+    double m_alpha;
     double m_speedFluctuationSTD;
 
   public:
     /// @brief Construct a new First Order Dynamics object
     /// @param graph, The graph representing the network
-    FirstOrderDynamics(Graph& graph, std::optional<unsigned int> seed = std::nullopt)
-        : RoadDynamics<delay_t>(graph, seed), m_speedFluctuationSTD{0.} {};
+    FirstOrderDynamics(Graph& graph,
+                       std::optional<unsigned int> seed = std::nullopt,
+                       double minSpeedRateo = 0.);
     /// @brief Set the speed of an agent
     /// @param agentId The id of the agent
     /// @throw std::invalid_argument, If the agent is not found
@@ -38,18 +40,49 @@ namespace dsm {
     Measurement<double> streetMeanSpeed(double threshold, bool above) const override;
   };
 
+  template <typename delay_t>
+    requires(std::unsigned_integral<delay_t>)
+  FirstOrderDynamics<delay_t>::FirstOrderDynamics(Graph& graph,
+                                                  std::optional<unsigned int> seed,
+                                                  double minSpeedRateo)
+      : RoadDynamics<delay_t>(graph, seed),
+        m_alpha{0.},
+        m_speedFluctuationSTD{0.} {
+    if (minSpeedRateo < 0. || minSpeedRateo > 1.) {
+      throw std::invalid_argument(buildLog(
+          std::format("The minimum speed rateo must be between 0 and 1, but it is {}",
+                      minSpeedRateo)));
+    } else {
+      m_alpha = minSpeedRateo;
+    }
+    double globMaxTimePenalty{0.};
+    for (const auto& [streetId, street] : this->m_graph.streetSet()) {
+      globMaxTimePenalty =
+          std::max(globMaxTimePenalty,
+                   std::ceil(street->length() /
+                             ((1. - m_alpha) * street->maxSpeed())));
+    }
+    if (globMaxTimePenalty > static_cast<double>(std::numeric_limits<delay_t>::max())) {
+      throw std::overflow_error(
+          buildLog(std::format("The maximum time penalty ({}) is greater than the "
+                               "maximum value of delay_t ({})",
+                               globMaxTimePenalty,
+                               std::numeric_limits<delay_t>::max())));
+    }
+  }
+
   template <typename delay_t>
     requires(std::unsigned_integral<delay_t>)
   void FirstOrderDynamics<delay_t>::setAgentSpeed(Size agentId) {
     const auto& agent{this->m_agents[agentId]};
     const auto& street{this->m_graph.streetSet()[agent->streetId().value()]};
     double speed{street->maxSpeed() *
-                 (1. - this->m_minSpeedRateo * street->density(true))};
+                 (1. - m_alpha * street->density(true))};
     if (m_speedFluctuationSTD > 0.) {
       std::normal_distribution<double> speedDist{speed, speed * m_speedFluctuationSTD};
       speed = speedDist(this->m_generator);
     }
-    speed < 0. ? agent->setSpeed(street->maxSpeed() * (1. - this->m_minSpeedRateo))
+    speed < 0. ? agent->setSpeed(street->maxSpeed() * (1. - m_alpha))
                : agent->setSpeed(speed);
   }
 
@@ -74,7 +107,7 @@ namespace dsm {
     Size n{0};
     if (street->nExitingAgents() == 0) {
       n = static_cast<Size>(street->waitingAgents().size());
-      double alpha{this->m_minSpeedRateo / street->capacity()};
+      double alpha{m_alpha / street->capacity()};
       meanSpeed = street->maxSpeed() * n * (1. - 0.5 * alpha * (n - 1.));
     } else {
       for (const auto& agentId : street->waitingAgents()) {

src/dsm/headers/RoadDynamics.hpp

@@ -43,7 +43,6 @@ namespace dsm {
   protected:
     Time m_previousOptimizationTime;
     double m_errorProbability;
-    double m_minSpeedRateo;
     double m_maxFlowPercentage;
     std::vector<double> m_travelTimes;
     std::unordered_map<Id, Id> m_agentNextStreetId;
@@ -82,12 +81,12 @@ namespace dsm {
   public:
     /// @brief Construct a new RoadDynamics object
     /// @param graph The graph representing the network
-    RoadDynamics(Graph& graph, std::optional<unsigned int> seed);
+    /// @param seed The seed for the random number generator
+    /// @param minSpeedRateo The minimum speed rateo
+    RoadDynamics(Graph& graph,
+                 std::optional<unsigned int> seed,
+                 double minSpeedRateo = 0.);
 
-    /// @brief Set the minim speed rateo, i.e. the minim speed with respect to the speed limit
-    /// @param minSpeedRateo The minim speed rateo
-    /// @throw std::invalid_argument If the minim speed rateo is not between 0 and 1
-    void setMinSpeedRateo(double minSpeedRateo);
     /// @brief Set the error probability
     /// @param errorProbability The error probability
     /// @throw std::invalid_argument If the error probability is not between 0 and 1
@@ -151,11 +150,12 @@ namespace dsm {
 
   template <typename delay_t>
     requires(is_numeric_v<delay_t>)
-  RoadDynamics<delay_t>::RoadDynamics(Graph& graph, std::optional<unsigned int> seed)
+  RoadDynamics<delay_t>::RoadDynamics(Graph& graph,
+                                      std::optional<unsigned int> seed,
+                                      double minSpeedRateo)
       : Dynamics<delay_t>(graph, seed),
         m_previousOptimizationTime{0},
         m_errorProbability{0.},
-        m_minSpeedRateo{0.},
         m_maxFlowPercentage{1.},
         m_forcePriorities{false} {
     for (const auto& [streetId, street] : this->m_graph.streetSet()) {
@@ -429,16 +429,6 @@ namespace dsm {
     }
   }
 
-  template <typename delay_t>
-    requires(is_numeric_v<delay_t>)
-  void RoadDynamics<delay_t>::setMinSpeedRateo(double minSpeedRateo) {
-    if (minSpeedRateo < 0. || minSpeedRateo > 1.) {
-      throw std::invalid_argument(buildLog(std::format(
-          "The minimum speed rateo ({}) must be between 0 and 1", minSpeedRateo)));
-    }
-    m_minSpeedRateo = minSpeedRateo;
-  }
-
   template <typename delay_t>
     requires(is_numeric_v<delay_t>)
   void RoadDynamics<delay_t>::setErrorProbability(double errorProbability) {

test/Test_dynamics.cpp

@@ -912,8 +912,7 @@ TEST_CASE("Dynamics") {
       node->setCapacity(4);
       node->setTransportCapacity(4);
     }
-    Dynamics dynamics{graph2, 69};
-    dynamics.setMinSpeedRateo(0.5);
+    Dynamics dynamics{graph2, 69, 0.5};
     Itinerary itinerary{0, 2};
     dynamics.addItinerary(itinerary);
     dynamics.updatePaths();