Simplify Streets class (#243)

* Add Edge base class

* Bugfix: capacity sometimes drop to 0

* Resolve deprecation warning

* Remove unused functions in Street

* Remove unused things

* Add u, v getters

* Less constructors

* Remove now useless function

* Adjust tests

* Bugfix

* Compiling examples

* Fix some warnings

* Bugfix

Author: Grufoony

benchmark/Street/BenchStreet.cpp

@@ -13,7 +13,7 @@ using SparseMatrix = dsm::SparseMatrix<bool>;
 using Bench = sb::Bench<long long int>;
 
 int main() {
-  Street street(0, 1000, 10., std::make_pair(0, 1));
+  Street street(0, std::make_pair(0, 1), 5000.);
   Agent agent(0, 0, 0);
   Bench b(1000);
 

examples/slow_charge_rb.cpp

@@ -83,12 +83,7 @@ int main(int argc, char** argv) {
   graph.importMatrix(IN_MATRIX, false);
   graph.importCoordinates(IN_COORDS);
   std::cout << "Setting street parameters..." << '\n';
-  for (const auto& [streetId, street] : graph.streetSet()) {
-    street->setTransportCapacity(1);
-    street->setMaxSpeed(13.9);
-  }
   graph.buildAdj();
-  graph.normalizeStreetCapacities();
 
   std::cout << "Number of nodes: " << graph.nNodes() << '\n';
   std::cout << "Number of streets: " << graph.nEdges() << '\n';

examples/slow_charge_tl.cpp

@@ -90,12 +90,7 @@ int main(int argc, char** argv) {
   graph.importMatrix(IN_MATRIX, false);
   graph.importCoordinates(IN_COORDS);
   std::cout << "Setting street parameters..." << '\n';
-  for (const auto& [streetId, street] : graph.streetSet()) {
-    street->setTransportCapacity(1);
-    street->setMaxSpeed(13.9);
-  }
   graph.buildAdj();
-  graph.normalizeStreetCapacities();
   const auto dv = graph.adjMatrix().getDegreeVector();
 
   // graph.addStreet(Street(100002, std::make_pair(0, 108)));

examples/stalingrado.cpp

@@ -49,10 +49,11 @@ int main() {
   Graph graph;
 
   // 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, 1, 651., 13.9, std::make_pair(3, 4), 2};
+  Street::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.};
+  Street s34{19, std::make_pair(3, 4), 651., 13.9, 2};
   // Viale Aldo Moro
   auto& tl1 = graph.addNode<TrafficLight>(1, 132);
   tl1.setCycle(s01.id(), dsm::Direction::ANY, {62, 0});
@@ -73,7 +74,6 @@ int main() {
   graph.addStreets(s01, s12, s23, s34);
   graph.buildAdj();
   graph.adjustNodeCapacities();
-  graph.normalizeStreetCapacities();
   auto& spire = graph.makeSpireStreet(19);
 
   std::cout << "Intersections: " << graph.nNodes() << '\n';

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 = 2;
-static constexpr uint8_t DSM_VERSION_PATCH = 12;
+static constexpr uint8_t DSM_VERSION_MINOR = 3;
+static constexpr uint8_t DSM_VERSION_PATCH = 0;
 
 static auto const DSM_VERSION =
     std::format("{}.{}.{}", DSM_VERSION_MAJOR, DSM_VERSION_MINOR, DSM_VERSION_PATCH);
@@ -24,6 +24,7 @@ namespace dsm {
 #include "headers/TrafficLight.hpp"
 #include "headers/Roundabout.hpp"
 #include "headers/SparseMatrix.hpp"
+#include "headers/Edge.hpp"
 #include "headers/Street.hpp"
 #include "headers/FirstOrderDynamics.hpp"
 #include "utility/TypeTraits/is_node.hpp"

src/dsm/headers/Dynamics.hpp

@@ -221,7 +221,7 @@ namespace dsm {
     const std::map<Id, std::unique_ptr<agent_t>>& agents() const { return m_agents; }
     /// @brief Get the number of agents currently in the simulation
     /// @return Size The number of agents
-    const Size nAgents() const { return m_agents.size(); }
+    Size nAgents() const { return m_agents.size(); }
     /// @brief Get the time
     /// @return Time The time
     Time time() const { return m_time; }

src/dsm/headers/Edge.cpp

@@ -0,0 +1,44 @@
+#include "Edge.hpp"
+#include "../utility/Logger.hpp"
+
+#include <stdexcept>
+#include <format>
+
+namespace dsm {
+  Edge::Edge(Id id, std::pair<Id, Id> nodePair, int capacity, int transportCapacity)
+      : m_id(id),
+        m_nodePair(nodePair),
+        m_capacity{capacity},
+        m_transportCapacity{transportCapacity} {
+    if (capacity < 1) {
+      throw std::invalid_argument(
+          buildLog(std::format("Edge capacity ({}) must be greater than 0.", capacity)));
+    }
+    if (transportCapacity < 1) {
+      throw std::invalid_argument(buildLog(std::format(
+          "Edge transport capacity ({}) must be greater than 0.", transportCapacity)));
+    }
+  }
+
+  void Edge::setCapacity(int capacity) {
+    if (capacity < 1) {
+      throw std::invalid_argument(
+          buildLog(std::format("Edge capacity ({}) must be greater than 0.", capacity)));
+    }
+    m_capacity = capacity;
+  }
+  void Edge::setTransportCapacity(int capacity) {
+    if (capacity < 1) {
+      throw std::invalid_argument(buildLog(
+          std::format("Edge transport capacity ({}) must be greater than 0.", capacity)));
+    }
+    m_transportCapacity = capacity;
+  }
+
+  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; }
+  int Edge::capacity() const { return m_capacity; }
+  int Edge::transportCapacity() const { return m_transportCapacity; }
+};  // namespace dsm

src/dsm/headers/Edge.hpp

@@ -0,0 +1,29 @@
+#pragma once
+
+#include <utility>
+#include "../utility/Typedef.hpp"
+
+namespace dsm {
+  class Edge {
+  protected:
+    Id m_id;
+    std::pair<Id, Id> m_nodePair;
+    int m_capacity;
+    int m_transportCapacity;
+
+  public:
+    Edge(Id id, std::pair<Id, Id> nodePair, int capacity = 1, int transportCapacity = 1);
+
+    void setCapacity(int capacity);
+    void setTransportCapacity(int capacity);
+
+    Id id() const;
+    Id u() const;
+    Id v() const;
+    std::pair<Id, Id> nodePair() const;
+    int capacity() const;
+    int transportCapacity() const;
+
+    virtual bool isFull() const = 0;
+  };
+};  // namespace dsm

src/dsm/headers/Graph.cpp

@@ -126,23 +126,13 @@ namespace dsm {
       for (const auto& [streetId, _] : m_adjacency.getRow(nodeId, true)) {
         value += m_streets[streetId]->nLanes() * m_streets[streetId]->transportCapacity();
       }
-      m_nodes[nodeId]->setTransportCapacity(value);
+      m_nodes[nodeId]->setTransportCapacity(value == 0 ? 1 : value);
       if (m_nodes[nodeId]->capacity() == 0) {
         m_nodes[nodeId]->setCapacity(value);
       }
     }
   }
 
-  void Graph::normalizeStreetCapacities(double meanVehicleLength) {
-    m_maxAgentCapacity = 0;
-    for (const auto& [_, street] : m_streets) {
-      auto const maxCapacity{
-          static_cast<Size>(street->length() * street->nLanes() / meanVehicleLength)};
-      m_maxAgentCapacity += maxCapacity;
-      street->setCapacity(maxCapacity);
-    }
-  }
-
   void Graph::importMatrix(const std::string& fileName, bool isAdj, double defaultSpeed) {
     // check the file extension
     std::string fileExt = fileName.substr(fileName.find_last_of(".") + 1);
@@ -172,11 +162,11 @@ namespace dsm {
         if (!m_nodes.contains(dstId)) {
           m_nodes.emplace(dstId, std::make_unique<Intersection>(dstId));
         }
-        m_streets.emplace(index,
-                          std::make_unique<Street>(index, std::make_pair(srcId, dstId)));
         assert(index == srcId * n + dstId);
-        if (!isAdj) {
-          m_streets[index]->setLength(val);
+        if (isAdj) {
+          addEdge<Street>(index, std::make_pair(srcId, dstId));
+        } else {
+          addEdge<Street>(index, std::make_pair(srcId, dstId), val);
         }
         m_streets[index]->setMaxSpeed(defaultSpeed);
       }
@@ -218,11 +208,11 @@ namespace dsm {
           if (!m_nodes.contains(dstId)) {
             m_nodes.emplace(dstId, std::make_unique<Intersection>(dstId));
           }
-          m_streets.emplace(
-              index, std::make_unique<Street>(index, std::make_pair(srcId, dstId)));
           assert(index == srcId * n + dstId);
-          if (!isAdj) {
-            m_streets[index]->setLength(value);
+          if (isAdj) {
+            addEdge<Street>(index, std::make_pair(srcId, dstId));
+          } else {
+            addEdge<Street>(index, std::make_pair(srcId, dstId), value);
           }
           m_streets[index]->setMaxSpeed(defaultSpeed);
         }
@@ -374,11 +364,10 @@ namespace dsm {
 
         Id streetId = std::stoul(sourceId) + std::stoul(targetId) * m_nodes.size();
         addEdge<Street>(streetId,
-                        std::stod(length) / 5,
-                        std::stod(maxspeed),
-                        std::stod(length),
                         std::make_pair(m_nodeMapping[std::stoul(sourceId)],
                                        m_nodeMapping[std::stoul(targetId)]),
+                        std::stod(length),
+                        std::stod(maxspeed),
                         std::stoul(lanes),
                         name);
       }
@@ -393,14 +382,14 @@ namespace dsm {
       throw std::invalid_argument(buildLog("Cannot open file: " + path));
     }
     if (isAdj) {
-      file << m_adjacency.getRowDim() << '\t' << m_adjacency.getColDim() << '\n';
+      file << m_adjacency.getRowDim() << '\t' << m_adjacency.getColDim();
       for (const auto& [id, value] : m_adjacency) {
-        file << id << '\t' << value << '\n';
+        file << '\n' << id << '\t' << value;
       }
     } else {
-      file << m_adjacency.getRowDim() << " " << m_adjacency.getColDim() << '\n';
+      file << m_adjacency.getRowDim() << '\t' << m_adjacency.getColDim();
       for (const auto& [id, street] : m_streets) {
-        file << id << '\t' << street->length() << '\n';
+        file << '\n' << id << '\t' << street->length();
       }
     }
   }

src/dsm/headers/Graph.hpp

@@ -110,11 +110,6 @@ 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 Normalize the streets' capacities
-    /// @param meanVehicleLength The mean vehicle length
-    /// @details The streets' capacities are normalized using the mean vehicle length following the formula:
-    /// \f$ \text{capacity} = \frac{\text{length} * \text{nLanes}}{\text{meanVehicleLength}} \f$
-    void normalizeStreetCapacities(double meanVehicleLength = 5.);
 
     /// @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