EVRoutePlanning_ValueIteration.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "Il-Wk5Sspx-L"
   },
   "outputs": [],
   "source": [
    "#### Script written by Yash Gupta ####"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "tWzokFbUp33j"
   },
   "outputs": [],
   "source": [
    "# Import libraries!\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import scipy.stats as ss\n",
    "from datetime import datetime, timedelta\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "vxhcNr-ep36p"
   },
   "outputs": [],
   "source": [
    "'''\n",
    "Below class creates an environment/map with each node as a charging station or just a freeway/road.\n",
    "Details for later additions to the class to be explained soon!!\n",
    "\n",
    "'''\n",
    "\n",
    "class EVRoutePlanning_ValueIteration:\n",
    "    def __init__(\n",
    "        self,\n",
    "        X: int = 10,\n",
    "        Y: int = 10,\n",
    "        grid_length: int = 10,\n",
    "        num_chargers: int = 10\n",
    "    ):\n",
    "        self.X = X # size of map/grid in X direction\n",
    "        self.Y = Y # size of map/grid in Y direction\n",
    "        self.grid_length = grid_length # length/size of grid(square) in miles\n",
    "        self.map_shape = (self.X, self.Y)\n",
    "        self.num_chargers = num_chargers # total number of chargers on the map\n",
    "        self.map, self.charging_stations = self._initialize_map_with_charging_stations()\n",
    "        self.charging_wait_times = {} # dictionary for wait times (in minutes) for every charger at each hour of the day\n",
    "        self.origin = 0 # index of origin on the map/grid\n",
    "        self.destination = 0 # index of destination on the map/grid\n",
    "        self.start_time = datetime.fromisoformat(\"2023-03-01\") # start time of the journey\n",
    "        self.start_soc = 0.85 # start soc of the journey\n",
    "        self.desired_soc = 0.5 # desired soc at the end of the journey\n",
    "        self.vehicle_range = 400 # maximum range of the car in miles\n",
    "        self.minimum_journey_time = 0 # minimum time(in minutes) required to reach the destination\n",
    "        self.max_soc = 0.95 # max soc upto which charging is recommended\n",
    "        self.min_soc = 0.15 # min soc going below which isn't recommended\n",
    "        self.charging_rate = 5 # charging rate = 5 miles/minute\n",
    "        self.position_reward = np.zeros(shape = self.map_shape) # rewards based on positions on the map/grid\n",
    "        self.value_function = np.zeros(shape = self.map_shape) # value function for each positions on the map/grid\n",
    "\n",
    "    \n",
    "    def _initialize_map_with_charging_stations(self):\n",
    "        map = np.zeros(shape = self.map_shape, dtype = int)\n",
    "        charging_stations = np.random.choice(np.arange(self.X * self.Y - 1, dtype = int), \n",
    "                                             size = self.num_chargers, \n",
    "                                             replace = False)\n",
    "        for index in charging_stations:\n",
    "            i, j = np.unravel_index(index, shape = self.map_shape)\n",
    "            map[i][j] = 1\n",
    "        \n",
    "        return map, charging_stations\n",
    "    \n",
    "    def generate_wait_time_distribution_per_charger(self, prob_peak_hour, list_sd_hours, list_peak_wait_time, prob_peak_wait_time):\n",
    "        '''prob_peak_hour is a list of size 24 with probability values such that peak time(hour) \n",
    "        of the day for a charger occurs at hour \"i\" i.e., P(peak_hour == i) = prob_peak_hour[i]\n",
    "        Note - sum(prob_peak_hour) should be equal to 1, ofcourse!! \n",
    "        \n",
    "        list_sd_hours is a list of choices given for choosing the standard deviation of the \n",
    "        wait time distributon at each charger. An example of this list could be [2, 3, 4] or \n",
    "        [3, 4, 5] or even [4] which means a fixed standard deviation of 4 hours for each charger.\n",
    "\n",
    "        list_peak_wait_time is a list of choices given for choosing the expected wait time at \n",
    "        peak hour of the day for each charger. An example of this list could be [20, 30, 40, 50]\n",
    "        or [25, 30, 35, 40, 50, 60]. We can also give as input, in prob_peak_wait_time, the \n",
    "        probability for each wait time choices in the list to make it more realistic.\n",
    "        '''\n",
    "\n",
    "        list_hours = np.arange(24, dtype = int)\n",
    "        for charger_index in self.charging_stations:\n",
    "            peak_hour = np.random.choice(a = list_hours, \n",
    "                                         size = 1, \n",
    "                                         p = prob_peak_hour)\n",
    "            sd_hour = np.random.choice(a = list_sd_hours,\n",
    "                                       size = 1)\n",
    "            peak_wait_time = np.random.choice(a = list_peak_wait_time,\n",
    "                                              size = 1,\n",
    "                                              p = prob_peak_wait_time)\n",
    "\n",
    "            # create a random variable for wait time distribution\n",
    "            # Please refer to scipy.stats.truncnorm for details of the following distribution\n",
    "            a = -12 / sd_hour\n",
    "            b = 11 / sd_hour\n",
    "            rv = ss.truncnorm(a, b, loc = peak_hour, scale = sd_hour)\n",
    "            peak_pdf = rv.pdf(peak_hour)\n",
    "            for i in range(-12, 12):\n",
    "                hour = (i + peak_hour + 24) % 24\n",
    "                wait_time = int(rv.pdf(i + peak_hour) / peak_pdf * peak_wait_time)\n",
    "                key = str(charger_index) + ',' + str(hour[0])\n",
    "                self.charging_wait_times[key] = wait_time\n",
    "        return\n",
    "\n",
    "    def create_journey(self, origin, destination, start_time, start_soc = 0.85, desired_soc = 0.5, vehicle_range = 220):\n",
    "        '''This function allows us to create a journey for an origin-destination pair. \n",
    "        It simply means that we now have a game/problem for our given environment/map \n",
    "        for which we need to do route planning/finding the best optimal policy.\n",
    "        \n",
    "        minimum_journey_time is estimated using the origin-destination to calculate \n",
    "        total distance to be travelled, start soc, desired soc, vehicle range, \n",
    "        average vehicle speed and charging speed'''\n",
    "\n",
    "        x_origin, y_origin = np.unravel_index(origin, shape = self.map_shape)\n",
    "        x_destination, y_destination = np.unravel_index(destination, shape = self.map_shape)\n",
    "        L1_distance_org_dest = abs(x_origin - x_destination) + abs(y_origin - y_destination)\n",
    "        total_journey_distance = L1_distance_org_dest * self.grid_length # in miles\n",
    "        dest_soc = start_soc - total_journey_distance / self.vehicle_range # soc at destination if not charged\n",
    "        required_charging_time = int((desired_soc - dest_soc) * self.vehicle_range / self.charging_rate) # answer in minutes\n",
    "        minimum_journey_time = total_journey_distance + required_charging_time # in minutes - assuming average vehicle speed of 1 miles/min\n",
    "\n",
    "        self.origin = origin\n",
    "        self.destination = destination\n",
    "        self.start_time = start_time\n",
    "        self.start_soc = start_soc\n",
    "        self.desired_soc = desired_soc\n",
    "        self.vehicle_range = vehicle_range\n",
    "        self.minimum_journey_time = minimum_journey_time\n",
    "        return\n",
    "\n",
    "        \n",
    "    def initialize_position_rewards(self, weight_L1 = 0.1, dest_over_org = 1):\n",
    "        '''origin takes the index of charging station from which we start our journey while\n",
    "        destination takes the index of the charging station where we end our journey. To get \n",
    "        (x, y) pair of coordinates we will unravel these indices. To initialize the rewards \n",
    "        based on positions, we need to define a distance metric. Our goal is to have higher \n",
    "        rewards for positions closer to the shortest path b/w origin and destination and lower \n",
    "        or even negative rewards for positions farther from the shortest path.\n",
    "        \n",
    "        weight_L1 is a hyperparameter that controls the weights of L1 distance relative to \n",
    "        L2 distance in computing the rewards for each position. Note that the value of \n",
    "        weight_L1 should be in the range [0,1]. default value is 0.1\n",
    "        \n",
    "        dest_over_org is another hyperparameter that controls the relative importance of \n",
    "        closing in on destination while moving away from origin. Rationally, we would want \n",
    "        dest_over_org > 1 at all times. default value is 1'''\n",
    "\n",
    "        x_origin, y_origin = np.unravel_index(self.origin, shape = self.map_shape)\n",
    "        x_destination, y_destination = np.unravel_index(self.destination, shape = self.map_shape)\n",
    "        L1_distance_org_dest = abs(x_origin - x_destination) + abs(y_origin - y_destination)\n",
    "        L2_distance_org_dest = np.sqrt((x_origin - x_destination)**2 + (y_origin - y_destination)**2)\n",
    "        \n",
    "        for i in range(self.X):\n",
    "            for j in range(self.Y):\n",
    "                L1_distance_cur_pos_dest = abs(i - x_destination) + abs(j - y_destination)\n",
    "                L2_distance_cur_pos_dest = np.sqrt((i - x_destination)**2 + (j - y_destination)**2)\n",
    "                dest_reward = weight_L1 * (L1_distance_org_dest - L1_distance_cur_pos_dest) + (1 - weight_L1) * (L2_distance_org_dest - L2_distance_cur_pos_dest)\n",
    "                dest_reward = weight_L1 * np.exp((L1_distance_org_dest - L1_distance_cur_pos_dest) / L1_distance_org_dest * dest_over_org) + (1 - weight_L1) * np.exp((L2_distance_org_dest - L2_distance_cur_pos_dest) / L2_distance_org_dest * dest_over_org)\n",
    "                L1_distance_cur_pos_org = abs(i - x_origin) + abs(j - y_origin)\n",
    "                L2_distance_cur_pos_org = np.sqrt((i - x_origin)**2 + (j - y_origin)**2)\n",
    "                org_reward = weight_L1 * (L1_distance_org_dest - L1_distance_cur_pos_org) + (1 - weight_L1) * (L2_distance_org_dest - L2_distance_cur_pos_org)\n",
    "                org_reward = weight_L1 * np.exp((L1_distance_org_dest - L1_distance_cur_pos_org) / L1_distance_org_dest) + (1 - weight_L1) * np.exp((L2_distance_org_dest - L2_distance_cur_pos_org) / L2_distance_org_dest)\n",
    "                cur_pos_reward = dest_over_org * dest_reward + org_reward\n",
    "                cur_pos_reward = dest_reward + org_reward\n",
    "                self.position_reward[i][j] = cur_pos_reward\n",
    "        \n",
    "        # Normalize the rewards based in the rewards range for time_reward and soc_reward\n",
    "        self.position_reward = self.position_reward / np.max(self.position_reward) * 100\n",
    "        self.position_reward[x_destination][y_destination] = 2 * (np.max(self.position_reward) - np.min(self.position_reward)) # very high reward for destination\n",
    "        self.position_reward[x_origin][y_origin] = 0\n",
    "\n",
    "        # Initialize value function using position rewards\n",
    "        discount_factor = 0.8 # choice based on how much we want our positions rewards to spread and act as a route guide\n",
    "        self._initialize_value_function(discount_factor = discount_factor)\n",
    "\n",
    "        return\n",
    "    \n",
    "    def _initialize_value_function(self, discount_factor = 0.8):\n",
    "        self.value_function = np.copy(self.position_reward) # initialize value function as position rewards\n",
    "        num_iterations = 2 * int(1/(1 - discount_factor))\n",
    "        for itr in range(num_iterations):\n",
    "            for i in range(self.X):\n",
    "                for j in range(self.Y):\n",
    "                    current_state = (i, j, self.start_time, self.start_soc)\n",
    "                    best_action, max_action_value_function, next_state = self._find_best_action(current_state=current_state, \n",
    "                                                                                            discount_factor=discount_factor, \n",
    "                                                                                            initializing_value_function=True)\n",
    "                    self.value_function[i][j] = max_action_value_function\n",
    "\n",
    "        return\n",
    "\n",
    "    def _transition_model(self, initial_state, action):\n",
    "        '''initial_state is in the form of (x_cur, y_cur, time_cur, soc_cur) and it returns \n",
    "        the final state reached by taking the given action. Remember that our action space \n",
    "        is [left, right, up, down] which is indexed as [0, 1, 2, 3]'''\n",
    "\n",
    "        x_cur, y_cur, time_cur, soc_cur = initial_state\n",
    "        time_fin = time_cur + timedelta(minutes = self.grid_length) # assuming average speed of 1 miles/min\n",
    "        soc_fin = soc_cur - self.grid_length / self.vehicle_range # assuming constant discharge over range\n",
    "        hit_the_wall = False # to record if we hit the wall by taking the given action\n",
    "        if(action == 0):\n",
    "            y_fin = y_cur\n",
    "            x_fin = x_cur - 1\n",
    "            if(x_fin < 0):\n",
    "                hit_the_wall = True\n",
    "        elif(action == 1):\n",
    "            y_fin = y_cur\n",
    "            x_fin = x_cur + 1\n",
    "            if(x_fin >= self.X):\n",
    "                hit_the_wall = True\n",
    "        elif(action == 2):\n",
    "            x_fin = x_cur\n",
    "            y_fin = y_cur - 1\n",
    "            if(y_fin < 0):\n",
    "                hit_the_wall = True\n",
    "        elif(action == 3):\n",
    "            x_fin = x_cur\n",
    "            y_fin = y_cur + 1\n",
    "            if(y_fin >= self.Y):\n",
    "                hit_the_wall = True\n",
    "        else:\n",
    "            print('Action not allowed!') # give error message\n",
    "        \n",
    "        # Return initial state if you hit the wall as no state transition occurs!!\n",
    "        if(hit_the_wall):\n",
    "            return initial_state, hit_the_wall\n",
    "\n",
    "        # Check if the final position is a charging station\n",
    "        if(self.map[x_fin][y_fin] == 1):\n",
    "            charger_index = np.ravel_multi_index((x_fin, y_fin), self.map_shape)\n",
    "            key = str(charger_index) + ',' + str(time_fin.hour)\n",
    "            wait_time = self.charging_wait_times[key]\n",
    "            time_fin = time_fin + timedelta(minutes = wait_time) # add waiting time to final time\n",
    "            charging_time = int((self.max_soc - soc_fin) * self.vehicle_range / self.charging_rate) # answer in minutes\n",
    "            time_fin = time_fin + timedelta(minutes = charging_time) # add charging time to the final time\n",
    "            buffer_time = np.random.choice([5.,10.]) # assuming 5 or 10 minutes buffer time for charging set up and hitting the road\n",
    "            time_fin = time_fin + timedelta(minutes = buffer_time)\n",
    "            soc_fin = self.max_soc # charging is done!\n",
    "        \n",
    "        final_state = (x_fin, y_fin, time_fin, soc_fin)\n",
    "\n",
    "        return final_state, hit_the_wall\n",
    "    \n",
    "    def _reward_for_state(self, state):\n",
    "        x, y, time, soc = state\n",
    "\n",
    "        # reward based on the soc of the state\n",
    "        soc_reward = (soc - self.min_soc) / (self.max_soc - self.min_soc) * 100\n",
    "\n",
    "        # required parameters for calculating time based reward\n",
    "        time_travelled_till_now = int((time - self.start_time) / timedelta(minutes=1)) # in minutes\n",
    "\n",
    "        x_destination, y_destination = np.unravel_index(self.destination, shape = self.map_shape)\n",
    "        L1_distance_state_dest = abs(x - x_destination) + abs(y - y_destination)\n",
    "        total_journey_distance = L1_distance_state_dest * self.grid_length # in miles\n",
    "        dest_soc = soc - total_journey_distance / self.vehicle_range # soc at destination if not charged\n",
    "        required_charging_time = int((self.desired_soc - dest_soc) * self.vehicle_range / self.charging_rate) # answer in minutes\n",
    "        state_journey_time = total_journey_distance + required_charging_time # in minutes\n",
    "\n",
    "        # reward based on the time of the state\n",
    "        importance_of_time = 5 # hyperparameter \n",
    "        time_reward = 100 * np.exp((self.minimum_journey_time - time_travelled_till_now - state_journey_time) / self.minimum_journey_time * importance_of_time)\n",
    "        # To-Do: Think more about the function or time reward\n",
    "\n",
    "        return soc_reward + time_reward\n",
    "    \n",
    "    def _find_best_action(self, current_state, discount_factor, initializing_value_function = False):\n",
    "        '''Returns the best action to take for the current state after calculating the values \n",
    "        of action value function for each action'''\n",
    "\n",
    "        (x_cur, y_cur, time_cur, soc_cur) = current_state # extracting the variables associated with the current state\n",
    "        if(initializing_value_function):\n",
    "            current_reward = self.position_reward[x_cur][y_cur] # only position rewards if initializing value function\n",
    "        else:\n",
    "            current_reward = self.position_reward[x_cur][y_cur] + self._reward_for_state(current_state)\n",
    "        \n",
    "        action_value_function = np.zeros(4) # value function for all 4 possible actions\n",
    "        list_next_state = [] # store next state for each action\n",
    "        for action in range(4):\n",
    "            next_state, hit_the_wall = self._transition_model(current_state, action)\n",
    "            action_value_function[action] = discount_factor * self.value_function[next_state[0]][next_state[1]]\n",
    "            list_next_state.append(next_state)\n",
    "            if(hit_the_wall):\n",
    "                action_value_function[action] = action_value_function[action] - 2 * abs(current_reward) # negative reward\n",
    "            else:\n",
    "                action_value_function[action] = action_value_function[action] + current_reward\n",
    "        best_action = np.argmax(action_value_function)\n",
    "        max_action_value_function = action_value_function[best_action]\n",
    "        next_state = list_next_state[best_action]\n",
    "        \n",
    "        return best_action, max_action_value_function, next_state\n",
    "    \n",
    "    def value_iteration(self, num_iterations = 5, discount_factor = 0.9):\n",
    "        # Initialize value function\n",
    "        self._initialize_value_function()\n",
    "        for itr in range(num_iterations):\n",
    "            x_route = []\n",
    "            y_route = []\n",
    "            k = 0\n",
    "            k_max = self.X * self.Y\n",
    "            previous_state_index = self.origin # initializing as origin\n",
    "            x_cur, y_cur = np.unravel_index(self.origin, shape = self.map_shape) # get current (x,y) from origin index\n",
    "            soc_cur = self.start_soc\n",
    "            time_cur = self.start_time\n",
    "            current_state = (x_cur, y_cur, time_cur, soc_cur)\n",
    "            while(previous_state_index != self.destination):\n",
    "                # can record policy here by storing the route\n",
    "                x_route.append(x_cur)\n",
    "                y_route.append(y_cur)\n",
    "\n",
    "                # Find the best action for the current state\n",
    "                best_action, max_action_value_function, next_state = self._find_best_action(current_state=current_state, \n",
    "                                                                                            discount_factor=discount_factor)\n",
    "                self.value_function[x_cur][y_cur] = max_action_value_function\n",
    "                current_state = next_state # updating the current state as next state reached after taking the best action\n",
    "                \n",
    "                previous_state_index = np.ravel_multi_index((x_cur, y_cur), self.map_shape) # updating the previous state index\n",
    "                x_cur, y_cur, time_cur, soc_cur = current_state # updating the current state variables\n",
    "                \n",
    "                # Check if the number of steps is less than k_max\n",
    "                k = k + 1 # step increment\n",
    "                if(k == k_max):\n",
    "                    print(\"Maximum steps reached!!\")\n",
    "                    break\n",
    "\n",
    "        return x_route, y_route\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "Xw5acQUpPKlT"
   },
   "outputs": [],
   "source": [
    "# Testing the environment\n",
    "m = EVRoutePlanning_ValueIteration(X=25, Y=25, grid_length=10, num_chargers=15)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 441
    },
    "id": "WBUBM5vXhPqK",
    "outputId": "dddd3185-dd61-43c7-838f-9a3f938ad562"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot the map with the location of all charging stations\n",
    "fig, ax = plt.subplots(figsize=(6, 6))\n",
    "\n",
    "ax.imshow(m.map, cmap = 'binary')\n",
    "ax.invert_yaxis()\n",
    "ax.set_title('Location of Charging Stations', fontsize = 15)\n",
    "ax.set_xlabel('X', fontsize = 13)\n",
    "ax.set_ylabel('Y', fontsize = 13)\n",
    "fig.tight_layout()\n",
    "fig.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "ERKEwRduNVZ_"
   },
   "outputs": [],
   "source": [
    "# Generate the wait time distribution with hour for each charging station\n",
    "m.generate_wait_time_distribution_per_charger(prob_peak_hour=[1/24] * 24 , list_sd_hours=[3,4], list_peak_wait_time=[20,25,30], prob_peak_wait_time=[0.3,0.4,0.3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "X07Ddmn7NVit"
   },
   "outputs": [],
   "source": [
    "# Sample an origin-destination pair\n",
    "o, d = np.random.choice(np.arange(m.X * m.Y), 2)\n",
    "date = datetime.fromisoformat(\"2020-03-01-09\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "C1Jbs5LkuO_c"
   },
   "outputs": [],
   "source": [
    "m.create_journey(origin=o, destination=d, start_time=date, start_soc=0.8, desired_soc=0.5, vehicle_range=180)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "hjJBW1IOuPGM"
   },
   "outputs": [],
   "source": [
    "# Initialize the position rewards based on origin-destination\n",
    "m.initialize_position_rewards(0.1, 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 385
    },
    "id": "J3oSj0f0VCLI",
    "outputId": "ed1dea86-09e5-4066-d5b0-f8357efdd25d"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x432 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot the position rewards for each location\n",
    "# Test out various hyperparameter choices and how they influence the position rewards\n",
    "fig, ax1 = plt.subplots(figsize=(6, 6))\n",
    "\n",
    "pos = ax1.imshow(m.position_reward.T)\n",
    "ax1.invert_yaxis()\n",
    "ax1.set_title('Position Rewards for each Location', fontsize = 15)\n",
    "ax1.set_xlabel('X', fontsize = 13)\n",
    "ax1.set_ylabel('Y', fontsize = 13)\n",
    "fig.tight_layout()\n",
    "fig.colorbar(pos, ax=ax1, shrink=0.9)\n",
    "fig.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "4RGU0O5gy2o1",
    "outputId": "eed09f22-7511-4971-f10f-ac60393d4ead"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Maximum steps reached!!\n"
     ]
    }
   ],
   "source": [
    "# Get the optimal policy/route using value iteration approach\n",
    "policy = m.value_iteration(num_iterations=5, discount_factor=0.9)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 441
    },
    "id": "yB_i2wN3y2zb",
    "outputId": "490e63ef-5d6e-4173-bbe0-feafed68531d"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot the route\n",
    "fig, ax1 = plt.subplots(figsize=(6, 6))\n",
    "\n",
    "# Plot the route using actions\n",
    "ax1.plot(policy[0], policy[1])\n",
    "\n",
    "# Plot the origin\n",
    "o_x, o_y = np.unravel_index(o, m.map_shape)\n",
    "ax1.scatter(o_x, o_y, color = 'orange', label = 'Origin')\n",
    "\n",
    "# Plot the destination\n",
    "d_x, d_y = np.unravel_index(d, m.map_shape)\n",
    "ax1.scatter(d_x, d_y, color = 'red', label = 'Destination')\n",
    "\n",
    "# Plot the charging stations\n",
    "c_x, c_y = np.unravel_index(m.charging_stations, m.map_shape)\n",
    "ax1.scatter(c_x, c_y, color = 'black', label = 'Charging Station', marker = '*')\n",
    "\n",
    "ax1.set_title('Optimal Policy/Route', fontsize = 15)\n",
    "ax1.set_xlabel('X', fontsize = 13)\n",
    "ax1.set_ylabel('Y', fontsize = 13)\n",
    "ax1.legend()\n",
    "fig.tight_layout()\n",
    "fig.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 385
    },
    "id": "T-ipTie5eZbR",
    "outputId": "890fc65f-1b89-4e0b-fece-a77e5a60bcfb"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x432 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot the value function for each location\n",
    "# Test out various hyperparameter choices and how they influence the position rewards\n",
    "fig, ax1 = plt.subplots(figsize=(6, 6))\n",
    "\n",
    "pos = ax1.imshow(m.value_function.T)\n",
    "ax1.invert_yaxis()\n",
    "ax1.set_title('Value Function for each Location', fontsize = 15)\n",
    "ax1.set_xlabel('X', fontsize = 13)\n",
    "ax1.set_ylabel('Y', fontsize = 13)\n",
    "fig.tight_layout()\n",
    "fig.colorbar(pos, ax=ax1, shrink=0.9)\n",
    "fig.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 354
    },
    "id": "-cbb1rQ9zEA5",
    "outputId": "62715417-5ac9-4217-801c-012d4ea5a76b"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Sample plot for truncnorm distribution\n",
    "\n",
    "peak = 18 # enter any peak hour value from [0, 23] - if unaware, pls remember datatime stores hours from 0 to 23 :))\n",
    "rv = ss.truncnorm(-12/4, 11/4, peak, 4)\n",
    "prob = np.zeros(24)\n",
    "for i in range(-12, 12):\n",
    "    prob[(i + peak + 24) % 24] = rv.pdf(i + peak) / rv.pdf(peak) * 40\n",
    "\n",
    "fig, ax1 = plt.subplots(figsize=(6, 5))\n",
    "\n",
    "ax1.plot(np.arange(24), prob)\n",
    "ax1.set_title('Wait time Distribution (Peak wait time of 40 mins at 6 p.m.)', fontsize = 14)\n",
    "ax1.set_xlabel('Time of the day (in hours)', fontsize = 13)\n",
    "ax1.set_ylabel('Wait time (in minutes)', fontsize = 13)\n",
    "ax1.set_xlim([0,23])\n",
    "fig.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "AFczSDGazEGB"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "W-tKnrIrOR9m"
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "colab": {
   "provenance": []
  },
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "name": "python",
   "version": "3.9.0"
  },
  "vscode": {
   "interpreter": {
    "hash": "147e0fad0828e2829dfb9aab4e3f1be6d10c3c50df9361cc18f4e91b899401fc"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}