Rework traffic lights

examples/slow_charge_tl.cpp

@@ -34,7 +34,7 @@
 using Dynamics = dsm::FirstOrderDynamics<Delay>;
 using Street = dsm::Street;
 using SpireStreet = dsm::SpireStreet;
-using TrafficLight = dsm::TrafficLight<Delay>;
+using TrafficLight = dsm::TrafficLight;
 
 void printLoadingBar(int const i, int const n) {
   std::cout << "Loading: " << std::setprecision(2) << std::fixed << (i * 100. / n) << "%"
@@ -149,7 +149,7 @@
 
   std::cout << "Traffic Lightning the simulation...\n";
   for (Unit i{0}; i < graph.nodeSet().size(); ++i) {
-    graph.makeTrafficLight<Delay>(i);
+    graph.makeTrafficLight(i, 120);
   }
   std::cout << "Making every street a spire...\n";
   for (const auto& [id, street] : graph.streetSet()) {
@@ -179,7 +179,6 @@
     while (value < 0.) {
       value = random();
     }
-    tl.setDelay(static_cast<Delay>(value));
     const auto& col = adj.getCol(nodeId, true);
     std::set<Unit> streets;
     const auto id = col.begin();
@@ -199,7 +198,14 @@
         streets.emplace(c);
       }
     }
-    tl.setStreetPriorities(streets);
+    for (auto const& streetId : streets) {
+      tl.setCycle(streetId, dsm::Direction::ANY, {static_cast<dsm::Delay>(value), 0});
+    }
+    for (const auto& [c, value] : col) {
+      if (streets.find(c) == streets.end()) {
+        tl.setComplementaryCycle(c, *streets.begin());
+      }
+    }
     ++sda[streets.size() - 1];
     // std::cout << "Node id: " << nodeId << " has " << streets.size()
     //           << "streets.\n";
@@ -313,7 +319,7 @@
     }
     dynamics.evolve(false);
     if (OPTIMIZE && (dynamics.time() % 420 == 0)) {
-      dynamics.optimizeTrafficLights(std::floor(420. / 60), 0.15, 3. / 10);
+      dynamics.optimizeTrafficLights(0.15, 3. / 10);
     }
     if (dynamics.time() % 2400 == 0 && nAgents > 0) {
       // auto meanDelta = std::accumulate(deltas.begin(), deltas.end(), 0) /

examples/stalingrado.cpp

@@ -24,7 +24,7 @@ using Itinerary = dsm::Itinerary;
 using Dynamics = dsm::FirstOrderDynamics<Delay>;
 using Street = dsm::Street;
 using SpireStreet = dsm::SpireStreet;
-using TrafficLight = dsm::TrafficLight<Delay>;
+using TrafficLight = dsm::TrafficLight;
 
 void printLoadingBar(int const i, int const n) {
   std::cout << "Loading: " << std::setprecision(2) << std::fixed << (i * 100. / n) << "%"
@@ -46,29 +46,28 @@ int main() {
   const auto MAX_TIME{static_cast<Unit>(timeUnit * vehiclesToInsert.size())};
 
   // Create the graph
-  TrafficLight tl1{1}, tl2{2}, tl3{3}, tl4{4};
 
   // Street(StreetId, Capacity, Length, vMax, (from, to))
   Street s01{1, 2281 / 8, 2281., 13.9, std::make_pair(0, 1)};
   Street s12{7, 118 / 8, 118., 13.9, std::make_pair(1, 2)};
   Street s23{13, 222 / 8, 222., 13.9, std::make_pair(2, 3)};
   Street s34{19, 651 / 4, 651., 13.9, std::make_pair(3, 4)};
   // Viale Aldo Moro
-  tl1.setDelay(std::make_pair(62, 70));  // 40, 70
+  TrafficLight tl1{1, 132};
+  tl1.setCycle(s01.id(), dsm::Direction::ANY, {62, 0});
   tl1.setCapacity(1);
-  tl1.addStreetPriority(s01.id());
   // Via Donato Creti
-  tl2.setDelay(std::make_pair(72, 69));  // 50, 75
+  TrafficLight tl2{2, 141};
+  tl2.setCycle(s12.id(), dsm::Direction::ANY, {72, 0});
   tl2.setCapacity(1);
-  tl2.addStreetPriority(s12.id());
   // Via del Lavoro
-  tl3.setDelay(std::make_pair(88, 50));  // 40, 70
+  TrafficLight tl3{3, 138};
+  tl3.setCycle(s23.id(), dsm::Direction::ANY, {88, 0});
   tl3.setCapacity(1);
-  tl3.addStreetPriority(s23.id());
   // Viali
-  tl4.setDelay(std::make_pair(81, 50));  // 38, 106 = 144
+  TrafficLight tl4{4, 131};
+  tl4.setCycle(s34.id(), dsm::Direction::ANY, {81, 0});
   tl4.setCapacity(1);
-  tl4.addStreetPriority(s34.id());
 
   Graph graph;
   graph.addNode(std::make_unique<TrafficLight>(tl1));
@@ -77,7 +76,7 @@ int main() {
   graph.addNode(std::make_unique<TrafficLight>(tl4));
   graph.addStreets(s01, s12, s23, s34);
   graph.buildAdj();
-  graph.makeSpireStreet(19);
+  auto& spire = graph.makeSpireStreet(19);
 
   std::cout << "Intersections: " << graph.nodeSet().size() << '\n';
   std::cout << "Streets: " << graph.streetSet().size() << '\n';
@@ -91,8 +90,6 @@ int main() {
   dynamics.addItinerary(itinerary);
   dynamics.updatePaths();
 
-  auto& spire = dynamic_cast<SpireStreet&>(*dynamics.graph().streetSet().at(19));
-
   // lauch progress bar
   std::jthread t([MAX_TIME]() {
     while (progress < MAX_TIME) {

src/dsm/dsm.hpp

@@ -5,8 +5,8 @@
 #include <format>
 
 static constexpr uint8_t DSM_VERSION_MAJOR = 2;
-static constexpr uint8_t DSM_VERSION_MINOR = 1;
-static constexpr uint8_t DSM_VERSION_PATCH = 10;
+static constexpr uint8_t DSM_VERSION_MINOR = 2;
+static constexpr uint8_t DSM_VERSION_PATCH = 0;
 
 static auto const DSM_VERSION =
     std::format("{}.{}.{}", DSM_VERSION_MAJOR, DSM_VERSION_MINOR, DSM_VERSION_PATCH);

src/dsm/headers/Agent.hpp

@@ -4,7 +4,7 @@
 /// @details    This file contains the definition of the Agent class.
 ///             The Agent class represents an agent in the network. It is templated by the type
 ///             of the agent's id and the size of agents, which must both be unsigned integrals.
-///				      It is also templated by the Delay type, which must be a numeric (see utility/TypeTraits/is_numeric.hpp)
+///				      It is also templated by the delay_t type, which must be a numeric (see utility/TypeTraits/is_numeric.hpp)
 ///				      and represents the spatial or temporal (depending on the type of the template) distance
 ///				      between the agent and the one in front of it.
 
@@ -25,16 +25,16 @@
   /// @brief The Agent class represents an agent in the network.
   /// @tparam Id, The type of the agent's id. It must be an unsigned integral type.
   /// @tparam Size, The type of the size of a street. It must be an unsigned integral type.
-  /// @tparam Delay, The type of the agent's delay. It must be a numeric type (see utility/TypeTraits/is_numeric.hpp).
-  template <typename Delay>
-    requires(is_numeric_v<Delay>)
+  /// @tparam delay_t, The type of the agent's delay. It must be a numeric type (see utility/TypeTraits/is_numeric.hpp).
+  template <typename delay_t>
+    requires(is_numeric_v<delay_t>)
   class Agent {
   private:
     Id m_id;
     Id m_itineraryId;
     std::optional<Id> m_streetId;
     std::optional<Id> m_srcNodeId;
-    Delay m_delay;
+    delay_t m_delay;
     double m_speed;
     double m_distance;    // Travelled distance
     unsigned int m_time;  // Travelled time
@@ -68,7 +68,7 @@
     /// @brief Increment the agent's delay by a given value
     /// @param delay The agent's delay
     /// @throw std::overflow_error, if delay has reached its maximum value
-    void incrementDelay(Delay const delay);
+    void incrementDelay(delay_t const delay);
     /// @brief Decrement the agent's delay by 1
     /// @throw std::underflow_error, if delay has reached its minimum value
     void decrementDelay();
@@ -105,7 +105,7 @@
     double speed() const { return m_speed; }
     /// @brief Get the agent's delay
     /// @return	The agent's delay
-    Delay delay() const { return m_delay; }
+    delay_t delay() const { return m_delay; }
     /// @brief Get the agent's travelled distance
     /// @return The agent's travelled distance
     double distance() const { return m_distance; }
@@ -114,19 +114,19 @@
     unsigned int time() const { return m_time; }
   };
 
-  template <typename Delay>
-    requires(is_numeric_v<Delay>)
-  Agent<Delay>::Agent(Id id, Id itineraryId)
+  template <typename delay_t>
+    requires(is_numeric_v<delay_t>)
+  Agent<delay_t>::Agent(Id id, Id itineraryId)
       : m_id{id},
         m_itineraryId{itineraryId},
         m_delay{0},
         m_speed{0.},
         m_distance{0.},
         m_time{0} {}
 
-  template <typename Delay>
-    requires(is_numeric_v<Delay>)
-  Agent<Delay>::Agent(Id id, Id itineraryId, Id srcNodeId)
+  template <typename delay_t>
+    requires(is_numeric_v<delay_t>)
+  Agent<delay_t>::Agent(Id id, Id itineraryId, Id srcNodeId)
       : m_id{id},
         m_itineraryId{itineraryId},
         m_srcNodeId{srcNodeId},
@@ -135,59 +135,59 @@
         m_distance{0.},
         m_time{0} {}
 
-  template <typename Delay>
-    requires(is_numeric_v<Delay>)
-  void Agent<Delay>::setSpeed(double speed) {
+  template <typename delay_t>
+    requires(is_numeric_v<delay_t>)
+  void Agent<delay_t>::setSpeed(double speed) {
     if (speed < 0) {
       throw std::invalid_argument(buildLog("Speed must be positive"));
     }
     m_speed = speed;
   }
-  template <typename Delay>
-    requires(is_numeric_v<Delay>)
-  void Agent<Delay>::incrementDelay() {
-    if (m_delay == std::numeric_limits<Delay>::max()) {
-      throw std::overflow_error(buildLog("Delay has reached its maximum value"));
+  template <typename delay_t>
+    requires(is_numeric_v<delay_t>)
+  void Agent<delay_t>::incrementDelay() {
+    if (m_delay == std::numeric_limits<delay_t>::max()) {
+      throw std::overflow_error(buildLog("delay_t has reached its maximum value"));
     }
     ++m_delay;
   }
-  template <typename Delay>
-    requires(is_numeric_v<Delay>)
-  void Agent<Delay>::incrementDelay(Delay const delay) {
+  template <typename delay_t>
+    requires(is_numeric_v<delay_t>)
+  void Agent<delay_t>::incrementDelay(delay_t const delay) {
     if (m_delay + delay < m_delay) {
-      throw std::overflow_error(buildLog("Delay has reached its maximum value"));
+      throw std::overflow_error(buildLog("delay_t has reached its maximum value"));
     }
     m_delay += delay;
   }
-  template <typename Delay>
-    requires(is_numeric_v<Delay>)
-  void Agent<Delay>::decrementDelay() {
+  template <typename delay_t>
+    requires(is_numeric_v<delay_t>)
+  void Agent<delay_t>::decrementDelay() {
     if (m_delay == 0) {
-      throw std::underflow_error(buildLog("Delay has reached its minimum value"));
+      throw std::underflow_error(buildLog("delay_t has reached its minimum value"));
     }
     --m_delay;
   }
 
-  template <typename Delay>
-    requires(is_numeric_v<Delay>)
-  void Agent<Delay>::incrementDistance(double distance) {
+  template <typename delay_t>
+    requires(is_numeric_v<delay_t>)
+  void Agent<delay_t>::incrementDistance(double distance) {
     if (distance < 0) {
       throw std::invalid_argument(buildLog("Distance travelled must be positive"));
     }
     m_distance += distance;
   }
 
-  template <typename Delay>
-    requires(is_numeric_v<Delay>)
-  void Agent<Delay>::incrementTime() {
+  template <typename delay_t>
+    requires(is_numeric_v<delay_t>)
+  void Agent<delay_t>::incrementTime() {
     if (m_time == std::numeric_limits<unsigned int>::max()) {
       throw std::overflow_error(buildLog("Time has reached its maximum value"));
     }
     ++m_time;
   }
-  template <typename Delay>
-    requires(is_numeric_v<Delay>)
-  void Agent<Delay>::incrementTime(unsigned int const time) {
+  template <typename delay_t>
+    requires(is_numeric_v<delay_t>)
+  void Agent<delay_t>::incrementTime(unsigned int const time) {
     if (m_time + time < m_time) {
       throw std::overflow_error(buildLog("Time has reached its maximum value"));
     }