functional_program-VarRed.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "a764fe5c",
   "metadata": {},
   "source": [
    "## Variables\n",
    "#### Buses\n",
    "* bus: ($ch_n, st_n, r_{n,m}, tb_{n,m}, sb_{n,m}$)\n",
    "    * $ch_n$ - charging state of bus n\n",
    "    * $st_n$ - state of bus n (3 states: deployed, not-deployed, charging/refueling)\n",
    "    * $r_{n,m}$ - the route on which the bus is deployed\n",
    "    * $tb_{n,m}$ - the previous stop the bus travelled to (travel time)\n",
    "    * $sb_{n,m}$ - the previous stop which was served by the bus (service time)\n",
    "        * If $tb_n$= $sb_n$, generate travel time for $tb_{n+1}$; $tb_n$ = $tb_{n+1}$ if accepted\n",
    "        * Else if $tb_n$> $sb_n$, generate service time for $sb_{n+1}$; $sb_n$ = $sb_{n+1}$ if accepted\n",
    "    * Arrival time - route generated arrays\n",
    "    * Service Time - route generated arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6b52600c",
   "metadata": {},
   "source": [
    "___\n",
    "### System State New\n",
    "SS = (n_buses, curr_dem, buses_deployed, buses_recharge, buses_standstill)\n",
    "SS = (n_buses, curr_dem, buses_deployed, buses_recharge, buses_standstill, route_1_buses, route_2_buses,....)\n",
    "\n",
    "#### Monitoring System State \n",
    "\n",
    "| Time | System State | Bus | Charge | Route | State | Event | Process Time | Demand-Current | Demand-Actual | Demand-Charge |\n",
    "| ---- | ------------ | --- | ------ | ----- | ----- | ----- | ------------ | -------------- | ------------- | ------------- |\n",
    "| 0    | (1,1,1,0,0)  | 1   | 50     | '1'   | 1     | 0     | 0            | 0              | 0             | 15            |\n",
    "| 10.3 | (1,0,1,0,0)  | 1   | 48     | '1'   | 1     | 1     | 10.3         | -              | -             | -             |\n",
    "| 12.3 | (1,0,1,0,0)  | 1   | 47.5   | '1'   | 1     | 0     | 2.0          | -              | -             | -             |\n",
    "\n",
    "___\n",
    "\n",
    "#### Monitoring Bus Deployments\n",
    "\n",
    "| Time | Demand-Current | Demand-Actual | Demand-Charge | Bus | Charge | Route | Event Array  | Time Array   |\n",
    "| ---- | -------------- | ------------- | ------------- | --- | ------ | ----- | ------------ | ------------ |\n",
    "| 0    | 0              | 0             | 15            | 1   | 50     | '1'   | [1, 0, 1]    | [12, 35, 41] |\n",
    "| 40   | 41             | 40            | 20            | 1   | 35     | '2'   | [1, 0, 1]    | [48, 50, 55] |\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "1c83e8f4",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import numpy.random as random\n",
    "from route_functions import *\n",
    "import matplotlib.pyplot as plt\n",
    "import scipy.stats as st\n",
    "import statsmodels.api as sm \n",
    "\n",
    "# to ignore warning on calculations\n",
    "import warnings\n",
    "warnings.filterwarnings(\"ignore\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "d3797890",
   "metadata": {},
   "outputs": [],
   "source": [
    "path = r\"C:\\Users\\krishrao\\Desktop\\Laptop Backup\\Krishna\\Fall'21\\IOE 574\\Term Project\\IOE574_Project\\data_files\\LiqFuel_SensAnalysis\\buses\\\\\"\n",
    "varred = pd.read_parquet(path+'bd_table_refill_10_60_0.071_0.061.parquet')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "4f60821c",
   "metadata": {},
   "outputs": [],
   "source": [
    "# intializing route table\n",
    "routes = pd.read_excel('Model_Parameters.xlsx', 'Routes')\n",
    "\n",
    "n_buses = 8                            # number of buses\n",
    "\n",
    "# For liquid fuel buses\n",
    "running_consumption = 0.071             # fuel(lts.)/kWh per minute\n",
    "service_consumption = 0.061             # fuel(lts.)/kWh per minute\n",
    "refuel_consumption = -30                # -30 for fuel, -2 for electric\n",
    "tank_size = 150                         # 150 lts. / 240 kWh \n",
    "level_mean = 50                         # normal distribution.. can be changed\n",
    "level_std = 0                           # currently constant at level_mean\n",
    "refuel = 'refill'                       # 'refill', recharge'\n",
    "\n",
    "'''\n",
    "# For electric buses\n",
    "running_consumption = 0.5              # fuel(lts.)/kWh per minute\n",
    "service_consumption = 0.3              # fuel(lts.)/kWh per minute\n",
    "refuel_consumption = -2                # -30 for fuel, -2 for electric\n",
    "tank_size = 240                         # 150 lts. / 240 kWh \n",
    "level_mean = 80                         # normal distribution.. can be changed\n",
    "level_std = 0                           # currently constant at level_mean\n",
    "refuel = 'recharge'                     # 'refill', recharge'\n",
    "'''\n",
    "\n",
    "#-----\n",
    "# customizable parameters\n",
    "#average_bus_speed = 30 miles /hr\n",
    "refuel_stations = 2\n",
    "conversion_factor = 100/tank_size\n",
    "\n",
    "# cost rates\n",
    "emp_rate = 15                           # per hour basis\n",
    "fuel_rate = 0.882                       # dollar 0.882 per lt. / 0.1275 per kWhr\n",
    "delay_rate = 2.4                        # dollar per min ** reason\n",
    "maintain_rate = 1.67                    # dollar per min 1.67 for fuel, 2.25 for elctric\n",
    "\n",
    "\n",
    "# setting up initial values for simulation\n",
    "n_routes = 4                            # number of routes\n",
    "SimTime = 720\n",
    "\n",
    "SS_cols = ['Time', 'System_State', 'Bus', 'Charge', 'Route', \n",
    "           'State', 'Event', 'Process_Time', 'Demand_Current', \n",
    "           'Demand_Actual', 'Demand_Charge']\n",
    "BD_cols = ['Time', 'Demand_Current', 'Demand_Actual', 'Demand_Charge', \n",
    "           'Bus', 'Charge', 'Route', 'Event_Array', 'Time_Array']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "15d64465",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-----\n",
      "Running buses on Day  1\n",
      "-----\n",
      "Running buses on Day  2\n",
      "-----\n",
      "Running buses on Day  3\n",
      "-----\n",
      "Running buses on Day  4\n",
      "-----\n",
      "Running buses on Day  5\n",
      "-----\n",
      "Running buses on Day  6\n",
      "-----\n",
      "Running buses on Day  7\n",
      "-----\n",
      "Running buses on Day  8\n",
      "-----\n",
      "Running buses on Day  9\n",
      "-----\n",
      "Running buses on Day  10\n",
      "-----\n",
      "Running buses on Day  11\n",
      "-----\n",
      "Running buses on Day  12\n",
      "-----\n",
      "Running buses on Day  13\n",
      "-----\n",
      "Running buses on Day  14\n",
      "-----\n",
      "Running buses on Day  15\n",
      "-----\n",
      "Running buses on Day  16\n",
      "-----\n",
      "Running buses on Day  17\n",
      "-----\n",
      "Running buses on Day  18\n",
      "-----\n",
      "Running buses on Day  19\n",
      "-----\n",
      "Running buses on Day  20\n",
      "-----\n",
      "Running buses on Day  21\n",
      "-----\n",
      "Running buses on Day  22\n",
      "-----\n",
      "Running buses on Day  23\n",
      "-----\n",
      "Running buses on Day  24\n",
      "-----\n",
      "Running buses on Day  25\n",
      "-----\n",
      "Running buses on Day  26\n",
      "-----\n",
      "Running buses on Day  27\n",
      "-----\n",
      "Running buses on Day  28\n",
      "-----\n",
      "Running buses on Day  29\n",
      "-----\n",
      "Running buses on Day  30\n"
     ]
    }
   ],
   "source": [
    "replicates = int(varred['Replication'].max())\n",
    "ss_table = pd.DataFrame(columns=SS_cols+['Replication'])\n",
    "bd_table = pd.DataFrame(columns=BD_cols+['Replication'])\n",
    "\n",
    "for i in range(replicates):\n",
    "    print('-----\\nRunning buses on Day ', i+1)                     # intializing required variabes\n",
    "    event_array = list(varred['Event_Array'][(varred['Replication']==(i+1))&(varred['Route']!='refill')])\n",
    "    time_array = list(varred['Time_Array'][(varred['Replication']==(i+1))&(varred['Route']!='refill')])\n",
    "\n",
    "    # intializing required variabes\n",
    "    buses = [bus(level_mean, level_std) for i in range(n_buses)]    # fleet of buses\n",
    "    t = 0                                      # start time of simulation\n",
    "    T = SimTime\n",
    "\n",
    "    # updating demands\n",
    "    demand_at, demand_r, demand_c = gen_demands(n_routes, T)\n",
    "    demand_ct = demand_at.copy()         # demand current time and demand actual time\n",
    "    dct_flag = 0                         # demand at current time\n",
    "\n",
    "    ss_tab, bd_tab = fleet_simulation_varred(t, T, routes, event_array, time_array, buses, refuel, \n",
    "                                             running_consumption, service_consumption, refuel_stations, \n",
    "                                             refuel_consumption, conversion_factor, demand_at, demand_ct, \n",
    "                                             demand_r, demand_c, dct_flag, SS_cols, BD_cols)\n",
    "    ss_tab['Replication'] = i+1\n",
    "    bd_tab['Replication'] = i+1\n",
    "    ss_table = ss_table.append(ss_tab, ignore_index=True)\n",
    "    bd_table = bd_table.append(bd_tab, ignore_index=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2cb8be29",
   "metadata": {},
   "source": [
    "ss_table"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9b286bee",
   "metadata": {},
   "source": [
    "bd_table"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "81226cd9",
   "metadata": {},
   "source": [
    "varred"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3c480d6b",
   "metadata": {},
   "source": [
    "___\n",
    "## Model Analysis"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "88e4e9de",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "---\n",
      "Current half-width -  1.948 min\n",
      "Current replications - 30\n",
      "Number of bus deployments - 4108\n",
      "The extra replications to be done -  22\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "\"\\nwhile n_beta > beta:\\n    s2_n =  (std_delay)**2\\n    t = st.t.ppf(ci_n, df=replicates-1)\\n    n_rep = int((t*np.sqrt(s2_n)/beta)**2) + 1\\n    n_rep = int(n_rep*replicates/replicates) + 1\\n    print('The extra replications to be done - ', n_rep-replicates)\\n    \\n    for h in range(replicates, n_rep):\\n        print('-----\\nRunning buses on Day ', h+1)                     # intializing required variabes\\n        buses = [bus(level_mean, level_std) for i in range(n_buses)]   # fleet of buses\\n        t = 0                                                          # start time of simulation\\n        T = SimTime\\n        demand_at, demand_r, demand_c = gen_demands(n_routes, T)     # updating demands\\n        demand_ct = demand_at.copy()                                 # demand current time and demand actual time\\n        dct_flag = 0                                                 # demand at current time\\n        ss_tab, bd_tab = fleet_simulation(t, T, routes, 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        ss_tab['Replication'] = h + 1\\n        bd_tab['Replication'] = h + 1\\n        ss_table = ss_table.append(ss_tab, ignore_index=True)\\n        bd_table = bd_table.append(bd_tab, ignore_index=True)\\n        \\n    replicates = n_rep\\n    n_beta = (st.t.ppf(ci_n, df=replicates-1)*std_delay/np.sqrt(replicates))\\n    print('---\\nThe new half-width', round(n_beta, 3), 'min')\\n    print('Current replications -', replicates)\\n    print('Number of bus deployments -', bd_table.shape[0])\\n\""
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#del varred\n",
    "\n",
    "# delay analysis on deployments\n",
    "num_delay = sum(np.array(bd_table['Demand_Current'] - bd_table['Demand_Actual'])>0)\n",
    "total_delay = sum(np.nan_to_num(np.array(bd_table['Demand_Current'] - bd_table['Demand_Actual'])))\n",
    "avg_delay = round(np.mean(np.nan_to_num(np.array(bd_table['Demand_Current'] - bd_table['Demand_Actual']))), 3)\n",
    "std_delay = round(np.std(np.nan_to_num(np.array(bd_table['Demand_Current'] - bd_table['Demand_Actual']))), 3)\n",
    "max_delay = max(np.nan_to_num(np.array(bd_table['Demand_Current'] - bd_table['Demand_Actual'])))\n",
    "\n",
    "# cost analysis\n",
    "run_time, ser_time, ref_time, emp_cost, fuel_cost, delay_cost = cost_analysis(n_buses, replicates, refuel, ss_table, \n",
    "                                                                              bd_table, emp_rate, fuel_rate, delay_rate, \n",
    "                                                                              refuel_consumption)\n",
    "\n",
    "# convergence on delays\n",
    "beta = 1.5\n",
    "alpha = 0.05\n",
    "ci_n = 1-alpha/2    \n",
    "n_beta = (st.t.ppf(ci_n, df=replicates-1)*std_delay\n",
    "          /np.sqrt(replicates))\n",
    "\n",
    "print('---\\nCurrent half-width - ', round(n_beta, 3), 'min')\n",
    "print('Current replications -', replicates)\n",
    "print('Number of bus deployments -', bd_table.shape[0])\n",
    "\n",
    "if n_beta > beta:\n",
    "    s2_n =  (std_delay)**2\n",
    "    t = st.t.ppf(ci_n, df=replicates-1)\n",
    "    n_rep = int((t*np.sqrt(s2_n)/beta)**2) + 1\n",
    "    n_rep = int(n_rep*replicates/replicates) + 1\n",
    "    print('The extra replications to be done - ', n_rep-replicates)\n",
    "    \n",
    "'''\n",
    "while n_beta > beta:\n",
    "    s2_n =  (std_delay)**2\n",
    "    t = st.t.ppf(ci_n, df=replicates-1)\n",
    "    n_rep = int((t*np.sqrt(s2_n)/beta)**2) + 1\n",
    "    n_rep = int(n_rep*replicates/replicates) + 1\n",
    "    print('The extra replications to be done - ', n_rep-replicates)\n",
    "    \n",
    "    for h in range(replicates, n_rep):\n",
    "        print('-----\\nRunning buses on Day ', h+1)                     # intializing required variabes\n",
    "        buses = [bus(level_mean, level_std) for i in range(n_buses)]   # fleet of buses\n",
    "        t = 0                                                          # start time of simulation\n",
    "        T = SimTime\n",
    "        demand_at, demand_r, demand_c = gen_demands(n_routes, T)     # updating demands\n",
    "        demand_ct = demand_at.copy()                                 # demand current time and demand actual time\n",
    "        dct_flag = 0                                                 # demand at current time\n",
    "        ss_tab, bd_tab = fleet_simulation(t, T, routes, 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",
    "        ss_tab['Replication'] = h + 1\n",
    "        bd_tab['Replication'] = h + 1\n",
    "        ss_table = ss_table.append(ss_tab, ignore_index=True)\n",
    "        bd_table = bd_table.append(bd_tab, ignore_index=True)\n",
    "        \n",
    "    replicates = n_rep\n",
    "    n_beta = (st.t.ppf(ci_n, df=replicates-1)*std_delay/np.sqrt(replicates))\n",
    "    print('---\\nThe new half-width', round(n_beta, 3), 'min')\n",
    "    print('Current replications -', replicates)\n",
    "    print('Number of bus deployments -', bd_table.shape[0])\n",
    "'''\n",
    "#."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "2d2e77e5",
   "metadata": {},
   "outputs": [],
   "source": [
    "# delay analysis on deployments\n",
    "num_delay = sum(np.array(bd_table['Demand_Current'] - bd_table['Demand_Actual'])>0)\n",
    "total_delay = sum(np.nan_to_num(np.array(bd_table['Demand_Current'] - bd_table['Demand_Actual'])))\n",
    "avg_delay = round(np.mean(np.nan_to_num(np.array(bd_table['Demand_Current'] - bd_table['Demand_Actual']))), 3)\n",
    "std_delay = round(np.std(np.nan_to_num(np.array(bd_table['Demand_Current'] - bd_table['Demand_Actual']))), 3)\n",
    "max_delay = max(np.nan_to_num(np.array(bd_table['Demand_Current'] - bd_table['Demand_Actual'])))\n",
    "\n",
    "# cost analysis\n",
    "run_time, ser_time, ref_time, emp_cost, fuel_cost, delay_cost = cost_analysis(n_buses, replicates, refuel, ss_table, \n",
    "                                                                              bd_table, emp_rate, fuel_rate, delay_rate, \n",
    "                                                                              refuel_consumption)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "bc94589a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Delay Analyis\n",
      "\tTotal number of replications (days) - 30\n",
      "\tTotal number of delays - 2449\n",
      "\tTotal delay in minutes - 19350.45\n",
      "\tAverage of delay events in minutes - 7.9\n",
      "\n",
      "\tAverage delay (all events) in minutes - 4.71\n",
      "\tStd. Deviation of delay (all events) in minutes - 5.22\n",
      "\tMaximum delay (all events) in minutes - 24.59\n",
      "\n",
      "\tTotal number of deployments - 4108\n",
      "\tTotal number of route deployments - 3870\n",
      "\tTotal number of refills deployments - 238\n",
      "\n",
      "\n",
      "Cost Analysis\n",
      "\tAverage running time for all buses per day in minutes - 3588.35\n",
      "\tAverage service time for all buses per day in minutes - 1513.22\n",
      "\tAverage refuel time for all buses per day in minutes - 21.68\n",
      "\n",
      "\tAverage employeee costs paid per day in dollars - 1281\n",
      "\tAverage fuel costs paid per day in dollars - 574\n",
      "\tAverage delay costs paid per day in dollars - 46441\n",
      "\tAverage maintenance costs paid per day in dollars - 8556\n"
     ]
    }
   ],
   "source": [
    "print('Delay Analyis')\n",
    "print('\\tTotal number of replications (days) -', replicates)\n",
    "print('\\tTotal number of delays -', num_delay)\n",
    "print('\\tTotal delay in minutes -', round(total_delay, 2))\n",
    "print('\\tAverage of delay events in minutes -', round(total_delay/num_delay, 2))\n",
    "\n",
    "print('\\n\\tAverage delay (all events) in minutes -', round(avg_delay, 2))\n",
    "print('\\tStd. Deviation of delay (all events) in minutes -', round(std_delay, 2))\n",
    "print('\\tMaximum delay (all events) in minutes -', round(max_delay, 2))\n",
    "\n",
    "\n",
    "print('\\n\\tTotal number of deployments -', bd_table.shape[0])\n",
    "print('\\tTotal number of route deployments -', sum(bd_table['Route']!=refuel))\n",
    "print('\\tTotal number of refills deployments -', sum(bd_table['Route']==refuel))\n",
    "\n",
    "print('\\n\\nCost Analysis')\n",
    "print('\\tAverage running time for all buses per day in minutes -', run_time)\n",
    "print('\\tAverage service time for all buses per day in minutes -', ser_time)\n",
    "print('\\tAverage refuel time for all buses per day in minutes -', ref_time)\n",
    "\n",
    "print('\\n\\tAverage employeee costs paid per day in dollars -', emp_cost)\n",
    "print('\\tAverage fuel costs paid per day in dollars -', fuel_cost)\n",
    "print('\\tAverage delay costs paid per day in dollars -', delay_cost)\n",
    "print('\\tAverage maintenance costs paid per day in dollars -', round(maintain_rate*(run_time+ser_time+ref_time)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "e66dadfd",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(22.258, 95.547)"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Charge distribution\n",
    "ss_table['Charge'].min(), ss_table['Charge'].max()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "68fa20cc",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "delay_arr = np.array(bd_table['Demand_Current'] - bd_table['Demand_Actual'])\n",
    "ecdf(delay_arr, 'Delay (min)')\n",
    "inv_ecdf(delay_arr, 'Delay (min)')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "4440ef51",
   "metadata": {},
   "outputs": [],
   "source": [
    "ss_table.to_parquet(path+'ss_table_'+refuel+'_'+np.str(n_buses)+'_'+\n",
    "                    np.str(level_mean)+'_'+np.str(running_consumption)+'_'+\n",
    "                    np.str(service_consumption)+'.parquet')\n",
    "bd_table.to_parquet(path+'bd_table_'+refuel+'_'+np.str(n_buses)+'_'+\n",
    "                    np.str(level_mean)+'_'+np.str(running_consumption)+'_'+\n",
    "                    np.str(service_consumption)+'.parquet')"
   ]
  }
 ],
 "metadata": {
  "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
}