route_functions.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "940ae008",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as  np\n",
    "import string as str\n",
    "import numpy.random as rand\n",
    "import matplotlib.pyplot as plt\n",
    "import scipy.stats as st\n",
    "import statsmodels.api as sm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b0691733",
   "metadata": {},
   "outputs": [],
   "source": [
    "def route_time(routes, route_c, t):\n",
    "    \"\"\"\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    routes : DataFrame\n",
    "        Dataframe containing route information. Extracted from \n",
    "        Model_Parameters.xlsx.\n",
    "        \n",
    "    route_c : String (Numeric)\n",
    "        The route number over which bus needs to be deployed.\n",
    "    \n",
    "    t : Float\n",
    "        The clock time at deployment of the bus.\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    list(time_ar): List\n",
    "        List object containing the times of arrival and service at \n",
    "        each stop of the route.\n",
    "        \n",
    "    list(stops): List\n",
    "        List object containing the attribute of the travel/service times.\n",
    "        1 denotes Travel time between stops and 0 denotes the service \n",
    "        time at a particular stop.\n",
    "        \n",
    "    \"\"\"\n",
    "    time_ar = []\n",
    "    if route_c.isnumeric():\n",
    "        search_r = 'route_' + route_c\n",
    "    else:\n",
    "        search_r = route_c\n",
    "    sm_data = routes[routes.columns[routes.columns.str.match(search_r)]]\n",
    "    sm_data.dropna(inplace=True)\n",
    "    for i in range(sm_data.shape[0]):\n",
    "        if sm_data[search_r+'_index'][i]==0:\n",
    "            t_arr = rand.gamma(sm_data[search_r+'_mean'][i], \n",
    "                                 sm_data[search_r+'_std'][i])         # change distributions\n",
    "            t = t + t_arr\n",
    "        elif sm_data[search_r+'_index'][i]==1:\n",
    "            t_ser = rand.gamma(sm_data[search_r+'_mean'][i], \n",
    "                                 sm_data[search_r+'_std'][i])         # change distributions\n",
    "            t = t + t_ser\n",
    "        time_ar.append(round(t, 2))\n",
    "    stops = np.array(sm_data[search_r+'_index'])\n",
    "    return list(time_ar), list(stops)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "515fafa8",
   "metadata": {},
   "outputs": [],
   "source": [
    "class bus:\n",
    "    def __init__(self, charge, charge_std):            # Class initialization\n",
    "        self.charge = round(rand.normal(charge, charge_std), 3)\n",
    "        self.state = -1                                # deployed = 1, refill = 0, standstill = -1\n",
    "        self.route = None                              # route in string, eg. '1', 'refill', 'recharge' \n",
    "        self.time_arr = list()                         # array containing travel or stop service times for the bus\n",
    "        self.event_arr = list()                        # array to denote travel or stop service state\n",
    "        \n",
    "    def assign_route(self, routes, route_c, t):        # assigning a specific route to the bus\n",
    "        self.time_arr, self.event_arr = route_time(routes, route_c, t)\n",
    "        self.route = route_c\n",
    "        if (route_c=='refill')or(route_c=='recharge'): # deployed = 1, refill = 0, standstill = -1\n",
    "            self.state = 0\n",
    "        elif route_c.isnumeric():\n",
    "            self.state = 1\n",
    "    \n",
    "    def assign_route_varred(self, e_array, t_array, route_c, t):  # assigning a specific route to the bus\n",
    "        self.time_arr, self.event_arr = list(t_array), list(e_array)\n",
    "        self.route = route_c\n",
    "        if (route_c=='refill')or(route_c=='recharge'):  # deployed = 1, refill = 0, standstill = -1\n",
    "            self.state = 0\n",
    "        elif route_c.isnumeric():\n",
    "            self.state = 1\n",
    "    \n",
    "    def next_t(self):                       # passing the next event time\n",
    "        if len(self.time_arr)==0:\n",
    "            return np.inf\n",
    "        else:\n",
    "            return self.time_arr[0]\n",
    "    \n",
    "    def next_e(self):                       # passing the next event type\n",
    "        if len(self.event_arr)==0:\n",
    "            return np.inf\n",
    "        else:\n",
    "            return self.event_arr[0]\n",
    "        \n",
    "    def last_t(self):                       # passing the last event time for a route\n",
    "        if len(self.event_arr)==0:\n",
    "            return np.inf\n",
    "        else:\n",
    "            return self.time_arr[len(self.event_arr)-1]\n",
    "    \n",
    "    def info(self):                         # all details passed as a dictionary for table insertion\n",
    "        bus_dict = {'charge': self.charge,\n",
    "                    'state' : self.state,\n",
    "                    'route' : self.route,\n",
    "                    'event' : self.event_arr[0]}\n",
    "        return bus_dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5160692d",
   "metadata": {},
   "outputs": [],
   "source": [
    "def gen_demands(routes, T):\n",
    "    dem = pd.read_excel('Model_Parameters.xlsx', 'Demands')\n",
    "    t_arr = np.array(range(0, T, 60))\n",
    "    demand_r, demand_t, demand_c = [], [], []\n",
    "    for row in dem.itertuples(index=False):\n",
    "        if row[0]<=routes:\n",
    "        # generating demands\n",
    "            route, a, b, c, d, charge = np.str_(row[0]), row[1], row[2], row[3], row[4], row[5]\n",
    "            demand = np.ceil(a*np.sin((t_arr+c)/d) + b)        # a distribution can also be used\n",
    "        # generating times wrt demands\n",
    "            for i, t in enumerate(t_arr):\n",
    "                if demand[i]>0:\n",
    "                    for t_d in range(0, 60, int(60/demand[i])):\n",
    "                        demand_t.append(round(t + t_d, 2))\n",
    "                        demand_r.append(route)\n",
    "                        demand_c.append(charge)\n",
    "\n",
    "    demand_r.append(None)\n",
    "    demand_c.append(np.inf)\n",
    "    demand_t.append(np.inf)\n",
    "    all_dt = pd.DataFrame(columns=['routes', 'times', 'charge'])\n",
    "    all_dt['routes'] = demand_r\n",
    "    all_dt['times'] = demand_t\n",
    "    all_dt['charge'] = demand_c\n",
    "    all_dt = all_dt.sort_values(['times','routes'], ignore_index=True)\n",
    "    demand_r = np.array(all_dt['routes'])\n",
    "    demand_c = np.array(all_dt['charge'])\n",
    "    demand_t = np.array(all_dt['times'])\n",
    "    return list(demand_t), list(demand_r), list(demand_c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bfbbc644",
   "metadata": {},
   "outputs": [],
   "source": [
    "def next_bus_e(buses):\n",
    "    min_t = np.inf\n",
    "    index = None\n",
    "    for i in range(len(buses)):\n",
    "        if (buses[i].next_t()<min_t):\n",
    "            min_t = buses[i].next_t()\n",
    "            index = i\n",
    "    return min_t, buses[i].next_e(), index\n",
    "\n",
    "def available_bus(buses, dem_charge):\n",
    "    b_charges = [buses[i].charge for i in range(len(buses)) if buses[i].state==-1]\n",
    "    b_index = [i for i in range(len(buses)) if buses[i].state==-1]\n",
    "    index = -1\n",
    "    if len(b_charges)>0:\n",
    "        if (max(b_charges)>dem_charge):\n",
    "            for i in range(len(b_charges)):\n",
    "                if max(b_charges)==b_charges[i]:\n",
    "                    index = b_index[i]\n",
    "    return index\n",
    "\n",
    "def unavailable_bus(buses, min_charge):\n",
    "    b_charges = [buses[i].charge for i in range(len(buses)) if buses[i].state==-1]\n",
    "    b_index = [i for i in range(len(buses)) if buses[i].state==-1]\n",
    "    index = -1\n",
    "    if (len(b_charges)>0)and(min_charge!=np.inf):\n",
    "        if (min(b_charges)<min_charge):\n",
    "            for i in range(len(b_charges)):\n",
    "                if min(b_charges)==b_charges[i]:\n",
    "                    index = b_index[i]\n",
    "    return index\n",
    "\n",
    "def buses_status(buses):\n",
    "    n_dep = sum([1 for i in buses if i.state==1])\n",
    "    n_ref = sum([1 for i in buses if i.state==0])\n",
    "    n_stds = sum([1 for i in buses if i.state==-1])\n",
    "    return n_dep, n_ref, n_stds"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e07b465b",
   "metadata": {
    "lines_to_next_cell": 0
   },
   "outputs": [],
   "source": [
    "def SS_update(SS_table, t, buses, dct, bus_e, t_updt, index=-1, dem_ct=0, dem_at=0, dem_c=0):\n",
    "    ss_d = {}\n",
    "    ss_d['Time'] = t_updt\n",
    "    ss_arr = [len(buses), dct]\n",
    "    ss_dep, ss_re, ss_ss = buses_status(buses)\n",
    "    ss_arr.append(ss_dep)\n",
    "    ss_arr.append(ss_re)\n",
    "    ss_arr.append(ss_ss)\n",
    "    ss_d['System_State'] = ss_arr\n",
    "    if index!=-1:\n",
    "        ss_d['Bus'] = index + 1\n",
    "        ss_d['Charge'] = buses[index].charge\n",
    "        ss_d['Route'] = buses[index].route\n",
    "        ss_d['State'] = buses[index].state\n",
    "    else:\n",
    "        ss_d['Bus'] = np.nan\n",
    "        ss_d['Charge'] = np.nan\n",
    "        ss_d['Route'] = None\n",
    "        ss_d['State'] = np.nan\n",
    "    ss_d['Event'] = bus_e\n",
    "    ss_d['Process_Time'] = t_updt - t    \n",
    "    if dem_c==0:\n",
    "        ss_d['Demand_Current'] = np.nan\n",
    "        ss_d['Demand_Actual'] = np.nan\n",
    "        ss_d['Demand_Charge'] = np.nan\n",
    "    else:\n",
    "        ss_d['Demand_Current'] = dem_ct\n",
    "        ss_d['Demand_Actual'] = dem_at\n",
    "        ss_d['Demand_Charge'] = dem_c\n",
    "    SS_table = SS_table.append(ss_d, ignore_index=True)\n",
    "    return SS_table\n",
    "\n",
    "def BD_update(BD_table, t_updt, dem_ct, dem_at, dem_c, buses, index):\n",
    "    bd_d = {}\n",
    "    bd_d['Time'] = t_updt\n",
    "    bd_d['Demand_Current'] = dem_ct\n",
    "    bd_d['Demand_Actual'] = dem_at\n",
    "    bd_d['Demand_Charge'] = dem_c\n",
    "    bd_d['Bus'] = index + 1\n",
    "    bd_d['Charge'] = buses[index].charge\n",
    "    bd_d['Route'] = buses[index].route\n",
    "    bd_d['State'] = buses[index].state\n",
    "    bd_d['Event_Array'] = np.array(buses[index].event_arr)\n",
    "    bd_d['Time_Array'] = np.array(buses[index].time_arr)\n",
    "    BD_table = BD_table.append(bd_d, ignore_index=True)\n",
    "    return BD_table"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "907c2aea",
   "metadata": {},
   "outputs": [],
   "source": [
    "def fleet_simulation(t, T, routes, buses, refuel, running_consumption, service_consumption, \n",
    "                     refuel_stations, refuel_consumption, conversion_factor,\n",
    "                     demand_at, demand_ct, demand_r, demand_c, dct_flag, SS_cols, BD_cols):\n",
    "    ss_table = pd.DataFrame(columns=SS_cols)\n",
    "    bd_table = pd.DataFrame(columns=BD_cols)\n",
    "\n",
    "    # Initial SS update\n",
    "    time_check = np.inf\n",
    "    ss_table = SS_update(ss_table, t, buses, dct_flag, np.nan, np.nan)\n",
    "    \n",
    "    # previous times for fleet\n",
    "    prev_time = [np.nan]*len(buses)\n",
    "    \n",
    "    \n",
    "    t_check = []\n",
    "    # Simulate! Simulate! Simulate!        \n",
    "    while (t<T)or(time_check!=np.inf):\n",
    "        #print('---\\nNew Event')\n",
    "\n",
    "        time_check = min(next_bus_e(buses)[0], demand_ct[0])\n",
    "        #print('\\tTime check -', time_check)\n",
    "\n",
    "        # -----\n",
    "        # Priority One: Updating demands\n",
    "        if ((demand_ct[0]!=np.inf) and\n",
    "            (demand_ct[0]==time_check)):\n",
    "            new_demand = [1 for i in range(len(demand_ct)) if demand_ct[i]==time_check]\n",
    "            dct_flag = sum(new_demand)\n",
    "            # testing\n",
    "            t = time_check\n",
    "            \n",
    "        ##print('\\tDemands -', demand_ct[:10], demand_at[:10], demand_r[:10], demand_c[:10])\n",
    "        ##print('\\tdct_flag -', dct_flag)\n",
    "\n",
    "\n",
    "        #----------\n",
    "        # Main Simulation\n",
    "        bus_chk = available_bus(buses, demand_c[0])\n",
    "        #print('\\tBus Check -', bus_chk)\n",
    "\n",
    "\n",
    "        #-----\n",
    "        # Case 1: Sending low-fuel buses to refuel\n",
    "        refuel_index = unavailable_bus(buses, min(demand_c))\n",
    "        if ((time_check!=np.inf) and ((t<T) or (dct_flag>0)) and\n",
    "            (refuel_index!=-1) and\n",
    "            (buses_status(buses)[1]<refuel_stations)): \n",
    "            # and(refuel_index!=np.inf)):- might create complications\n",
    "            dem_ct, dem_at, dem_c = np.nan, np.nan, np.nan\n",
    "            #print('\\tSending Bus for Refuel')\n",
    "            msg = 'Sending Bus for Refuel'\n",
    "            buses[refuel_index].assign_route(routes, refuel, t)\n",
    "            prev_time[refuel_index] = t\n",
    "            bus_e = 0\n",
    "            t_updt = t\n",
    "\n",
    "            ss_table = SS_update(ss_table, t, buses, dct_flag, bus_e, t_updt, refuel_index)\n",
    "            bd_table = BD_update(bd_table, t_updt, dem_ct, dem_at, dem_c, buses, refuel_index)\n",
    "\n",
    "            t = t_updt\n",
    "            refuel_index = -1\n",
    "\n",
    "\n",
    "        #-----\n",
    "        # Case 2: Checking bus availability and deploying buses\n",
    "        elif ((t<T) and\n",
    "              (demand_ct[0]==time_check) and\n",
    "              (demand_ct[0]!=np.inf) and\n",
    "              (bus_chk!=-1)):\n",
    "\n",
    "            #print('\\tDeploying Bus')\n",
    "            msg = 'Deploying Bus'\n",
    "            dem_ct, dem_at = demand_ct.pop(0), demand_at.pop(0)\n",
    "            dem_c, dem_r = demand_c.pop(0), demand_r.pop(0)\n",
    "            index = available_bus(buses, dem_c)\n",
    "            t_updt = dem_ct\n",
    "            buses[index].assign_route(routes, dem_r, t_updt)\n",
    "            prev_time[index] = t_updt\n",
    "            bus_e = 0\n",
    "\n",
    "            ss_table = SS_update(ss_table, t, buses, dct_flag, bus_e, t_updt, index, dem_ct, dem_at, dem_c)\n",
    "            bd_table = BD_update(bd_table, t_updt, dem_ct, dem_at, dem_c, buses, index)\n",
    "            dct_flag -= 1\n",
    "            t = t_updt\n",
    "\n",
    "            dem_ct, dem_at, dem_c, dem_r = np.nan, np.nan, np.nan, np.nan\n",
    "            t_updt = np.nan\n",
    "            index = np.nan\n",
    "\n",
    "\n",
    "        #-----\n",
    "        # Case 3: Checking next bus event and updating SS\n",
    "        elif ((t<T) and\n",
    "              (next_bus_e(buses)[0]==time_check) and \n",
    "              (next_bus_e(buses)[0]!=np.inf) and \n",
    "              ((buses_status(buses)[0]>0) or (buses_status(buses)[1]>0))):\n",
    "\n",
    "            #print('\\tUpdating next bus event')\n",
    "            msg = 'Updating next bus event'\n",
    "            index = next_bus_e(buses)[2]\n",
    "            t_updt = buses[index].time_arr.pop(0)\n",
    "            bus_e = buses[index].event_arr.pop(0)\n",
    "            diff_t = prev_time[index]\n",
    "            \n",
    "            if (bus_e==1):\n",
    "                mul_c = running_consumption\n",
    "            elif (bus_e==0)and(buses[index].state==1):\n",
    "                mul_c = service_consumption\n",
    "            elif (bus_e==0)and(buses[index].state==0):\n",
    "                mul_c = refuel_consumption\n",
    "            buses[index].charge = round(buses[index].charge - (t_updt - diff_t)*mul_c*conversion_factor, 3)\n",
    "\n",
    "            ss_table = SS_update(ss_table, diff_t, buses, dct_flag, bus_e, t_updt, index)\n",
    "            t = t_updt\n",
    "            prev_time[index] = t\n",
    "            \n",
    "            # if its the last event for the bus, update bus parameters to standstill\n",
    "            if buses[index].next_e()==np.inf:\n",
    "                buses[index].state = -1\n",
    "                buses[index].route = None\n",
    "                buses[index].time_arr = list()\n",
    "                buses[index].event_arr = list()\n",
    "                prev_time[index] = np.nan\n",
    "            index = np.nan\n",
    "            t_updt = np.nan\n",
    "            bus_e = np.nan\n",
    "        \n",
    "        \n",
    "        #-----\n",
    "        # Case 4: Jumping to next demand \n",
    "        elif ((t<T) and (bus_chk==-1) and\n",
    "              (demand_ct[0]==time_check) and \n",
    "              (demand_ct[0]!=np.inf)):\n",
    "            #print('\\tJumping to next demand')\n",
    "            msg = 'Jumping to next demand'\n",
    "            t = next_bus_e(buses)[0]\n",
    "            #dct_flag += 1\n",
    "        \n",
    "              \n",
    "        #-----\n",
    "        # Case 5: All demands are completed within the timeframe \n",
    "        elif ((t<T) and\n",
    "              (time_check==np.inf)):\n",
    "\n",
    "            #print('\\tJumping to EOD')\n",
    "            msg = 'Jumping to EOD'\n",
    "            t_updt = T\n",
    "\n",
    "            ss_table = SS_update(ss_table, t, buses, dct_flag, bus_e, t_updt)\n",
    "            t = t_updt    \n",
    "\n",
    "\n",
    "        #-----\n",
    "        # Case 6: Demands still exist beyond timeframe and need to be met\n",
    "        elif ((t>T) and\n",
    "              (demand_ct[0]==time_check) and\n",
    "              (demand_ct[0]!=np.inf) and\n",
    "              (bus_chk!=-1)):\n",
    "\n",
    "            #print('\\tDeploying Bus beyond timeframe')\n",
    "            msg = 'Deploying Bus beyond timeframe'\n",
    "            dem_ct, dem_at = demand_ct.pop(0), demand_at.pop(0)\n",
    "            dem_c, dem_r = demand_c.pop(0), demand_r.pop(0)\n",
    "            index = available_bus(buses, dem_c)\n",
    "            t_updt = dem_ct\n",
    "            buses[index].assign_route(routes, dem_r, t_updt)\n",
    "            prev_time[index] = t_updt\n",
    "            bus_e = 0\n",
    "\n",
    "            ss_table = SS_update(ss_table, t, buses, dct_flag, bus_e, t_updt, index, dem_ct, dem_at, dem_c)\n",
    "            bd_table = BD_update(bd_table, t_updt, dem_ct, dem_at, dem_c, buses, index)\n",
    "            dct_flag -= 1\n",
    "            t = t_updt\n",
    "\n",
    "            dem_ct, dem_at, dem_c, dem_r = np.nan, np.nan, np.nan, np.nan\n",
    "            t_updt = np.nan\n",
    "            index = np.nan\n",
    "\n",
    "\n",
    "        #-----\n",
    "        # Case 7: Going beyond timeframe, checking deployed buses and updating SS\n",
    "        elif (((t>T) and\n",
    "              (next_bus_e(buses)[0]==time_check) and\n",
    "              (next_bus_e(buses)[0]!=np.inf)) or\n",
    "              ((t>T) and\n",
    "              (demand_ct[0]==time_check) and \n",
    "              (demand_ct[0]!=np.inf) and \n",
    "              (bus_chk==-1))):\n",
    "            \n",
    "            #print('\\tUpdating next bus event beyond timeframe')\n",
    "            msg = 'Updating next bus event beyond timeframe'\n",
    "            index = next_bus_e(buses)[2]\n",
    "            t_updt = buses[index].time_arr.pop(0)\n",
    "            bus_e = buses[index].event_arr.pop(0)\n",
    "            diff_t = prev_time[index]\n",
    "            \n",
    "            if (bus_e==1):\n",
    "                mul_c = running_consumption\n",
    "            elif (bus_e==0)and(buses[index].state==1):\n",
    "                mul_c = service_consumption\n",
    "            elif (bus_e==0)and(buses[index].state==0):                       # different for 'refill' and 'recharge' \n",
    "                mul_c = refuel_consumption                                   # difference from 90 for refill\n",
    "            buses[index].charge = buses[index].charge - (t_updt - diff_t)*mul_c*conversion_factor\n",
    "\n",
    "            ss_table = SS_update(ss_table, diff_t, buses, dct_flag, bus_e, t_updt, index)\n",
    "            t = t_updt\n",
    "            prev_time[index] = t\n",
    "            \n",
    "            # if its the last event for the bus, update bus parameters to standstill\n",
    "            if buses[index].next_e()==np.inf:\n",
    "                buses[index].state = -1\n",
    "                buses[index].route = None\n",
    "                buses[index].time_arr = list()\n",
    "                buses[index].event_arr = list()\n",
    "                prev_time[index] = np.nan\n",
    "            index = np.nan\n",
    "            t_updt = np.nan\n",
    "            bus_e = np.nan\n",
    "\n",
    "            \n",
    "        #-----\n",
    "        # Case 8: Jumping to next demand \n",
    "        elif ((t>T) and (bus_chk==-1) and\n",
    "              (demand_ct[0]==time_check) and \n",
    "              (demand_ct[0]!=np.inf)):\n",
    "            #print('\\tJumping to next demand')\n",
    "            msg = 'Jumping to next demand'\n",
    "            t = next_bus_e(buses)[0]\n",
    "            #dct_flag += 1\n",
    "        \n",
    "        #-----\n",
    "        # Case 9: All demands are completed outside the timeframe \n",
    "        elif ((t>T) and\n",
    "              (time_check==np.inf)):\n",
    "\n",
    "            #print('\\tJumping to EOD')\n",
    "            msg = 'Jumping to EOD'\n",
    "            t_updt = np.inf        \n",
    "            ss_table = SS_update(ss_table, t, buses, dct_flag, bus_e, t_updt)\n",
    "            t = t_updt    \n",
    "\n",
    "\n",
    "\n",
    "        ##print('\\tDemands -', demand_ct[:10], demand_at[:10], demand_r[:10], demand_c[:10])\n",
    "        ##print('\\tdct_flag -', dct_flag)\n",
    "\n",
    "        # updating the current demand - if demand exists it'll automatically be updated\n",
    "        demand_ct = list(np.sort(demand_ct))\n",
    "        for k in range(dct_flag):\n",
    "            demand_ct[k] = t\n",
    "        \n",
    "        #checking alternative\n",
    "        #if (refuel_index!=-1):\n",
    "        #    refuel_index = -1\n",
    "        #else:\n",
    "        #    for k in range(dct_flag):\n",
    "        #        demand_ct[k] = t\n",
    "            \n",
    "        \n",
    "        \n",
    "        ##print('\\tDemands -', demand_ct[:10], demand_at[:10], demand_r[:10], demand_c[:10])\n",
    "        ##print('\\tdct_flag -', dct_flag)\n",
    "        #print('t -', t)\n",
    "    \n",
    "        if len(t_check)<5:\n",
    "            t_check.append(t)\n",
    "        else:\n",
    "            t_check.pop(0)\n",
    "            t_check.append(t)\n",
    "        if (len(t_check)==5)and(t_check[0]==max(t_check)):\n",
    "            print('Stuck in a loop!')\n",
    "            print(msg)\n",
    "            ss_table.to_parquet('ss_check.parquet')\n",
    "            bd_table.to_parquet('bd_check.parquet')\n",
    "            print('\\tTime -', t)\n",
    "            print('\\tTime Check -', time_check)\n",
    "            print('\\tDemands -', demand_ct[:6], demand_at[:6], demand_r[:6], demand_c[:6])\n",
    "            print('\\tdct_flag -', dct_flag)\n",
    "            \n",
    "            \n",
    "    return ss_table, bd_table"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ad7e5eef",
   "metadata": {},
   "outputs": [],
   "source": [
    "def fleet_simulation_varred(t, T, routes, event_array, time_array, buses, refuel, running_consumption, \n",
    "                     service_consumption, refuel_stations, refuel_consumption, conversion_factor,\n",
    "                     demand_at, demand_ct, demand_r, demand_c, dct_flag, SS_cols, BD_cols):\n",
    "    \n",
    "    ss_table = pd.DataFrame(columns=SS_cols)\n",
    "    bd_table = pd.DataFrame(columns=BD_cols)\n",
    "\n",
    "    # Initial SS update\n",
    "    time_check = np.inf\n",
    "    ss_table = SS_update(ss_table, t, buses, dct_flag, np.nan, np.nan)\n",
    "    \n",
    "    # previous times for fleet\n",
    "    prev_time = [np.nan]*len(buses)\n",
    "    \n",
    "    # Simulate! Simulate! Simulate!        \n",
    "    while (t<T)or(time_check!=np.inf):\n",
    "        #print('---\\nNew Event')\n",
    "\n",
    "        time_check = min(next_bus_e(buses)[0], demand_ct[0])\n",
    "        #print('\\tTime check -', time_check)\n",
    "\n",
    "        # -----\n",
    "        # Priority One: Updating demands\n",
    "        if ((demand_ct[0]!=np.inf) and\n",
    "            (demand_ct[0]==time_check)):\n",
    "            new_demand = [1 for i in range(len(demand_ct)) if demand_ct[i]==time_check]\n",
    "            dct_flag = sum(new_demand)\n",
    "            # testing\n",
    "            t = time_check\n",
    "            \n",
    "        ##print('\\tDemands -', demand_ct[:10], demand_at[:10], demand_r[:10], demand_c[:10])\n",
    "        ##print('\\tdct_flag -', dct_flag)\n",
    "\n",
    "\n",
    "        #----------\n",
    "        # Main Simulation\n",
    "        bus_chk = available_bus(buses, demand_c[0])\n",
    "        #print('\\tBus Check -', bus_chk)\n",
    "\n",
    "\n",
    "        #-----\n",
    "        # Case 1: Sending low-fuel buses to refuel\n",
    "        refuel_index = unavailable_bus(buses, min(demand_c))\n",
    "        if (((t<T) or(dct_flag>0)) and  # or (time_check!=np.inf)\n",
    "            (refuel_index!=-1) and\n",
    "            (buses_status(buses)[1]<refuel_stations)): \n",
    "            # and(refuel_index!=np.inf)):- might create complications\n",
    "            dem_ct, dem_at, dem_c = np.nan, np.nan, np.nan\n",
    "            #print('\\tSending Bus for Refuel')\n",
    "            buses[refuel_index].assign_route(routes, refuel, t)\n",
    "            prev_time[refuel_index] = t\n",
    "            bus_e = 0\n",
    "            t_updt = t\n",
    "\n",
    "            ss_table = SS_update(ss_table, t, buses, dct_flag, bus_e, t_updt, refuel_index)\n",
    "            bd_table = BD_update(bd_table, t_updt, dem_ct, dem_at, dem_c, buses, refuel_index)\n",
    "\n",
    "            t = t_updt\n",
    "            refuel_index = -1\n",
    "\n",
    "\n",
    "        #-----\n",
    "        # Case 2: Checking bus availability and deploying buses\n",
    "        elif ((t<T) and\n",
    "              (demand_ct[0]==time_check) and\n",
    "              (demand_ct[0]!=np.inf) and\n",
    "              (bus_chk!=-1)):\n",
    "\n",
    "            #print('\\tDeploying Bus')\n",
    "            dem_ct, dem_at = demand_ct.pop(0), demand_at.pop(0)\n",
    "            dem_c, dem_r = demand_c.pop(0), demand_r.pop(0)\n",
    "            index = available_bus(buses, dem_c)\n",
    "            t_updt = dem_ct\n",
    "            buses[index].assign_route_varred(event_array.pop(0), time_array.pop(0), dem_r, t_updt)\n",
    "            prev_time[index] = t_updt\n",
    "            bus_e = 0\n",
    "\n",
    "            ss_table = SS_update(ss_table, t, buses, dct_flag, bus_e, t_updt, index, dem_ct, dem_at, dem_c)\n",
    "            bd_table = BD_update(bd_table, t_updt, dem_ct, dem_at, dem_c, buses, index)\n",
    "            ##print(buses[index].event_arr, buses[index].time_arr)\n",
    "            dct_flag -= 1\n",
    "            ##print(prev_time[index], t_updt)\n",
    "            t = t_updt\n",
    "\n",
    "            dem_ct, dem_at, dem_c, dem_r = np.nan, np.nan, np.nan, np.nan\n",
    "            t_updt = np.nan\n",
    "            index = np.nan\n",
    "\n",
    "\n",
    "        #-----\n",
    "        # Case 3: Checking next bus event and updating SS\n",
    "        elif ((t<T) and\n",
    "              (next_bus_e(buses)[0]==time_check) and \n",
    "              (next_bus_e(buses)[0]!=np.inf) and \n",
    "              ((buses_status(buses)[0]>0) or (buses_status(buses)[1]>0))):\n",
    "\n",
    "            #print('\\tUpdating next bus event')\n",
    "            index = next_bus_e(buses)[2]\n",
    "            t_updt = buses[index].time_arr.pop(0)\n",
    "            bus_e = buses[index].event_arr.pop(0)\n",
    "            diff_t = prev_time[index]\n",
    "            \n",
    "            if (bus_e==1):\n",
    "                mul_c = running_consumption\n",
    "            elif (bus_e==0)and(buses[index].state==1):\n",
    "                mul_c = service_consumption\n",
    "            elif (bus_e==0)and(buses[index].state==0):                       # different for 'refill' and 'recharge' \n",
    "                mul_c = refuel_consumption                                   # difference from 90 for refill\n",
    "            buses[index].charge = round(buses[index].charge - (t_updt - diff_t)*mul_c*conversion_factor, 3)\n",
    "\n",
    "            ss_table = SS_update(ss_table, diff_t, buses, dct_flag, bus_e, t_updt, index)\n",
    "            t = t_updt\n",
    "            prev_time[index] = t\n",
    "            \n",
    "            # if its the last event for the bus, update bus parameters to standstill\n",
    "            if buses[index].next_e()==np.inf:\n",
    "                buses[index].state = -1\n",
    "                buses[index].route = None\n",
    "                buses[index].time_arr = list()\n",
    "                buses[index].event_arr = list()\n",
    "                prev_time[index] = np.nan\n",
    "            index = np.nan\n",
    "            t_updt = np.nan\n",
    "            bus_e = np.nan\n",
    "        \n",
    "        \n",
    "        #-----\n",
    "        # Case 4: Jumping to next demand \n",
    "        elif ((t<T) and\n",
    "              (demand_ct[0]==time_check) and \n",
    "              (demand_ct[0]!=np.inf) and \n",
    "              (bus_chk==-1)):\n",
    "            #print('\\tJumping to next demand')\n",
    "            msg = 'Jumping to next demand'\n",
    "            t = next_bus_e(buses)[0]\n",
    "            #dct_flag += 1\n",
    "        \n",
    "              \n",
    "        #-----\n",
    "        # Case 5: All demands are completed within the timeframe \n",
    "        elif ((t<T) and\n",
    "              (time_check==np.inf)):\n",
    "\n",
    "            #print('\\tJumping to EOD')\n",
    "            t_updt = T\n",
    "\n",
    "            ss_table = SS_update(ss_table, t, buses, dct_flag, bus_e, t_updt)\n",
    "            t = t_updt    \n",
    "\n",
    "\n",
    "        #-----\n",
    "        # Case 6: Demands still exist beyond timeframe and need to be met\n",
    "        elif ((t>T) and\n",
    "              (demand_ct[0]==time_check) and\n",
    "              (demand_ct[0]!=np.inf) and\n",
    "              (bus_chk!=-1)):\n",
    "\n",
    "            #print('\\tDeploying Bus beyond timeframe')\n",
    "            dem_ct, dem_at = demand_ct.pop(0), demand_at.pop(0)\n",
    "            dem_c, dem_r = demand_c.pop(0), demand_r.pop(0)\n",
    "            index = available_bus(buses, dem_c)\n",
    "            t_updt = dem_ct\n",
    "            buses[index].assign_route_varred(event_array.pop(0), time_array.pop(0), dem_r, t_updt)\n",
    "            prev_time[index] = t_updt\n",
    "            bus_e = 0\n",
    "\n",
    "            ss_table = SS_update(ss_table, t, buses, dct_flag, bus_e, t_updt, index, dem_ct, dem_at, dem_c)\n",
    "            bd_table = BD_update(bd_table, t_updt, dem_ct, dem_at, dem_c, buses, index)\n",
    "            dct_flag -= 1\n",
    "            t = t_updt\n",
    "\n",
    "            dem_ct, dem_at, dem_c, dem_r = np.nan, np.nan, np.nan, np.nan\n",
    "            t_updt = np.nan\n",
    "            index = np.nan\n",
    "\n",
    "\n",
    "        #-----\n",
    "        # Case 7: Going beyond timeframe, checking deployed buses and updating SS\n",
    "        elif (((t>T) and\n",
    "              (next_bus_e(buses)[0]==time_check) and\n",
    "              (next_bus_e(buses)[0]!=np.inf)) or\n",
    "              ((t>T) and\n",
    "              (demand_ct[0]==time_check) and \n",
    "              (demand_ct[0]!=np.inf) and \n",
    "              (bus_chk==-1))):\n",
    "            \n",
    "            #print('\\tUpdating next bus event beyond timeframe')\n",
    "            index = next_bus_e(buses)[2]\n",
    "            t_updt = buses[index].time_arr.pop(0)\n",
    "            bus_e = buses[index].event_arr.pop(0)\n",
    "            diff_t = prev_time[index]\n",
    "            \n",
    "            if (bus_e==1):\n",
    "                mul_c = running_consumption\n",
    "            elif (bus_e==0)and(buses[index].state==1):\n",
    "                mul_c = service_consumption\n",
    "            elif (bus_e==0)and(buses[index].state==0):                       # different for 'refill' and 'recharge' \n",
    "                mul_c = refuel_consumption                                   # difference from 90 for refill\n",
    "            buses[index].charge = buses[index].charge - (t_updt - diff_t)*mul_c*conversion_factor\n",
    "\n",
    "            ss_table = SS_update(ss_table, diff_t, buses, dct_flag, bus_e, t_updt, index)\n",
    "            t = t_updt\n",
    "            prev_time[index] = t\n",
    "            \n",
    "            # if its the last event for the bus, update bus parameters to standstill\n",
    "            if buses[index].next_e()==np.inf:\n",
    "                buses[index].state = -1\n",
    "                buses[index].route = None\n",
    "                buses[index].time_arr = list()\n",
    "                buses[index].event_arr = list()\n",
    "                prev_time[index] = np.nan\n",
    "            index = np.nan\n",
    "            t_updt = np.nan\n",
    "            bus_e = np.nan\n",
    "\n",
    "        #-----\n",
    "        # Case 8: Jumping to next demand \n",
    "        elif ((t>T) and (bus_chk==-1) and\n",
    "              (demand_ct[0]==time_check) and \n",
    "              (demand_ct[0]!=np.inf)):\n",
    "            #print('\\tJumping to next demand')\n",
    "            msg = 'Jumping to next demand'\n",
    "            t = next_bus_e(buses)[0]\n",
    "            #dct_flag += 1\n",
    "        \n",
    "        #-----\n",
    "        # Case 9: All demands are completed outside the timeframe \n",
    "        elif ((t>T) and\n",
    "              (time_check==np.inf)):\n",
    "\n",
    "            #print('\\tJumping to EOD')\n",
    "            msg = 'Jumping to EOD'\n",
    "            t_updt = np.inf        \n",
    "            ss_table = SS_update(ss_table, t, buses, dct_flag, bus_e, t_updt)\n",
    "            t = t_updt    \n",
    "\n",
    "\n",
    "\n",
    "\n",
    "        ##print('\\tDemands -', demand_ct[:10], demand_at[:10], demand_r[:10], demand_c[:10])\n",
    "        ##print('\\tdct_flag -', dct_flag)\n",
    "\n",
    "        # updating the current demand - if demand exists it'll automatically be updated\n",
    "        \n",
    "        demand_ct = list(np.sort(demand_ct))\n",
    "        for k in range(dct_flag):\n",
    "            demand_ct[k] = t\n",
    "        \n",
    "        #checking alternative\n",
    "        #if (refuel_index!=-1):\n",
    "        #    refuel_index = -1\n",
    "        #else:\n",
    "        #    for k in range(dct_flag):\n",
    "        #        demand_ct[k] = t\n",
    "        \n",
    "        ##print('\\tDemands -', demand_ct[:10], demand_at[:10], demand_r[:10], demand_c[:10])\n",
    "        ##print('\\tdct_flag -', dct_flag)\n",
    "        #print('t -', t)\n",
    "    \n",
    "    return ss_table, bd_table"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "baa84e42",
   "metadata": {},
   "outputs": [],
   "source": [
    "def cost_analysis(n_buses, replicates, refuel, ss_table, bd_table, emp_rate, fuel_rate, delay_rate, refuel_consumption):\n",
    "    ss_table['Process_Time'].replace({np.inf: 0}, inplace=True)\n",
    "    ss_table['Demand_Charge'].replace({np.nan: -1}, inplace=True)\n",
    "    cost_ss = ss_table[(ss_table['Demand_Charge'])==-1][['Bus', 'Route', 'Event', 'Process_Time']].dropna()\n",
    "\n",
    "    runcost_ss = cost_ss[cost_ss['Event']==1]\n",
    "    sercost_ss = cost_ss[(cost_ss['Event']!=1)&(cost_ss['Route']!=refuel)]\n",
    "    refcost_ss = cost_ss[(cost_ss['Event']!=1)&(cost_ss['Route']==refuel)]\n",
    "    runcost_ss = runcost_ss[['Bus', 'Process_Time']].groupby('Bus').sum()/replicates\n",
    "    sercost_ss = sercost_ss[['Bus', 'Process_Time']].groupby('Bus').sum()/replicates\n",
    "    refcost_ss = refcost_ss[['Bus', 'Process_Time']].groupby('Bus').sum()/replicates\n",
    "\n",
    "    run_time = round(np.sum(runcost_ss['Process_Time']), 2)\n",
    "    ser_time = round(np.sum(sercost_ss['Process_Time']), 2)\n",
    "    ref_time = round(np.sum(refcost_ss['Process_Time']), 2)\n",
    "    emp_cost = round((run_time + ser_time + ref_time)*emp_rate/60)\n",
    "    fuel_cost = round(ref_time*refuel_consumption*-1*fuel_rate)\n",
    "    tot_delay = round(sum(np.nan_to_num(np.array(bd_table['Demand_Current'] - bd_table['Demand_Actual']))), 2)\n",
    "    delay_cost = round(tot_delay* delay_rate)\n",
    "    return run_time, ser_time, ref_time, emp_cost, fuel_cost, delay_cost"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a925a6d2",
   "metadata": {},
   "outputs": [],
   "source": [
    "def ecdf(target, title):\n",
    "    numbs = np.array(target)\n",
    "    ecdf = sm.distributions.ECDF(numbs)\n",
    "    x = np.linspace(min(numbs), max(numbs), len(target))\n",
    "    y = ecdf(x)\n",
    "    plt.step(x, y, color='r')\n",
    "    plt.xlabel(title)\n",
    "    plt.ylabel('CDF(P)')\n",
    "    plt.title('Empirical CDF of ' + title)\n",
    "    plt.show()\n",
    "    return\n",
    "\n",
    "def inv_ecdf(target, title):\n",
    "    numbs = np.array(target)\n",
    "    ecdf = sm.distributions.ECDF(numbs)\n",
    "    x = np.linspace(min(numbs), max(numbs), len(target))\n",
    "    y = 1-ecdf(x)\n",
    "    plt.step(x, y, color='r')\n",
    "    plt.xlabel(title)\n",
    "    plt.ylabel('Inverse CDF(P)')\n",
    "    plt.title('Inverse Empirical CDF of ' + title)\n",
    "    #plt.gca().invert_yaxis()\n",
    "    plt.show()\n",
    "    return"
   ]
  }
 ],
 "metadata": {
  "jupytext": {
   "formats": "ipynb,py:light"
  },
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}