Make RoadJunction's transportCapacity attribute a real number

src/dsm/headers/Intersection.hpp

@@ -8,15 +8,15 @@
 
 #pragma once
 
-#include "Node.hpp"
+#include "RoadJunction.hpp"
 
 #include <map>
 #include <set>
 
 namespace dsm {
   /// @brief The Intersection class represents a node in the network.
   /// @tparam Id The type of the node's id. It must be an unsigned integral type.
-  class Intersection : public Node {
+  class Intersection : public RoadJunction {
   protected:
     std::multimap<int16_t, Id> m_agents;
     std::set<Id>
@@ -26,13 +26,13 @@
   public:
     /// @brief Construct a new Intersection object
     /// @param id The node's id
-    explicit Intersection(Id id) : Node{id} {};
+    explicit Intersection(Id id) : RoadJunction{id} {};
     /// @brief Construct a new Intersection object
     /// @param id The node's id
     /// @param coords A std::pair containing the node's coordinates
-    Intersection(Id id, std::pair<double, double> coords) : Node{id, coords} {};
+    Intersection(Id id, std::pair<double, double> coords) : RoadJunction{id, coords} {};
 
-    Intersection(Node const& node) : Node{node} {};
+    Intersection(RoadJunction const& node) : RoadJunction{node} {};
 
     virtual ~Intersection() = default;
 
@@ -69,11 +69,11 @@
     /// @brief Returns the node's density
     /// @return double The node's density
     double density() const override {
-      return static_cast<double>(m_agents.size()) / m_capacity;
+      return static_cast<double>(m_agents.size()) / this->capacity();
     }
     /// @brief Returns true if the node is full
     /// @return bool True if the node is full
-    bool isFull() const override { return m_agents.size() == this->m_capacity; }
+    bool isFull() const override { return m_agents.size() == this->capacity(); }
 
     /// @brief Get the node's street priorities
     /// @details This function returns a std::set containing the node's street priorities.

src/dsm/headers/Node.hpp

@@ -29,38 +29,26 @@ namespace dsm {
     Id m_id;
     std::optional<std::pair<double, double>> m_coords;
     std::string m_name;
-    Size m_capacity;
-    int m_transportCapacity;
 
   public:
     /// @brief Construct a new Node object with capacity 1
     /// @param id The node's id
-    explicit Node(Id id) : m_id{id}, m_name{""}, m_capacity{1}, m_transportCapacity{1} {}
+    explicit Node(Id id) : m_id{id}, m_name{""} {}
     /// @brief Construct a new Node object with capacity 1
     /// @param id The node's id
     /// @param coords A std::pair containing the node's coordinates (lat, lon)
     Node(Id id, std::pair<double, double> coords)
-        : m_id{id},
-          m_coords{std::move(coords)},
-          m_name{""},
-          m_capacity{1},
-          m_transportCapacity{1} {}
+        : m_id{id}, m_coords{std::move(coords)}, m_name{""} {}
 
     Node(Node const& other)
-        : m_id{other.m_id},
-          m_coords{other.m_coords},
-          m_name{other.m_name},
-          m_capacity{other.m_capacity},
-          m_transportCapacity{other.m_transportCapacity} {};
+        : m_id{other.m_id}, m_coords{other.m_coords}, m_name{other.m_name} {};
     virtual ~Node() = default;
 
     Node& operator=(Node const& other) {
       if (this != &other) {
         m_id = other.m_id;
         m_coords = other.m_coords;
         m_name = other.m_name;
-        m_capacity = other.m_capacity;
-        m_transportCapacity = other.m_transportCapacity;
       }
       return *this;
     }
@@ -74,18 +62,6 @@ namespace dsm {
     /// @brief Set the node's name
     /// @param name The node's name
     void setName(const std::string& name) { m_name = name; }
-    /// @brief Set the node's capacity
-    /// @param capacity The node's capacity
-    virtual void setCapacity(Size capacity) { m_capacity = capacity; }
-    /// @brief Set the node's transport capacity
-    /// @param capacity The node's transport capacity
-    virtual void setTransportCapacity(int capacity) {
-      if (capacity < 1) {
-        Logger::error(std::format(
-            "The transport capacity of a node ({}) must be greater than 0.", capacity));
-      }
-      m_transportCapacity = capacity;
-    }
     /// @brief Get the node's id
     /// @return Id The node's id
     Id id() const { return m_id; }
@@ -95,19 +71,6 @@ namespace dsm {
     /// @brief Get the node's name
     /// @return std::string The node's name
     const std::string& name() const { return m_name; }
-    /// @brief Get the node's capacity
-    /// @return Size The node's capacity
-    Size capacity() const { return m_capacity; }
-    /// @brief Get the node's transport capacity
-    /// @return Size The node's transport capacity
-    int transportCapacity() const { return m_transportCapacity; }
-
-    virtual double density() const { return 0.; };
-    virtual bool isFull() const { return true; };
-
-    virtual bool isIntersection() const noexcept { return false; }
-    virtual bool isTrafficLight() const noexcept { return false; }
-    virtual bool isRoundabout() const noexcept { return false; }
 
     virtual bool isStation() const noexcept { return false; }
   };

src/dsm/headers/RoadDynamics.hpp

@@ -88,8 +88,7 @@ namespace dsm {
     void m_evolveStreet(const std::unique_ptr<Street>& pStreet, bool reinsert_agents);
     /// @brief If possible, removes one agent from the node, putting it on the next street.
     /// @param pNode A std::unique_ptr to the node
-    /// @return bool True if the agent has been moved, false otherwise
-    bool m_evolveNode(const std::unique_ptr<Node>& pNode);
+    bool m_evolveNode(std::unique_ptr<RoadJunction> const& pNode);
     /// @brief Evolve the agents.
     /// @details Puts all new agents on a street, if possible, decrements all delays
     /// and increments all travel times.
@@ -643,7 +642,7 @@ namespace dsm {
 
   template <typename delay_t>
     requires(is_numeric_v<delay_t>)
-  bool RoadDynamics<delay_t>::m_evolveNode(const std::unique_ptr<Node>& pNode) {
+  bool RoadDynamics<delay_t>::m_evolveNode(std::unique_ptr<RoadJunction> const& pNode) {
     if (pNode->isIntersection()) {
       auto& intersection = dynamic_cast<Intersection&>(*pNode);
       if (intersection.agents().empty()) {
@@ -1134,7 +1133,9 @@ namespace dsm {
                   this->graph().nodes().cend(),
                   [&](const auto& pair) {
                     for (auto i = 0; i < pair.second->transportCapacity(); ++i) {
-                      m_evolveNode(pair.second);
+                      if (!m_evolveNode(pair.second)) {
+                        break;
+                      }
                     }
                     if (pair.second->isTrafficLight()) {
                       auto& tl = dynamic_cast<TrafficLight&>(*pair.second);

src/dsm/headers/RoadJunction.hpp

@@ -0,0 +1,47 @@
+#pragma once
+
+#include "Node.hpp"
+
+#include "../utility/Typedef.hpp"
+
+namespace dsm {
+  class RoadJunction : public Node {
+    Size m_capacity;
+    double m_transportCapacity;
+
+  public:
+    explicit RoadJunction(Id id);
+    RoadJunction(Id id, std::pair<double, double> coords);
+    RoadJunction(RoadJunction const& other);
+
+    RoadJunction& operator=(RoadJunction const& other) {
+      if (this != &other) {
+        Node::operator=(other);
+        m_capacity = other.m_capacity;
+        m_transportCapacity = other.m_transportCapacity;
+      }
+      return *this;
+    }
+
+    /// @brief Set the junction's capacity
+    /// @param capacity The junction's capacity
+    virtual void setCapacity(Size capacity);
+    /// @brief Set the junction's transport capacity
+    /// @param capacity The junction's transport capacity
+    void setTransportCapacity(double capacity);
+
+    /// @brief Get the junction's capacity
+    /// @return Size The junction's capacity
+    Size capacity() const;
+    /// @brief Get the junction's transport capacity
+    /// @return Size The junction's transport capacity
+    double transportCapacity() const;
+
+    virtual double density() const;
+    virtual bool isFull() const;
+
+    virtual bool isIntersection() const noexcept;
+    virtual bool isTrafficLight() const noexcept;
+    virtual bool isRoundabout() const noexcept;
+  };
+}  // namespace dsm

src/dsm/headers/RoadNetwork.hpp

@@ -29,6 +29,7 @@
 #include "AdjacencyMatrix.hpp"
 #include "DijkstraWeights.hpp"
 #include "Network.hpp"
+#include "RoadJunction.hpp"
 #include "Intersection.hpp"
 #include "TrafficLight.hpp"
 #include "Roundabout.hpp"
@@ -45,7 +46,7 @@
   /// @brief The RoadNetwork class represents a graph in the network.
   /// @tparam Id, The type of the graph's id. It must be an unsigned integral type.
   /// @tparam Size, The type of the graph's capacity. It must be an unsigned integral type.
-  class RoadNetwork : public Network<Node, Street> {
+  class RoadNetwork : public Network<RoadJunction, Street> {
   private:
     std::unordered_map<std::string, Id> m_nodeMapping;
     std::vector<Id> m_inputNodes;
@@ -87,7 +88,7 @@
     RoadNetwork& operator=(const RoadNetwork& other) {
       std::for_each(other.m_nodes.begin(), other.m_nodes.end(), [this](const auto& pair) {
         this->m_nodes.insert_or_assign(pair.first,
-                                       std::unique_ptr<Node>(pair.second.get()));
+                                       std::unique_ptr<RoadJunction>(pair.second.get()));
       });
       std::for_each(other.m_edges.begin(), other.m_edges.end(), [this](const auto& pair) {
         this->m_edges.insert_or_assign(pair.first,

src/dsm/headers/Roundabout.hpp

@@ -7,28 +7,28 @@
 
 #pragma once
 
-#include "Node.hpp"
+#include "RoadJunction.hpp"
 #include "../utility/queue.hpp"
 
 namespace dsm {
   /// @brief The Roundabout class represents a roundabout node in the network.
   /// @tparam Id The type of the node's id
   /// @tparam Size The type of the node's capacity
-  class Roundabout : public Node {
+  class Roundabout : public RoadJunction {
   protected:
     dsm::queue<Id> m_agents;
 
   public:
     /// @brief Construct a new Roundabout object
     /// @param id The node's id
-    explicit Roundabout(Id id) : Node{id} {};
+    explicit Roundabout(Id id) : RoadJunction{id} {};
     /// @brief Construct a new Roundabout object
     /// @param id The node's id
     /// @param coords A std::pair containing the node's coordinates
-    Roundabout(Id id, std::pair<double, double> coords) : Node{id, coords} {};
+    Roundabout(Id id, std::pair<double, double> coords) : RoadJunction{id, coords} {};
     /// @brief Construct a new Roundabout object
     /// @param node An Intersection object
-    Roundabout(const Node& node);
+    Roundabout(const RoadJunction& node);
 
     ~Roundabout() = default;
 
@@ -45,11 +45,11 @@
     /// @brief Returns the node's density
     /// @return double The node's density
     double density() const override {
-      return static_cast<double>(m_agents.size()) / m_capacity;
+      return static_cast<double>(m_agents.size()) / this->capacity();
     }
     /// @brief Returns true if the node is full
     /// @return bool True if the node is full
-    bool isFull() const override { return m_agents.size() == this->m_capacity; }
+    bool isFull() const override { return m_agents.size() == this->capacity(); }
     /// @brief Returns true if the node is a roundabout
     /// @return bool True if the node is a roundabout
     bool isRoundabout() const noexcept override { return true; }

src/dsm/headers/Station.hpp

@@ -6,12 +6,12 @@
 
 #pragma once
 
-#include "Node.hpp"
+#include "RoadJunction.hpp"
 
 #include <map>
 
 namespace dsm {
-  class Station : public Node {
+  class Station : public RoadJunction {
   private:
     Delay m_managementTime;
     std::multimap<train_t, Id, std::greater<train_t>> m_trains;
@@ -29,7 +29,7 @@
     /// @brief Construct a new Station object
     /// @param node A Node object representing the station
     /// @param managementTime The time it takes between two train departures/arrivals
-    Station(Node const& node, Delay managementTime);
+    Station(RoadJunction const& node, Delay managementTime);
     /// @brief Construct a new Station object by copying another Station object
     /// @param other The Station object to copy
     Station(Station const& other);
@@ -45,10 +45,10 @@
     Delay managementTime() const;
     /// @brief Get the train density of the station
     /// @return The train density of the station
-    double density() const final;
+    double density() const;
     /// @brief Check if the station is full
     /// @return True if the station is full, false otherwise
-    bool isFull() const final;
+    bool isFull() const;
     /// @brief Check if the node is a station
     /// @return True
     bool isStation() const noexcept final;

src/dsm/headers/TrafficLight.hpp

@@ -65,7 +65,7 @@
     TrafficLight(Id id, Delay cycleTime, std::pair<double, double> coords)
         : Intersection{id, std::move(coords)}, m_cycleTime{cycleTime}, m_counter{0} {}
 
-    TrafficLight(Node const& node, Delay const cycleTime, Delay const counter = 0)
+    TrafficLight(RoadJunction const& node, Delay const cycleTime, Delay const counter = 0)
         : Intersection{node}, m_cycleTime{cycleTime}, m_counter{counter} {}
 
     ~TrafficLight() = default;

src/dsm/sources/Intersection.cpp

@@ -12,7 +12,7 @@ namespace dsm {
           capacity,
           m_agents.size())));
     }
-    Node::setCapacity(capacity);
+    RoadJunction::setCapacity(capacity);
   }
 
   void Intersection::addAgent(double angle, Id agentId) {

src/dsm/sources/RoadJunction.cpp

@@ -0,0 +1,26 @@
+#include "../headers/RoadJunction.hpp"
+
+namespace dsm {
+  RoadJunction::RoadJunction(Id id) : Node(id), m_capacity{1}, m_transportCapacity{1.} {}
+  RoadJunction::RoadJunction(Id id, std::pair<double, double> coords)
+      : Node(id, coords), m_capacity{1}, m_transportCapacity{1.} {}
+  RoadJunction::RoadJunction(RoadJunction const& other)
+      : Node(other),
+        m_capacity{other.m_capacity},
+        m_transportCapacity{other.m_transportCapacity} {}
+
+  void RoadJunction::setCapacity(Size capacity) { m_capacity = capacity; }
+  void RoadJunction::setTransportCapacity(double capacity) {
+    assert(capacity > 0.);
+    m_transportCapacity = capacity;
+  }
+
+  Size RoadJunction::capacity() const { return m_capacity; }
+  double RoadJunction::transportCapacity() const { return m_transportCapacity; }
+  double RoadJunction::density() const { return 0.; }
+  bool RoadJunction::isFull() const { return true; }
+
+  bool RoadJunction::isIntersection() const noexcept { return false; }
+  bool RoadJunction::isTrafficLight() const noexcept { return false; }
+  bool RoadJunction::isRoundabout() const noexcept { return false; }
+}  // namespace dsm

src/dsm/sources/RoadNetwork.cpp

@@ -121,9 +121,9 @@
   }
 
   void RoadNetwork::adjustNodeCapacities() {
-    int16_t value;
+    double value;
     for (Id nodeId = 0; nodeId < m_nodes.size(); ++nodeId) {
-      value = 0;
+      value = 0.;
       auto const N{nNodes()};
       for (const auto& sourceId : m_adjacencyMatrix.getCol(nodeId)) {
         auto const streetId{sourceId * N + nodeId};
@@ -132,13 +132,13 @@
       }
       auto const& pNode{m_nodes.at(nodeId)};
       pNode->setCapacity(value);
-      value = 0;
+      value = 0.;
       for (const auto& targetId : m_adjacencyMatrix.getRow(nodeId)) {
         auto const streetId{nodeId * N + targetId};
         auto const& pStreet{m_edges.at(streetId)};
         value += pStreet->nLanes() * pStreet->transportCapacity();
       }
-      pNode->setTransportCapacity(value == 0 ? 1 : value);
+      pNode->setTransportCapacity(value == 0. ? 1. : value);
       if (pNode->capacity() == 0) {
         pNode->setCapacity(value);
       }