diff --git a/.gitattributes b/.gitattributes index 5020a1ffb6459bae64d573f389d3a080cc43634b..528588774bf0b9ea52c886881579449b40311174 100644 --- a/.gitattributes +++ b/.gitattributes @@ -111,3 +111,58 @@ ved_2/VED_181017_week.csv filter=lfs diff=lfs merge=lfs -text ved_2/VED_181024_week.csv filter=lfs diff=lfs merge=lfs -text ved_2/VED_181031_week.csv filter=lfs diff=lfs merge=lfs -text ved_2/VED_181107_week.csv filter=lfs diff=lfs merge=lfs -text +code/visualize-osm-data.ipynb filter=lfs diff=lfs merge=lfs -text +eVED/eVED_171101_week.csv filter=lfs diff=lfs merge=lfs -text +eVED/eVED_171108_week.csv filter=lfs diff=lfs merge=lfs -text +eVED/eVED_171115_week.csv filter=lfs diff=lfs merge=lfs -text +eVED/eVED_171122_week.csv filter=lfs diff=lfs merge=lfs -text +eVED/eVED_171129_week.csv filter=lfs diff=lfs merge=lfs -text +eVED/eVED_171206_week.csv filter=lfs diff=lfs merge=lfs -text +eVED/eVED_171213_week.csv filter=lfs diff=lfs merge=lfs -text +eVED/eVED_171220_week.csv filter=lfs diff=lfs merge=lfs -text +eVED/eVED_171227_week.csv filter=lfs diff=lfs merge=lfs -text +eVED/eVED_180103_week.csv filter=lfs diff=lfs merge=lfs -text +eVED/eVED_180110_week.csv filter=lfs diff=lfs merge=lfs -text +eVED/eVED_180117_week.csv filter=lfs diff=lfs merge=lfs -text +eVED/eVED_180124_week.csv filter=lfs diff=lfs merge=lfs -text +eVED/eVED_180131_week.csv filter=lfs diff=lfs merge=lfs -text +eVED/eVED_180207_week.csv filter=lfs diff=lfs merge=lfs -text +eVED/eVED_180214_week.csv filter=lfs diff=lfs merge=lfs -text +eVED/eVED_180221_week.csv filter=lfs diff=lfs merge=lfs -text +eVED/eVED_180228_week.csv filter=lfs diff=lfs merge=lfs -text +eVED/eVED_180307_week.csv filter=lfs diff=lfs merge=lfs -text +eVED/eVED_180314_week.csv filter=lfs diff=lfs merge=lfs -text +eVED/eVED_180321_week.csv filter=lfs diff=lfs merge=lfs -text +eVED/eVED_180328_week.csv filter=lfs diff=lfs merge=lfs -text +eVED/eVED_180404_week.csv filter=lfs diff=lfs merge=lfs -text +eVED/eVED_180411_week.csv filter=lfs diff=lfs merge=lfs -text +eVED/eVED_180418_week.csv filter=lfs diff=lfs merge=lfs -text +eVED/eVED_180425_week.csv filter=lfs diff=lfs merge=lfs -text +eVED/eVED_180502_week.csv filter=lfs diff=lfs merge=lfs -text +eVED/eVED_180509_week.csv filter=lfs diff=lfs merge=lfs -text +eVED/eVED_180516_week.csv filter=lfs diff=lfs merge=lfs -text +eVED/eVED_180523_week.csv filter=lfs diff=lfs merge=lfs -text +eVED/eVED_180530_week.csv filter=lfs diff=lfs merge=lfs -text +eVED/eVED_180606_week.csv filter=lfs diff=lfs merge=lfs -text +eVED/eVED_180613_week.csv filter=lfs diff=lfs merge=lfs -text +eVED/eVED_180620_week.csv filter=lfs diff=lfs merge=lfs -text +eVED/eVED_180627_week.csv filter=lfs diff=lfs merge=lfs -text +eVED/eVED_180704_week.csv filter=lfs diff=lfs merge=lfs -text +eVED/eVED_180711_week.csv filter=lfs diff=lfs merge=lfs -text +eVED/eVED_180718_week.csv filter=lfs diff=lfs merge=lfs -text +eVED/eVED_180725_week.csv filter=lfs diff=lfs merge=lfs -text +eVED/eVED_180801_week.csv filter=lfs diff=lfs merge=lfs -text +eVED/eVED_180808_week.csv filter=lfs diff=lfs merge=lfs -text +eVED/eVED_180815_week.csv filter=lfs diff=lfs merge=lfs -text +eVED/eVED_180822_week.csv filter=lfs diff=lfs merge=lfs -text +eVED/eVED_180829_week.csv filter=lfs diff=lfs merge=lfs -text +eVED/eVED_180905_week.csv filter=lfs diff=lfs merge=lfs -text +eVED/eVED_180912_week.csv filter=lfs diff=lfs merge=lfs -text +eVED/eVED_180919_week.csv filter=lfs diff=lfs merge=lfs -text +eVED/eVED_180926_week.csv filter=lfs diff=lfs merge=lfs -text +eVED/eVED_181003_week.csv filter=lfs diff=lfs merge=lfs -text +eVED/eVED_181010_week.csv filter=lfs diff=lfs merge=lfs -text +eVED/eVED_181017_week.csv filter=lfs diff=lfs merge=lfs -text +eVED/eVED_181024_week.csv filter=lfs diff=lfs merge=lfs -text +eVED/eVED_181031_week.csv filter=lfs diff=lfs merge=lfs -text +eVED/eVED_181107_week.csv filter=lfs diff=lfs merge=lfs -text diff --git a/code/EnergyConsumptionCalculation.ipynb b/code/EnergyConsumptionCalculation.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..01e1987007e850f8a7218369ec4e34f7aa0c01a0 --- /dev/null +++ b/code/EnergyConsumptionCalculation.ipynb @@ -0,0 +1,451 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "id": "ZS2siGtqyq-f" + }, + "outputs": [], + "source": [ + "import pandas as pd\n", + "import numpy as np\n", + "import math\n", + "import os\n", + "import datetime\n", + "import matplotlib.pyplot as plt\n", + "import math" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# Paths for input and output\n", + "path_in = \"./../data/\"\n", + "path_out = \"./../data/\"" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "id": "6SyijUrB4Y8t" + }, + "outputs": [], + "source": [ + "# Create dictionary for mapping of VehId to Vehicle_Type\n", + "df_IceHev = pd.read_excel (path_in+'/VED_Static_Data_ICE&HEV.xlsx')\n", + "df_IceHev.rename(columns={'Vehicle Type': 'Vehicle_Type'}, inplace=True)\n", + "df_PhevEv = pd.read_excel (path_in+'/VED_Static_Data_PHEV&EV.xlsx')\n", + "df_PhevEv.rename(columns={'EngineType': 'Vehicle_Type'}, inplace=True)\n", + "df_VehId = df_IceHev.append(df_PhevEv, ignore_index = True)\n", + "df_VehId.sort_values(by='VehId', inplace=True)\n", + "df_VehId = df_VehId.set_index('VehId')\n", + "pd.set_option(\"display.max_rows\", None, \"display.max_columns\", None)\n", + "dictVehId = df_VehId.to_dict('index')\n", + "#dictVehId[12]['Vehicle_Type']" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "7KE0rghhp9YV" + }, + "source": [ + "# Energy Consumption Calculation" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "id": "LgwTfDyYarGs", + "scrolled": false + }, + "outputs": [], + "source": [ + "def calculateEnergyConsumption(df):\n", + " df_org = df.copy()\n", + " column_name = 'Energy_Consumption'\n", + " if column_name not in df.columns:\n", + " #print(\"Create column\", column_name)\n", + " df[column_name] = \"\"\n", + "\n", + " arr_VehId = df[[\"VehId\" , \"Vehicle Speed[km/h]\", \"MAF[g/sec]\", \"Short Term Fuel Trim Bank 1[%]\", \"Long Term Fuel Trim Bank 1[%]\", \"HV Battery Current[A]\", \"HV Battery Voltage[V]\", column_name]].to_numpy()\n", + " list_Energy_Consumption = []\n", + " for row in arr_VehId:\n", + " vehicle_type = dictVehId[row[0]]['Vehicle_Type']\n", + " if vehicle_type == \"ICE\" or vehicle_type == \"HEV\":\n", + " '''\n", + " The formula to calculate the energy consumption is as following:\n", + "\n", + " Energy consumption=DrivingLength/100*MassAirFlow*(1+ShortTermFuelTrimBank1/100+LongTermFuelTrimBank1/100)/AirFuelRation\n", + "\n", + " where the Mass Air Flow is measured by gallon per second, Driving Length is measured by km, and the Air Fuel \n", + " Ration is provided with the value of 14.08 according to a literature:\n", + "\n", + " G. Oh, D. J. Leblanc and H. Peng, \"Vehicle Energy Dataset (VED), A Large-Scale Dataset for Vehicle Energy \n", + " Consumption Research,\" in IEEE Transactions on Intelligent Transportation Systems, \n", + " doi: 10.1109/TITS.2020.3035596.\n", + " '''\n", + " #print(\"ICE or HEV found\")\n", + " # calculate energy consumption\n", + " # /3600 as sampling rate is 1 sec ; value from \"Vehicle Speed[km/h]\"\n", + " # The reason is as following:\n", + " # row[1] is measured by km/h, which is treated to be the constant value during the sampling time of one second.\n", + " # So, if we need to calculate the length during each sampling time, we need to multiple the speed (measured by km/h) by the duration (measured by h), which lead to:\n", + " # row[1]*1/60/60=row[1]/3600\n", + " DrivingLength = row[1] / 3600 # row[1] = Vehicle Speed[km/h]\n", + " MassAirFlow = row[2] * 3.78541 # recalculation from gallons to liters; value from \"MAF[g/sec]\"\n", + " ShortTermFuelTrimBank1 = row[3] # value from \"Short Term Fuel Trim Bank 1[%]\"\n", + " LongTermFuelTrimBank1 = row[4] # value from \"Long Term Fuel Trim Bank 1[%]\"\n", + " AirFuelRation = 14.08\n", + " #print(\"Length=\", DrivingLength, \"MassAirFlow=\", MassAirFlow, \"ShortTermFuelTrimBank1=\", ShortTermFuelTrimBank1, \"LongTermFuelTrimBank1=\", LongTermFuelTrimBank1)\n", + " in_liter_per_hour=DrivingLength/100*MassAirFlow*(1+ShortTermFuelTrimBank1/100+LongTermFuelTrimBank1/100)/AirFuelRation\n", + " # recalcualte energy consuption into kWh ; 1 kw*h = 0.1123 liter\n", + " in_kilo_watts_perHour = in_liter_per_hour / 0.1123\n", + " #if not math.isnan(in_kilo_watts_perHour):\n", + " # print(\"EC =\", in_kilo_watts_perHour, \"kWh (\", in_liter_per_hour, \")\" )\n", + " list_Energy_Consumption.append(in_kilo_watts_perHour)\n", + "\n", + " elif vehicle_type == \"PHEV\" or vehicle_type == \"EV\":\n", + " '''\n", + " The energy consumption for EV can be calculated by integrating the voltage and current of the EV battery over \n", + " time, and this energy consumption can be measured by kw*h.\n", + "\n", + " The convert between EV energy consumption (kw*h) and gas consumption (measured by liter) can be achieved as \n", + " following:\n", + "\n", + " 1 kw*h = 0.1123 liter\n", + "\n", + " The EV energy consumption calculation can be referred from: \n", + " https://www.google.com/url?sa=t&rct=j&q=&esrc=s&source=web&cd=&cad=rja&uact=8&ved=2ahUKEwiY3Jzc3K70AhVpo4sKHTLUA9gQFnoECAYQAQ&url=https%3A%2F%2Fwww.mdpi.com%2F1996-1073%2F8%2F8%2F8573%2Fpdf&usg=AOvVaw3LyboWSueHI9UM0mJe5ypq\n", + "\n", + " The convert from kw*h to liter can be referred from: \n", + " https://en.wikipedia.org/wiki/Miles_per_gallon_gasoline_equivalent#Description\n", + " '''\n", + " #print(\"PHEV or EV found\")\n", + " # calculate energy consumption\n", + " in_watts = row[5] * row[6] * (-1) # = \"HV Battery Current[A]\" * \"HV Battery Voltage[V]\", *(-1) EV formula needs to interpreted in that way that the consumed energy is negative while the produced one is positive\n", + " in_kilo_watts = in_watts / 1000\n", + " # recalcualte energy consuption into kWh\n", + " # measurement of A in 1 sec ; V in 5 sec => Therefore one line covers the smaller unit 1 second\n", + " #print(\"HV Battery Current[A]\", row[5], \"HV Battery Voltage[V]\", row[6])\n", + " in_kilo_watts_perHour = in_kilo_watts / 3600\n", + " #print(\"EC =\", in_kilo_watts_perHour, \"kWh (\", in_kilo_watts, in_watts, \")\" )\n", + " list_Energy_Consumption.append(in_kilo_watts_perHour)\n", + "\n", + " else:\n", + " print(\"Unknown Vehicle_Type\", row[0], \"found\")\n", + "\n", + " #df['Energy_Consumption'] = list_Energy_Consumption\n", + " df_org['Energy_Consumption'] = list_Energy_Consumption\n", + " return df_org" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "j0syPBlrjmrd" + }, + "source": [ + "# Reworking of all original files" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "list_files = [] \n", + "for file in os.listdir(path_in):\n", + " if file.endswith(\"_week.csv\"):\n", + " list_files.append(file)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Execution time = VED_171101_week.csv : 9.888816118240356\n", + "Execution time = VED_171108_week.csv : 9.541045904159546\n", + "Execution time = VED_171115_week.csv : 10.846029043197632\n", + "Execution time = VED_171122_week.csv : 8.577940940856934\n", + "Execution time = VED_171129_week.csv : 9.552509069442749\n", + "Execution time = VED_171206_week.csv : 10.801214933395386\n", + "Execution time = VED_171213_week.csv : 12.398997068405151\n", + "Execution time = VED_171220_week.csv : 9.741503953933716\n", + "Execution time = VED_171227_week.csv : 5.659049987792969\n", + "Execution time = VED_180103_week.csv : 7.128296136856079\n", + "Execution time = VED_180110_week.csv : 10.233113050460815\n", + "Execution time = VED_180117_week.csv : 9.690773963928223\n", + "Execution time = VED_180124_week.csv : 8.43485403060913\n", + "Execution time = VED_180131_week.csv : 8.949444055557251\n", + "Execution time = VED_180207_week.csv : 7.7250587940216064\n", + "Execution time = VED_180214_week.csv : 7.392001152038574\n", + "Execution time = VED_180221_week.csv : 5.865344047546387\n", + "Execution time = VED_180228_week.csv : 7.966830015182495\n", + "Execution time = VED_180307_week.csv : 7.3129050731658936\n", + "Execution time = VED_180314_week.csv : 7.454961061477661\n", + "Execution time = VED_180321_week.csv : 7.334964990615845\n", + "Execution time = VED_180328_week.csv : 6.493051052093506\n", + "Execution time = VED_180404_week.csv : 8.315284013748169\n", + "Execution time = VED_180411_week.csv : 7.657871961593628\n", + "Execution time = VED_180418_week.csv : 8.63765001296997\n", + "Execution time = VED_180425_week.csv : 7.897945880889893\n", + "Execution time = VED_180502_week.csv : 7.535109996795654\n", + "Execution time = VED_180509_week.csv : 7.370058059692383\n", + "Execution time = VED_180516_week.csv : 8.234884977340698\n", + "Execution time = VED_180523_week.csv : 7.743973970413208\n", + "Execution time = VED_180530_week.csv : 7.505343914031982\n", + "Execution time = VED_180606_week.csv : 7.749966144561768\n", + "Execution time = VED_180613_week.csv : 6.840182065963745\n", + "Execution time = VED_180620_week.csv : 9.27295184135437\n", + "Execution time = VED_180627_week.csv : 10.812565088272095\n", + "Execution time = VED_180704_week.csv : 6.055830001831055\n", + "Execution time = VED_180711_week.csv : 7.213330984115601\n", + "Execution time = VED_180718_week.csv : 7.271965980529785\n", + "Execution time = VED_180725_week.csv : 5.97207498550415\n", + "Execution time = VED_180801_week.csv : 6.417394161224365\n", + "Execution time = VED_180808_week.csv : 6.360198974609375\n", + "Execution time = VED_180815_week.csv : 5.3010618686676025\n", + "Execution time = VED_180822_week.csv : 5.262967109680176\n", + "Execution time = VED_180829_week.csv : 6.512995958328247\n", + "Execution time = VED_180905_week.csv : 9.022238969802856\n", + "Execution time = VED_180912_week.csv : 7.027529001235962\n", + "Execution time = VED_180919_week.csv : 6.726388931274414\n", + "Execution time = VED_180926_week.csv : 6.687731027603149\n", + "Execution time = VED_181003_week.csv : 6.175661087036133\n", + "Execution time = VED_181010_week.csv : 5.615024089813232\n", + "Execution time = VED_181017_week.csv : 7.1177568435668945\n", + "Execution time = VED_181024_week.csv : 7.9306700229644775\n", + "Execution time = VED_181031_week.csv : 6.453009128570557\n", + "Execution time = VED_181107_week.csv : 2.064950942993164\n", + "Execution time overall = 415.75856614112854\n" + ] + } + ], + "source": [ + "time_overall_start = datetime.datetime.now().timestamp()\n", + "for file in list_files:\n", + " time_start = datetime.datetime.now().timestamp()\n", + " df = pd.read_csv (path_in + file)\n", + " #print(df.info())\n", + " df = calculateEnergyConsumption(df)\n", + " #print(df.Energy_Consumption.describe())\n", + " #print(df.info())\n", + " df.to_csv(path_out + file, index=False, na_rep='nan')\n", + " time_end = datetime.datetime.now().timestamp()\n", + " print(\"Execution time = \", file, \":\", (time_end-time_start))\n", + " \n", + " #break\n", + " \n", + "time_overall_end = datetime.datetime.now().timestamp()\n", + "print(\"Execution time overall = \", (time_overall_end-time_overall_start))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "M9tmmfISv6tM" + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Evaluation of generated Energy Consumption" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "def boxplot_EC_perVehicleType(df, surpress=False):\n", + " arr_VehId = df[[\"VehId\" , \"Energy_Consumption\"]].to_numpy()\n", + " list_EC_ICE = []\n", + " list_EC_EV = []\n", + " for row in arr_VehId:\n", + " vehicle_type = dictVehId[row[0]]['Vehicle_Type']\n", + " if vehicle_type == \"ICE\" or vehicle_type == \"HEV\":\n", + " if not math.isnan(row[1]):\n", + " #print(vehicle_type, row[1])\n", + " list_EC_ICE.append(row[1])\n", + " elif vehicle_type == \"PHEV\" or vehicle_type == \"EV\":\n", + " if not math.isnan(row[1]):\n", + " #print(vehicle_type, row[1])\n", + " list_EC_EV.append(row[1])\n", + " else:\n", + " print(\"Unknown Vehicle_Type\", row[0], \"found\")\n", + " \n", + " # Creating plot\n", + " if not surpress:\n", + " fig = plt.figure(figsize =(10, 7))\n", + " plt.subplot(1, 2, 1)\n", + " plt.title('EC for ICE/HEV vehicles')\n", + " plt.boxplot(list_EC_ICE)\n", + "\n", + " plt.subplot(1, 2, 2)\n", + " plt.title('EC for PHEV/EV vehicles')\n", + " plt.boxplot(list_EC_EV)\n", + "\n", + " # show plot\n", + " plt.show()\n", + " \n", + " avg_ICE = (sum(list_EC_ICE) / len(list_EC_ICE))\n", + " avg_EC = (sum(list_EC_EV) / len(list_EC_EV))\n", + " if not surpress:\n", + " print(\"Average EC ICE:\", avg_ICE)\n", + " print(\"Average EC EV:\", avg_EC)\n", + " \n", + " return [avg_ICE, avg_EC]" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Average EC ICE: 0.0032574152263156668\n", + "Average EC EV: 0.0011408219467592066\n" + ] + } + ], + "source": [ + "list_values = []\n", + "df_EC171101 = pd.read_csv (path_out+'VED_171101_week.csv')\n", + "list_values.append(boxplot_EC_perVehicleType(df_EC171101))" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "for file in os.listdir(path_out):\n", + " if file.endswith(\"_week.csv\"):\n", + " df_EC171115 = pd.read_csv (path_out+file)\n", + " list_values.append(boxplot_EC_perVehicleType(df_EC171115, True))" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "# line 1 points\n", + "x1 = list(range(1, len(list_values)+1))\n", + "y1 = [row[0] for row in list_values]\n", + "# plotting the line 1 points \n", + "plt.plot(x1, y1, label = \"ICE\")\n", + "# line 2 points\n", + "x2 = list(range(1, len(list_values)+1))\n", + "y2 = [row[1] for row in list_values]\n", + "# plotting the line 2 points \n", + "plt.plot(x2, y2, label = \"EV\")\n", + "plt.xlabel('Number of trip file')\n", + "# Set the y axis label of the current axis.\n", + "plt.ylabel('Energy Consumption')\n", + "# Set a title of the current axes.\n", + "plt.title('Average EC over all trip files')\n", + "# show a legend on the plot\n", + "plt.legend()\n", + "# Display a figure.\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "colab": { + "collapsed_sections": [], + "name": "EnergyConsumption.ipynb", + "provenance": [] + }, + "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.8.8" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/code/export-processed-data.ipynb b/code/export-processed-data.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..647006c1a07db8cd918e9ca45e95ccfb5574bee2 --- /dev/null +++ b/code/export-processed-data.ipynb @@ -0,0 +1,339 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "56055bd3", + "metadata": {}, + "source": [ + "### Exporting the processed intersections, bus stops and focus points to the VED files." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "b1e30678", + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "import pandas as pd\n", + "import numpy as np\n", + "from tqdm.notebook import tqdm\n", + "import folium\n", + "import csv" + ] + }, + { + "cell_type": "markdown", + "id": "0591f464", + "metadata": {}, + "source": [ + "Read three CSV files: intersections, focus points and bus stops." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "b380a50a", + "metadata": {}, + "outputs": [], + "source": [ + "intersections = pd.read_csv('../data/processed/joined_coords_intersections.csv').to_numpy()\n", + "focus_points = pd.read_csv('../data/processed/joined_layer_coords_focus_points.csv')\n", + "# combine different focus points in the 'highway' column\n", + "focus_points['highway'] = focus_points.bfill(1)['highway']\n", + "focus_points = focus_points.to_numpy()\n", + "busstops = pd.read_csv('../data/processed/joined_coords_bus_stops.csv').to_numpy()" + ] + }, + { + "cell_type": "markdown", + "id": "bf202e40", + "metadata": {}, + "source": [ + "Create dictionaries where keys are the latitude/longitude coordinates." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "2a3c3ebb", + "metadata": {}, + "outputs": [], + "source": [ + "intersections_dict = {(intersections[i,0], intersections[i,1]) : 1 for i in range(len(intersections))}\n", + "busstops_dict = {(busstops[i,0], busstops[i,1]) : 1 for i in range(len(busstops))}\n", + "focus_points_dict = {(focus_points[i,0], focus_points[i,1]) : focus_points[i,4] for i in range(len(focus_points))}" + ] + }, + { + "cell_type": "markdown", + "id": "170161c7", + "metadata": {}, + "source": [ + "Let's visualize some of the intersections. Folium map is slow if we try to plot all of them. Therefore, we will plot the first 1000 intersections." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "66bb6abd", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
Make this Notebook Trusted to load map: File -> Trust Notebook
" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "def plot_map(latlon):\n", + " tiles = \"cartodbpositron\"\n", + " map = folium.Map(prefer_canvas=True, tiles=tiles)\n", + " t = folium.TileLayer(tiles).add_to(map)\n", + " lats = [point[0] for point in latlon]\n", + " lons = [point[1] for point in latlon]\n", + " min_lat, max_lat = min(lats), max(lats)\n", + " min_lon, max_lon = min(lons), max(lons)\n", + " map.fit_bounds([[min_lat, min_lon], [max_lat, max_lon]])\n", + " for point in latlon:\n", + " folium.CircleMarker(\n", + " location=[point[0], point[1]], radius=2, fill=True, color='red',\n", + " popup='').add_to(map)\n", + " return map\n", + "\n", + "plot_map(list(intersections_dict.keys())[0:1000])" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "453d7ed7", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "f4c1c8888532499d99ef9a3b3122c2ad", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/54 [00:00\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
WKTosm_idhighwaymaxspeed:forwardmaxspeed:backwardsource:maxspeedmaxspeed:advisorymaxspeedmaxspeed:practical
0LINESTRING (-83.6889144 42.3061218,-83.6890468...4411729motorway_link0000025 mph
1LINESTRING (-83.7392397 42.2366692,-83.7392406...4439869secondary000035 mph0
2LINESTRING (-83.6855813 42.3070306,-83.6852592...4569607motorway_link0000025 mph
3LINESTRING (-83.8373697 42.2896413,-83.8366383...4569609motorway_link000070 mph0
4LINESTRING (-83.7733019 42.2692107,-83.7730861...4574780service000000
\n", + "" + ], + "text/plain": [ + " WKT osm_id highway \\\n", + "0 LINESTRING (-83.6889144 42.3061218,-83.6890468... 4411729 motorway_link \n", + "1 LINESTRING (-83.7392397 42.2366692,-83.7392406... 4439869 secondary \n", + "2 LINESTRING (-83.6855813 42.3070306,-83.6852592... 4569607 motorway_link \n", + "3 LINESTRING (-83.8373697 42.2896413,-83.8366383... 4569609 motorway_link \n", + "4 LINESTRING (-83.7733019 42.2692107,-83.7730861... 4574780 service \n", + "\n", + " maxspeed:forward maxspeed:backward source:maxspeed maxspeed:advisory \\\n", + "0 0 0 0 0 \n", + "1 0 0 0 0 \n", + "2 0 0 0 0 \n", + "3 0 0 0 0 \n", + "4 0 0 0 0 \n", + "\n", + " maxspeed maxspeed:practical \n", + "0 0 25 mph \n", + "1 35 mph 0 \n", + "2 0 25 mph \n", + "3 70 mph 0 \n", + "4 0 0 " + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "fields = ['WKT', 'osm_id', 'highway', 'maxspeed:forward', 'maxspeed:backward', 'source:maxspeed', \n", + " 'maxspeed:advisory', 'maxspeed', 'maxspeed:practical']\n", + "\n", + "\n", + "dtype = {'maxspeed:forward': 'str', 'maxspeed:backward': 'str', 'source:maxspeed': 'str',\n", + " 'maxspeed:advisory': 'str', 'maxspeed': 'str', 'maxspeed:practical': 'str'}\n", + "\n", + "roads_df = pd.read_csv('../data/osm/highways-lines-layer.csv', usecols=fields, dtype=dtype).fillna('0')\n", + "roads_df.head()" + ] + }, + { + "cell_type": "markdown", + "id": "33674615", + "metadata": {}, + "source": [ + "Build a dictionary of roads, where keys are the OSM IDs and the values are the coordinates of the nodes in each road." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "ff3a1d34", + "metadata": {}, + "outputs": [], + "source": [ + "roads_arr = roads_df.to_numpy()\n", + "roads_dict = {roads_arr[i,1]: loads(roads_arr[i,0]) for i in range(len(roads_arr))}" + ] + }, + { + "cell_type": "markdown", + "id": "4725b1fc", + "metadata": {}, + "source": [ + "Convert the roads DataFrame to GeoDataFrame." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "7ffb3615", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
osm_idhighwaymaxspeed:forwardmaxspeed:backwardsource:maxspeedmaxspeed:advisorymaxspeedmaxspeed:practicalgeometry
04411729motorway_link0000025 mphLINESTRING (-83.68891 42.30612, -83.68905 42.3...
14439869secondary000035 mph0LINESTRING (-83.73924 42.23667, -83.73924 42.2...
24569607motorway_link0000025 mphLINESTRING (-83.68558 42.30703, -83.68526 42.3...
34569609motorway_link000070 mph0LINESTRING (-83.83737 42.28964, -83.83664 42.2...
44574780service000000LINESTRING (-83.77330 42.26921, -83.77309 42.2...
\n", + "
" + ], + "text/plain": [ + " osm_id highway maxspeed:forward maxspeed:backward source:maxspeed \\\n", + "0 4411729 motorway_link 0 0 0 \n", + "1 4439869 secondary 0 0 0 \n", + "2 4569607 motorway_link 0 0 0 \n", + "3 4569609 motorway_link 0 0 0 \n", + "4 4574780 service 0 0 0 \n", + "\n", + " maxspeed:advisory maxspeed maxspeed:practical \\\n", + "0 0 0 25 mph \n", + "1 0 35 mph 0 \n", + "2 0 0 25 mph \n", + "3 0 70 mph 0 \n", + "4 0 0 0 \n", + "\n", + " geometry \n", + "0 LINESTRING (-83.68891 42.30612, -83.68905 42.3... \n", + "1 LINESTRING (-83.73924 42.23667, -83.73924 42.2... \n", + "2 LINESTRING (-83.68558 42.30703, -83.68526 42.3... \n", + "3 LINESTRING (-83.83737 42.28964, -83.83664 42.2... \n", + "4 LINESTRING (-83.77330 42.26921, -83.77309 42.2... " + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "roads_df['geometry'] = roads_df.WKT.apply(wkt.loads)\n", + "roads_df.drop('WKT', axis=1, inplace=True) #Drop WKT column\n", + "\n", + "roads_gdf = gpd.GeoDataFrame(roads_df, geometry='geometry')\n", + "roads_gdf.head()" + ] + }, + { + "cell_type": "markdown", + "id": "00f520db", + "metadata": {}, + "source": [ + "Function that calculates the bearing of the two points whose coordinates are given in the parameters." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "d378fee8", + "metadata": {}, + "outputs": [], + "source": [ + "def get_bearing(lat1, lat2, lon1, lon2):\n", + " \"\"\" Calculate the initial bearing for start point (lat1, lon1) and end point (lat2, lon2) \"\"\"\n", + " lat1, lat2 = math.radians(lat1), math.radians(lat2), \n", + " lon1, lon2 = math.radians(lon1), math.radians(lon2)\n", + " dLon = lon2 - lon1\n", + " y = math.sin(dLon) * math.cos(lat2)\n", + " x = math.cos(lat1) * math.sin(lat2) - math.sin(lat1) * math.cos(lat2) * math.cos(dLon)\n", + " brng = math.atan2(y, x)\n", + " return brng" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "27a18498", + "metadata": {}, + "outputs": [], + "source": [ + "def mph2kph(speed):\n", + " return round(speed * 1.609344)\n", + "\n", + "def speed2numeric(speed):\n", + " return mph2kph(int(speed.split()[0]))" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "fa9cda87", + "metadata": {}, + "outputs": [], + "source": [ + "def_maxspeed = {'residential': (1, speed2numeric('25 mph')), \n", + " 'motorway': (1, speed2numeric('70 mph')), \n", + " 'trunk': (1, speed2numeric('55 mph')),\n", + " 'primary': (1, speed2numeric('55 mph')),\n", + " 'secondary': (1, speed2numeric('45 mph')),\n", + " 'tertiary': (1, speed2numeric('35 mph')),\n", + " 'unclassified': (1, speed2numeric('55 mph')),\n", + " 'service': (1, speed2numeric('25 mph'))}\n", + "\n", + "\n", + "def get_speed(highway, maxspeed):\n", + " \"\"\" Returns two values, the class of the speed limit and the speed limit.\"\"\"\n", + " if maxspeed['maxspeed'] != '0':\n", + " return 0, speed2numeric(maxspeed['maxspeed'])\n", + " elif maxspeed['maxspeed:forward'] != '0':\n", + " sp = '{}-{}'.format(speed2numeric(maxspeed['maxspeed:forward']), \n", + " speed2numeric(maxspeed['maxspeed:backward']))\n", + " return -1, sp\n", + " elif maxspeed['maxspeed:advisory'] != '0':\n", + " return 2, speed2numeric(maxspeed['maxspeed:advisory'])\n", + " elif maxspeed['maxspeed:practical'] != '0':\n", + " return 3, str(speed2numeric(maxspeed['maxspeed:practical']))\n", + " else:\n", + " return def_maxspeed.get(highway, (np.nan, np.nan))" + ] + }, + { + "cell_type": "markdown", + "id": "c1ac5816", + "metadata": {}, + "source": [ + "The function below looks a bit messy and could probably be written in a clearer and better way, but it does the job. It first checks if the current point has two different speed limits depending on the direction (is of class -1). If so, it saves the coordinates of this point and goes forward until it finds a point in the same trip that has different coordinates. It then uses these two points to calculate the bearing and decides on the direction of travel. The second case is when the road the point lies has the same speed limit regardless of the direction. In such case, it checks if the point that follows along the same trip is of class -1. If this is the case, it uses these two points to decide on the direction and updates all duplicate points (if any) that follow. " + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "8b5872c1", + "metadata": {}, + "outputs": [], + "source": [ + "# 1: VehId, 2: Trip, 4: Latitude, 5: Longitude, 22: matched_lat, 23: matched_lon, 24: match_type\n", + "\n", + "def set_direction_sp(records):\n", + " np_arr = np.zeros(len(records)) # set the size to the correct one\n", + " for i in range(len(records)):\n", + " p_lat1, p_lon1 = records[i, 22], records[i, 23]\n", + "\n", + " if records[i, 25] == -1 and np_arr[i] == 0:\n", + " j = i\n", + " osm_id = records[i, 27]\n", + " road_lon1, road_lat1 = roads_dict[osm_id].coords[0]\n", + " road_lon2, road_lat2 = roads_dict[osm_id].coords[-1]\n", + "\n", + " while (records[j, 4] == records[i, 4]) and \\\n", + " (records[j, 5] == records[i, 5]) and \\\n", + " (records[j, 1] == records[i, 1]) and \\\n", + " (records[j, 2] == records[i, 2]) and \\\n", + " (j < len(records)-1):\n", + " j += 1\n", + "\n", + " if i != j:\n", + " p_lat2, p_lon2 = records[j, 22], records[j, 23]\n", + " # perform the computations and update all relevant rows\n", + " br1 = get_bearing(p_lat1, p_lat2, p_lon1, p_lon2)\n", + " br2 = get_bearing(road_lat1, road_lat2, road_lon1, road_lon2)\n", + " direction = math.cos(br1-br2)\n", + " speed = None\n", + "\n", + " while i <= j:\n", + " if records[i, 25] == -1:\n", + " if direction > 0: # same direction\n", + " # extract the correct speed limit and set it\n", + " speed = records[i, 26].split('-')[0]\n", + " else:\n", + " speed = records[i, 26].split('-')[1]\n", + " else:\n", + " speed = records[i, 26]\n", + " np_arr[i] = speed\n", + " i += 1\n", + " else:\n", + " np_arr[i] = records[i, 26]\n", + " else:\n", + " if np_arr[i] == 0:\n", + " np_arr[i] = records[i, 26]\n", + " j = i + 1\n", + " if j < len(records):\n", + " if records[j, 25] == -1:\n", + " i = j\n", + " p_lat2, p_lon2 = records[i, 22], records[i, 23]\n", + " osm_id = records[i, 27]\n", + " road_lon1, road_lat1 = roads_dict[osm_id].coords[0]\n", + " road_lon2, road_lat2 = roads_dict[osm_id].coords[-1]\n", + " \n", + " while (records[j, 4] == records[i, 4]) and \\\n", + " (records[j, 5] == records[i, 5]) and \\\n", + " (records[j, 1] == records[i, 1]) and \\\n", + " (records[j, 2] == records[i, 2]) and \\\n", + " (j < len(records)-1):\n", + " j += 1\n", + " \n", + " # perform the computations and update all relevant rows\n", + " br1 = get_bearing(p_lat1, p_lat2, p_lon1, p_lon2)\n", + " br2 = get_bearing(road_lat1, road_lat2, road_lon1, road_lon2)\n", + " direction = math.cos(br1-br2)\n", + " speed = None\n", + " while i <= j:\n", + " if records[i, 25] == -1:\n", + " if direction > 0: # same direction\n", + " # extract the correct speed limit and set it\n", + " speed = records[i, 26].split('-')[0]\n", + " else:\n", + " speed = records[i, 26].split('-')[1]\n", + " else:\n", + " speed = records[i, 26]\n", + " np_arr[i] = speed\n", + " i += 1\n", + " return np_arr" + ] + }, + { + "cell_type": "markdown", + "id": "401d6fd8", + "metadata": {}, + "source": [ + "Read all files that contain the matched coordinates." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "a4bd3a80", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "3bfd0cb4118a4746b51862d20096674a", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/54 [00:00