Line data    Source code

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