Add RoadStatus

src/dsf/bindings.cpp

@@ -34,6 +34,12 @@ PYBIND11_MODULE(dsf_cpp, m) {
       .value("DOUBLE_TAIL", dsf::TrafficLightOptimization::DOUBLE_TAIL)
       .export_values();
 
+  // Bind RoadStatus enum
+  pybind11::enum_<dsf::mobility::RoadStatus>(mobility, "RoadStatus")
+      .value("OPEN", dsf::mobility::RoadStatus::OPEN)
+      .value("CLOSED", dsf::mobility::RoadStatus::CLOSED)
+      .export_values();
+
   // Bind spdlog log level enum
   pybind11::enum_<spdlog::level::level_enum>(m, "LogLevel")
       .value("TRACE", spdlog::level::trace)
@@ -243,6 +249,30 @@ PYBIND11_MODULE(dsf_cpp, m) {
           pybind11::arg("cycleTime"),
           pybind11::arg("counter"),
           dsf::g_docstrings.at("dsf::mobility::RoadNetwork::makeTrafficLight").c_str())
+      .def(
+          "setStreetStatusById",
+          &dsf::mobility::RoadNetwork::setStreetStatusById,
+          pybind11::arg("streetId"),
+          pybind11::arg("status"),
+          dsf::g_docstrings.at("dsf::mobility::RoadNetwork::setStreetStatusById").c_str())
+      .def("setStreetStatusByName",
+           &dsf::mobility::RoadNetwork::setStreetStatusByName,
+           pybind11::arg("name"),
+           pybind11::arg("status"),
+           dsf::g_docstrings.at("dsf::mobility::RoadNetwork::setStreetStatusByName")
+               .c_str())
+      .def("changeStreetCapacityById",
+           &dsf::mobility::RoadNetwork::changeStreetCapacityById,
+           pybind11::arg("streetId"),
+           pybind11::arg("factor"),
+           dsf::g_docstrings.at("dsf::mobility::RoadNetwork::changeStreetCapacityById")
+               .c_str())
+      .def("changeStreetCapacityByName",
+           &dsf::mobility::RoadNetwork::changeStreetCapacityByName,
+           pybind11::arg("name"),
+           pybind11::arg("factor"),
+           dsf::g_docstrings.at("dsf::mobility::RoadNetwork::changeStreetCapacityByName")
+               .c_str())
       .def("addCoil",
            &dsf::mobility::RoadNetwork::addCoil,
            pybind11::arg("streetId"),

src/dsf/dsf.hpp

@@ -6,7 +6,7 @@
 
 static constexpr uint8_t DSF_VERSION_MAJOR = 4;
 static constexpr uint8_t DSF_VERSION_MINOR = 7;
-static constexpr uint8_t DSF_VERSION_PATCH = 5;
+static constexpr uint8_t DSF_VERSION_PATCH = 6;
 
 static auto const DSF_VERSION =
     std::format("{}.{}.{}", DSF_VERSION_MAJOR, DSF_VERSION_MINOR, DSF_VERSION_PATCH);

src/dsf/mobility/Road.hpp

@@ -2,6 +2,7 @@
 
 #include "../base/Edge.hpp"
 
+#include <format>
 #include <memory>
 #include <optional>
 #include <set>
@@ -15,6 +16,10 @@
     TERTIARY = 3,
     RESIDENTIAL = 4,
   };
+  enum class RoadStatus : std::uint8_t {
+    OPEN = 0,
+    CLOSED = 1,
+  };
 
   /// @brief The Road class represents a road in the network.
   class Road : public Edge {
@@ -29,6 +34,7 @@
     bool m_hasPriority = false;
     std::set<Id> m_forbiddenTurns;  // Stores the forbidden turns (road ids)
     std::optional<RoadType> m_roadType{std::nullopt};
+    RoadStatus m_roadStatus = RoadStatus::OPEN;
 
   public:
     /// @brief Construct a new Road object
@@ -80,7 +86,10 @@
     void setForbiddenTurns(std::set<Id> const& forbiddenTurns);
     /// @brief Set the road type
     /// @param roadType The road type
-    inline void setRoadType(RoadType roadType) { m_roadType = roadType; }
+    inline void setRoadType(RoadType const roadType) { m_roadType = roadType; }
+    /// @brief Set the road status
+    /// @param status The road status
+    inline void setStatus(RoadStatus const status) { m_roadStatus = status; }
 
     /// @brief Get the length, in meters
     /// @return double The length, in meters
@@ -111,6 +120,9 @@
     /// @brief Get the road type
     /// @return std::optional<RoadType> The road type
     inline auto roadType() const noexcept { return m_roadType; }
+    /// @brief Get the road status
+    /// @return RoadStatus The road status
+    inline auto roadStatus() const noexcept { return m_roadStatus; }
     /// @brief Get the road's turn direction given the previous road angle
     /// @param previousStreetAngle The angle of the previous road
     /// @return Direction The turn direction
@@ -127,4 +139,25 @@
     virtual double nExitingAgents(Direction direction, bool normalizeOnNLanes) const = 0;
     virtual double density(bool normalized = false) const = 0;
   };
-}  // namespace dsf::mobility
+}  // namespace dsf::mobility
+
+template <>
+struct std::formatter<dsf::mobility::RoadStatus> {
+  constexpr auto parse(std::format_parse_context& ctx) { return ctx.begin(); }
+  template <typename FormatContext>
+  auto format(dsf::mobility::RoadStatus const& status, FormatContext&& ctx) const {
+    std::string_view name;
+    switch (status) {
+      case dsf::mobility::RoadStatus::OPEN:
+        name = "OPEN";
+        break;
+      case dsf::mobility::RoadStatus::CLOSED:
+        name = "CLOSED";
+        break;
+      default:
+        name = "UNKNOWN";
+        break;
+    }
+    return std::format_to(ctx.out(), "{}", name);
+  }
+};

src/dsf/mobility/RoadDynamics.hpp

@@ -499,10 +499,10 @@ namespace dsf::mobility {
     pItinerary->setPath(path);
     auto const newSize{pItinerary->path().size()};
     if (oldSize > 0 && newSize != oldSize) {
-      spdlog::warn("Path for itinerary {} changed size from {} to {}",
-                   pItinerary->id(),
-                   oldSize,
-                   newSize);
+      spdlog::debug("Path for itinerary {} changed size from {} to {}",
+                    pItinerary->id(),
+                    oldSize,
+                    newSize);
     }
     if (m_bCacheEnabled) {
       pItinerary->save(std::format("{}{}.ity", CACHE_FOLDER, pItinerary->id()));
@@ -731,7 +731,7 @@ namespace dsf::mobility {
           auto const timeTolerance{m_timeToleranceFactor.value() *
                                    std::ceil(pStreet->length() / pStreet->maxSpeed())};
           if (timeDiff > timeTolerance) {
-            spdlog::warn(
+            spdlog::debug(
                 "Time-step {} - {} currently on {} ({} turn - Traffic Light? {}), "
                 "has been still for more than {} seconds ({} seconds). Killing it.",
                 this->time_step(),
@@ -1302,7 +1302,7 @@ namespace dsf::mobility {
     m_nAddedAgents += nAgents;
     if (m_timeToleranceFactor.has_value() && !m_agents.empty()) {
       auto const nStagnantAgents{m_agents.size()};
-      spdlog::warn(
+      spdlog::debug(
           "Removing {} stagnant agents that were not inserted since the previous call to "
           "addAgentsUniformly().",
           nStagnantAgents);
@@ -1414,7 +1414,7 @@ namespace dsf::mobility {
     m_nAddedAgents += nAgents;
     if (m_timeToleranceFactor.has_value() && !m_agents.empty()) {
       auto const nStagnantAgents{m_agents.size()};
-      spdlog::warn(
+      spdlog::debug(
           "Removing {} stagnant agents that were not inserted since the previous call to "
           "addAgentsRandomly().",
           nStagnantAgents);
@@ -1520,9 +1520,9 @@ namespace dsf::mobility {
       // Check if destination is reachable from source
       auto const& itinerary = itineraryIt->second;
       if (!itinerary->path().contains(*srcId)) {
-        spdlog::warn("Destination {} not reachable from source {}. Skipping agent.",
-                     *dstId,
-                     *srcId);
+        spdlog::debug("Destination {} not reachable from source {}. Skipping agent.",
+                      *dstId,
+                      *srcId);
         --nAgents;
         continue;
       }

src/dsf/mobility/RoadNetwork.cpp

@@ -802,7 +802,7 @@ namespace dsf::mobility {
       }
 
       if (priorityRoads.size() < 2) {
-        spdlog::warn("Node {}: unable to auto-assign road priorities", pNode->id());
+        spdlog::warn("{}: unable to auto-assign road priorities", *pNode);
         return;
       }
 
@@ -934,6 +934,59 @@ namespace dsf::mobility {
     addEdge<Street>(std::move(street));
   }
 
+  void RoadNetwork::setStreetStatusById(Id const streetId, RoadStatus const status) {
+    try {
+      edge(streetId)->setStatus(status);
+    } catch (const std::out_of_range&) {
+      throw std::out_of_range(std::format("Street with id {} not found", streetId));
+    }
+  }
+  void RoadNetwork::setStreetStatusByName(std::string const& streetName,
+                                          RoadStatus const status) {
+    std::atomic<std::size_t> nAffectedRoads{0};
+    std::for_each(DSF_EXECUTION m_edges.cbegin(),
+                  m_edges.cend(),
+                  [this, &streetName, &status, &nAffectedRoads](auto const& pair) {
+                    auto const& pStreet = pair.second;
+                    if (pStreet->name().find(streetName) != std::string::npos) {
+                      pStreet->setStatus(status);
+                      ++nAffectedRoads;
+                    }
+                  });
+    spdlog::info("Set status {} to {} streets with name containing \"{}\"",
+                 status,
+                 nAffectedRoads.load(),
+                 streetName);
+  }
+  void RoadNetwork::changeStreetCapacityById(Id const streetId, double const factor) {
+    try {
+      auto const& pStreet{edge(streetId)};
+      auto const& currentCapacity{pStreet->capacity()};
+      pStreet->setCapacity(std::ceil(currentCapacity * factor));
+    } catch (const std::out_of_range&) {
+      throw std::out_of_range(std::format("Street with id {} not found", streetId));
+    }
+  }
+  void RoadNetwork::changeStreetCapacityByName(std::string const& streetName,
+                                               double const factor) {
+    std::atomic<std::size_t> nAffectedRoads{0};
+    std::for_each(DSF_EXECUTION m_edges.cbegin(),
+                  m_edges.cend(),
+                  [this, &streetName, &factor, &nAffectedRoads](auto const& pair) {
+                    auto const& pStreet = pair.second;
+                    if (pStreet->name().find(streetName) != std::string::npos) {
+                      auto const& currentCapacity = pStreet->capacity();
+                      pStreet->setCapacity(std::ceil(currentCapacity * factor));
+                      ++nAffectedRoads;
+                    }
+                  });
+    spdlog::info(
+        "Changed capacity by factor {} to {} streets with name containing \"{}\"",
+        factor,
+        nAffectedRoads.load(),
+        streetName);
+  }
+
   void RoadNetwork::setStreetStationaryWeights(
       std::unordered_map<Id, double> const& weights) {
     std::for_each(DSF_EXECUTION m_edges.cbegin(),

src/dsf/mobility/RoadNetwork.hpp

@@ -198,6 +198,24 @@ namespace dsf::mobility {
       requires is_street_v<std::remove_reference_t<T1>> &&
                (is_street_v<std::remove_reference_t<Tn>> && ...)
     void addStreets(T1&& street, Tn&&... streets);
+
+    /// @brief Set the street's status by its id
+    /// @param streetId The id of the street
+    /// @param status The status to set
+    void setStreetStatusById(Id const streetId, RoadStatus const status);
+    /// @brief Set the street's status of all streets with the given name
+    /// @param name The name to match
+    /// @param status The status to set
+    void setStreetStatusByName(std::string const& name, RoadStatus const status);
+    /// @brief Change the street's capacity by its id
+    /// @param streetId The id of the street
+    /// @param factor The factor to multiply the capacity by
+    void changeStreetCapacityById(Id const streetId, double const factor);
+    /// @brief Change the street's capacity of all streets with the given name
+    /// @param name The name to match
+    /// @param factor The factor to multiply the capacity by
+    void changeStreetCapacityByName(std::string const& name, double const factor);
+
     /// @brief Set the streets' stationary weights
     /// @param streetWeights A map where the key is the street id and the value is the street stationary weight. If a street id is not present in the map, its stationary weight is set to 1.0.
     void setStreetStationaryWeights(std::unordered_map<Id, double> const& streetWeights);
@@ -366,6 +384,10 @@ namespace dsf::mobility {
       // Explore all incoming edges (nodes that can reach currentNode)
       auto const& inEdges = node(currentNode)->ingoingEdges();
       for (auto const& inEdgeId : inEdges) {
+        // Skip closed roads
+        if (edge(inEdgeId)->roadStatus() == RoadStatus::CLOSED) {
+          continue;
+        }
         Id neighborId = edge(inEdgeId)->source();
 
         // Calculate the weight of the edge from neighbor to currentNode using the dynamics function
@@ -471,6 +493,10 @@ namespace dsf::mobility {
       // Explore all incoming edges (nodes that can reach currentNode)
       auto const& inEdges = node(currentNode)->ingoingEdges();
       for (auto const& inEdgeId : inEdges) {
+        // Skip closed roads
+        if (edge(inEdgeId)->roadStatus() == RoadStatus::CLOSED) {
+          continue;
+        }
         Id neighborId = edge(inEdgeId)->source();
 
         // Calculate the weight of the edge from neighbor to currentNode using the dynamics function