Init Itineraries rework

Author: Grufoony

src/dsm/headers/Dynamics.hpp

@@ -67,7 +67,7 @@ namespace dsm {
     requires(is_numeric_v<Delay>)
   class Dynamics {
   protected:
-    std::unordered_map<Id, std::unique_ptr<Itinerary>> m_itineraries;
+    std::vector<std::unique_ptr<Itinerary>> m_itineraries;
     std::map<Id, std::unique_ptr<Agent<Delay>>> m_agents;
     TimePoint m_time, m_previousSpireTime;
     Graph m_graph;
@@ -154,9 +154,8 @@ namespace dsm {
       }
       if (path.size() == 0) {
         throw std::runtime_error(
-            buildLog(std::format("Path with id {} and destination {} is empty. Please "
+            buildLog(std::format("Path destination {} is empty. Please "
                                  "check the adjacency matrix.",
-                                 pItinerary->id(),
                                  pItinerary->destination())));
       }
       pItinerary->setPath(path);
@@ -232,9 +231,11 @@ namespace dsm {
     /// @brief Get the graph
     /// @return const Graph&, The graph
     const Graph& graph() const { return m_graph; };
+
+    const std::unique_ptr<Itinerary>& itinerary(Id destination) const;
     /// @brief Get the itineraries
     /// @return const std::unordered_map<Id, Itinerary>&, The itineraries
-    const std::unordered_map<Id, std::unique_ptr<Itinerary>>& itineraries() const {
+    const std::vector<std::unique_ptr<Itinerary>>& itineraries() const {
       return m_itineraries;
     }
     /// @brief Get the agents
@@ -703,25 +704,38 @@ namespace dsm {
     requires(is_numeric_v<Delay>)
   void Dynamics<Delay>::setDestinationNodes(const std::span<Id>& destinationNodes,
                                             bool updatePaths) {
+    m_itineraries.clear();
+    m_itineraries.reserve(destinationNodes.size());
     for (const auto& nodeId : destinationNodes) {
       if (!m_graph.nodeSet().contains(nodeId)) {
         throw std::invalid_argument(
             buildLog(std::format("Node with id {} not found", nodeId)));
       }
-      this->addItinerary(Itinerary{nodeId, nodeId});
+      this->addItinerary(Itinerary{nodeId});
     }
     if (updatePaths) {
       this->updatePaths();
     }
   }
 
+  template <typename Delay>
+    requires(is_numeric_v<Delay>)
+  const std::unique_ptr<Itinerary>& Dynamics<Delay>::itinerary(Id destination) const {
+    for (auto const& pItinerary : m_itineraries) {
+      if (pItinerary->destination() == destination) {
+        return pItinerary;
+      }
+    }
+    return nullptr;
+  }
+
   template <typename Delay>
     requires(is_numeric_v<Delay>)
   void Dynamics<Delay>::updatePaths() {
     std::vector<std::thread> threads;
     threads.reserve(m_itineraries.size());
     std::exception_ptr pThreadException;
-    for (const auto& [itineraryId, itinerary] : m_itineraries) {
+    for (const auto& itinerary : m_itineraries) {
       threads.emplace_back(std::thread([this, &itinerary, &pThreadException] {
         try {
           this->m_updatePath(itinerary);
@@ -937,47 +951,49 @@ namespace dsm {
   }
   template <typename Delay>
     requires(is_numeric_v<Delay>)
-  void Dynamics<Delay>::addAgent(Id srcNodeId, Id itineraryId) {
+  void Dynamics<Delay>::addAgent(Id srcNodeId, Id dstNodeId) {
     if (this->m_agents.size() + 1 > this->m_graph.maxCapacity()) {
       throw std::overflow_error(buildLog(
           std::format("Graph its already holding the max possible number of agents ({})",
                       this->m_graph.maxCapacity())));
     }
-    if (!(srcNodeId < this->m_graph.nodeSet().size())) {
-      throw std::invalid_argument(
-          buildLog(std::format("Node with id {} not found", srcNodeId)));
-    }
-    if (!(this->m_itineraries.contains(itineraryId))) {
-      throw std::invalid_argument(
-          buildLog(std::format("Itinerary with id {} not found", itineraryId)));
-    }
+    assert((void("Nodes indexes out of range."),
+            srcNodeId < this->m_graph.nodeSet().size() &&
+                dstNodeId < this->m_graph.nodeSet().size()));
+    assert((void("No itineray associated with the destination node."),
+            std::find_if(m_itineraries.begin(),
+                         m_itineraries.end(),
+                         [dstNodeId](const std::unique_ptr<Itinerary>& itinerary) {
+                           return itinerary->destination() == dstNodeId;
+                         }) != m_itineraries.end()));
     Size agentId{0};
     if (!this->m_agents.empty()) {
       agentId = this->m_agents.rbegin()->first + 1;
     }
-    this->addAgent(Agent<Delay>{agentId, itineraryId, srcNodeId});
+    this->addAgent(Agent<Delay>{agentId, dstNodeId, srcNodeId});
   }
   template <typename Delay>
     requires(is_numeric_v<Delay>)
-  void Dynamics<Delay>::addAgents(Id itineraryId,
+  void Dynamics<Delay>::addAgents(Id dstNodeId,
                                   Size nAgents,
                                   std::optional<Id> srcNodeId) {
     if (this->m_agents.size() + nAgents > this->m_graph.maxCapacity()) {
       throw std::overflow_error(buildLog(
           std::format("Graph its already holding the max possible number of agents ({})",
                       this->m_graph.maxCapacity())));
     }
-    auto itineraryIt{m_itineraries.find(itineraryId)};
-    if (itineraryIt == m_itineraries.end()) {
-      throw std::invalid_argument(
-          buildLog(std::format("Itinerary with id {} not found", itineraryId)));
-    }
+    assert((void("No itineray associated with the destination node."),
+            std::find_if(m_itineraries.begin(),
+                         m_itineraries.end(),
+                         [dstNodeId](const std::unique_ptr<Itinerary>& itinerary) {
+                           return itinerary->destination() == dstNodeId;
+                         }) != m_itineraries.end()));
     Size agentId{0};
     if (!this->m_agents.empty()) {
       agentId = this->m_agents.rbegin()->first + 1;
     }
     for (Size i{0}; i < nAgents; ++i, ++agentId) {
-      this->addAgent(Agent<Delay>{agentId, itineraryId});
+      this->addAgent(Agent<Delay>{agentId, dstNodeId});
       if (srcNodeId.has_value()) {
         this->m_agents[agentId]->setSourceNodeId(srcNodeId.value());
       }
@@ -1032,9 +1048,7 @@ namespace dsm {
         0, static_cast<Size>(this->m_graph.streetSet().size() - 1)};
     for (Size i{0}; i < nAgents; ++i) {
       if (randomItinerary) {
-        auto itineraryIt{this->m_itineraries.begin()};
-        std::advance(itineraryIt, itineraryDist(this->m_generator));
-        itineraryId = itineraryIt->first;
+        itineraryId = m_itineraries[itineraryDist(m_generator)]->destination();
       }
       Id agentId{0};
       if (!this->m_agents.empty()) {
@@ -1111,16 +1125,13 @@ namespace dsm {
           }
         }
       }
-      // find the itinerary with the given destination as destination
-      auto itineraryIt{std::find_if(
-          m_itineraries.begin(), m_itineraries.end(), [dstId](const auto& itinerary) {
-            return itinerary.second->destination() == dstId;
-          })};
-      if (itineraryIt == m_itineraries.end()) {
-        throw std::invalid_argument(
-            buildLog(std::format("Itinerary with destination {} not found.", dstId)));
-      }
-      this->addAgent(srcId, itineraryIt->first);
+      assert((void("No itineray associated with the destination node."),
+              std::find_if(m_itineraries.begin(),
+                           m_itineraries.end(),
+                           [dstId](const std::unique_ptr<Itinerary>& itinerary) {
+                             return itinerary->destination() == dstId;
+                           }) != m_itineraries.end()));
+      this->addAgent(srcId, dstId);
       --nAgents;
     }
   }
@@ -1146,13 +1157,13 @@ namespace dsm {
   template <typename Delay>
     requires(is_numeric_v<Delay>)
   void Dynamics<Delay>::addItinerary(const Itinerary& itinerary) {
-    m_itineraries.emplace(itinerary.id(), std::make_unique<Itinerary>(itinerary));
+    m_itineraries.emplace_back(std::make_unique<Itinerary>(itinerary));
   }
 
   template <typename Delay>
     requires(is_numeric_v<Delay>)
   void Dynamics<Delay>::addItinerary(std::unique_ptr<Itinerary> itinerary) {
-    m_itineraries.emplace(itinerary->id(), std::move(itinerary));
+    m_itineraries.emplace_back(std::move(itinerary));
   }
 
   template <typename Delay>

src/dsm/headers/Graph.hpp

@@ -207,9 +207,7 @@ namespace dsm {
     }
     /// @brief Get the graph's street map
     /// @return A std::unordered_map containing the graph's streets
-    std::unordered_map<Id, std::unique_ptr<Street>>& streetSet() {
-      return m_streets;
-    }
+    std::unordered_map<Id, std::unique_ptr<Street>>& streetSet() { return m_streets; }
     /// @brief Get a street from the graph
     /// @param source The source node
     /// @param destination The destination node

src/dsm/headers/Itinerary.cpp

@@ -2,15 +2,10 @@
 #include "Itinerary.hpp"
 
 namespace dsm {
-  Itinerary::Itinerary(Id id, Id destination) : m_id{id}, m_destination{destination} {}
+  Itinerary::Itinerary(Id destination) : m_destination{destination} {}
 
-  Itinerary::Itinerary(Id id, Id destination, SparseMatrix<bool> path)
-      : m_id{id}, m_path{std::move(path)}, m_destination{destination} {}
-
-  void Itinerary::setDestination(Id destination) {
-    m_destination = destination;
-    this->m_path.clear();
-  }
+  Itinerary::Itinerary(Id destination, SparseMatrix<bool> path)
+      : m_path{std::move(path)}, m_destination{destination} {}
 
   void Itinerary::setPath(SparseMatrix<bool> path) {
     if (path.getRowDim() != path.getColDim()) {

src/dsm/headers/Itinerary.hpp

@@ -21,30 +21,23 @@ namespace dsm {
   /// @tparam Id The type of the itinerary's id. It must be an unsigned integral type.
   class Itinerary {
   private:
-    Id m_id;
     SparseMatrix<bool> m_path;
     Id m_destination;
 
   public:
     /// @brief Construct a new Itinerary object
     /// @param destination The itinerary's destination
-    Itinerary(Id id, Id destination);
+    Itinerary(Id destination);
     /// @brief Construct a new Itinerary object
     /// @param destination The itinerary's destination
     /// @param path An adjacency matrix made by a SparseMatrix representing the itinerary's path
-    Itinerary(Id id, Id destination, SparseMatrix<bool> path);
+    Itinerary(Id destination, SparseMatrix<bool> path);
 
-    /// @brief Set the itinerary's destination
-    /// @param destination The itinerary's destination
-    void setDestination(Id destination);
     /// @brief Set the itinerary's path
     /// @param path An adjacency matrix made by a SparseMatrix representing the itinerary's path
     /// @throw std::invalid_argument, if the itinerary's source or destination is not in the path's
     void setPath(SparseMatrix<bool> path);
 
-    /// @brief Get the itinerary's id
-    /// @return Id, The itinerary's id
-    Id id() const { return m_id; }
     /// @brief Get the itinerary's destination
     /// @return Id, The itinerary's destination
     Id destination() const { return m_destination; }

src/dsm/headers/Node.hpp

@@ -52,25 +52,19 @@ namespace dsm {
     void setId(Id id) { m_id = id; }
     /// @brief Set the node's coordinates
     /// @param coords A std::pair containing the node's coordinates (lat, lon)
-    void setCoords(std::pair<double, double> coords) {
-      m_coords = std::move(coords);
-    }
+    void setCoords(std::pair<double, double> coords) { m_coords = std::move(coords); }
     /// @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(Size capacity) {
-      m_transportCapacity = capacity;
-    }
+    virtual void setTransportCapacity(Size capacity) { m_transportCapacity = capacity; }
     /// @brief Get the node's id
     /// @return Id The node's id
     Id id() const { return m_id; }
     /// @brief Get the node's coordinates
     /// @return std::optional<std::pair<double, double>> A std::pair containing the node's coordinates
-    const std::optional<std::pair<double, double>>& coords() const {
-      return m_coords;
-    }
+    const std::optional<std::pair<double, double>>& coords() const { return m_coords; }
     /// @brief Get the node's capacity
     /// @return Size The node's capacity
     Size capacity() const { return m_capacity; }
@@ -146,9 +140,7 @@ namespace dsm {
     ///        If a street has priority, it means that the agents that are on that street
     ///        have priority over the agents that are on the other streets.
     /// @return std::set<Id> A std::set containing the node's street priorities
-    virtual const std::set<Id>& streetPriorities() const {
-      return m_streetPriorities;
-    };
+    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; };

src/dsm/headers/Street.hpp

@@ -110,9 +110,7 @@ namespace dsm {
     /// @brief Set the street's node pair
     /// @param node1 The source node of the street
     /// @param node2 The destination node of the street
-    void setNodePair(Id node1, Id node2) {
-      m_nodePair = std::make_pair(node1, node2);
-    }
+    void setNodePair(Id node1, Id node2) { m_nodePair = std::make_pair(node1, node2); }
     /// @brief Set the street's node pair
     /// @param node1 The source node of the street
     /// @param node2 The destination node of the street
@@ -158,14 +156,10 @@ namespace dsm {
     const std::set<Id>& waitingAgents() const { return m_waitingAgents; }
     /// @brief Get the street's queue
     /// @return dsm::queue<Size>, The street's queue
-    const dsm::queue<Size>& queue(size_t index) const {
-      return m_exitQueues[index];
-    }
+    const dsm::queue<Size>& queue(size_t index) const { return m_exitQueues[index]; }
     /// @brief Get the street's queues
     /// @return std::vector<dsm::queue<Size>> The street's queues
-    const std::vector<dsm::queue<Size>>& exitQueues() const {
-      return m_exitQueues;
-    }
+    const std::vector<dsm::queue<Size>>& exitQueues() const { return m_exitQueues; }
     /// @brief Get the street's node pair
     /// @return std::pair<Id, Id>, The street's node pair
     const std::pair<Id, Id>& nodePair() const { return m_nodePair; }
@@ -177,9 +171,7 @@ namespace dsm {
     double density() const { return nAgents() / (m_len * m_nLanes); }
     /// @brief Get the street's normalized density
     /// @return double, The street's normalized density
-    double normDensity() const {
-      return nAgents() / static_cast<double>(m_capacity);
-    }
+    double normDensity() const { return nAgents() / static_cast<double>(m_capacity); }
     /// @brief Check if the street is full
     /// @return bool, True if the street is full, false otherwise
     bool isFull() const { return nAgents() == m_capacity; }