Add initTrafficLights function to RoadNetwork class

src/dsm/headers/RoadNetwork.hpp

@@ -80,6 +80,11 @@ namespace dsm {
     /// @brief Adjust the nodes' transport capacity
     /// @details The nodes' capacity is adjusted using the graph's streets transport capacity, which may vary basing on the number of lanes. The node capacity will be set to the sum of the incoming streets' transport capacity.
     void adjustNodeCapacities();
+    /// @brief Initialize the traffic lights with random parameters
+    /// @details Traffic Lights with no parameters set are initialized with random parameters.
+    /// Street priorities are assigned considering the number of lanes and the speed limit.
+    /// Traffic Lights with an input degree lower than 3 are converted to standard intersections.
+    void initTrafficLights();
 
     /// @brief Import the graph's adjacency matrix from a file.
     /// If the file is not of a supported format, it will read the file as a matrix with the first two elements being

src/dsm/sources/RoadNetwork.cpp

@@ -88,10 +88,162 @@
     }
   }
 
+  void RoadNetwork::initTrafficLights() {
+    for (auto const& [id, pNode] : m_nodes) {
+      if (!pNode->isTrafficLight()) {
+        continue;
+      }
+      auto& tl = dynamic_cast<TrafficLight&>(*pNode);
+      if (!tl.streetPriorities().empty() || !tl.cycles().empty()) {
+        continue;
+      }
+      auto const& inNeighbours = m_adjacencyMatrix.getCol(id);
+      std::map<Id, int, std::greater<int>> capacities;
+      std::unordered_map<Id, double> streetAngles;
+      std::unordered_map<Id, double> maxSpeeds;
+      std::unordered_map<Id, int> nLanes;
+      double higherSpeed{0.}, lowerSpeed{std::numeric_limits<double>::max()};
+      int higherNLanes{0}, lowerNLanes{std::numeric_limits<int>::max()};
+      if (inNeighbours.size() < 3) {
+        Logger::warning(std::format(
+            "Not enough in neighbours {} for Traffic Light {}", inNeighbours.size(), id));
+        // Replace with a normal intersection
+        auto const& coordinates{pNode->coords()};
+        if (coordinates.has_value()) {
+          m_nodes[id] = std::make_unique<Intersection>(id, *coordinates);
+        } else {
+          m_nodes[id] = std::make_unique<Intersection>(id);
+        }
+        continue;
+      }
+      for (auto const& inId : inNeighbours) {
+        auto const streetId{inId * nNodes() + id};
+        auto const& pStreet{m_edges.at(streetId)};
+
+        double const speed{pStreet->maxSpeed()};
+        int const nLan{pStreet->nLanes()};
+        auto const cap{pStreet->capacity()};
+        Logger::debug(std::format("Street {} with capacity {}", streetId, cap));
+        capacities.emplace(streetId, cap);
+        streetAngles.emplace(streetId, pStreet->angle());
+
+        maxSpeeds.emplace(streetId, speed);
+        nLanes.emplace(streetId, nLan);
+
+        higherSpeed = std::max(higherSpeed, speed);
+        lowerSpeed = std::min(lowerSpeed, speed);
+
+        higherNLanes = std::max(higherNLanes, nLan);
+        lowerNLanes = std::min(lowerNLanes, nLan);
+      }
+      if (higherSpeed != lowerSpeed) {
+        // Assign streets with higher speed to priority
+        for (auto const& [sid, speed] : maxSpeeds) {
+          if (speed == higherSpeed) {
+            tl.addStreetPriority(sid);
+          }
+        }
+        // continue;
+      } else if (higherNLanes != lowerNLanes) {
+        for (auto const& [sid, nLan] : nLanes) {
+          if (nLan == higherNLanes) {
+            tl.addStreetPriority(sid);
+          }
+        }
+        // continue;
+      }
+      // Set first two elements of capacities to street priorities
+      // auto it{capacities.begin()};
+      // tl.addStreetPriority(it->first);
+      // ++it;
+      // if (it != capacities.end()) {
+      //   tl.addStreetPriority(it->first);
+      //   continue;
+      // }
+      // Id firstStreetId{streetAngles.begin()->first};
+      // tl.addStreetPriority(firstStreetId);
+      // for (auto const& [streetId, angle] : streetAngles) {
+      //   if (streetId == firstStreetId) {
+      //     continue;
+      //   }
+      //   if (angle == streetAngles.begin()->second) {
+      //     tl.addStreetPriority(streetId);
+      //   }
+      // }
+      // if (tl.streetPriorities().size() > 1) {
+      //   continue;
+      // }
+      if (tl.streetPriorities().empty()) {
+        Logger::warning(std::format("Failed to auto-init Traffic Light {}", id));
+        continue;
+      }
+
+      // Assign cycles
+      std::pair<Delay, Delay> greenTimes;
+      {
+        auto capPriority{0.}, capNoPriority{0.};
+        std::unordered_map<Id, double> normCapacities;
+        auto sum{0.};
+        for (auto const& [streetId, cap] : capacities) {
+          sum += cap;
+        }
+        for (auto const& [streetId, cap] : capacities) {
+          normCapacities.emplace(streetId, cap / sum);
+        }
+        for (auto const& [streetId, normCap] : normCapacities) {
+          if (tl.streetPriorities().contains(streetId)) {
+            capPriority += normCap;
+          } else {
+            capNoPriority += normCap;
+          }
+        }
+        Logger::debug(
+            std::format("Capacities for Traffic Light {}: priority {} no priority {}",
+                        id,
+                        capPriority,
+                        capNoPriority));
+        greenTimes = std::make_pair(static_cast<Delay>(capPriority * tl.cycleTime()),
+                                    static_cast<Delay>(capNoPriority * tl.cycleTime()));
+      }
+      std::for_each(inNeighbours.begin(), inNeighbours.end(), [&](Id const inId) {
+        auto const streetId{inId * nNodes() + id};
+        auto const nLane{nLanes.at(streetId)};
+        Delay greenTime{greenTimes.first};
+        Delay phase{0};
+        if (!tl.streetPriorities().contains(streetId)) {
+          phase = greenTime;
+          greenTime = greenTimes.second;
+        }
+        Logger::debug(
+            std::format("Setting cycle for street {} with green time {} and phase {}",
+                        streetId,
+                        greenTime,
+                        phase));
+        switch (nLane) {
+          case 3:
+            tl.setCycle(streetId,
+                        dsm::Direction::RIGHTANDSTRAIGHT,
+                        TrafficLightCycle{static_cast<Delay>(greenTime * 2. / 3), phase});
+            tl.setCycle(
+                streetId,
+                dsm::Direction::LEFT,
+                TrafficLightCycle{
+                    static_cast<Delay>(greenTime / 3.),
+                    static_cast<Delay>(phase + static_cast<Delay>(greenTime * 2. / 3))});
+            break;
+          default:
+            tl.setCycle(
+                streetId, dsm::Direction::ANY, TrafficLightCycle{greenTime, phase});
+            break;
+        }
+      });
+    }
+  }
+
   void RoadNetwork::buildAdj() {
     // find max values in streets node pairs
     m_maxAgentCapacity = 0;
-    for (const auto& [streetId, pStreet] : m_edges) {
+    for (auto const& [streetId, pStreet] : m_edges) {
       m_maxAgentCapacity += pStreet->capacity();
       if (pStreet->geometry().empty()) {
         std::vector<std::pair<double, double>> coords;
@@ -319,7 +471,7 @@
         std::getline(iss, highway, ';');
         if (highway.find("traffic_signals") != std::string::npos) {
           addNode<TrafficLight>(
-              nodeIndex, 60, std::make_pair(std::stod(lat), std::stod(lon)));
+              nodeIndex, 120, std::make_pair(std::stod(lat), std::stod(lon)));
         } else if (highway.find("roundabout") != std::string::npos) {
           addNode<Roundabout>(nodeIndex, std::make_pair(std::stod(lat), std::stod(lon)));
         } else {

test/Test_dynamics.cpp

@@ -604,12 +604,10 @@ TEST_CASE("FirstOrderDynamics") {
       RoadNetwork graph2;
       graph2.addNode<TrafficLight>(1, 4);
       graph2.addStreets(s1, s2, s3, s4);
-      graph2.buildAdj();
       auto& tl = graph2.node<TrafficLight>(1);
       tl.setCycle(1, dsm::Direction::RIGHT, {2, 0});
-      tl.setCycle(7, dsm::Direction::RIGHT, {2, 0});
       tl.setCycle(16, dsm::Direction::RIGHT, {2, 2});
-      tl.setCycle(9, dsm::Direction::RIGHT, {2, 2});
+      graph2.buildAdj();
       FirstOrderDynamics dynamics{
           graph2, false, 69, 0., dsm::weight_functions::streetLength, 1.};
       dynamics.addItinerary(2, 2);

test/Test_graph.cpp

@@ -268,6 +268,52 @@
     CHECK_FALSE(graph.street(1, 0));
   }
   SUBCASE("make trafficlight") {
+    GIVEN("A graph with a traffic light with no parameters") {
+      Street s1{1, std::make_pair(0, 1), 30., 15., 3};
+      Street s2{11, std::make_pair(2, 1), 30., 15., 3};
+      Street s3{16, std::make_pair(3, 1), 30., 15., 1};
+      Street s4{21, std::make_pair(4, 1), 30., 15., 2};
+      RoadNetwork graph2;
+      graph2.addNode<dsm::TrafficLight>(1, 120);
+      graph2.addStreets(s1, s2, s3, s4);
+      for (auto const& pair : graph2.edges()) {
+        pair.second->setCapacity(2 * pair.second->nLanes());
+      }
+      graph2.buildAdj();
+      WHEN("We auto-init Traffic Lights") {
+        graph2.initTrafficLights();
+        THEN("Parameters are correctly set") {
+          auto& tl{graph2.node<dsm::TrafficLight>(1)};
+          CHECK_EQ(tl.cycleTime(), 120);
+          auto const& cycles{tl.cycles()};
+          CHECK_EQ(cycles.size(), 4);
+          CHECK_EQ(cycles.at(1)[0].greenTime(), 53);
+          CHECK_EQ(cycles.at(1)[1].greenTime(), 53);
+          CHECK_EQ(cycles.at(1)[2].greenTime(), 26);
+          CHECK_EQ(cycles.at(1)[0].phase(), 0);
+          CHECK_EQ(cycles.at(1)[1].phase(), 0);
+          CHECK_EQ(cycles.at(1)[2].phase(), 53);
+          CHECK_EQ(cycles.at(11)[0].greenTime(), 53);
+          CHECK_EQ(cycles.at(11)[1].greenTime(), 53);
+          CHECK_EQ(cycles.at(11)[2].greenTime(), 26);
+          CHECK_EQ(cycles.at(11)[0].phase(), 0);
+          CHECK_EQ(cycles.at(11)[1].phase(), 0);
+          CHECK_EQ(cycles.at(11)[2].phase(), 53);
+          CHECK_EQ(cycles.at(16)[0].greenTime(), 40);
+          CHECK_EQ(cycles.at(16)[1].greenTime(), 40);
+          CHECK_EQ(cycles.at(16)[2].greenTime(), 40);
+          CHECK_EQ(cycles.at(16)[0].phase(), 80);
+          CHECK_EQ(cycles.at(16)[1].phase(), 80);
+          CHECK_EQ(cycles.at(16)[2].phase(), 80);
+          CHECK_EQ(cycles.at(21)[0].greenTime(), 40);
+          CHECK_EQ(cycles.at(21)[1].greenTime(), 40);
+          CHECK_EQ(cycles.at(21)[2].greenTime(), 40);
+          CHECK_EQ(cycles.at(21)[0].phase(), 80);
+          CHECK_EQ(cycles.at(21)[1].phase(), 80);
+          CHECK_EQ(cycles.at(21)[2].phase(), 80);
+        }
+      }
+    }
     GIVEN("A graph object with two nodes and one street") {
       RoadNetwork graph{};
       graph.addStreet(Street{1, std::make_pair(0, 1)});