functional_program.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": "4f60821c",
   "metadata": {},
   "outputs": [],
   "source": [
    "# intializing route table\n",
    "routes = pd.read_excel('Model_Parameters.xlsx', 'Routes')\n",
    "\n",
    "n_buses = 10                            # number of buses\n",
    "\n",
    "# For liquid fuel buses\n",
    "running_consumption = 0.57             # 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 = 60                         # normal distribution.. can be changed\n",
    "level_std = 0                           # currently constant at level_mean\n",
    "refuel = 'refill'                       # 'refill', recharge'\n",
    "\n",
    "# For electric buses\n",
    "running_consumption = 0.27              # fuel(lts.)/kWh per minute\n",
    "service_consumption = 0.05             # 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 = 60                         # normal distribution.. can be changed\n",
    "level_std = 0                           # currently constant at level_mean\n",
    "refuel = 'recharge'                     # 'refill', recharge'\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": 3,
   "id": "15d64465",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-----\n",
      "Running buses on Day  1\n",
      "Stuck in a loop!\n",
      "Deploying Bus\n",
      "\tTime - 612.02\n",
      "\tTime Check - 612.02\n",
      "\tDemands - [612.02, 612.02, 612.02, 612.02, 612.02, 612.02] [540.0, 540.0, 555.0, 560.0, 560.0, 560.0] ['3', '4', '1', '2', '3', '4'] [25.0, 25.0, 25.0, 25.0, 25.0, 25.0]\n",
      "\tdct_flag - 15\n",
      "Stuck in a loop!\n",
      "Deploying Bus\n",
      "\tTime - 686.22\n",
      "\tTime Check - 686.22\n",
      "\tDemands - [686.22, 686.22, 686.22, 686.22, 686.22, 686.22] [560.0, 560.0, 570.0, 580.0, 580.0, 580.0] ['3', '4', '1', '2', '3', '4'] [25.0, 25.0, 25.0, 25.0, 25.0, 25.0]\n",
      "\tdct_flag - 26\n",
      "-----\n",
      "Running buses on Day  2\n",
      "Stuck in a loop!\n",
      "Updating next bus event\n",
      "\tTime - 300.0\n",
      "\tTime Check - 300.0\n",
      "\tDemands - [315.0, 315.0, 320.0, 330.0, 330.0, 340.0] [315.0, 315.0, 320.0, 330.0, 330.0, 340.0] ['1', '3', '2', '1', '3', '2'] [25.0, 25.0, 25.0, 25.0, 25.0, 25.0]\n",
      "\tdct_flag - 0\n",
      "-----\n",
      "Running buses on Day  3\n",
      "-----\n",
      "Running buses on Day  4\n",
      "Stuck in a loop!\n",
      "Updating next bus event\n",
      "\tTime - 603.89\n",
      "\tTime Check - 603.89\n",
      "\tDemands - [603.89, 603.89, 603.89, 603.89, 603.89, 603.89] [540.0, 540.0, 540.0, 540.0, 555.0, 560.0] ['1', '2', '3', '4', '1', '2'] [25.0, 25.0, 25.0, 25.0, 25.0, 25.0]\n",
      "\tdct_flag - 17\n",
      "-----\n",
      "Running buses on Day  5\n",
      "Stuck in a loop!\n",
      "Updating next bus event\n",
      "\tTime - 460.77\n",
      "\tTime Check - 460.77\n",
      "\tDemands - [460.77, 465.0, 465.0, 480.0, 480.0, 480.0] [460.0, 465.0, 465.0, 480.0, 480.0, 480.0] ['4', '1', '3', '1', '2', '3'] [25.0, 25.0, 25.0, 25.0, 25.0, 25.0]\n",
      "\tdct_flag - 1\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",
      "Stuck in a loop!\n",
      "Deploying Bus\n",
      "\tTime - 480.73\n",
      "\tTime Check - 480.73\n",
      "\tDemands - [495.0, 495.0, 500.0, 500.0, 510.0, 510.0] [495.0, 495.0, 500.0, 500.0, 510.0, 510.0] ['1', '3', '2', '4', '1', '3'] [25.0, 25.0, 25.0, 25.0, 25.0, 25.0]\n",
      "\tdct_flag - 0\n",
      "-----\n",
      "Running buses on Day  10\n"
     ]
    }
   ],
   "source": [
    "replicates = 10\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",
    "    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'] = 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": "8c311e0c",
   "metadata": {},
   "source": [
    "ss_table"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c727a1be",
   "metadata": {},
   "source": [
    "bd_table"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "83843622",
   "metadata": {},
   "source": [
    "___\n",
    "## Converging the model on delays\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "c6ed5c94",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "---\n",
      "Current half-width -  47.637 min\n",
      "Current replications - 10\n",
      "Number of bus deployments - 1390\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": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "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)\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",
    "'''\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",
    "'''"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3c480d6b",
   "metadata": {},
   "source": [
    "___\n",
    "## Model Analysis"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "bc94589a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The extra replications to be done -  10077\n",
      "Delay Analyis\n",
      "\tTotal number of replications (days) - 10\n",
      "\tTotal number of delays - 567\n",
      "\tTotal delay in minutes - 53462.53\n",
      "\tAverage of delay events in minutes - 94.29\n",
      "\n",
      "\tAverage delay (all events) in minutes - 38.46\n",
      "\tStd. Deviation of delay (all events) in minutes - 66.59\n",
      "\tMaximum delay (all events) in minutes - 189.98\n",
      "\n",
      "\tTotal number of deployments - 1390\n",
      "\tTotal number of route deployments - 1290\n",
      "\tTotal number of refills deployments - 100\n",
      "\n",
      "\n",
      "Cost Analysis\n",
      "\tAverage running time for all buses per day in minutes - 4155.2\n",
      "\tAverage service time for all buses per day in minutes - 1517.77\n",
      "\tAverage refuel time for all buses per day in minutes - 705.76\n",
      "\n",
      "\tAverage employeee costs paid per day in dollars - 1595\n",
      "\tAverage fuel costs paid per day in dollars - 1245\n",
      "\tAverage delay costs paid per day in dollars - 128310\n",
      "\tAverage maintenance costs paid per day in dollars - 10652\n"
     ]
    }
   ],
   "source": [
    "# half-width analysis\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",
    "# 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",
    "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": 6,
   "id": "e66dadfd",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(19.405, 85.89429166666669)"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Charge distribution\n",
    "ss_table['Charge'].min(), ss_table['Charge'].max()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "8fe5fd07",
   "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": 8,
   "id": "308be32e",
   "metadata": {},
   "outputs": [],
   "source": [
    "path = r\"C:\\Users\\krishrao\\Desktop\\Laptop Backup\\Krishna\\Fall'21\\IOE 574\\Term Project\\IOE574_Project\\data_files\\LiqFuel_SensAnalysis\\\\\"\n",
    "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')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0d86cc3e",
   "metadata": {},
   "source": [
    "___\n",
    "## Testing Area"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f270fd58",
   "metadata": {},
   "source": [
    "#### Testing for route demands"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "b88f3464",
   "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"
    }
   ],
   "source": [
    "# route demand functions\n",
    "array_t = np.array(range(0, 12*60+1, 60))\n",
    "\n",
    "# https://ltp.umich.edu/wp-content/uploads/bursley_baits.pdf\n",
    "a, b, c, d = 0, 4, 0, 1\n",
    "plt.plot(array_t, np.ceil(a*np.sin((array_t+c)/d) + b), \n",
    "         color='r', label='bus_1', marker='o')\n",
    "\n",
    "# https://ltp.umich.edu/wp-content/uploads/northwood.pdf\n",
    "a, b, c, d = 1.5, 1.5, -180, 180\n",
    "plt.plot(array_t, np.ceil(a*np.sin((array_t+c)/d) + b), \n",
    "         color='b', label='bus_2', marker='o')\n",
    "\n",
    "# https://ltp.umich.edu/wp-content/uploads/diag_diag.pdf\n",
    "a, b, c, d = 3, 1, -60, 180\n",
    "plt.plot(array_t, np.ceil(a*np.sin((array_t+c)/d) + b), \n",
    "         color='g', label='bus_3', marker='o')\n",
    "\n",
    "# https://ltp.umich.edu/wp-content/uploads/oxford_shuttle.pdf\n",
    "a, b, c, d = 2, 1, -320, 180\n",
    "plt.plot(array_t, np.ceil(a*np.sin((array_t+c)/d) + b), \n",
    "         color='black', label='bus_4', marker='o')\n",
    "\n",
    "plt.xlabel('Time')\n",
    "plt.ylabel('Buses')\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  }
 ],
 "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
}