Line data    Source code

       1             : #include "Static/supply/BPRNetwork.hpp"
       2             : 
       3             : #include <cmath>
       4             : #include <color/color.hpp>
       5             : #include <cstdio>
       6             : #include <filesystem>
       7             : #include <fstream>
       8             : #include <iostream>
       9             : #include <rapidxml.hpp>
      10             : #include <rapidxml_print.hpp>
      11             : #include <stdexcept>
      12             : 
      13             : #include "Static/SUMOAdapter.hpp"
      14             : #include "Static/Solution.hpp"
      15             : #include "data/SUMO/EdgeData.hpp"
      16             : #include "data/SUMO/Network.hpp"
      17             : #include "data/SUMO/NetworkTAZ.hpp"
      18             : #include "data/SUMO/Routes.hpp"
      19             : #include "data/SUMO/SUMO.hpp"
      20             : #include "data/SUMO/TAZ.hpp"
      21             : #include "utils/stringify.hpp"
      22             : #include "utils/timer.hpp"
      23             : #include "utils/xml.hpp"
      24             : 
      25             : using namespace std;
      26             : using namespace rapidxml;
      27             : using namespace Static;
      28             : using namespace utils::stringify;
      29             : 
      30             : typedef BPRNetwork::Node           Node;
      31             : typedef BPRNetwork::Edge           Edge;
      32             : typedef BPRNetwork::NormalEdge     NormalEdge;
      33             : typedef BPRNetwork::ConnectionEdge ConnectionEdge;
      34             : 
      35             : typedef SUMO::Network::Edge::Lane Lane;
      36             : typedef SUMO::Speed               Speed;
      37             : 
      38       21100 : BPRNetwork::Edge::Edge(Edge::ID id_, Node u_, Node v_, const BPRNetwork &network_, Time t0_, Flow c_):
      39             :     NetworkDifferentiable::Edge(id_, u_, v_),
      40             :     network(network_),
      41             :     t0(t0_),
      42           0 :     c(c_) {}
      43             : 
      44       21100 : BPRNetwork::Edge::~Edge() {}
      45             : 
      46           0 : Time BPRNetwork::Edge::calculateCongestion(const Solution &x) const {
      47           0 :     Flow f = x.getFlowInEdge(id);
      48           0 :     return f / c;
      49             : }
      50             : 
      51        9706 : BPRNetwork::NormalEdge::NormalEdge(NormalEdge::ID id_, Node u_, Node v_, const BPRNetwork &network_, Time t0_, Flow c_):
      52        9706 :     Edge(id_, u_, v_, network_, t0_, c_) {}
      53             : 
      54        9706 : Time BPRNetwork::NormalEdge::calculateCost(const Solution &x) const {
      55        9706 :     Flow f = x.getFlowInEdge(id);
      56        9706 :     return t0 * (1.0 + network.alpha * pow(f / c, network.beta));
      57             : }
      58             : 
      59           0 : Time BPRNetwork::NormalEdge::calculateCostGlobal(const Solution &x) const {
      60           0 :     Flow f = x.getFlowInEdge(id);
      61           0 :     return t0 * f * ((network.alpha / (network.beta + 1.0)) * pow(f / c, network.beta) + 1.0);
      62             : }
      63             : 
      64           0 : Time BPRNetwork::NormalEdge::calculateCostDerivative(const Solution &x) const {
      65           0 :     Flow f = x.getFlowInEdge(id);
      66           0 :     return t0 * network.alpha * network.beta * pow(f / c, network.beta - 1);
      67             : }
      68             : 
      69       11394 : BPRNetwork::ConnectionEdge::ConnectionEdge(ConnectionEdge::ID id_, Node u_, Node v_, const BPRNetwork &network_, Time t0_, Flow c_):
      70       11394 :     Edge(id_, u_, v_, network_, t0_, c_) {}
      71             : 
      72           0 : Time BPRNetwork::ConnectionEdge::calculateCost(const Solution &x) const {
      73           0 :     Flow f = x.getFlowInEdge(id);
      74           0 :     return t0 * (1.0 + network.alpha * pow(f / c, network.beta));
      75             : }
      76             : 
      77           0 : Time BPRNetwork::ConnectionEdge::calculateCostGlobal(const Solution &x) const {
      78           0 :     Flow f = x.getFlowInEdge(id);
      79           0 :     return t0 * f * ((network.alpha / (network.beta + 1.0)) * pow(f / c, network.beta) + 1.0);
      80             : }
      81             : 
      82           0 : Time BPRNetwork::ConnectionEdge::calculateCostDerivative(const Solution &x) const {
      83           0 :     Flow f = x.getFlowInEdge(id);
      84           0 :     return t0 * network.alpha * network.beta * pow(f / c, network.beta - 1);
      85             : }
      86             : 
      87           3 : BPRNetwork::BPRNetwork(Time alpha_, Time beta_):
      88           3 :     alpha(alpha_), beta(beta_) {}
      89             : 
      90           0 : void BPRNetwork::addNode(Node u) {
      91           0 :     adj[u];
      92           0 : }
      93             : 
      94           0 : NormalEdge *BPRNetwork::addNormalEdge(
      95             :     Edge::ID          id,
      96             :     Node              u,
      97             :     Node              v,
      98             :     const BPRNetwork &network,
      99             :     Time              t0,
     100             :     Flow              c
     101             : ) {
     102           0 :     NormalEdge *e = new NormalEdge(id, u, v, network, t0, c);
     103           0 :     adj[e->u].push_back(e);
     104           0 :     adj[e->v];
     105           0 :     edges[e->id] = e;
     106           0 :     return e;
     107             : }
     108             : 
     109           0 : ConnectionEdge *BPRNetwork::addConnectionEdge(
     110             :     Edge::ID          id,
     111             :     Node              u,
     112             :     Node              v,
     113             :     const BPRNetwork &network,
     114             :     Time              t0,
     115             :     Flow              c
     116             : ) {
     117           0 :     ConnectionEdge *e = new ConnectionEdge(id, u, v, network, t0, c);
     118           0 :     adj[e->u].push_back(e);
     119           0 :     adj[e->v];
     120           0 :     edges[e->id] = e;
     121           0 :     return e;
     122             : }
     123             : 
     124           3 : vector<Node> BPRNetwork::getNodes() const {
     125           3 :     vector<Node> ret;
     126           3 :     ret.reserve(adj.size());
     127       15309 :     for(const auto &[u, _]: adj)
     128       15306 :         ret.push_back(u);
     129           3 :     return ret;
     130             : }
     131             : 
     132       69102 : Edge &BPRNetwork::getEdge(Edge::ID e) const {
     133       69102 :     return *edges.at(e);
     134             : }
     135             : 
     136       15306 : vector<Network::Edge *> BPRNetwork::getAdj(Node u) const {
     137       15306 :     const auto &v = adj.at(u);
     138       15306 :     return vector<Network::Edge *>(v.begin(), v.end());
     139             : }
     140             : 
     141           3 : BPRNetwork::~BPRNetwork() {
     142       21103 :     for(const auto &[_, e]: edges)
     143       21100 :         delete e;
     144           3 : }