From a49e185a63cc95be9a90671eaa50515f8595fcfb Mon Sep 17 00:00:00 2001 From: Toru Seo <34780089+toruseo@users.noreply.github.com> Date: Tue, 30 Jul 2024 15:53:14 +0900 Subject: [PATCH] Create demo_notebook_08en_chicago.ipynb --- .../demo_notebook_08en_chicago.ipynb | 711 ++++++++++++++++++ 1 file changed, 711 insertions(+) create mode 100644 demos_and_examples/demo_notebook_08en_chicago.ipynb diff --git a/demos_and_examples/demo_notebook_08en_chicago.ipynb b/demos_and_examples/demo_notebook_08en_chicago.ipynb new file mode 100644 index 0000000..ddc2637 --- /dev/null +++ b/demos_and_examples/demo_notebook_08en_chicago.ipynb @@ -0,0 +1,711 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib inline" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Huge-scale simulation using Chicago-Sketch dataset\n", + "\n", + "In this example, we demonstrate how UXsim can be used for huge-scale simulation in metropolitan area. We use [Chicago-Sketch](https://github.com/bstabler/TransportationNetworks/tree/master/Chicago-Sketch) dataset provided by Transportation Networks for Research. The scenario data for UXsim is derived from the original TNTP dataset and provided as [`chicago_sketch.uxsim_scenario`](https://github.com/toruseo/UXsim/blob/main/dat/chicago_sketch.uxsim_scenario) at UXsim repo. The code generated UXsim scenario file is attached to the end of this notebook.\n", + "\n", + "The dataset contains an abstract road network of Chicago metropolitan area with 546 nodes and 2176 links. The traffic demand is almost 1 million vehicles for 1 hour in the peak period. Note that the data is modified from the original dataset in order to make them suitable for UXsim.\n", + "\n", + "With this scale, we cannot simulate each individual vehicle one by one due to extremely high computational cost. Instead, by leveraging the mesoscopic nature of UXsim, we aggregate some vehicles into 1 platoon and simulate their behavior. This is achieved by changing `deltan` argument of `World`. This is very efficient approach as it does not only reduce the number of agents, but also reduce the number of time steps for the same time duration. It is known that the underlying traffic flow model output the equivalent results for within-link traffic dynamics regardless of `deltan` value. The network-scale dynamics will change as this setting alters inter-link traffic behavior, but this can be considered as an acceptable cost for the efficiency.\n", + "\n", + "By loading the pre-defined scenario file `dat/chicago_sketch.uxsim_scenario`, this simulation can be done easily as follows." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "loading scenario from 'dat/chicago_sketch.uxsim_scenario'\n", + " DATA SOURCE AND LICENCE : Chicago-Sketch network. This is based on https://github.com/bstabler/TransportationNetworks/tree/master/Chicago-Sketch by Transportation Networks for Research Core Team. Users need to follow their licence. Especially, this data is for academic research purposes only, and users must indicate the source of any dataset they are using in any publication that relies on any of the datasets provided in this web site.\n", + " Number of loaded nodes: 546\n", + " Number of loaded links: 2176\n", + " Number of loaded `adddemand`s: 8406\n", + "simulation setting:\n", + " scenario name: \n", + " simulation duration:\t 10000 s\n", + " number of vehicles:\t 968520 veh\n", + " total road length:\t 12115219.047323605 m\n", + " time discret. width:\t 30 s\n", + " platoon size:\t\t 30 veh\n", + " number of timesteps:\t 333\n", + " number of platoons:\t 32284\n", + " number of links:\t 2176\n", + " number of nodes:\t 546\n", + " setup time:\t\t 3.93 s\n", + "simulating...\n", + " time| # of vehicles| ave speed| computation time\n", + " 0 s| 0 vehs| 0.0 m/s| 0.01 s\n", + " 600 s| 61170 vehs| 17.0 m/s| 2.54 s\n", + " 1200 s| 125430 vehs| 15.6 m/s| 5.21 s\n", + " 1800 s| 173760 vehs| 14.2 m/s| 8.57 s\n", + " 2400 s| 220560 vehs| 12.3 m/s| 12.09 s\n", + " 3000 s| 267330 vehs| 10.4 m/s| 15.69 s\n", + " 3600 s| 322110 vehs| 8.5 m/s| 19.42 s\n", + " 4200 s| 249960 vehs| 7.7 m/s| 22.84 s\n", + " 4800 s| 190860 vehs| 8.0 m/s| 25.55 s\n", + " 5400 s| 156390 vehs| 8.5 m/s| 27.73 s\n", + " 6000 s| 120330 vehs| 9.6 m/s| 29.55 s\n", + " 6600 s| 93360 vehs| 10.0 m/s| 30.98 s\n", + " 7200 s| 70560 vehs| 11.1 m/s| 32.20 s\n", + " 7800 s| 46410 vehs| 12.6 m/s| 33.12 s\n", + " 8400 s| 26340 vehs| 15.4 m/s| 33.83 s\n", + " 9000 s| 11850 vehs| 17.9 m/s| 34.35 s\n", + " 9600 s| 5400 vehs| 20.8 m/s| 34.75 s\n", + " 9960 s| 3870 vehs| 22.3 m/s| 34.90 s\n", + " simulation finished\n", + "results:\n", + " average speed:\t 11.3 m/s\n", + " number of completed trips:\t 964650 / 968520\n", + " average travel time of trips:\t 1581.4 s\n", + " average delay of trips:\t 953.2 s\n", + " delay ratio:\t\t\t 0.603\n" + ] + } + ], + "source": [ + "from uxsim import *\n", + "\n", + "W = World(\n", + " name=\"\",\n", + " deltan=30, #for huge scale simulation (e.g., 100000+ vehicles or 1000+ links), large deltan is recommended. \n", + " tmax=10000,\n", + " print_mode=1, save_mode=1, show_mode=1,\n", + " random_seed=42,\n", + ")\n", + "\n", + "W.load_scenario(\"dat/chicago_sketch.uxsim_scenario\")\n", + "\n", + "W.exec_simulation()\n", + "W.analyzer.print_simple_stats()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You can see that the simulation finishes in about 40 seconds. Now let's visualize the results." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " generating animation...\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "44c676e0048241a7be397c847d2a6553", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/167 [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "W.analyzer.network_fancy(animation_speed_inverse=10, sample_ratio=0.2, interval=5, trace_length=10, figsize=6, antialiasing=True)\n", + "display_image_in_notebook(\"out/anim_network_fancy.gif\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You can see a peak hour traffic congestion at the downtown area." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Validation" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The original TNTP dataset includes traffic volumes and travel time of every links based on static static assignment. Since *static* traffic assignment and *dynamic* traffic assignment of UXsim is substantially different, these results will not match exactly. Nevertheless, it would be worth comparing these results to see whether UXsim outputs plausible results or not.\n", + "\n", + "First, read the link traffic states of UXsim.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "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", + " \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", + "
linkstart_nodeend_nodetraffic_volumevehicles_remainfree_travel_timeaverage_travel_timestddiv_travel_time
038738839012090665.400000662.6270272.699014
13883883914200358.800000334.59459510.561172
2389388708900174.000000161.09909912.496454
339038880200286.800000-1.000000-1.000000
4391389390300260.400000266.6558564.573892
...........................
2171294192944230001322.9499001347.9692127.128038
21722943930518001543.188079-1.000000-1.000000
21732945931906300911.461779923.6535828.796265
2174294793251500420.142347-1.000000-1.000000
2175294993353449800357.600000407.70450523.938101
\n", + "

2176 rows × 8 columns

\n", + "
" + ], + "text/plain": [ + " link start_node end_node traffic_volume vehicles_remain \\\n", + "0 387 388 390 120 90 \n", + "1 388 388 391 420 0 \n", + "2 389 388 708 90 0 \n", + "3 390 388 802 0 0 \n", + "4 391 389 390 30 0 \n", + "... ... ... ... ... ... \n", + "2171 2941 929 442 300 0 \n", + "2172 2943 930 518 0 0 \n", + "2173 2945 931 906 30 0 \n", + "2174 2947 932 515 0 0 \n", + "2175 2949 933 534 4980 0 \n", + "\n", + " free_travel_time average_travel_time stddiv_travel_time \n", + "0 665.400000 662.627027 2.699014 \n", + "1 358.800000 334.594595 10.561172 \n", + "2 174.000000 161.099099 12.496454 \n", + "3 286.800000 -1.000000 -1.000000 \n", + "4 260.400000 266.655856 4.573892 \n", + "... ... ... ... \n", + "2171 1322.949900 1347.969212 7.128038 \n", + "2172 1543.188079 -1.000000 -1.000000 \n", + "2173 911.461779 923.653582 8.796265 \n", + "2174 420.142347 -1.000000 -1.000000 \n", + "2175 357.600000 407.704505 23.938101 \n", + "\n", + "[2176 rows x 8 columns]" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df_res_link = W.analyzer.link_to_pandas()\n", + "df_res_link" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "And then TNTP data. \n", + "\n", + "NOTE: If you want to execute this notebook, please obtain `ChicagoSketch_flow.tntp` and place it to an appropriate path." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
fromtovolminsec
015474989.130.0345072.070408
125486719.410.0345072.070408
2354910095.530.0345072.070408
345509444.620.0345072.070408
4555117223.820.0345072.070408
..................
2945931906157.0015.707724942.463430
294693238625.000.0345072.070408
294793251522.006.347704380.862240
29489333875468.000.0345072.070408
29499335345837.0013.119813787.188793
\n", + "

2950 rows × 5 columns

\n", + "
" + ], + "text/plain": [ + " from to vol min sec\n", + "0 1 547 4989.13 0.034507 2.070408\n", + "1 2 548 6719.41 0.034507 2.070408\n", + "2 3 549 10095.53 0.034507 2.070408\n", + "3 4 550 9444.62 0.034507 2.070408\n", + "4 5 551 17223.82 0.034507 2.070408\n", + "... ... ... ... ... ...\n", + "2945 931 906 157.00 15.707724 942.463430\n", + "2946 932 386 25.00 0.034507 2.070408\n", + "2947 932 515 22.00 6.347704 380.862240\n", + "2948 933 387 5468.00 0.034507 2.070408\n", + "2949 933 534 5837.00 13.119813 787.188793\n", + "\n", + "[2950 rows x 5 columns]" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "df_tntp_flow = pd.read_csv('out/ChicagoSketch_flow.tntp', sep='\\t')\n", + "df_tntp_flow.columns = [\"from\", \"to\", \"vol\", \"min\"]\n", + "df_tntp_flow[\"sec\"] = df_tntp_flow[\"min\"]*60\n", + "\n", + "display(df_tntp_flow)" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [], + "source": [ + "from pylab import *\n", + "\n", + "res_tntp = {} #{(start_node, end_node): {}}\n", + "res_uxsim = {} #{(start_node, end_node): {}}\n", + "for i in lange(df_tntp_flow):\n", + " res_tntp[df_tntp_flow[\"from\"][i], df_tntp_flow[\"to\"][i]] = {\"vol\": df_tntp_flow[\"vol\"][i], \"sec\": df_tntp_flow[\"sec\"][i]}\n", + " \n", + "for i in lange(df_res_link):\n", + " if df_res_link[\"traffic_volume\"][i] > 0:\n", + " res_uxsim[int(df_res_link[\"start_node\"][i]), int(df_res_link[\"end_node\"][i])] = {\"vol\": df_res_link[\"traffic_volume\"][i], \"sec\": df_res_link[\"average_travel_time\"][i]}\n", + "\n", + "for key in list(res_tntp.keys()):\n", + " if key not in res_uxsim.keys():\n", + " del res_tntp[key]\n", + " #print(key, end=\", \")\n", + "#print(\"\")\n", + "\n", + "for key in list(res_uxsim.keys()):\n", + " if key not in res_tntp.keys():\n", + " del res_tntp[key]\n", + " #print(key, end=\", \")\n", + "\n", + "res_tntp_vol = array([res_tntp[key][\"vol\"] for key in res_uxsim.keys()])\n", + "res_uxsim_vol = array([res_uxsim[key][\"vol\"] for key in res_uxsim.keys()])\n", + "res_tntp_sec = array([res_tntp[key][\"sec\"] for key in res_uxsim.keys()])\n", + "res_uxsim_sec = array([res_uxsim[key][\"sec\"] for key in res_uxsim.keys()])" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "figure(figsize=(12,4))\n", + "subplot(121, aspect=\"equal\")\n", + "hist2d(res_tntp_vol, res_uxsim_vol, bins=20, cmap=\"Greys\", norm=mpl.colors.LogNorm())\n", + "colorbar()\n", + "xlabel(\"TNTP link traffic volume\")\n", + "ylabel(\"UXsim link traffic volume\")\n", + "\n", + "subplot(122, aspect=\"equal\")\n", + "hist2d(res_tntp_vol, res_uxsim_vol, bins=20, range=[[0,10000], [0,10000]], cmap=\"Greys\", norm=mpl.colors.LogNorm())\n", + "colorbar()\n", + "xlabel(\"TNTP link traffic volume\")\n", + "ylabel(\"UXsim link traffic volume\")\n", + "\n", + "\n", + "tight_layout()\n", + "show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The above figures show the comparison of link traffic volume. Roughly speaking, they are mostly correlated." + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "figure(figsize=(12,4))\n", + "subplot(131, aspect=\"equal\")\n", + "hist2d(res_tntp_sec, res_uxsim_sec, bins=20, cmap=\"Greys\", norm=mpl.colors.LogNorm())\n", + "xlabel(\"TNTP link travel time (sec)\")\n", + "ylabel(\"UXsim link travel time (sec)\")\n", + "colorbar()\n", + "\n", + "subplot(132, aspect=\"equal\")\n", + "hist2d(res_tntp_sec, res_uxsim_sec, bins=20, range=[[0,1000], [0,1000]], cmap=\"Greys\", norm=mpl.colors.LogNorm())\n", + "xlabel(\"TNTP link travel time (sec)\")\n", + "ylabel(\"UXsim link travel time (sec)\")\n", + "colorbar()\n", + "\n", + "subplot(133, aspect=\"equal\")\n", + "hist2d(res_tntp_sec, res_uxsim_sec, bins=20, range=[[0,600], [0,600]], cmap=\"Greys\", norm=mpl.colors.LogNorm())\n", + "xlabel(\"TNTP link travel time (sec)\")\n", + "ylabel(\"UXsim link travel time (sec)\")\n", + "colorbar()\n", + "\n", + "tight_layout()\n", + "show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The above figures show the comparison of link traffic travel time. You can see a clear 45-degree line. But this would not be an interesting result: in both of UXsim and TNTP, most of the links have very small number of users, so free-flow travel time is output. \n", + "\n", + "Another noticeable feature is that many links in UXsim experienced substantially longer travel time than TNTP. This is a reasonable result, because in dynamic traffic assignment with hard traffic capacity, traffic congestion can grow significantly if the demand was large.\n", + "\n", + "Now we compare the total travel time in the entire network. As shown in below, the results are not so different. From these results, we can say that UXsim output a plausible result for this scenario." + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "total travel time (h)\n", + "TNTP:\t 311681.3229930834\n", + "UXsim:\t 347367.7123302059\n" + ] + } + ], + "source": [ + "print(\"total travel time (h)\")\n", + "print(\"TNTP:\\t\", sum(res_tntp_sec*res_tntp_vol)/3600)\n", + "print(\"UXsim:\\t\", sum(res_uxsim_sec*res_uxsim_vol)/3600)" + ] + } + ], + "metadata": { + "anaconda-cloud": {}, + "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.9.19" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +}