I like to std::move it std::move it

examples/slow_charge_rb.cpp

@@ -71,7 +71,7 @@ int main(int argc, char** argv) {
                                            BASE_OUT_FOLDER,
                                            ERROR_PROBABILITY,
                                            std::to_string(SEED))};  // output folder
-  const auto MAX_TIME{static_cast<unsigned int>(1e6)};  // maximum time of simulation
+  const auto MAX_TIME{static_cast<unsigned int>(5e5)};  // maximum time of simulation
 
   // Clear output folder or create it if it doesn't exist
   if (!fs::exists(BASE_OUT_FOLDER)) {
@@ -205,14 +205,15 @@ int main(int argc, char** argv) {
     dynamics.evolve(false);
 
     if (dynamics.time() % 2400 == 0) {
-      deltaAgents = dynamics.agents().size() - previousAgents;
+      auto const totalDynamicsAgents{dynamics.nAgents()};
+      deltaAgents = totalDynamicsAgents - previousAgents;
       if (deltaAgents < 0) {
         ++nAgents;
         std::cout << "- Now I'm adding " << nAgents << " agents.\n";
         std::cout << "Delta agents: " << deltaAgents << '\n';
         std::cout << "At time: " << dynamics.time() << '\n';
       }
-      previousAgents = dynamics.agents().size();
+      previousAgents = totalDynamicsAgents;
     }
 
     if (dynamics.time() % 300 == 0) {

examples/slow_charge_tl.cpp

@@ -67,7 +67,7 @@ int main(int argc, char** argv) {
                                      BASE_OUT_FOLDER,
                                      ERROR_PROBABILITY,
                                      std::to_string(SEED))};  // output folder
-  constexpr auto MAX_TIME{static_cast<unsigned int>(1e6)};  // maximum time of simulation
+  constexpr auto MAX_TIME{static_cast<unsigned int>(5e5)};  // maximum time of simulation
 
   std::cout << "-------------------------------------------------\n";
   std::cout << "Input parameters:\n";
@@ -309,14 +309,15 @@ int main(int argc, char** argv) {
     if (dynamics.time() % 2400 == 0 && nAgents > 0) {
       // auto meanDelta = std::accumulate(deltas.begin(), deltas.end(), 0) /
       // deltas.size();
-      deltaAgents = dynamics.agents().size() - previousAgents;
+      auto const totalDynamicsAgents{dynamics.nAgents()};
+      deltaAgents = totalDynamicsAgents - previousAgents;
       if (deltaAgents < 0) {
         ++nAgents;
         std::cout << "- Now I'm adding " << nAgents << " agents.\n";
         std::cout << "Delta agents: " << deltaAgents << '\n';
         std::cout << "At time: " << dynamics.time() << '\n';
       }
-      previousAgents = dynamics.agents().size();
+      previousAgents = totalDynamicsAgents;
       // deltas.clear();
     }
 

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 = 5;
-static constexpr uint8_t DSM_VERSION_PATCH = 12;
+static constexpr uint8_t DSM_VERSION_MINOR = 6;
+static constexpr uint8_t DSM_VERSION_PATCH = 0;
 
 static auto const DSM_VERSION =
     std::format("{}.{}.{}", DSM_VERSION_MAJOR, DSM_VERSION_MINOR, DSM_VERSION_PATCH);

src/dsm/headers/Agent.hpp

@@ -38,22 +38,20 @@ namespace dsm {
   public:
     /// @brief Construct a new Agent object
     /// @param spawnTime The agent's spawn time
-    /// @param id The agent's id
     /// @param itineraryId Optional, The agent's destination node. If not provided, the agent is a random agent
     /// @param srcNodeId Optional, The id of the source node of the agent
     Agent(Time const& spawnTime,
-          Id id,
           std::optional<Id> itineraryId = std::nullopt,
           std::optional<Id> srcNodeId = std::nullopt);
     /// @brief Construct a new Agent object
     /// @param spawnTime The agent's spawn time
-    /// @param id The agent's id
     /// @param itineraryIds The agent's itinerary
     /// @param srcNodeId Optional, The id of the source node of the agent
     Agent(Time const& spawnTime,
-          Id id,
           std::vector<Id> const& trip,
           std::optional<Id> srcNodeId = std::nullopt);
+
+    void setSrcNodeId(Id srcNodeId);
     /// @brief Set the street occupied by the agent
     /// @param streetId The id of the street currently occupied by the agent
     void setStreetId(std::optional<Id> streetId = std::nullopt);

src/dsm/headers/Dynamics.hpp

@@ -26,8 +26,6 @@
 #include <functional>
 
 #include "Network.hpp"
-#include "../utility/TypeTraits/is_agent.hpp"
-#include "../utility/TypeTraits/is_itinerary.hpp"
 #include "../utility/Logger.hpp"
 #include "../utility/Typedef.hpp"
 

src/dsm/headers/Edge.hpp

@@ -31,7 +31,11 @@
          int capacity = 1,
          double transportCapacity = 1.,
          std::vector<std::pair<double, double>> geometry = {});
+    Edge(Edge&&) = default;
+    Edge(const Edge&) = delete;
+    virtual ~Edge() = default;
 
+    void resetId(Id newId);
     void setCapacity(int capacity);
     void setTransportCapacity(double capacity);
     void setGeometry(std::vector<std::pair<double, double>> geometry);

src/dsm/headers/FirstOrderDynamics.hpp

@@ -23,7 +23,7 @@ namespace dsm {
     /// @brief Set the speed of an agent
     /// @param agentId The id of the agent
     /// @throw std::invalid_argument, If the agent is not found
-    void setAgentSpeed(Size agentId) override;
+    void setAgentSpeed(std::unique_ptr<Agent> const& pAgent) override;
     /// @brief Set the standard deviation of the speed fluctuation
     /// @param speedFluctuationSTD The standard deviation of the speed fluctuation
     /// @throw std::invalid_argument, If the standard deviation is negative

src/dsm/headers/Intersection.hpp

@@ -8,31 +8,35 @@
 
 #pragma once
 
-#include "Node.hpp"
+#include "Agent.hpp"
+#include "RoadJunction.hpp"
 
 #include <map>
+#include <memory>
 #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::multimap<int16_t, std::unique_ptr<Agent>> m_agents;
     std::set<Id>
         m_streetPriorities;  // A set containing the street ids that have priority - like main roads
     Size m_agentCounter;
 
   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} {};
+
+    Intersection(Intersection const&) = delete;
 
     virtual ~Intersection() = default;
 
@@ -47,17 +51,17 @@
     ///          The agent with the smallest angle difference is the first one to be
     ///          removed from the node.
     /// @throws std::runtime_error if the node is full
-    void addAgent(double angle, Id agentId);
+    void addAgent(double angle, std::unique_ptr<Agent> pAgent);
     /// @brief Put an agent in the node
     /// @param agentId The agent's id
     /// @details The agent's angle difference is used to order the agents in the node.
     ///          The agent with the smallest angle difference is the first one to be
     ///          removed from the node.
     /// @throws std::runtime_error if the node is full
-    void addAgent(Id agentId);
-    /// @brief Removes an agent from the node
-    /// @param agentId The agent's id
-    void removeAgent(Id agentId);
+    void addAgent(std::unique_ptr<Agent> pAgent);
+    // /// @brief Removes an agent from the node
+    // /// @param agentId The agent's id
+    // void removeAgent(Id agentId);
     /// @brief Set the node streets with priority
     /// @param streetPriorities A std::set containing the node's street priorities
     void setStreetPriorities(std::set<Id> streetPriorities) {
@@ -69,11 +73,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.
@@ -83,7 +87,7 @@
     virtual const std::set<Id>& streetPriorities() const { return m_streetPriorities; };
     /// @brief Get the node's agent ids
     /// @return std::set<Id> A std::set containing the node's agent ids
-    const std::multimap<int16_t, Id>& agents() { return m_agents; };
+    std::multimap<int16_t, std::unique_ptr<Agent>>& agents() { return m_agents; };
     /// @brief Returns the number of agents that have passed through the node
     /// @return Size The number of agents that have passed through the node
     /// @details This function returns the number of agents that have passed through the node

src/dsm/headers/Network.hpp

@@ -48,6 +48,10 @@
       requires(std::is_base_of_v<node_t, TNode> &&
                std::constructible_from<TNode, Id, TArgs...>)
     void addNode(Id nodeId, TArgs&&... args);
+
+    template <typename TEdge = edge_t>
+      requires(std::is_base_of_v<edge_t, TEdge>)
+    void addEdge(TEdge&& edge);
     /// @brief Add an edge to the network
     /// @tparam TEdge The type of the edge (default is edge_t)
     /// @tparam TArgs The types of the arguments
@@ -74,11 +78,11 @@
       requires(std::is_base_of_v<node_t, TNode>)
     TNode& node(Id nodeId);
     /// @brief Get an edge by id
     /// @tparam TEdge The type of the edge
     /// @param edgeId The edge's id
     /// @return TEdge& A reference to the edge
     template <typename TEdge>
       requires(std::is_base_of_v<edge_t, TEdge>)
     TEdge& edge(Id edgeId);
   };
 
@@ -160,6 +164,15 @@
     m_nodes.emplace(std::make_pair(
         nodeId, std::make_unique<TNode>(nodeId, std::forward<TArgs>(args)...)));
   }
+  template <typename node_t, typename edge_t>
+    requires(std::is_base_of_v<Node, node_t> && std::is_base_of_v<Edge, edge_t>)
+  template <typename TEdge>
+    requires(std::is_base_of_v<edge_t, TEdge>)
+  void Network<node_t, edge_t>::addEdge(TEdge&& edge) {
+    assert(!m_edges.contains(edge.id()));
+    m_edges.emplace(std::make_pair(edge.id(), std::make_unique<TEdge>(std::move(edge))));
+    m_addMissingNodes(edge.id());
+  }
   template <typename node_t, typename edge_t>
     requires(std::is_base_of_v<Node, node_t> && std::is_base_of_v<Edge, edge_t>)
   template <typename TEdge, typename... TArgs>
@@ -180,7 +193,7 @@
   template <typename node_t, typename edge_t>
     requires(std::is_base_of_v<Node, node_t> && std::is_base_of_v<Edge, edge_t>)
   std::unique_ptr<edge_t> const& Network<node_t, edge_t>::edge(Id edgeId) const {
     return m_edges.at(edgeId);
   }
 
   template <typename node_t, typename edge_t>

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/Road.hpp

@@ -2,6 +2,7 @@
 
 #include "Edge.hpp"
 
+#include <memory>
 #include <optional>
 #include <string>
 
@@ -15,12 +16,6 @@ namespace dsm {
     std::string m_name;
 
   public:
-    /// @brief Construct a new Road object starting from an existing road
-    /// @details The new road has different id but same capacity, length, speed limit, and node pair as the
-    ///          existing road.
-    /// @param Road The existing road
-    /// @param id The new road's id
-    Road(Id id, const Road&);
     /// @brief Construct a new Road object
     /// @param id The road's id
     /// @param nodePair The road's node pair
@@ -65,8 +60,6 @@ namespace dsm {
     /// @return std::string The name
     std::string name() const;
 
-    virtual void addAgent(Id agentId) = 0;
-
     virtual int nAgents() const = 0;
     virtual int nMovingAgents() const = 0;
     virtual int nExitingAgents() const = 0;