Line data    Source code

       1             : #include "Dynamic/Policy/RewardFunction/RewardFunctionDifference.hpp"
       2             : 
       3             : #include "Dynamic/Env/Env.hpp"
       4             : 
       5             : using namespace std;
       6             : using namespace Dynamic;
       7             : 
       8           0 : RewardFunctionDifference::RewardFunctionDifference(double greediness):
       9           0 :     w(greediness) {}
      10             : 
      11           0 : Reward RewardFunctionDifference::operator()(const Env::Env &env, const Env::Vehicle &vehicle) {
      12           0 :     const Env::Lane &lane = vehicle.position.lane;
      13             : 
      14           0 :     Time leftLane = env.getTime();
      15             : 
      16           0 : #pragma GCC diagnostic push
      17           0 : #pragma GCC diagnostic ignored "-Wfloat-equal"
      18           0 :     assert(vehicle.enteredLane == vehicle.path.back().first);
      19           0 : #pragma GCC diagnostic pop
      20             : 
      21           0 :     Time t = leftLane - vehicle.enteredLane;
      22             : 
      23           0 :     Reward r = -t;
      24             : 
      25           0 :     const size_t N = lane.moving.size() + lane.stopped.size();
      26             : 
      27           0 :     Time tWith = 0.0;
      28           0 :     {
      29           0 :         Length K = (double)(N) / lane.edge.length;
      30           0 :         Speed  v = lane.edge.calculateSpeed() * (1.0 - K / Env::Lane::K_JAM);
      31           0 :         v        = max(v, Env::Lane::QUEUE_SPEED);
      32             : 
      33           0 :         Length queuePos = lane.edge.length;
      34             : 
      35           0 :         tWith += queuePos / v;
      36             :     }
      37           0 :     Time tWithout = 0.0;
      38           0 :     {
      39           0 :         Length K = (double)(N - 1) / lane.edge.length;
      40           0 :         Speed  v = lane.edge.calculateSpeed() * (1.0 - K / Env::Lane::K_JAM);
      41           0 :         v        = max(v, Env::Lane::QUEUE_SPEED);
      42             : 
      43           0 :         Length queuePos = lane.edge.length;
      44             : 
      45           0 :         tWithout += queuePos / v;
      46             :     }
      47           0 :     Time deltaMoving = tWith - tWithout;
      48             : 
      49             :     // Time deltaQueue = (lane.stopped.empty() ? 0 : Env::Lane::JUNCTION_PERIOD);
      50             :     // Time deltaQueue = Env::Lane::JUNCTION_PERIOD;
      51           0 :     Time deltaQueue = 0.0;
      52             : 
      53           0 :     if(N >= 1) {
      54           0 :         r -= w * (deltaMoving + deltaQueue) * (Time)(N - 1);
      55             :         // if(N >= 30 && deltaMoving > 0)
      56             :         //     cerr
      57             :         //         << ", KWith = " << KWith
      58             :         //         << ", KWithout = " << KWithout
      59             :         //         << ", vWith = " << vWith
      60             :         //         << ", vWithout = " << vWithout
      61             :         //         << ", tWith = " << tWith
      62             :         //         << ", tWithout = " << tWithout
      63             :         //         << ", deltaMoving = " << deltaMoving
      64             :         //         << ", deltaQueue = " << deltaQueue
      65             :         //         << ", N = " << N
      66             :         //         << ", r = " << r
      67             :         //         << endl;
      68             :     }
      69             : 
      70           0 :     return r;
      71             : }
      72             : 
      73             : RewardFunctionDifference RewardFunctionDifference::INSTANCE;