add StochasticStreet class

examples/stalingrado.cpp

@@ -49,7 +49,7 @@ int main() {
   Graph graph;
 
   // Street(StreetId, Capacity, Length, vMax, (from, to))
-  Street::setMeanVehicleLength(8.);
+  dsm::Road::setMeanVehicleLength(8.);
   Street s01{1, std::make_pair(0, 1), 2281.};
   Street s12{7, std::make_pair(1, 2), 118.};
   Street s23{13, std::make_pair(2, 3), 222.};
@@ -74,7 +74,8 @@ int main() {
   graph.addStreets(s01, s12, s23, s34);
   graph.buildAdj();
   graph.adjustNodeCapacities();
-  auto& spire = graph.makeSpireStreet(19);
+  graph.makeSpireStreet(19);
+  auto& spire = dynamic_cast<SpireStreet&>(*graph.streetSet().at(19));
 
   std::cout << "Intersections: " << graph.nNodes() << '\n';
   std::cout << "Streets: " << graph.nEdges() << '\n';

src/dsm/dsm.hpp

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

src/dsm/headers/Dynamics.hpp

@@ -428,7 +428,7 @@ namespace dsm {
       return 0.;
     }
     double speed{0.};
-    for (auto const& agentId : pStreet->waitingAgents()) {
+    for (auto const& agentId : pStreet->movingAgents()) {
       speed += m_agents.at(agentId)->speed();
     }
     return speed / nAgents;

src/dsm/headers/Edge.cpp

@@ -1,15 +1,23 @@
 #include "Edge.hpp"
 #include "../utility/Logger.hpp"
 
-#include <stdexcept>
+#include <cassert>
+#include <cmath>
 #include <format>
+#include <numbers>
+#include <stdexcept>
 
 namespace dsm {
-  Edge::Edge(Id id, std::pair<Id, Id> nodePair, int capacity, int transportCapacity)
+  Edge::Edge(Id id,
+             std::pair<Id, Id> nodePair,
+             int capacity,
+             int transportCapacity,
+             double angle)
       : m_id(id),
         m_nodePair(nodePair),
         m_capacity{capacity},
-        m_transportCapacity{transportCapacity} {
+        m_transportCapacity{transportCapacity},
+        m_angle{angle} {
     if (capacity < 1) {
       throw std::invalid_argument(
           buildLog(std::format("Edge capacity ({}) must be greater than 0.", capacity)));
@@ -18,6 +26,10 @@
       throw std::invalid_argument(buildLog(std::format(
           "Edge transport capacity ({}) must be greater than 0.", transportCapacity)));
     }
+    if (std::abs(angle) > 2 * std::numbers::pi) {
+      throw std::invalid_argument(buildLog(
+          std::format("Edge angle ({}) must be in the range [-2pi, 2pi].", angle)));
+    }
   }
 
   void Edge::setCapacity(int capacity) {
@@ -35,10 +47,34 @@
     m_transportCapacity = capacity;
   }
 
+  void Edge::setAngle(std::pair<double, double> srcNodeCoordinates,
+                      std::pair<double, double> dstNodeCoordinates) {
+    // N.B.: lat, lon <==> y, x
+    double const dy{dstNodeCoordinates.first - srcNodeCoordinates.first};
+    double const dx{dstNodeCoordinates.second - srcNodeCoordinates.second};
+    double angle{std::atan2(dy, dx)};
+    if (angle < 0.) {
+      angle += 2 * std::numbers::pi;
+    }
+    assert(!(std::abs(angle) > 2 * std::numbers::pi));
+    m_angle = angle;
+  }
+
   Id Edge::id() const { return m_id; }
   Id Edge::u() const { return m_nodePair.first; }
   Id Edge::v() const { return m_nodePair.second; }
-  std::pair<Id, Id> Edge::nodePair() const { return m_nodePair; }
+  std::pair<Id, Id> const& Edge::nodePair() const { return m_nodePair; }
   int Edge::capacity() const { return m_capacity; }
   int Edge::transportCapacity() const { return m_transportCapacity; }
+  double Edge::angle() const { return m_angle; }
+
+  double Edge::deltaAngle(double const previousEdgeAngle) const {
+    double deltaAngle{this->m_angle - previousEdgeAngle};
+    if (deltaAngle > std::numbers::pi) {
+      deltaAngle -= 2 * std::numbers::pi;
+    } else if (deltaAngle < -std::numbers::pi) {
+      deltaAngle += 2 * std::numbers::pi;
+    }
+    return deltaAngle;
+  }
 };  // namespace dsm

src/dsm/headers/Edge.hpp

@@ -10,20 +10,53 @@ namespace dsm {
     std::pair<Id, Id> m_nodePair;
     int m_capacity;
     int m_transportCapacity;
+    double m_angle;
 
   public:
-    Edge(Id id, std::pair<Id, Id> nodePair, int capacity = 1, int transportCapacity = 1);
+    /// @brief Construct a new Edge object
+    /// @param id The edge's id
+    /// @param nodePair The edge's node pair (u, v) with the edge u -> v
+    /// @param capacity The edge's capacity, in number of agents, i.e. the maximum number of agents that can be on the
+    /// edge at the same time. Default is 1.
+    /// @param transportCapacity The edge's transport capacity, in number of agents, i.e. the maximum number of agents
+    /// that can be emitted by the same time. Default is 1.
+    /// @param angle The edge's angle, in radians, between the source and destination nodes
+    Edge(Id id,
+         std::pair<Id, Id> nodePair,
+         int capacity = 1,
+         int transportCapacity = 1,
+         double angle = 0.0);
 
     void setCapacity(int capacity);
     void setTransportCapacity(int capacity);
+    void setAngle(std::pair<double, double> srcNodeCoordinates,
+                  std::pair<double, double> dstNodeCoordinates);
 
+    /// @brief Get the edge's id
+    /// @return Id The edge's id
     Id id() const;
+    /// @brief Get the edge's source node id
+    /// @return Id The edge's source node id
     Id u() const;
+    /// @brief Get the edge's destination node id
+    /// @return Id The edge's destination node id
     Id v() const;
-    std::pair<Id, Id> nodePair() const;
+    /// @brief Get the edge's node pair
+    /// @return std::pair<Id, Id> The edge's node pair, where the first element is the source node id and the second
+    /// element is the destination node id. The pair is (u, v) with the edge u -> v.
+    std::pair<Id, Id> const& nodePair() const;
+    /// @brief Get the edge's capacity, in number of agents
+    /// @return int The edge's capacity, in number of agents
     int capacity() const;
+    /// @brief Get the edge's transport capacity, in number of agents
+    /// @return int The edge's transport capacity, in number of agents
     int transportCapacity() const;
+    /// @brief Get the edge's angle, in radians, between the source and destination nodes
+    /// @return double The edge's angle, in radians
+    double angle() const;
 
     virtual bool isFull() const = 0;
+
+    double deltaAngle(double const previousEdgeAngle) const;
   };
 };  // namespace dsm

src/dsm/headers/FirstOrderDynamics.cpp

@@ -54,11 +54,11 @@ namespace dsm {
     double meanSpeed{0.};
     Size n{0};
     if (street->nExitingAgents() == 0) {
-      n = static_cast<Size>(street->waitingAgents().size());
+      n = static_cast<Size>(street->movingAgents().size());
       double alpha{m_alpha / street->capacity()};
       meanSpeed = street->maxSpeed() * n * (1. - 0.5 * alpha * (n - 1.));
     } else {
-      for (const auto& agentId : street->waitingAgents()) {
+      for (const auto& agentId : street->movingAgents()) {
         meanSpeed += this->agents().at(agentId)->speed();
         ++n;
       }

src/dsm/headers/Graph.cpp

@@ -45,18 +45,29 @@
     const auto n{static_cast<Size>(m_nodes.size())};
     std::unordered_map<Id, Id> newStreetIds;
     for (const auto& [streetId, street] : oldStreetSet) {
-      const auto srcId{street->nodePair().first};
-      const auto dstId{street->nodePair().second};
+      const auto srcId{street->u()};
+      const auto dstId{street->v()};
       const auto newStreetId{static_cast<Id>(srcId * n + dstId)};
       if (m_streets.contains(newStreetId)) {
         throw std::invalid_argument(buildLog("Street with same id already exists."));
       }
-      if (street->isSpire()) {
+      if (street->isSpire() && street->isStochastic()) {
+        m_streets.emplace(newStreetId,
+                          std::make_unique<StochasticSpireStreet>(
+                              newStreetId,
+                              *street,
+                              dynamic_cast<StochasticSpireStreet&>(*street).flowRate()));
+      } else if (street->isStochastic()) {
+        m_streets.emplace(newStreetId,
+                          std::make_unique<StochasticStreet>(
+                              newStreetId,
+                              *street,
+                              dynamic_cast<StochasticStreet&>(*street).flowRate()));
+      } else if (street->isSpire()) {
         m_streets.emplace(newStreetId,
                           std::make_unique<SpireStreet>(newStreetId, *street));
       } else {
-        m_streets.emplace(newStreetId,
-                          std::make_unique<Street>(Street{newStreetId, *street}));
+        m_streets.emplace(newStreetId, std::make_unique<Street>(newStreetId, *street));
       }
       newStreetIds.emplace(streetId, newStreetId);
     }
@@ -444,15 +455,27 @@
     pNode = std::make_unique<Station>(*pNode, managementTime);
     return dynamic_cast<Station&>(*pNode);
   }
-
-  SpireStreet& Graph::makeSpireStreet(Id streetId) {
+  StochasticStreet& Graph::makeStochasticStreet(Id streetId, double const flowRate) {
     if (!m_streets.contains(streetId)) {
       throw std::invalid_argument(
           buildLog(std::format("Street with id {} does not exist.", streetId)));
     }
     auto& pStreet = m_streets[streetId];
+    pStreet = std::make_unique<StochasticStreet>(pStreet->id(), *pStreet, flowRate);
+    return dynamic_cast<StochasticStreet&>(*pStreet);
+  }
+  void Graph::makeSpireStreet(Id streetId) {
+    if (!m_streets.contains(streetId)) {
+      throw std::invalid_argument(
+          buildLog(std::format("Street with id {} does not exist.", streetId)));
+    }
+    auto& pStreet = m_streets[streetId];
+    if (pStreet->isStochastic()) {
+      pStreet = std::make_unique<StochasticSpireStreet>(
+          pStreet->id(), *pStreet, dynamic_cast<StochasticStreet&>(*pStreet).flowRate());
+      return;
+    }
     pStreet = std::make_unique<SpireStreet>(pStreet->id(), *pStreet);
-    return dynamic_cast<SpireStreet&>(*pStreet);
   }
 
   void Graph::addStreet(std::unique_ptr<Street> street) {

src/dsm/headers/Graph.hpp

@@ -159,10 +159,6 @@ namespace dsm {
                std::constructible_from<node_t, Id, TArgs...>)
     node_t& addNode(Id id, TArgs&&... args);
 
-    template <typename... Tn>
-      requires(is_node_v<std::remove_reference_t<Tn>> && ...)
-    void addNodes(Tn&&... nodes);
-
     template <typename T1, typename... Tn>
       requires is_node_v<std::remove_reference_t<T1>> &&
                (is_node_v<std::remove_reference_t<Tn>> && ...)
@@ -182,11 +178,12 @@ namespace dsm {
     /// @return A reference to the roundabout
     /// @throws std::invalid_argument if the node does not exist
     Roundabout& makeRoundabout(Id nodeId);
+
+    StochasticStreet& makeStochasticStreet(Id streetId, double const flowRate);
     /// @brief Convert an existing street into a spire street
     /// @param streetId The id of the street to convert to a spire street
-    /// @return A reference to the spire street
     /// @throws std::invalid_argument if the street does not exist
-    SpireStreet& makeSpireStreet(Id streetId);
+    void makeSpireStreet(Id streetId);
     /// @brief Convert an existing node into a station
     /// @param nodeId The id of the node to convert to a station
     /// @param managementTime The station's management time
@@ -286,9 +283,6 @@ namespace dsm {
     addNode(std::make_unique<node_t>(id, std::forward<TArgs>(args)...));
     return dynamic_cast<node_t&>(*m_nodes[id]);
   }
-  template <typename... Tn>
-    requires(is_node_v<std::remove_reference_t<Tn>> && ...)
-  void Graph::addNodes(Tn&&... nodes) {}
   template <typename T1, typename... Tn>
     requires is_node_v<std::remove_reference_t<T1>> &&
              (is_node_v<std::remove_reference_t<Tn>> && ...)
@@ -313,8 +307,8 @@ namespace dsm {
           buildLog(std::format("Street with id {} already exists.", street.id())));
     }
     // emplace nodes
-    const auto srcId{street.nodePair().first};
-    const auto dstId{street.nodePair().second};
+    auto const srcId{street.u()};
+    auto const dstId{street.v()};
     if (!m_nodes.contains(srcId)) {
       m_nodes.emplace(srcId, std::make_unique<Intersection>(srcId));
     }

src/dsm/headers/Road.cpp

@@ -0,0 +1,69 @@
+#include "Road.hpp"
+#include "../utility/Logger.hpp"
+
+#include <cmath>
+#include <format>
+#include <stdexcept>
+
+namespace dsm {
+  double Road::m_meanVehicleLength = 5.;
+
+  Road::Road(Id id, const Road& road)
+      : Edge(
+            id, road.nodePair(), road.capacity(), road.transportCapacity(), road.angle()),
+        m_length{road.length()},
+        m_maxSpeed{road.maxSpeed()},
+        m_nLanes{road.nLanes()},
+        m_name{road.name()} {}
+
+  Road::Road(Id id,
+             std::pair<Id, Id> nodePair,
+             double length,
+             double maxSpeed,
+             int nLanes,
+             std::string name,
+             std::optional<int> capacity,
+             int transportCapacity)
+      : Edge(id,
+             std::move(nodePair),
+             capacity.value_or(std::ceil((length * nLanes) / m_meanVehicleLength)),
+             transportCapacity),
+        m_length{length},
+        m_maxSpeed{maxSpeed},
+        m_nLanes{nLanes},
+        m_name{std::move(name)} {
+    if (!(length > 0.)) {
+      throw std::invalid_argument(buildLog(
+          std::format("The length of a road ({}) must be greater than 0.", length)));
+    }
+    if (!(maxSpeed > 0.)) {
+      throw std::invalid_argument(buildLog(std::format(
+          "The maximum speed of a road ({}) must be greater than 0.", maxSpeed)));
+    }
+    if (nLanes < 1) {
+      throw std::invalid_argument(buildLog(std::format(
+          "The number of lanes of a road ({}) must be greater than 0.", nLanes)));
+    }
+  }
+  void Road::setMeanVehicleLength(double meanVehicleLength) {
+    if (!(meanVehicleLength > 0.)) {
+      throw std::invalid_argument(buildLog(std::format(
+          "The mean vehicle length ({}) must be greater than 0.", meanVehicleLength)));
+    }
+    m_meanVehicleLength = meanVehicleLength;
+  }
+  double Road::meanVehicleLength() { return m_meanVehicleLength; }
+
+  void Road::setMaxSpeed(double speed) {
+    if (speed < 0.) {
+      throw std::invalid_argument(buildLog(
+          std::format("The maximum speed of a road ({}) cannot be negative.", speed)));
+    }
+    m_maxSpeed = speed;
+  }
+
+  double Road::length() const { return m_length; }
+  double Road::maxSpeed() const { return m_maxSpeed; }
+  int Road::nLanes() const { return m_nLanes; }
+  std::string Road::name() const { return m_name; }
+};  // namespace dsm