Parttime Driver.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 131,
   "id": "de98a3de",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import csv\n",
    "import random\n",
    "import math"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "id": "d9b87446",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Total number of driver: 46224\n",
    "numdriver = 46224\n",
    "numfulldriver = int(818/15670*numdriver)\n",
    "numpartdriver = int(7770/15670*numdriver)\n",
    "numoccadriver = int(7081/15670*numdriver)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "id": "19a158dd",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Parttime number of shifts\n",
    "def fullnumshifts():\n",
    "    temp = []\n",
    "    temp0 = 0\n",
    "    temp1 = -0.635 + 1.26 * 0 + (-1.35) * 0\n",
    "    temp2 = -1.58 + 1.95 * 0 + (-2.65) * 0\n",
    "    temp3 = -3.34 + 2.42 * 0 + (-4.07) * 0\n",
    "    temp.append(temp0)\n",
    "    temp.append(temp1)\n",
    "    temp.append(temp2)\n",
    "    temp.append(temp3)\n",
    "    U = []\n",
    "    sumU = 0\n",
    "    for i in range(len(temp)):\n",
    "        sumU += math.exp(temp[i])\n",
    "    P = 0\n",
    "    for i in range(len(temp)):\n",
    "        P += math.exp(temp[i])/sumU\n",
    "        U.append(P)\n",
    "    return(U)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "id": "c2ab47ef",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Parttime primary shift duration\n",
    "def fullpr(numshift):\n",
    "    temppdur = []\n",
    "    temppdur1 = 0\n",
    "    temppdur2 = 0.0428 + 0.00594*0 - 0.784*0 + 0.979*(numshift-1)\n",
    "    temppdur3 = -0.0115 + 0.535*0 - 1.40*0 + 1.22*(numshift-1)\n",
    "    temppdur4 = -0.185 + 0.861*0 - 2*0 + 1.29*(numshift-1)\n",
    "    temppdur5 = -0.437 + 1.37*0 - 2.39*0 + 1.18*(numshift-1)\n",
    "    temppdur6 = -0.772 + 1.77*0 - 2.91*0 + 1.07*(numshift-1)\n",
    "    temppdur7 = -1.11 + 2.07*0 - 3.05*0 + 0.766*(numshift-1)\n",
    "    temppdur8 = -1.5 + 2.39*0 -3.17*0 + 0.484*(numshift-1)\n",
    "    temppdur9 = -1.93 + 2.68*0 -3.71*0 + 0.16*(numshift-1)\n",
    "    temppdur10 = -2.41 + 2.91*0 -3.71*0 - 0.283*(numshift-1)\n",
    "    temppdur11 =  -2.89 + 3.14*0 -3.71*0 - 0.464*(numshift-1)\n",
    "    temppdur.append(temppdur1)\n",
    "    temppdur.append(temppdur2)\n",
    "    temppdur.append(temppdur3)\n",
    "    temppdur.append(temppdur4)\n",
    "    temppdur.append(temppdur5)\n",
    "    temppdur.append(temppdur6)\n",
    "    temppdur.append(temppdur7)\n",
    "    temppdur.append(temppdur8)\n",
    "    temppdur.append(temppdur9)\n",
    "    temppdur.append(temppdur10)\n",
    "    temppdur.append(temppdur11)\n",
    "    durU = []\n",
    "    dursumU = 0\n",
    "    for i in range(11):\n",
    "        dursumU += math.exp(temppdur[i])\n",
    "    durP = 0\n",
    "    for i in range(len(temppdur)):\n",
    "        durP += math.exp(temppdur[i])/dursumU\n",
    "        durU.append(durP)\n",
    "    return(durU)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "id": "5a72e30d",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Parttime secondary shift duration\n",
    "def fullsec(numshift,prdur):\n",
    "    tempsdur = []\n",
    "    tempsdur1 = 0\n",
    "    tempsdur2 = -0.517 + 0.346*0 - 0.609*0 + 0.696*(numshift-2) + 0.127*prdur\n",
    "    tempsdur3 = -0.914 + 0.629*0 - 0.904*0 + 0.696*(numshift-2) + 0.168*prdur\n",
    "    tempsdur4 = -1.54 + 1.02*0 - 0.904*0 + 0.601*(numshift-2) + 0.188*prdur\n",
    "    tempsdur5 = -2.30 + 1.35*0 - 0.904*0 + 0.601*(numshift-2) + 0.188*prdur\n",
    "    tempsdur.append(tempsdur1)\n",
    "    tempsdur.append(tempsdur2)\n",
    "    tempsdur.append(tempsdur3)\n",
    "    tempsdur.append(tempsdur4)\n",
    "    tempsdur.append(tempsdur5)\n",
    "    durs0U = []\n",
    "    durs0sumU = 0\n",
    "    for i in range(5):\n",
    "        durs0sumU += math.exp(tempsdur[i])\n",
    "    durs0P = 0\n",
    "    for i in range(len(tempsdur)):\n",
    "        durs0P += math.exp(tempsdur[i])/durs0sumU\n",
    "        durs0U.append(durs0P)\n",
    "    return(durs0U)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "id": "29843f2e",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Parttime tertiary shift duration\n",
    "def fullter(prdur,secdur):\n",
    "    temptdur = []\n",
    "    temptdur1 = 0\n",
    "    temptdur2 = -1.32 + 0.353*0 - 0.0891*prdur + 0.427*secdur\n",
    "    temptdur3 = -2.53 + 0.314*0 + 0.0194*prdur + 0.430*secdur \n",
    "    temptdur4 = -4.36 + 0.314*0 - 0.0194*prdur + 0.430*secdur \n",
    "    temptdur5 = -5.63 + 0.314*0 - 0.0194*prdur + 0.430*secdur \n",
    "    temptdur.append(temptdur1)\n",
    "    temptdur.append(temptdur2)\n",
    "    temptdur.append(temptdur3)\n",
    "    temptdur.append(temptdur4)\n",
    "    temptdur.append(temptdur5)\n",
    "    durtU = []\n",
    "    durtsumU = 0\n",
    "    for i in range(5):\n",
    "        durtsumU += math.exp(temptdur[i])\n",
    "    durtP = 0\n",
    "    for i in range(len(temptdur)):\n",
    "        durtP += math.exp(temptdur[i])/durtsumU\n",
    "        durtU.append(durtP)\n",
    "    return(durtU)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "id": "d3758a08",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Parttime primary starting time\n",
    "def fullps(numshift,primaryduration):\n",
    "    constant = [0,0.372281251,0.344461679,-1.137854098,-0.489390461,-0.320669653,-1.277397511,-1.169159768,1.461446615,2.352501297,2.341344621,2.183317427,1.641789515,1.394355673,1.061433805,0.779923145,0.919234267,0.252872163,1.337061588,2.128967606,2.46744309,2.197880196,1.584188565,1.83891762]\n",
    "    fulltime = [0,0.119,0.138,0.315,0.52,0.518,0.486,0.452,0.387,0.391,0.418,0.508,0.514,0.539,0.544,0.534,0.481,0.434,0.368,0.322,0.263,0.214,0.102,0.0472]\n",
    "    parttime = [0,0.449,0.503,1.44,0.891,1.01,1,1.32,0.533,-0.0654,-0.223,-0.299,0.000198,0.183,0.349,0.585,0.728,1.02,0.631,0.358,0.2,0.133,0.132,-0.0276]\n",
    "    numshifts = [0,0.00766,0.173,0.0689,0.211,0.15,0.231,0.166,0.0278,-0.0131,-0.0972,-0.158,-0.0457,0.0774,0.148,0.227,0.189,0.148,-0.108,-0.292,-0.38,-0.226,-0.105,-0.209]\n",
    "    prdur = [0,-0.0817,-0.315,0.181,0.238,0.344,0.587,0.65,0.197,-0.194,-0.38,-0.42,-0.363,-0.314,-0.122,0.0266,0.181,0.409,0.196,0.0891,-0.0253,-0.0492,0.0586,-0.149]\n",
    "    tempps = []\n",
    "    for i in range(24):\n",
    "        temppsU = constant[i] + fulltime[i]*0 + parttime[i]*1 + numshifts[i]*numshift + prdur[i]*primaryduration\n",
    "        tempps.append(temppsU)\n",
    "    starttimepU = []\n",
    "    starttimesumU = 0\n",
    "    for i in range(24):\n",
    "        starttimesumU += math.exp(tempps[i])\n",
    "    starttimeP = 0\n",
    "    for i in range(len(tempps)):\n",
    "        starttimeP += math.exp(tempps[i])/starttimesumU\n",
    "        starttimepU.append(starttimeP)\n",
    "    return(starttimepU)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "id": "64acf4bf",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Parttime secondary starting time\n",
    "def fullss(numshift,secduration,prtime,prduration):\n",
    "    constant = [0,2.407281251,2.514461679,2.902145902,5.140609539,6.027330347,5.972602489,6.348840232,9.512446615,10.7385013,10.74334462,11.21431743,10.97078951,11.23085567,10.8409338,11.18992315,11.01323427,9.804872163,9.826061588,10.04896761,9.06744309,8.887880196,9.358188565,9.98191762]\n",
    "    numshifts = [0,-0.359,-0.238,-0.0533,-0.00546,-0.204,-0.465,-0.459,-0.42,-0.237,-0.237,-0.261,-0.239,-0.34,-0.323,-0.531,-0.59,-0.518,-0.37,-0.365,-0.303,-0.168,-0.424,-0.56]\n",
    "    secdur =[0,-0.264,-0.184,-0.0616,0.105,0.218,0.252,0.231,-0.161,-0.467,-0.396,-0.411,-0.307,-0.204,-0.00965,0.0494,0.0807,-0.0288,-0.288,-0.534,-0.409,-0.49,-0.677,-0.824]\n",
    "    gap = [0,0.0395,0.0857,0.275,0.409,0.494,0.493,0.517,0.621,0.77,0.865,0.946,0.984,1.02,1.05,1.09,1.18,1.3,1.34,1.37,1.47,1.48,1.45,1.42]\n",
    "    tempps = []\n",
    "    for i in range(24):\n",
    "        temppsU = constant[i] + numshifts[i]*numshift + secdur[i]*secduration + gap[i]*0#(i-prtime-prduration)\n",
    "        tempps.append(temppsU)\n",
    "    starttimepU = []\n",
    "    starttimesumU = 0\n",
    "    for i in range(24):\n",
    "        starttimesumU += math.exp(tempps[i])\n",
    "    starttimeP = 0\n",
    "    for i in range(len(tempps)):\n",
    "        starttimeP += math.exp(tempps[i])/starttimesumU\n",
    "        starttimepU.append(starttimeP)\n",
    "    starttimeppU = []\n",
    "    for i in range(24):\n",
    "        starttimeppU.append(math.exp(tempps[i]))\n",
    "    return(starttimepU,starttimeppU)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "id": "9f0b608d",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Parttime tertiary starting time\n",
    "def fullts(numshift,terduration,secduration,sectime,prtime,prduration):\n",
    "    constant = [0,0.270281251,4.224461679,5.952145902,8.180609539,7.867330347,8.632602489,8.898840232,11.80244661,13.7585013,14.50334462,14.91431743,15.07078951,14.86085567,14.4509338,14.08992315,13.41323427,12.51487216,12.46606159,12.24896761,9.64744309,8.907880196,7.938188565,8.06191762]\n",
    "    tdur = [0,-0.251,-2.2,-0.62,-0.455,-0.0697,-0.311,0.209,0.0139,-0.234,-0.507,-0.515,-0.708,-0.494,-0.622,-0.676,-0.77,-0.661,-0.521,-0.67,-0.858,-0.524,-0.826,-1.46]\n",
    "    secdur =[0,0.529,0.311,0.349,0.00137,0.215,0.0987,0.0271,-0.115,0.052,-0.361,-0.237,-0.0247,0.0465,0.176,0.349,0.349,0.57,0.243,0.0837,0.721,0.635,0.918,0.578]\n",
    "    gap23 = [0,-0.0105,0.137,0.208,0.309,0.336,0.366,0.396,0.434,0.488,0.531,0.606,0.734,0.869,0.962,0.992,1.1,1.08,1.18,1.25,1.29,1.38,1.41,1.45]\n",
    "    gap13 = [0,0.0235,0.127,0.407,0.385,0.394,0.484,0.55,0.577,0.701,0.765,0.863,1.01,1.14,1.27,1.28,1.46,1.46,1.58,1.63,1.81,1.84,1.85,1.92]\n",
    "    tempps = []\n",
    "    for i in range(24):\n",
    "        temppsU = constant[i] + tdur[i]*terduration + secdur[i]*secduration + gap23[i]*0#(i-sectime-secduration) + gap13[i]*(i-prtime-prduration)\n",
    "        tempps.append(temppsU)\n",
    "    starttimepU = []\n",
    "    starttimesumU = 0\n",
    "    for i in range(24):\n",
    "        starttimesumU += math.exp(tempps[i])\n",
    "    starttimeP = 0\n",
    "    for i in range(len(tempps)):\n",
    "        starttimeP += math.exp(tempps[i])/starttimesumU\n",
    "        starttimepU.append(starttimeP)\n",
    "    starttimeppU = []\n",
    "    for i in range(24):\n",
    "        starttimeppU.append(math.exp(tempps[i]))\n",
    "    return(starttimepU,starttimeppU)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "id": "b768f902",
   "metadata": {},
   "outputs": [],
   "source": [
    "data = pd.read_csv('tazdata981.csv')\n",
    "district = [[] for i in range(15)]\n",
    "tempPOP = [[0] for _ in range(15)]\n",
    "tempEMP = [[0] for _ in range(15)]\n",
    "tempPARK = [[0] for _ in range(15)]\n",
    "tempCOLL = [[0] for _ in range(15)]\n",
    "tempAREA = [[0] for _ in range(15)]\n",
    "tempINCQ1 = [[0] for _ in range(15)]\n",
    "tempINCQ2 = [[0] for _ in range(15)]\n",
    "tempINCQ3 = [[0] for _ in range(15)]\n",
    "tempINCQ4 = [[0] for _ in range(15)]\n",
    "tempON = [[0] for _ in range(15)]\n",
    "tempOFF = [[0] for _ in range(15)]\n",
    "for i in range(981):\n",
    "    district[data['DIST22'][i]].append(data['SFTAZ'][i])\n",
    "    tempPOP[data['DIST22'][i]][0] += data['POP'][i]\n",
    "    tempEMP[data['DIST22'][i]][0] += data['TOTALEMP'][i]\n",
    "    tempPARK[data['DIST22'][i]][0] += data['TOTPARK'][i]\n",
    "    tempCOLL[data['DIST22'][i]][0] += data['COLLENROLL'][i]\n",
    "    tempAREA[data['DIST22'][i]][0] += data['TOTACRE'][i]\n",
    "    tempINCQ1[data['DIST22'][i]][0] += data['HHINCQ1'][i]\n",
    "    tempINCQ2[data['DIST22'][i]][0] += data['HHINCQ2'][i]\n",
    "    tempINCQ3[data['DIST22'][i]][0] += data['HHINCQ3'][i]\n",
    "    tempINCQ4[data['DIST22'][i]][0] += data['HHINCQ4'][i]\n",
    "    tempON[data['DIST22'][i]][0] += data['ONSTREET'][i]*data['TOTPARK'][i]\n",
    "    tempOFF[data['DIST22'][i]][0] += data['OFSTREET'][i]*data['TOTPARK'][i]\n",
    "df1 = pd.read_csv(\"fullTAZthird+.txt\",sep =' ',names=['ID','f','p','o','num','dur0','start0',\"taz0\",'x0','y0','dur1','start1',\"taz\",'x1','y1','dur2','start2','taz2','x2','y2'])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "id": "b22d446e",
   "metadata": {},
   "outputs": [],
   "source": [
    "# fulltime first starting location\n",
    "def fullpsl():\n",
    "    EMP = 4\n",
    "    COLL = -0.000243\n",
    "    POPEMP = 0.0173\n",
    "    INCQ1 = -0.0000637\n",
    "    INCQ4 = 0.000213\n",
    "    POP=1\n",
    "    PARK = 0\n",
    "    temp = []\n",
    "    for i in range(1,15):\n",
    "        if(POP*tempPOP[i][0] + EMP*tempEMP[i][0] == 0):\n",
    "                tempU = PARK*tempPARK[i][0] + COLL * tempCOLL[i][0] + POPEMP * (tempPOP[i][0]+tempEMP[i][0]) / tempAREA[i][0] + INCQ1 * tempINCQ1[i][0]  + INCQ4 * tempINCQ4[i][0]\n",
    "                temp.append(tempU)\n",
    "        else:\n",
    "                tempU = math.log(POP*tempPOP[i][0]+EMP*tempEMP[i][0]) + PARK*tempPARK[i][0] + COLL * tempCOLL[i][0] + POPEMP * (tempPOP[i][0]+tempEMP[i][0]) / tempAREA[i][0] + INCQ1 * tempINCQ1[i][0] + INCQ4 * tempINCQ4[i][0]\n",
    "                temp.append(tempU)\n",
    "    U = []\n",
    "    sumU = 0\n",
    "    for i in range(len(temp)):\n",
    "        sumU += math.exp(temp[i])\n",
    "    P = 0\n",
    "    for i in range(len(temp)):\n",
    "        P += math.exp(temp[i])/sumU\n",
    "        U.append(P)\n",
    "    return(U)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "id": "09e1a19e",
   "metadata": {},
   "outputs": [],
   "source": [
    "def fullssl():\n",
    "    COLL=-0.000147   \n",
    "    INCQ1=-0.000008   \n",
    "    INCQ4=0.000151    \n",
    "    EMP=6.105598   \n",
    "    POPEMP=0.009310   \n",
    "    PARK=-0.000026    \n",
    "    POP =1\n",
    "    temp = []\n",
    "    for i in range(1,15):\n",
    "        if(POP*tempPOP[i][0] + EMP*tempEMP[i][0] == 0):\n",
    "            tempU = PARK*tempPARK[i][0] + COLL * tempCOLL[i][0] + POPEMP * (tempPOP[i][0]+tempEMP[i][0]) / tempAREA[i][0] + INCQ1 * tempINCQ1[i][0]  + INCQ4 * tempINCQ4[i][0]\n",
    "            temp.append(tempU)\n",
    "        else:\n",
    "            tempU = math.log(POP*tempPOP[i][0]+EMP*tempEMP[i][0]) + PARK*tempPARK[i][0] + COLL * tempCOLL[i][0] + POPEMP * (tempPOP[i][0]+tempEMP[i][0]) / tempAREA[i][0] + INCQ1 * tempINCQ1[i][0] + INCQ4 * tempINCQ4[i][0]\n",
    "            temp.append(tempU)\n",
    "    U = []\n",
    "    sumU = 0\n",
    "    for i in range(len(temp)):\n",
    "        sumU += math.exp(temp[i])\n",
    "    P = 0\n",
    "    for i in range(len(temp)):\n",
    "        P += math.exp(temp[i])/sumU\n",
    "        U.append(P)\n",
    "    return(U)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "id": "0e3317b5",
   "metadata": {},
   "outputs": [],
   "source": [
    "board =[[],[2,9,10],[1,3,10],[2,4,10,11],[3,5,11,12,13],[4,13,14],[7,12,13,14],[8,6,12],[9,11,12,7],[1,10,11,8],[1,2,3,11,9],[8,9,10,12,3,4],[4,6,7,8,11,13],[4,5,14,6,12],[5,6,13]]\n",
    "temponboard = []\n",
    "temponboard1 = []\n",
    "for i in range(len(df1)):\n",
    "    if(data['DIST22'][int(df1['taz'][i]-1)]!=data['DIST22'][int(df1['taz2'][i]-1)]):\n",
    "        tempdisid1 = data['DIST22'][int(df1['taz'][i]-1)]\n",
    "        tempdisid2 = data['DIST22'][int(df1['taz2'][i]-1)]\n",
    "        if(tempdisid2 in board[tempdisid1]):\n",
    "            temponboard.append(1)\n",
    "            temponboard1.append(1)\n",
    "        else:\n",
    "            temponboard.append(0)\n",
    "            temponboard1.append(0)\n",
    "    else:\n",
    "        temponboard.append(1)\n",
    "        temponboard1.append(0)\n",
    "\n",
    "onsummary1 = [[0] for _ in range(15)]\n",
    "onsummary0 = [[0] for _ in range(15)]\n",
    "for i in range(len(df1)):\n",
    "    tempdistrictid = data['DIST22'][int(df1['taz'][i]-1)]\n",
    "    if(temponboard[i]==1):\n",
    "        onsummary1[tempdistrictid][0]+=1\n",
    "    else:\n",
    "        onsummary0[tempdistrictid][0]+=1\n",
    "        \n",
    "probsummary =[[] for _ in range(15)]\n",
    "for i in range(1,15):\n",
    "    tempsum = onsummary1[i][0]+onsummary0[i][0]\n",
    "    probsummary[i].append((onsummary1[i][0])/tempsum)\n",
    "    \n",
    "def fulltsl():\n",
    "    EMP=7.61\n",
    "    POPEMP = 0.0103\n",
    "    COLL=-0.000157\n",
    "    ON = 1.1\n",
    "    INCQ1 = -0.0000376\n",
    "    INCQ4=0.000108\n",
    "    POP=1\n",
    "    PARK=0\n",
    "    DIS = 0\n",
    "    temp = []\n",
    "    for i in range(1,15):\n",
    "        prob = random.uniform(0, 1)\n",
    "        if(POP*tempPOP[i][0] + EMP*tempEMP[i][0] == 0):\n",
    "            if(prob<=probsummary[i][0]):\n",
    "                tempU = PARK*tempPARK[i][0] + COLL * tempCOLL[i][0] + POPEMP * (tempPOP[i][0]+tempEMP[i][0]) / tempAREA[i][0] + INCQ1 * tempINCQ1[i][0]  + INCQ4 * tempINCQ4[i][0] + ON * 1\n",
    "            else:\n",
    "                tempU = PARK*tempPARK[i][0] + COLL * tempCOLL[i][0] + POPEMP * (tempPOP[i][0]+tempEMP[i][0]) / tempAREA[i][0] + INCQ1 * tempINCQ1[i][0]  + INCQ4 * tempINCQ4[i][0]\n",
    "            temp.append(tempU)\n",
    "        else:\n",
    "            if(prob<=probsummary[i][0]):\n",
    "                tempU = math.log(POP*tempPOP[i][0]+EMP*tempEMP[i][0]) + PARK*tempPARK[i][0] + COLL * tempCOLL[i][0] + POPEMP * (tempPOP[i][0]+tempEMP[i][0]) / tempAREA[i][0] + INCQ1 * tempINCQ1[i][0] + INCQ4 * tempINCQ4[i][0] + ON * 1\n",
    "            else:\n",
    "                tempU = math.log(POP*tempPOP[i][0]+EMP*tempEMP[i][0]) + PARK*tempPARK[i][0] + COLL * tempCOLL[i][0] + POPEMP * (tempPOP[i][0]+tempEMP[i][0]) / tempAREA[i][0] + INCQ1 * tempINCQ1[i][0] + INCQ4 * tempINCQ4[i][0]\n",
    "            temp.append(tempU)\n",
    "    U = []\n",
    "    sumU = 0\n",
    "    for i in range(len(temp)):\n",
    "        sumU += math.exp(temp[i])\n",
    "    P = 0\n",
    "    for i in range(len(temp)):\n",
    "        P += math.exp(temp[i])/sumU\n",
    "        U.append(P)\n",
    "    return(U)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "id": "5a1e1347",
   "metadata": {},
   "outputs": [],
   "source": [
    "##### Generate the driver fleet"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "id": "7013ce38",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.5645419518317988, 0.8637127667515363, 0.9799943507208676, 0.9999999999999998]\n"
     ]
    }
   ],
   "source": [
    "# estimate the number of shifts of each fulltime driver\n",
    "fulltimedrivernumshift = [[] for _ in range(numpartdriver)]\n",
    "Unumshift = fullnumshifts()\n",
    "print(Unumshift)\n",
    "for i in range(numpartdriver):\n",
    "    drawnum = np.random.random()\n",
    "    for j in range(len(Unumshift)):\n",
    "        if(j==0):\n",
    "            if(drawnum<Unumshift[j]):\n",
    "                fulltimedrivernumshift[i].append(0)\n",
    "        else:\n",
    "            if(drawnum<Unumshift[j] and drawnum>=Unumshift[j-1]):\n",
    "                fulltimedrivernumshift[i].append(j)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "id": "4c13cde9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12968\n",
      "6803\n",
      "2680\n",
      "469\n",
      "22920\n"
     ]
    }
   ],
   "source": [
    "# fulltime driver number of shifts summary\n",
    "count1 = 0 \n",
    "count2 = 0\n",
    "count3 = 0\n",
    "count0 = 0\n",
    "for i in fulltimedrivernumshift:\n",
    "    if(i[0]==0):\n",
    "        count0+=1\n",
    "    elif(i[0]==1):\n",
    "        count1+=1\n",
    "    elif(i[0]==2):\n",
    "        count2+=1\n",
    "    else:\n",
    "        count3+=1\n",
    "print(count0)\n",
    "print(count1)\n",
    "print(count2)\n",
    "print(count3)\n",
    "print(count0+count1+count2+count3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "id": "1dbd046e",
   "metadata": {},
   "outputs": [],
   "source": [
    "fulltimedrivershift = []\n",
    "fulltimedriverduration = []\n",
    "fulltimedriverstartingtime = []\n",
    "fulltimedriverstartinglocation = []\n",
    "for i in range(numpartdriver):\n",
    "    summaryduration = []\n",
    "    summarystartingtime = []\n",
    "    summarystartinglocation = []\n",
    "    # number of shifts of this driver\n",
    "    numberofshifts = fulltimedrivernumshift[i][0]\n",
    "    #print(numberofshifts)\n",
    "    fulltimedrivershift.append(numberofshifts)\n",
    "    # estimate primary shift duration\n",
    "    primarydurationU = fullpr(numberofshifts)\n",
    "    pdurdraw = np.random.random()\n",
    "    for j in range(len(primarydurationU)):\n",
    "        if(j==0):\n",
    "            if(pdurdraw<primarydurationU[j]):\n",
    "                primaryduration=1\n",
    "        else:\n",
    "            if(pdurdraw<primarydurationU[j] and pdurdraw>=primarydurationU[j-1]):\n",
    "                primaryduration=j+1\n",
    "    #print('prdur',primaryduration)\n",
    "    summaryduration.append(primaryduration)\n",
    "    if(numberofshifts>=2):\n",
    "        # estimate second shift duration\n",
    "        secondarydurationU = fullsec(numberofshifts,primaryduration)\n",
    "        secondaryduration = 99\n",
    "        while(secondaryduration>primaryduration):\n",
    "            sdurdraw = np.random.random()\n",
    "            for j in range(len(secondarydurationU)):\n",
    "                if(j==0):\n",
    "                    if(sdurdraw<secondarydurationU[j]):\n",
    "                        secondaryduration=1\n",
    "                else:\n",
    "                    if(sdurdraw<secondarydurationU[j] and sdurdraw>=secondarydurationU[j-1]):\n",
    "                        secondaryduration=j+1\n",
    "        #print('secdur',secondaryduration)\n",
    "        summaryduration.append(secondaryduration)\n",
    "        if(numberofshifts>=3):\n",
    "            #estimate tertiary shift duration\n",
    "            tertiarydurationU = fullter(primaryduration,secondaryduration)\n",
    "            tertiaryduration = 99\n",
    "            while(tertiaryduration>secondaryduration):\n",
    "                tdurdraw = np.random.random()\n",
    "                for j in range(len(tertiarydurationU)):\n",
    "                    if(j==0):\n",
    "                        if(tdurdraw<tertiarydurationU[j]):\n",
    "                            tertiaryduration=1\n",
    "                    else:\n",
    "                        if(tdurdraw<tertiarydurationU[j] and tdurdraw>=tertiarydurationU[j-1]):\n",
    "                            tertiaryduration=j+1\n",
    "            summaryduration.append(tertiaryduration)\n",
    "    #estimate primary starting time\n",
    "    primarytimeU = fullps(numberofshifts,primaryduration)\n",
    "    ptimedraw = np.random.random()\n",
    "    for j in range(len(primarytimeU)):\n",
    "        if(j==0):\n",
    "            if(ptimedraw<primarytimeU[j]):\n",
    "                primarytime=1\n",
    "        else:\n",
    "            if(ptimedraw<primarytimeU[j] and ptimedraw>=primarytimeU[j-1]):\n",
    "                primarytime=j+1\n",
    "    summarystartingtime.append(primarytime)\n",
    "    #estimate secondary starting time\n",
    "    if(numberofshifts>=2):\n",
    "        secondarytimeU, secondarytimeP = fullss(numberofshifts,secondaryduration,primarytime,primaryduration)\n",
    "        sectimedraw = np.random.random()\n",
    "        secondarytime = primarytime\n",
    "        ava = list(range(1,25))\n",
    "        for k in range(primaryduration):\n",
    "            if(primarytime+k<=24):\n",
    "                ava.remove(primarytime+k)\n",
    "            else:\n",
    "                ava.remove(primarytime+k-24)\n",
    "        for k in range(secondaryduration):\n",
    "            if(primarytime-k<0 and primarytime-k in ava):\n",
    "                ava.remove(primarytime-k+24)\n",
    "            else:\n",
    "                if(primarytime-k-1 in ava):\n",
    "                    ava.remove(primarytime-k-1)\n",
    "        #print(ava)\n",
    "        tempsecondarytimeP = []\n",
    "        for j in ava:\n",
    "            tempsecondarytimeP.append(secondarytimeP[j-1])\n",
    "        newsecondarytimeU = []\n",
    "        tempsumU = 0\n",
    "        for j in tempsecondarytimeP:\n",
    "            tempsumU+=j/sum(tempsecondarytimeP)\n",
    "            newsecondarytimeU.append(tempsumU)\n",
    "        for j in range(len(newsecondarytimeU)):\n",
    "            if(j==0):\n",
    "                if(sectimedraw<newsecondarytimeU[j]):\n",
    "                    tempsecondarytime=1\n",
    "            else:\n",
    "                if(sectimedraw<newsecondarytimeU[j] and sectimedraw>=newsecondarytimeU[j-1]):\n",
    "                    tempsecondarytime=j+1\n",
    "        secondarytime = ava[tempsecondarytime-1]\n",
    "        summarystartingtime.append(secondarytime)\n",
    "        if(numberofshifts>=3):\n",
    "            tertiarytimeU, tertiarytimeP = fullts(numberofshifts,tertiaryduration,secondaryduration,secondarytime,primarytime,primaryduration)\n",
    "            tertimedraw = np.random.random()\n",
    "            tertiarytime = primarytime\n",
    "            tava = list(range(1,25))\n",
    "            for k in range(primaryduration):\n",
    "                if(primarytime+k<=24):\n",
    "                    tava.remove(primarytime+k)\n",
    "                else:\n",
    "                    tava.remove(primarytime+k-24)\n",
    "            for k in range(tertiaryduration):\n",
    "                if(primarytime-k<0 and primarytime-k+24 in tava):\n",
    "                    tava.remove(primarytime-k+24)\n",
    "                else:\n",
    "                    if(primarytime-k-1 in tava):\n",
    "                        tava.remove(primarytime-k-1)\n",
    "            for k in range(secondaryduration):\n",
    "                if(secondarytime+k<=24 and secondarytime+k in tava):\n",
    "                    tava.remove(secondarytime+k)\n",
    "                elif(secondarytime+k>24 and secondarytime+k-24 in tava):\n",
    "                    tava.remove(secondarytime+k-24)\n",
    "            for k in range(tertiaryduration):\n",
    "                if(secondarytime-k<0 and secondarytime-k+24 in tava):\n",
    "                    tava.remove(secondarytime-k+24)\n",
    "                elif(secondarytime-k>=0 and secondarytime-k in tava):\n",
    "                    tava.remove(secondarytime-k)\n",
    "            #print(tava)\n",
    "            temptertiarytimeP = []\n",
    "            for j in tava:\n",
    "                temptertiarytimeP.append(tertiarytimeP[j-1])\n",
    "            newtertiarytimeU = []\n",
    "            temptsumU = 0\n",
    "            for j in temptertiarytimeP:\n",
    "                temptsumU+=j/sum(temptertiarytimeP)\n",
    "                newtertiarytimeU.append(temptsumU)\n",
    "            for j in range(len(newtertiarytimeU)):\n",
    "                if(j==0):\n",
    "                    if(tertimedraw<newtertiarytimeU[j]):\n",
    "                        temptertiarytime=1\n",
    "                else:\n",
    "                    if(tertimedraw<newtertiarytimeU[j] and tertimedraw>=newtertiarytimeU[j-1]):\n",
    "                        temptertiarytime=j+1\n",
    "            tertiarytime = ava[temptertiarytime-1]\n",
    "            summarystartingtime.append(tertiarytime)\n",
    "    # estimate first starting location\n",
    "    primarylocationU = fullpsl()\n",
    "    plocdraw = np.random.random()\n",
    "    for j in range(len(primarylocationU)):\n",
    "        if(j==0):\n",
    "            if(plocdraw<primarylocationU[j]):\n",
    "                primarylocation=1\n",
    "        else:\n",
    "            if(plocdraw<primarylocationU[j] and plocdraw>=primarylocationU[j-1]):\n",
    "                primarylocation=j+1\n",
    "    summarystartinglocation.append(primarylocation)\n",
    "    if(numberofshifts>=2):\n",
    "        secondarylocationU = fullssl()\n",
    "        slocdraw = np.random.random()\n",
    "        for j in range(len(secondarylocationU)):\n",
    "            if(j==0):\n",
    "                if(slocdraw<secondarylocationU[j]):\n",
    "                    secondarylocation=1\n",
    "            else:\n",
    "                if(slocdraw<secondarylocationU[j] and slocdraw>=secondarylocationU[j-1]):\n",
    "                    secondarylocation=j+1\n",
    "        summarystartinglocation.append(secondarylocation)\n",
    "        if(numberofshifts>=3):\n",
    "            tertiarylocationU = fulltsl()\n",
    "            tlocdraw = np.random.random()\n",
    "            for j in range(len(tertiarylocationU)):\n",
    "                if(j==0):\n",
    "                    if(tlocdraw<tertiarylocationU[j]):\n",
    "                        tertiarylocation=1\n",
    "                else:\n",
    "                    if(tlocdraw<tertiarylocationU[j] and tlocdraw>=tertiarylocationU[j-1]):\n",
    "                        tertiarylocation=j+1\n",
    "            summarystartinglocation.append(tertiarylocation)\n",
    "    fulltimedriverduration.append(summaryduration)\n",
    "    fulltimedriverstartingtime.append(summarystartingtime)\n",
    "    fulltimedriverstartinglocation.append(summarystartinglocation)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "id": "802def26",
   "metadata": {},
   "outputs": [],
   "source": [
    "pshiftduration = [[] for _ in range(len(fulltimedrivershift))]\n",
    "pshiftstartingtime = [[] for _ in range(len(fulltimedrivershift))]\n",
    "pshiftstartinglocation = [[] for _ in range(len(fulltimedrivershift))]\n",
    "sshiftduration = [[] for _ in range(len(fulltimedrivershift))]\n",
    "sshiftstartingtime = [[] for _ in range(len(fulltimedrivershift))]\n",
    "sshiftstartinglocation = [[] for _ in range(len(fulltimedrivershift))]\n",
    "tshiftduration = [[] for _ in range(len(fulltimedrivershift))]\n",
    "tshiftstartingtime = [[] for _ in range(len(fulltimedrivershift))]\n",
    "tshiftstartinglocation = [[] for _ in range(len(fulltimedrivershift))]\n",
    "for i in range(len(fulltimedrivershift)):\n",
    "    if(fulltimedrivershift[i]!=0):\n",
    "        pshiftduration[i].append(fulltimedriverduration[i][0])\n",
    "        pshiftstartingtime[i].append(fulltimedriverstartingtime[i][0])\n",
    "        pshiftstartinglocation[i].append(fulltimedriverstartinglocation[i][0])\n",
    "    if(fulltimedrivershift[i]>=2):\n",
    "        sshiftduration[i].append(fulltimedriverduration[i][1])\n",
    "        sshiftstartingtime[i].append(fulltimedriverstartingtime[i][1])\n",
    "        sshiftstartinglocation[i].append(fulltimedriverstartinglocation[i][1]) \n",
    "    if(fulltimedrivershift[i]>=3):\n",
    "        tshiftduration[i].append(fulltimedriverduration[i][2])\n",
    "        tshiftstartingtime[i].append(fulltimedriverstartingtime[i][2])\n",
    "        tshiftstartinglocation[i].append(fulltimedriverstartinglocation[i][2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 153,
   "id": "1379db60",
   "metadata": {},
   "outputs": [],
   "source": [
    "pshifttaz = []\n",
    "pshiftdistrict =[0 for _ in range(15)]\n",
    "pshiftdistrictid =[[] for _ in range(15)]\n",
    "for i in range(len(pshiftstartinglocation)):\n",
    "    if(pshiftstartinglocation[i]!=[] and pshiftstartinglocation[i][0]>=1):\n",
    "        districtid = pshiftstartinglocation[i][0]\n",
    "        pshiftdistrict[districtid] +=1\n",
    "        pshiftdistrictid[districtid].append(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 154,
   "id": "a867075c",
   "metadata": {},
   "outputs": [],
   "source": [
    "TAZSH = [[[] for _ in range(982)] for _ in range(15)]\n",
    "for i in range(1,15):\n",
    "    tempTAZ = district[i]\n",
    "    sumPOP = 0\n",
    "    for j in tempTAZ:\n",
    "        sumPOP += data['POP'][j-1]\n",
    "    for j in tempTAZ:\n",
    "        TAZSH[i][j].append(math.ceil(data['POP'][j-1]/sumPOP*pshiftdistrict[i]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 155,
   "id": "485fe6ad",
   "metadata": {},
   "outputs": [],
   "source": [
    "TAZ = [[] for _ in range(15)]\n",
    "tempTAZ = [[] for _ in range(15)]\n",
    "for i in range(1,15):\n",
    "    for j in range(len(TAZSH[i])):\n",
    "        if(TAZSH[i][j]!=[]):\n",
    "            for k in range(TAZSH[i][j][0]):\n",
    "                TAZ[i].append(j)\n",
    "                tempTAZ[i].append(j)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 156,
   "id": "2f297872",
   "metadata": {},
   "outputs": [],
   "source": [
    "pshiftstartingTAZ = [[] for _ in range(len(fulltimedrivershift))]\n",
    "for i in range(len(pshiftstartinglocation)):\n",
    "    if(pshiftstartinglocation[i]!=[] and pshiftstartinglocation[i][0]>=1):\n",
    "        districtid = pshiftstartinglocation[i][0]\n",
    "        if(len(TAZ[districtid])!=0):\n",
    "            tempchoice = random.randrange(0,len(TAZ[districtid]))\n",
    "            pshiftstartingTAZ[i].append(TAZ[districtid][tempchoice])\n",
    "            TAZ[districtid].remove(TAZ[districtid][tempchoice])\n",
    "        else:\n",
    "            tempchoice = random.randrange(0,len(tempTAZ[districtid]))\n",
    "            pshiftstartingTAZ[i].append(tempTAZ[districtid][tempchoice])\n",
    "            tempTAZ[districtid].remove(tempTAZ[districtid][tempchoice])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 157,
   "id": "ffd4f93c",
   "metadata": {},
   "outputs": [],
   "source": [
    "sshifttaz = []\n",
    "sshiftdistrict =[0 for _ in range(15)]\n",
    "sshiftdistrictid =[[] for _ in range(15)]\n",
    "for i in range(len(sshiftstartinglocation)):\n",
    "    if(sshiftstartinglocation[i]!=[] and sshiftstartinglocation[i][0]>=1):\n",
    "        districtid = sshiftstartinglocation[i][0]\n",
    "        sshiftdistrict[districtid] +=1\n",
    "        sshiftdistrictid[districtid].append(i)\n",
    "sTAZSH = [[[] for _ in range(982)] for _ in range(15)]\n",
    "for i in range(1,15):\n",
    "    tempTAZ = district[i]\n",
    "    sumPOP = 0\n",
    "    for j in tempTAZ:\n",
    "        sumPOP += data['POP'][j-1]\n",
    "    for j in tempTAZ:\n",
    "        sTAZSH[i][j].append(math.ceil(data['POP'][j-1]/sumPOP*sshiftdistrict[i]))\n",
    "sTAZ = [[] for _ in range(15)]\n",
    "stempTAZ = [[] for _ in range(15)]\n",
    "for i in range(1,15):\n",
    "    for j in range(len(sTAZSH[i])):\n",
    "        if(sTAZSH[i][j]!=[]):\n",
    "            for k in range(sTAZSH[i][j][0]):\n",
    "                sTAZ[i].append(j)\n",
    "                stempTAZ[i].append(j)\n",
    "sshiftstartingTAZ = [[] for _ in range(len(fulltimedrivershift))]\n",
    "for i in range(len(sshiftstartinglocation)):\n",
    "    if(sshiftstartinglocation[i]!=[] and sshiftstartinglocation[i][0]>=1):\n",
    "        districtid = sshiftstartinglocation[i][0]\n",
    "        if(len(sTAZ[districtid])!=0):\n",
    "            tempchoice = random.randrange(0,len(sTAZ[districtid]))\n",
    "            sshiftstartingTAZ[i].append(sTAZ[districtid][tempchoice])\n",
    "            sTAZ[districtid].remove(sTAZ[districtid][tempchoice])\n",
    "        else:\n",
    "            print(districtid,stempTAZ[districtid])\n",
    "            tempchoice = random.randrange(0,len(stempTAZ[districtid]))\n",
    "            sshiftstartingTAZ[i].append(stempTAZ[districtid][tempchoice])\n",
    "            stempTAZ[districtid].remove(stempTAZ[districtid][tempchoice])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 158,
   "id": "95f86a6a",
   "metadata": {},
   "outputs": [],
   "source": [
    "tshifttaz = []\n",
    "tshiftdistrict =[0 for _ in range(15)]\n",
    "tshiftdistrictid =[[] for _ in range(15)]\n",
    "for i in range(len(tshiftstartinglocation)):\n",
    "    if(tshiftstartinglocation[i]!=[] and tshiftstartinglocation[i][0]>=1):\n",
    "        districtid = tshiftstartinglocation[i][0]\n",
    "        tshiftdistrict[districtid] +=1\n",
    "        tshiftdistrictid[districtid].append(i)\n",
    "tTAZSH = [[[] for _ in range(982)] for _ in range(15)]\n",
    "for i in range(1,15):\n",
    "    tempTAZ = district[i]\n",
    "    sumPOP = 0\n",
    "    for j in tempTAZ:\n",
    "        sumPOP += data['POP'][j-1]\n",
    "    for j in tempTAZ:\n",
    "        tTAZSH[i][j].append(math.ceil(data['POP'][j-1]/sumPOP*tshiftdistrict[i]))\n",
    "tTAZ = [[] for _ in range(15)]\n",
    "ttempTAZ = [[] for _ in range(15)]\n",
    "for i in range(1,15):\n",
    "    for j in range(len(tTAZSH[i])):\n",
    "        if(tTAZSH[i][j]!=[]):\n",
    "            for k in range(tTAZSH[i][j][0]):\n",
    "                tTAZ[i].append(j)\n",
    "                ttempTAZ[i].append(j)\n",
    "tshiftstartingTAZ = [[] for _ in range(len(fulltimedrivershift))]\n",
    "for i in range(len(tshiftstartinglocation)):\n",
    "    if(tshiftstartinglocation[i]!=[] and tshiftstartinglocation[i][0]>=1):\n",
    "        districtid = tshiftstartinglocation[i][0]\n",
    "        if(len(tTAZ[districtid])!=0):\n",
    "            tempchoice = random.randrange(0,len(tTAZ[districtid]))\n",
    "            tshiftstartingTAZ[i].append(tTAZ[districtid][tempchoice])\n",
    "            tTAZ[districtid].remove(tTAZ[districtid][tempchoice])\n",
    "        else:\n",
    "            print(districtid,stempTAZ[districtid])\n",
    "            tempchoice = random.randrange(0,len(stempTAZ[districtid]))\n",
    "            sshiftstartingTAZ[i].append(stempTAZ[districtid][tempchoice])\n",
    "            stempTAZ[districtid].remove(stempTAZ[districtid][tempchoice])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 159,
   "id": "bf9e82b1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9952\n",
      "3149\n",
      "469\n"
     ]
    }
   ],
   "source": [
    "p = 0\n",
    "for i in pshiftstartingTAZ:\n",
    "    if(i!=[]):\n",
    "        p+=1\n",
    "print(p)\n",
    "s = 0\n",
    "for i in sshiftstartingTAZ:\n",
    "    if(i!=[]):\n",
    "        s+=1\n",
    "print(s)\n",
    "t = 0\n",
    "for i in tshiftstartingTAZ:\n",
    "    if(i!=[]):\n",
    "        t+=1\n",
    "print(t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 160,
   "id": "c237f571",
   "metadata": {},
   "outputs": [],
   "source": [
    "driverfullorder = []\n",
    "for i in range(len(fulltimedrivershift)):\n",
    "    if(fulltimedrivershift[i]!=0):\n",
    "        tempfduration=[]\n",
    "        tempfduration.append(pshiftduration[i][0])\n",
    "        if(fulltimedrivershift[i]>=2):\n",
    "            tempfduration.append(sshiftduration[i][0])\n",
    "            if(fulltimedrivershift[i]>=3):\n",
    "                tempfduration.append(tshiftduration[i][0])\n",
    "        tempfstartingtime=[]\n",
    "        tempfstartingtime.append(pshiftstartingtime[i][0])\n",
    "        if(fulltimedrivershift[i]>=2):\n",
    "            tempfstartingtime.append(sshiftstartingtime[i][0])\n",
    "            if(fulltimedrivershift[i]>=3):\n",
    "                tempfstartingtime.append(tshiftstartingtime[i][0])\n",
    "        tempfstartingloc=[]\n",
    "        tempfstartingloc.append(pshiftstartingTAZ[i][0])\n",
    "        if(fulltimedrivershift[i]>=2):\n",
    "            tempfstartingloc.append(sshiftstartingTAZ[i][0])\n",
    "            if(fulltimedrivershift[i]>=3):\n",
    "                tempfstartingloc.append(tshiftstartingTAZ[i][0])\n",
    "        sortedtime = sorted(tempfstartingtime)\n",
    "    #print(tempfstartingtime)\n",
    "    #print(tempfduration)\n",
    "        if(fulltimedrivershift[i]!=0):\n",
    "            driverid = 1\n",
    "            for k in range(len(sortedtime)):\n",
    "                tempdriver = []\n",
    "                temploc = tempfstartingtime.index(sortedtime[k])\n",
    "                tempdriver.append(\"ParttimeDriver\"+str(i)+\"shift\"+str(driverid))\n",
    "                tempdriver.append(tempfduration[temploc])\n",
    "                tempdriver.append(tempfstartingtime[temploc])\n",
    "                tempdriver.append(tempfstartingloc[k])\n",
    "                tempdriver.append(2)\n",
    "                driverid+=1\n",
    "                driverfullorder.append(tempdriver)\n",
    "        #print(tempdriver)\n",
    "    #break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 161,
   "id": "f7e84f07",
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('Parttimedriver_ln3.csv', 'w', newline='') as file:\n",
    "    writer = csv.writer(file)\n",
    "    for i in driverfullorder:\n",
    "            writer.writerow(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "59c7610c",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "164f254b",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.9.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}