diff --git a/notebooks/Example 10 - Lock.ipynb b/notebooks/Example 10 - Lock.ipynb index 0475a344..bbf2cf89 100644 --- a/notebooks/Example 10 - Lock.ipynb +++ b/notebooks/Example 10 - Lock.ipynb @@ -4,14 +4,30 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Locks real-world data" + "## Vessels passing a lock in a real-world example\n", + "In this example we will discuss how to implement an existing lock from real-world data in OpenTNSim and how to analyse specific locking output.\n", + "\n", + "We take the following steps:\n", + "\n", + "1. [Imports](#1-imports)\n", + "2. [Create graph](#2-create-graph)\n", + "3. [Create locks](#3-create-locks)\n", + "4. [Create vessel](#4-create-vessel)\n", + "4. [Run simulation](#5-run-simulation)\n", + "5. [Inspect output](#6-inspect-ouput)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 1. Imports" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "### Imports\n", "Import the required libraries" ] }, @@ -88,7 +104,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### Create graph" + "### 2. Create graph" ] }, { @@ -113,21 +129,48 @@ "```" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The shapefile `Vaarwegvakken.shp` is used as a basis for creating the graph for this simulation. To make things easier, the directory (location) of the shapefile is expressed as the variable `location_graph`. The name of the file is expressed as the variable `name_graph`. This will be used troughout the rest of the code. " + ] + }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 17, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\maxva\\AppData\\Local\\Temp\\ipykernel_2660\\554145821.py:2: DeprecationWarning:\n", + "\n", + "read_shp is deprecated and will be removed in 3.0.See https://networkx.org/documentation/latest/auto_examples/index.html#geospatial.\n", + "\n" + ] + } + ], "source": [ + "# Create a directed graph with single edges using read_shp\n", "FG = nx.read_shp(os.path.join(location_graph, name_graph), simplify=True)\n", "\n", - "# The read_shp creates a directed graph with single edges\n", "# We require a directed graph but two-way traffic\n", "\n", "FG = FG.to_undirected()\n", "FG = FG.to_directed()" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Convert to WGS84\n", + "\n", + "WGS84 is the latest version of the World Geodetic System. More information can be found [here](https://en.wikipedia.org/wiki/World_Geodetic_System)." + ] + }, { "cell_type": "code", "execution_count": 4, @@ -177,6 +220,17 @@ "text": [ "Succes!\n" ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\maxva\\AppData\\Local\\Temp\\ipykernel_2660\\848080082.py:32: DeprecationWarning:\n", + "\n", + "info is deprecated and will be removed in version 3.0.\n", + "\n", + "\n" + ] } ], "source": [ @@ -219,7 +273,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### Select only relevant area" + "#### Select only relevant area" ] }, { @@ -278,12 +332,12 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### Show on map" + "#### Show on map" ] }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 21, "metadata": { "scrolled": false }, @@ -291,13 +345,13 @@ { "data": { "text/html": [ - "
" + "
Make this Notebook Trusted to load map: File -> Trust Notebook
" ], "text/plain": [ - "" + "" ] }, - "execution_count": 10, + "execution_count": 21, "metadata": {}, "output_type": "execute_result" } @@ -327,7 +381,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### Create locks\n", + "### 3. Create locks\n", "We can see on the maps that there are three locks on the graph, but that the information on the locks is limited. The following edges represent locks:\n", "\n", "- Voorhavens Jachtensluis\n", @@ -340,7 +394,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 12, "metadata": {}, "outputs": [], "source": [ @@ -367,7 +421,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 13, "metadata": {}, "outputs": [], "source": [ @@ -386,14 +440,26 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### Make vessels and paths" + "### 4. Create vessel" ] }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 16, "metadata": {}, - "outputs": [], + "outputs": [ + { + "ename": "KeyError", + "evalue": "'(4.430289, 51.700047)'", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mKeyError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32m~\\AppData\\Local\\Temp\\ipykernel_2660\\567025772.py\u001b[0m in \u001b[0;36m\u001b[1;34m()\u001b[0m\n\u001b[0;32m 5\u001b[0m \u001b[1;34m\"name\"\u001b[0m\u001b[1;33m:\u001b[0m \u001b[1;34m\"Vessel\"\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 6\u001b[0m \u001b[1;34m\"route\"\u001b[0m\u001b[1;33m:\u001b[0m \u001b[1;33m[\u001b[0m\u001b[1;34m\"(4.430289, 51.700047)\"\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m\"(4.392555, 51.681251)\"\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 7\u001b[1;33m \u001b[1;34m\"geometry\"\u001b[0m\u001b[1;33m:\u001b[0m \u001b[0mnx\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mget_node_attributes\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mFG_new\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m\"geometry\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m\"(4.430289, 51.700047)\"\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 8\u001b[0m \"capacity\": 1_000}\n\u001b[0;32m 9\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;31mKeyError\u001b[0m: '(4.430289, 51.700047)'" + ] + } + ], "source": [ "Vessel = type('Vessel', \n", " (core.Identifiable, core.Movable, core.HasContainer, core.HasResource, core.Routeable), {})\n", @@ -415,14 +481,26 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### Start simulation" + "### 5. Run simulation" ] }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 15, "metadata": {}, - "outputs": [], + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'data_vessel_one' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mNameError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32m~\\AppData\\Local\\Temp\\ipykernel_2660\\3922957051.py\u001b[0m in \u001b[0;36m\u001b[1;34m()\u001b[0m\n\u001b[0;32m 5\u001b[0m \u001b[0mvessels\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m[\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 6\u001b[0m \u001b[1;32mfor\u001b[0m \u001b[0mi\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m10\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 7\u001b[1;33m \u001b[0mvessel\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mVessel\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m**\u001b[0m\u001b[0mdata_vessel_one\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 8\u001b[0m \u001b[0mvessels\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mvessel\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 9\u001b[0m \u001b[0menv\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mprocess\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mvessel\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mmove\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;31mNameError\u001b[0m: name 'data_vessel_one' is not defined" + ] + } + ], "source": [ "# Start simpy environment\n", "env.FG = FG_new\n", @@ -442,6 +520,13 @@ "env.run()" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 6. Inspect ouput" + ] + }, { "cell_type": "code", "execution_count": 15, @@ -747,20 +832,6 @@ "pd.DataFrame.from_dict(lock_nr_1.log).head(10)" ] }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, { "cell_type": "code", "execution_count": 18, @@ -1047,103 +1118,6 @@ "# Tenth ship should be the first one the start waiting to enter the waiting area\n", "pd.DataFrame.from_dict(vessels[9].log)" ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Visualize sailed path\n", - "https://nbviewer.jupyter.org/github/python-visualization/folium/blob/master/examples/Plugins.ipynb#Timestamped-GeoJSON" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": 21, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "1, 0\n", - "[, , , ]\n", - "\n", - "5, -1\n", - "[, , ]\n", - "\n", - "2, -0.6266180102112903\n", - "[, ]\n", - "\n", - "3, -0.7535128117883658\n", - "[]\n", - "\n", - "4, -0.3062137446940345\n", - "[]\n", - "\n" - ] - } - ], - "source": [ - "import random\n", - "def resource_user(name, env, resource, prio):\n", - " req = resource.request(priority=prio)\n", - "\n", - " yield req\n", - " print(\"{}, {}\".format(name, req.priority))\n", - " yield env.timeout(3)\n", - " resource.release(req)\n", - " \n", - " for i in resource.queue:\n", - " if env.now - 4 > i.time:\n", - " i.priority = -random.random()\n", - " \n", - " print(resource.queue)\n", - " print(\"\")\n", - "\n", - "env = simpy.Environment()\n", - "res = simpy.PriorityResource(env, capacity=1)\n", - "p1 = env.process(resource_user(1, env, res, prio=0))\n", - "p2 = env.process(resource_user(2, env, res, prio=0))\n", - "p3 = env.process(resource_user(3, env, res, prio=0))\n", - "p4 = env.process(resource_user(4, env, res, prio=0))\n", - "p5 = env.process(resource_user(5, env, res, prio=-1))\n", - "env.run()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] } ], "metadata": { @@ -1162,7 +1136,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.6.6" + "version": "3.9.10" } }, "nbformat": 4, diff --git a/notebooks/Example 11 - Multiple vessels - from database.ipynb b/notebooks/Example 11 - Multiple vessels - from database.ipynb index 55398fd3..c33c2f28 100644 --- a/notebooks/Example 11 - Multiple vessels - from database.ipynb +++ b/notebooks/Example 11 - Multiple vessels - from database.ipynb @@ -8,20 +8,41 @@ ] }, { - "cell_type": "code", - "execution_count": null, + "cell_type": "markdown", "metadata": {}, - "outputs": [], "source": [ - "import opentnsim\n", - "print('This notebook has been tested with OpenTNSim version {}'.format(opentnsim.__version__))" + "In this example we will discuss how to generate vessels from existing dataset in OpenTNSim and how to analyse specific locking output.\n", + "\n", + "We take the following steps:\n", + "\n", + "1. [Imports](#1-imports)\n", + "2. [Create vessel](#2-create-vessel)\n", + "3. [Create graph](#3-create-graph)\n", + "4. [Run simulation](#4-run-simulation)\n", + "5. [Inspect output](#5-inspect-output)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 1. Imports\n", + "We start with importing the required libraries" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "This notebook has been tested with OpenTNSim version 1.0.0\n" + ] + } + ], "source": [ "# package(s) related to time, space and id\n", "import datetime, time\n", @@ -46,6 +67,7 @@ "import matplotlib.animation as animation\n", "\n", "# OpenTNSIM\n", + "import opentnsim \n", "import opentnsim.core as core\n", "import opentnsim.graph_module as graph_module\n", "import opentnsim.plot as plot\n", @@ -62,107 +84,269 @@ "name_graph = \"notebooks/Shape-Files/Rotterdam-Antwerpen-corridor/edges_2.shp\"\n", "\n", "# Vessel database\n", - "location_vessel_database = \"notebooks/Vessels/richtlijnen-vaarwegen-2017.csv\"" + "location_vessel_database = \"notebooks/Vessels/richtlijnen-vaarwegen-2017.csv\"\n", + "\n", + "print('This notebook has been tested with OpenTNSim version {}'.format(opentnsim.__version__))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "### Create graph" + "### 2. Create vessel\n", + "The following section shows how to use the file `richtlijnen-vaarwegen-2017.csv` as a database for generating vessels. Inspect the file be opening it in excel to get a feel for how these datasets are structured and how you can use pandas to process this data." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "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", + "
vessel_idvessel_typewidthlengthheight_emptyheight_fulldraught_emptydraught_fullcapacityinstalled_power
012ad8a02-4aef-11e9-9940-b469212bff5bCEMT - I5.0538.54.653.351.22.5365175
117746aee-4aef-11e9-8ebf-b469212bff5bCEMT - II6.6055.05.804.601.42.6615250
21be5fb2e-4aef-11e9-9bfb-b469212bff5bCEMT - III8.2085.06.305.101.52.71250435
3208a5aca-4aef-11e9-b7e9-b469212bff5bCEMT - IV9.50105.06.705.301.63.02040690
424f93100-4aef-11e9-8ff9-b469212bff5bCEMT - Va11.40135.07.105.401.83.537351425
\n", + "
" + ], + "text/plain": [ + " vessel_id vessel_type width length \\\n", + "0 12ad8a02-4aef-11e9-9940-b469212bff5b CEMT - I 5.05 38.5 \n", + "1 17746aee-4aef-11e9-8ebf-b469212bff5b CEMT - II 6.60 55.0 \n", + "2 1be5fb2e-4aef-11e9-9bfb-b469212bff5b CEMT - III 8.20 85.0 \n", + "3 208a5aca-4aef-11e9-b7e9-b469212bff5b CEMT - IV 9.50 105.0 \n", + "4 24f93100-4aef-11e9-8ff9-b469212bff5b CEMT - Va 11.40 135.0 \n", + "\n", + " height_empty height_full draught_empty draught_full capacity \\\n", + "0 4.65 3.35 1.2 2.5 365 \n", + "1 5.80 4.60 1.4 2.6 615 \n", + "2 6.30 5.10 1.5 2.7 1250 \n", + "3 6.70 5.30 1.6 3.0 2040 \n", + "4 7.10 5.40 1.8 3.5 3735 \n", + "\n", + " installed_power \n", + "0 175 \n", + "1 250 \n", + "2 435 \n", + "3 690 \n", + "4 1425 " + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#Load in the data\n", + "vessel_db = pd.read_csv(os.path.join(location_graph, location_vessel_database))\n", + "vessel_db.head()\n", + "\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "The cel below visualizes the problem. In graph theory the red dots are called *edges* and the lines are called *vertices*. Vessels (or any other object) move from edge 1 to edge 3 and from edge 4 to edge 2. The added complexity is that vertice 5-6 only allows traffic in one direction at a time. Vessels can travel simultanously in one direction.\n", + "We start with creating a vessel class. We call this class a *Vessel*, and add a number of OpenTNSim mix-ins to this class. Each mix-in requires certain input parameters. \n", "\n", - "**Important**: \n", - "\n", - "If you use windows and get the following error \"ImportError: read_shp requires OGR: http://www.gdal.org/\", you probably have [this issue](https://github.com/conda-forge/gdal-feedstock/issues/219). Solving it is possible by running the following commands in your terminal (as explained [here](https://gis.stackexchange.com/questions/294231/installing-gdal-with-anaconda)):\n", - "\n", - "```bash\n", - "#Create a new virtual environment\n", - "conda create -n testgdal -c conda-forge gdal vs2015_runtime=14\n", - "\n", - "#Activate virtual environment\n", - "activate testgdal\n", + "The following mix-ins are sufficient to create a vessel for our problem: \n", + "* _Identifiable_ - allows to give the vessel a name and a random ID, \n", + "* _Movable_ - allows the vessel to move, with a fixed speed, while logging this activity,\n", + " * Movable in turn relies on the mix-ins: _Locatable_, _Routeable_, and _Log_\n", + "* _VesselProperties_ - allows to give the vessel specific properties, \n", + "* _HasContainer_ - allows vessel to have cargo on board, \n", + "* _HasResource_ - allows vessel to be requested \n", "\n", - "#Open Jupyter notebook\n", - "jupyer notebook\n", - "```" + "These mixi-ins and the `vessels_db` dataframe are then combined in the vessel generator:" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ - "graph = graph_module.Graph()\n", - "graph.from_shape(location_graph, name_graph)" + "# Vessel type\n", + "Vessel = type('Vessel', \n", + " (core.Identifiable, core.Movable, core.HasContainer,\n", + " core.VesselProperties, core.HasResource, core.Routeable), \n", + " {})\n", + "\n", + "generator = model.VesselGenerator(Vessel, vessel_db)" ] }, { - "cell_type": "code", - "execution_count": null, + "cell_type": "markdown", "metadata": {}, - "outputs": [], - "source": [ - "graph.create_graph_new_projection()\n", - "graph.plot()" - ] + "source": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "### Create vessel database" + "### 3. Create graph" ] }, { - "cell_type": "code", - "execution_count": null, + "cell_type": "markdown", "metadata": {}, - "outputs": [], "source": [ - "vessel_db = pd.read_csv(os.path.join(location_graph, location_vessel_database))\n", - "vessel_db.head()" + "The cel below visualizes the problem. In graph theory the red dots are called *edges* and the lines are called *vertices*. Vessels (or any other object) move from edge 1 to edge 3 and from edge 4 to edge 2. The added complexity is that vertice 5-6 only allows traffic in one direction at a time. Vessels can travel simultanously in one direction.\n", + "\n", + "**Important**: \n", + "\n", + "If you use windows and get the following error \"ImportError: read_shp requires OGR: http://www.gdal.org/\", you probably have [this issue](https://github.com/conda-forge/gdal-feedstock/issues/219). Solving it is possible by running the following commands in your terminal (as explained [here](https://gis.stackexchange.com/questions/294231/installing-gdal-with-anaconda)):\n", + "\n", + "```bash\n", + "#Create a new virtual environment\n", + "conda create -n testgdal -c conda-forge gdal vs2015_runtime=14\n", + "\n", + "#Activate virtual environment\n", + "activate testgdal\n", + "\n", + "#Open Jupyter notebook\n", + "jupyer notebook\n", + "```" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ - "# Vessel type\n", - "Vessel = type('Vessel', \n", - " (core.Identifiable, core.Movable, core.HasContainer,\n", - " core.VesselProperties, core.HasResource, core.Routeable), \n", - " {})" + "graph = graph_module.Graph()\n", + "graph.from_shape(location_graph, name_graph)" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ - "generator = model.VesselGenerator(Vessel, vessel_db)" + "graph.create_graph_new_projection()\n", + "graph.plot()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "### Run simulation" + "### 4. Run simulation" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "metadata": {}, "outputs": [], "source": [ @@ -177,7 +361,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "metadata": {}, "outputs": [], "source": [ @@ -194,7 +378,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 11, "metadata": {}, "outputs": [], "source": [ @@ -217,7 +401,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 12, "metadata": {}, "outputs": [], "source": [ @@ -229,14 +413,102 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### Check results" + "### 5. Inspect output" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 13, "metadata": {}, - "outputs": [], + "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", + "
MessageTimestampValueGeometry
0Start sailing2022-05-11 10:36:34.0000000POINT (51.5136 4.2198)
1Waiting to pass edge (51.513600, 4.219800) - (...2022-05-11 10:36:34.0000000POINT (51.5136 4.2198)
2Waiting to pass edge (51.513600, 4.219800) - (...2022-05-11 10:46:29.3227420POINT (51.5136 4.2198)
3Sailing from node (51.513600, 4.219800) to nod...2022-05-11 10:46:29.3227420POINT (51.5136 4.2198)
4Sailing from node (51.513600, 4.219800) to nod...2022-05-11 10:56:24.6454830POINT (51.5184 4.2222)
\n", + "
" + ], + "text/plain": [ + " Message \\\n", + "0 Start sailing \n", + "1 Waiting to pass edge (51.513600, 4.219800) - (... \n", + "2 Waiting to pass edge (51.513600, 4.219800) - (... \n", + "3 Sailing from node (51.513600, 4.219800) to nod... \n", + "4 Sailing from node (51.513600, 4.219800) to nod... \n", + "\n", + " Timestamp Value Geometry \n", + "0 2022-05-11 10:36:34.000000 0 POINT (51.5136 4.2198) \n", + "1 2022-05-11 10:36:34.000000 0 POINT (51.5136 4.2198) \n", + "2 2022-05-11 10:46:29.322742 0 POINT (51.5136 4.2198) \n", + "3 2022-05-11 10:46:29.322742 0 POINT (51.5136 4.2198) \n", + "4 2022-05-11 10:56:24.645483 0 POINT (51.5184 4.2222) " + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "df = pd.DataFrame.from_dict(vessel.log)\n", "df.head()" @@ -244,9 +516,619 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 14, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "{'Message': ['Start sailing',\n", + " 'Waiting to pass edge (51.513600, 4.219800) - (51.518400, 4.222200) start',\n", + " 'Waiting to pass edge (51.513600, 4.219800) - (51.518400, 4.222200) stop',\n", + " 'Sailing from node (51.513600, 4.219800) to node (51.518400, 4.222200) start',\n", + " 'Sailing from node (51.513600, 4.219800) to node (51.518400, 4.222200) stop',\n", + " 'Sailing from node (51.518400, 4.222200) to node (51.519631, 4.222915) start',\n", + " 'Sailing from node (51.518400, 4.222200) to node (51.519631, 4.222915) stop',\n", + " 'Sailing from node (51.519631, 4.222915) to node (51.521194, 4.223780) start',\n", + " 'Sailing from node (51.519631, 4.222915) to node (51.521194, 4.223780) stop',\n", + " 'Sailing from node (51.521194, 4.223780) to node (51.523700, 4.225200) start',\n", + " 'Sailing from node (51.521194, 4.223780) to node (51.523700, 4.225200) stop',\n", + " 'Waiting to pass edge (51.523700, 4.225200) - (51.529474, 4.228499) start',\n", + " 'Waiting to pass edge (51.523700, 4.225200) - (51.529474, 4.228499) stop',\n", + " 'Sailing from node (51.523700, 4.225200) to node (51.529474, 4.228499) start',\n", + " 'Sailing from node (51.523700, 4.225200) to node (51.529474, 4.228499) stop',\n", + " 'Sailing from node (51.529474, 4.228499) to node (51.532800, 4.230400) start',\n", + " 'Sailing from node (51.529474, 4.228499) to node (51.532800, 4.230400) stop',\n", + " 'Sailing from node (51.532800, 4.230400) to node (51.536837, 4.232684) start',\n", + " 'Sailing from node (51.532800, 4.230400) to node (51.536837, 4.232684) stop',\n", + " 'Sailing from node (51.536837, 4.232684) to node (51.536926, 4.232737) start',\n", + " 'Sailing from node (51.536837, 4.232684) to node (51.536926, 4.232737) stop',\n", + " 'Sailing from node (51.536926, 4.232737) to node (51.537021, 4.232793) start',\n", + " 'Sailing from node (51.536926, 4.232737) to node (51.537021, 4.232793) stop',\n", + " 'Sailing from node (51.537021, 4.232793) to node (51.538010, 4.233572) start',\n", + " 'Sailing from node (51.537021, 4.232793) to node (51.538010, 4.233572) stop',\n", + " 'Sailing from node (51.538010, 4.233572) to node (51.543441, 4.235949) start',\n", + " 'Sailing from node (51.538010, 4.233572) to node (51.543441, 4.235949) stop',\n", + " 'Sailing from node (51.543441, 4.235949) to node (51.545750, 4.236459) start',\n", + " 'Sailing from node (51.543441, 4.235949) to node (51.545750, 4.236459) stop',\n", + " 'Sailing from node (51.545750, 4.236459) to node (51.547888, 4.236554) start',\n", + " 'Sailing from node (51.545750, 4.236459) to node (51.547888, 4.236554) stop',\n", + " 'Sailing from node (51.547888, 4.236554) to node (51.550479, 4.236304) start',\n", + " 'Sailing from node (51.547888, 4.236554) to node (51.550479, 4.236304) stop',\n", + " 'Sailing from node (51.550479, 4.236304) to node (51.555526, 4.234883) start',\n", + " 'Sailing from node (51.550479, 4.236304) to node (51.555526, 4.234883) stop',\n", + " 'Sailing from node (51.555526, 4.234883) to node (51.556948, 4.234005) start',\n", + " 'Sailing from node (51.555526, 4.234883) to node (51.556948, 4.234005) stop',\n", + " 'Sailing from node (51.556948, 4.234005) to node (51.560329, 4.231498) start',\n", + " 'Sailing from node (51.556948, 4.234005) to node (51.560329, 4.231498) stop',\n", + " 'Sailing from node (51.560329, 4.231498) to node (51.563708, 4.228138) start',\n", + " 'Sailing from node (51.560329, 4.231498) to node (51.563708, 4.228138) stop',\n", + " 'Sailing from node (51.563708, 4.228138) to node (51.566927, 4.223883) start',\n", + " 'Sailing from node (51.563708, 4.228138) to node (51.566927, 4.223883) stop',\n", + " 'Sailing from node (51.566927, 4.223883) to node (51.570799, 4.219050) start',\n", + " 'Sailing from node (51.566927, 4.223883) to node (51.570799, 4.219050) stop',\n", + " 'Waiting to pass edge (51.570799, 4.219050) - (51.577480, 4.210160) start',\n", + " 'Waiting to pass edge (51.570799, 4.219050) - (51.577480, 4.210160) stop',\n", + " 'Sailing from node (51.570799, 4.219050) to node (51.577480, 4.210160) start',\n", + " 'Sailing from node (51.570799, 4.219050) to node (51.577480, 4.210160) stop',\n", + " 'Sailing from node (51.577480, 4.210160) to node (51.584064, 4.201305) start',\n", + " 'Sailing from node (51.577480, 4.210160) to node (51.584064, 4.201305) stop',\n", + " 'Sailing from node (51.584064, 4.201305) to node (51.585129, 4.199855) start',\n", + " 'Sailing from node (51.584064, 4.201305) to node (51.585129, 4.199855) stop',\n", + " 'Sailing from node (51.585129, 4.199855) to node (51.589550, 4.195269) start',\n", + " 'Sailing from node (51.585129, 4.199855) to node (51.589550, 4.195269) stop',\n", + " 'Sailing from node (51.589550, 4.195269) to node (51.592075, 4.193655) start',\n", + " 'Sailing from node (51.589550, 4.195269) to node (51.592075, 4.193655) stop',\n", + " 'Sailing from node (51.592075, 4.193655) to node (51.593499, 4.192667) start',\n", + " 'Sailing from node (51.592075, 4.193655) to node (51.593499, 4.192667) stop',\n", + " 'Sailing from node (51.593499, 4.192667) to node (51.597653, 4.190875) start',\n", + " 'Sailing from node (51.593499, 4.192667) to node (51.597653, 4.190875) stop',\n", + " 'Sailing from node (51.597653, 4.190875) to node (51.601016, 4.190361) start',\n", + " 'Sailing from node (51.597653, 4.190875) to node (51.601016, 4.190361) stop',\n", + " 'Sailing from node (51.601016, 4.190361) to node (51.602106, 4.190247) start',\n", + " 'Sailing from node (51.601016, 4.190361) to node (51.602106, 4.190247) stop',\n", + " 'Sailing from node (51.602106, 4.190247) to node (51.606278, 4.190740) start',\n", + " 'Sailing from node (51.602106, 4.190247) to node (51.606278, 4.190740) stop',\n", + " 'Sailing from node (51.606278, 4.190740) to node (51.609680, 4.191985) start',\n", + " 'Sailing from node (51.606278, 4.190740) to node (51.609680, 4.191985) stop',\n", + " 'Sailing from node (51.609680, 4.191985) to node (51.612731, 4.193586) start',\n", + " 'Sailing from node (51.609680, 4.191985) to node (51.612731, 4.193586) stop',\n", + " 'Sailing from node (51.612731, 4.193586) to node (51.614833, 4.194962) start',\n", + " 'Sailing from node (51.612731, 4.193586) to node (51.614833, 4.194962) stop',\n", + " 'Sailing from node (51.614833, 4.194962) to node (51.618131, 4.197727) start',\n", + " 'Sailing from node (51.614833, 4.194962) to node (51.618131, 4.197727) stop',\n", + " 'Sailing from node (51.618131, 4.197727) to node (51.620599, 4.200697) start',\n", + " 'Sailing from node (51.618131, 4.197727) to node (51.620599, 4.200697) stop',\n", + " 'Sailing from node (51.620599, 4.200697) to node (51.622897, 4.204008) start',\n", + " 'Sailing from node (51.620599, 4.200697) to node (51.622897, 4.204008) stop',\n", + " 'Sailing from node (51.622897, 4.204008) to node (51.624697, 4.207307) start',\n", + " 'Sailing from node (51.622897, 4.204008) to node (51.624697, 4.207307) stop',\n", + " 'Sailing from node (51.624697, 4.207307) to node (51.626347, 4.210952) start',\n", + " 'Sailing from node (51.624697, 4.207307) to node (51.626347, 4.210952) stop',\n", + " 'Sailing from node (51.626347, 4.210952) to node (51.627769, 4.214945) start',\n", + " 'Sailing from node (51.626347, 4.210952) to node (51.627769, 4.214945) stop',\n", + " 'Sailing from node (51.627769, 4.214945) to node (51.628982, 4.219861) start',\n", + " 'Sailing from node (51.627769, 4.214945) to node (51.628982, 4.219861) stop',\n", + " 'Sailing from node (51.628982, 4.219861) to node (51.630335, 4.225275) start',\n", + " 'Sailing from node (51.628982, 4.219861) to node (51.630335, 4.225275) stop',\n", + " 'Sailing from node (51.630335, 4.225275) to node (51.632034, 4.231763) start',\n", + " 'Sailing from node (51.630335, 4.225275) to node (51.632034, 4.231763) stop',\n", + " 'Sailing from node (51.632034, 4.231763) to node (51.632653, 4.233760) start',\n", + " 'Sailing from node (51.632034, 4.231763) to node (51.632653, 4.233760) stop',\n", + " 'Sailing from node (51.632653, 4.233760) to node (51.633202, 4.235458) start',\n", + " 'Sailing from node (51.632653, 4.233760) to node (51.633202, 4.235458) stop',\n", + " 'Sailing from node (51.633202, 4.235458) to node (51.634271, 4.239405) start',\n", + " 'Sailing from node (51.633202, 4.235458) to node (51.634271, 4.239405) stop',\n", + " 'Waiting to pass edge (51.634271, 4.239405) - (51.638106, 4.251508) start',\n", + " 'Waiting to pass edge (51.634271, 4.239405) - (51.638106, 4.251508) stop',\n", + " 'Sailing from node (51.634271, 4.239405) to node (51.638106, 4.251508) start',\n", + " 'Sailing from node (51.634271, 4.239405) to node (51.638106, 4.251508) stop',\n", + " 'Sailing from node (51.638106, 4.251508) to node (51.639403, 4.255097) start',\n", + " 'Sailing from node (51.638106, 4.251508) to node (51.639403, 4.255097) stop',\n", + " 'Waiting to pass edge (51.639403, 4.255097) - (51.644457, 4.269914) start',\n", + " 'Waiting to pass edge (51.639403, 4.255097) - (51.644457, 4.269914) stop',\n", + " 'Sailing from node (51.639403, 4.255097) to node (51.644457, 4.269914) start',\n", + " 'Sailing from node (51.639403, 4.255097) to node (51.644457, 4.269914) stop',\n", + " 'Sailing from node (51.644457, 4.269914) to node (51.644899, 4.272531) start',\n", + " 'Sailing from node (51.644457, 4.269914) to node (51.644899, 4.272531) stop',\n", + " 'Sailing from node (51.644899, 4.272531) to node (51.645046, 4.282041) start',\n", + " 'Sailing from node (51.644899, 4.272531) to node (51.645046, 4.282041) stop',\n", + " 'Sailing from node (51.645046, 4.282041) to node (51.645230, 4.283246) start',\n", + " 'Sailing from node (51.645046, 4.282041) to node (51.645230, 4.283246) stop',\n", + " 'Sailing from node (51.645230, 4.283246) to node (51.645727, 4.286345) start',\n", + " 'Sailing from node (51.645230, 4.283246) to node (51.645727, 4.286345) stop',\n", + " 'Sailing from node (51.645727, 4.286345) to node (51.646047, 4.288435) start',\n", + " 'Sailing from node (51.645727, 4.286345) to node (51.646047, 4.288435) stop',\n", + " 'Sailing from node (51.646047, 4.288435) to node (51.646245, 4.289695) start',\n", + " 'Sailing from node (51.646047, 4.288435) to node (51.646245, 4.289695) stop',\n", + " 'Sailing from node (51.646245, 4.289695) to node (51.646669, 4.292582) start',\n", + " 'Sailing from node (51.646245, 4.289695) to node (51.646669, 4.292582) stop',\n", + " 'Sailing from node (51.646669, 4.292582) to node (51.647024, 4.294773) start',\n", + " 'Sailing from node (51.646669, 4.292582) to node (51.647024, 4.294773) stop',\n", + " 'Sailing from node (51.647024, 4.294773) to node (51.647320, 4.296648) start',\n", + " 'Sailing from node (51.647024, 4.294773) to node (51.647320, 4.296648) stop',\n", + " 'Sailing from node (51.647320, 4.296648) to node (51.647620, 4.298725) start',\n", + " 'Sailing from node (51.647320, 4.296648) to node (51.647620, 4.298725) stop',\n", + " 'Sailing from node (51.647620, 4.298725) to node (51.647921, 4.300013) start',\n", + " 'Sailing from node (51.647620, 4.298725) to node (51.647921, 4.300013) stop',\n", + " 'Sailing from node (51.647921, 4.300013) to node (51.648354, 4.301646) start',\n", + " 'Sailing from node (51.647921, 4.300013) to node (51.648354, 4.301646) stop',\n", + " 'Sailing from node (51.648354, 4.301646) to node (51.648696, 4.302887) start',\n", + " 'Sailing from node (51.648354, 4.301646) to node (51.648696, 4.302887) stop',\n", + " 'Sailing from node (51.648696, 4.302887) to node (51.649077, 4.304237) start',\n", + " 'Sailing from node (51.648696, 4.302887) to node (51.649077, 4.304237) stop',\n", + " 'Sailing from node (51.649077, 4.304237) to node (51.649595, 4.305939) start',\n", + " 'Sailing from node (51.649077, 4.304237) to node (51.649595, 4.305939) stop',\n", + " 'Sailing from node (51.649595, 4.305939) to node (51.650156, 4.307950) start',\n", + " 'Sailing from node (51.649595, 4.305939) to node (51.650156, 4.307950) stop',\n", + " 'Sailing from node (51.650156, 4.307950) to node (51.650717, 4.310095) start',\n", + " 'Sailing from node (51.650156, 4.307950) to node (51.650717, 4.310095) stop',\n", + " 'Sailing from node (51.650717, 4.310095) to node (51.651126, 4.312227) start',\n", + " 'Sailing from node (51.650717, 4.310095) to node (51.651126, 4.312227) stop',\n", + " 'Sailing from node (51.651126, 4.312227) to node (51.651393, 4.313727) start',\n", + " 'Sailing from node (51.651126, 4.312227) to node (51.651393, 4.313727) stop',\n", + " 'Sailing from node (51.651393, 4.313727) to node (51.651734, 4.316509) start',\n", + " 'Sailing from node (51.651393, 4.313727) to node (51.651734, 4.316509) stop',\n", + " 'Sailing from node (51.651734, 4.316509) to node (51.651963, 4.318706) start',\n", + " 'Sailing from node (51.651734, 4.316509) to node (51.651963, 4.318706) stop',\n", + " 'Stop sailing'],\n", + " 'Timestamp': [datetime.datetime(2022, 5, 11, 10, 36, 34),\n", + " datetime.datetime(2022, 5, 11, 10, 36, 34),\n", + " datetime.datetime(2022, 5, 11, 10, 46, 29, 322742),\n", + " datetime.datetime(2022, 5, 11, 10, 46, 29, 322742),\n", + " datetime.datetime(2022, 5, 11, 10, 56, 24, 645483),\n", + " datetime.datetime(2022, 5, 11, 10, 56, 24, 645483),\n", + " datetime.datetime(2022, 5, 11, 10, 59, 2, 536130),\n", + " datetime.datetime(2022, 5, 11, 10, 59, 2, 536130),\n", + " datetime.datetime(2022, 5, 11, 11, 2, 20, 656900),\n", + " datetime.datetime(2022, 5, 11, 11, 2, 20, 656900),\n", + " datetime.datetime(2022, 5, 11, 11, 7, 40, 141279),\n", + " datetime.datetime(2022, 5, 11, 11, 7, 40, 141279),\n", + " datetime.datetime(2022, 5, 11, 11, 10, 2, 368068),\n", + " datetime.datetime(2022, 5, 11, 11, 10, 2, 368068),\n", + " datetime.datetime(2022, 5, 11, 11, 22, 19, 917598),\n", + " datetime.datetime(2022, 5, 11, 11, 22, 19, 917598),\n", + " datetime.datetime(2022, 5, 11, 11, 29, 24, 817663),\n", + " datetime.datetime(2022, 5, 11, 11, 29, 24, 817663),\n", + " datetime.datetime(2022, 5, 11, 11, 37, 59, 284732),\n", + " datetime.datetime(2022, 5, 11, 11, 37, 59, 284732),\n", + " datetime.datetime(2022, 5, 11, 11, 38, 10, 820057),\n", + " datetime.datetime(2022, 5, 11, 11, 38, 10, 820057),\n", + " datetime.datetime(2022, 5, 11, 11, 38, 23, 6456),\n", + " datetime.datetime(2022, 5, 11, 11, 38, 23, 6456),\n", + " datetime.datetime(2022, 5, 11, 11, 40, 42, 518356),\n", + " datetime.datetime(2022, 5, 11, 11, 40, 42, 518356),\n", + " datetime.datetime(2022, 5, 11, 11, 51, 40, 305160),\n", + " datetime.datetime(2022, 5, 11, 11, 51, 40, 305160),\n", + " datetime.datetime(2022, 5, 11, 11, 56, 2, 736416),\n", + " datetime.datetime(2022, 5, 11, 11, 56, 2, 736416),\n", + " datetime.datetime(2022, 5, 11, 12, 0, 0, 404450),\n", + " datetime.datetime(2022, 5, 11, 12, 0, 0, 404450),\n", + " datetime.datetime(2022, 5, 11, 12, 4, 49, 367962),\n", + " datetime.datetime(2022, 5, 11, 12, 4, 49, 367962),\n", + " datetime.datetime(2022, 5, 11, 12, 14, 31, 281031),\n", + " datetime.datetime(2022, 5, 11, 12, 14, 31, 281031),\n", + " datetime.datetime(2022, 5, 11, 12, 17, 36, 643201),\n", + " datetime.datetime(2022, 5, 11, 12, 17, 36, 643201),\n", + " datetime.datetime(2022, 5, 11, 12, 25, 23, 221210),\n", + " datetime.datetime(2022, 5, 11, 12, 25, 23, 221210),\n", + " datetime.datetime(2022, 5, 11, 12, 34, 11, 209750),\n", + " datetime.datetime(2022, 5, 11, 12, 34, 11, 209750),\n", + " datetime.datetime(2022, 5, 11, 12, 44, 2, 75392),\n", + " datetime.datetime(2022, 5, 11, 12, 44, 2, 75392),\n", + " datetime.datetime(2022, 5, 11, 12, 55, 27, 883782),\n", + " datetime.datetime(2022, 5, 11, 12, 55, 27, 883782),\n", + " datetime.datetime(2022, 5, 11, 13, 3, 41, 840554),\n", + " datetime.datetime(2022, 5, 11, 13, 3, 41, 840554),\n", + " datetime.datetime(2022, 5, 11, 13, 24, 13, 346855),\n", + " datetime.datetime(2022, 5, 11, 13, 24, 13, 346855),\n", + " datetime.datetime(2022, 5, 11, 13, 44, 35, 333763),\n", + " datetime.datetime(2022, 5, 11, 13, 44, 35, 333763),\n", + " datetime.datetime(2022, 5, 11, 13, 47, 54, 530361),\n", + " datetime.datetime(2022, 5, 11, 13, 47, 54, 530361),\n", + " datetime.datetime(2022, 5, 11, 13, 59, 40, 291222),\n", + " datetime.datetime(2022, 5, 11, 13, 59, 40, 291222),\n", + " datetime.datetime(2022, 5, 11, 14, 5, 12, 651797),\n", + " datetime.datetime(2022, 5, 11, 14, 5, 12, 651797),\n", + " datetime.datetime(2022, 5, 11, 14, 8, 24, 776127),\n", + " datetime.datetime(2022, 5, 11, 14, 8, 24, 776127),\n", + " datetime.datetime(2022, 5, 11, 14, 16, 46, 758416),\n", + " datetime.datetime(2022, 5, 11, 14, 16, 46, 758416),\n", + " datetime.datetime(2022, 5, 11, 14, 23, 4, 339297),\n", + " datetime.datetime(2022, 5, 11, 14, 23, 4, 339297),\n", + " datetime.datetime(2022, 5, 11, 14, 25, 6, 22353),\n", + " datetime.datetime(2022, 5, 11, 14, 25, 6, 22353),\n", + " datetime.datetime(2022, 5, 11, 14, 32, 52, 475966),\n", + " datetime.datetime(2022, 5, 11, 14, 32, 52, 475966),\n", + " datetime.datetime(2022, 5, 11, 14, 39, 34, 419968),\n", + " datetime.datetime(2022, 5, 11, 14, 39, 34, 419968),\n", + " datetime.datetime(2022, 5, 11, 14, 45, 56, 676868),\n", + " datetime.datetime(2022, 5, 11, 14, 45, 56, 676868),\n", + " datetime.datetime(2022, 5, 11, 14, 50, 35, 281769),\n", + " datetime.datetime(2022, 5, 11, 14, 50, 35, 281769),\n", + " datetime.datetime(2022, 5, 11, 14, 58, 32, 312764),\n", + " datetime.datetime(2022, 5, 11, 14, 58, 32, 312764),\n", + " datetime.datetime(2022, 5, 11, 15, 5, 39, 980791),\n", + " datetime.datetime(2022, 5, 11, 15, 5, 39, 980791),\n", + " datetime.datetime(2022, 5, 11, 15, 13, 6, 242321),\n", + " datetime.datetime(2022, 5, 11, 15, 13, 6, 242321),\n", + " datetime.datetime(2022, 5, 11, 15, 20, 2, 252176),\n", + " datetime.datetime(2022, 5, 11, 15, 20, 2, 252176),\n", + " datetime.datetime(2022, 5, 11, 15, 27, 24, 924838),\n", + " datetime.datetime(2022, 5, 11, 15, 27, 24, 924838),\n", + " datetime.datetime(2022, 5, 11, 15, 35, 13, 900309),\n", + " datetime.datetime(2022, 5, 11, 15, 35, 13, 900309),\n", + " datetime.datetime(2022, 5, 11, 15, 44, 33, 939629),\n", + " datetime.datetime(2022, 5, 11, 15, 44, 33, 939629),\n", + " datetime.datetime(2022, 5, 11, 15, 54, 51, 134686),\n", + " datetime.datetime(2022, 5, 11, 15, 54, 51, 134686),\n", + " datetime.datetime(2022, 5, 11, 16, 7, 13, 51399),\n", + " datetime.datetime(2022, 5, 11, 16, 7, 13, 51399),\n", + " datetime.datetime(2022, 5, 11, 16, 11, 4, 294138),\n", + " datetime.datetime(2022, 5, 11, 16, 11, 4, 294138),\n", + " datetime.datetime(2022, 5, 11, 16, 14, 21, 686699),\n", + " datetime.datetime(2022, 5, 11, 16, 14, 21, 686699),\n", + " datetime.datetime(2022, 5, 11, 16, 21, 53, 941946),\n", + " datetime.datetime(2022, 5, 11, 16, 21, 53, 941946),\n", + " datetime.datetime(2022, 5, 11, 16, 24, 46, 889624),\n", + " datetime.datetime(2022, 5, 11, 16, 24, 46, 889624),\n", + " datetime.datetime(2022, 5, 11, 16, 48, 11, 343603),\n", + " datetime.datetime(2022, 5, 11, 16, 48, 11, 343603),\n", + " datetime.datetime(2022, 5, 11, 16, 55, 13, 545705),\n", + " datetime.datetime(2022, 5, 11, 16, 55, 13, 545705),\n", + " datetime.datetime(2022, 5, 11, 17, 0, 40, 954670),\n", + " datetime.datetime(2022, 5, 11, 17, 0, 40, 954670),\n", + " datetime.datetime(2022, 5, 11, 17, 29, 32, 817614),\n", + " datetime.datetime(2022, 5, 11, 17, 29, 32, 817614),\n", + " datetime.datetime(2022, 5, 11, 17, 34, 26, 291739),\n", + " datetime.datetime(2022, 5, 11, 17, 34, 26, 291739),\n", + " datetime.datetime(2022, 5, 11, 17, 51, 58, 115158),\n", + " datetime.datetime(2022, 5, 11, 17, 51, 58, 115158),\n", + " datetime.datetime(2022, 5, 11, 17, 54, 12, 942954),\n", + " datetime.datetime(2022, 5, 11, 17, 54, 12, 942954),\n", + " datetime.datetime(2022, 5, 11, 17, 59, 59, 973607),\n", + " datetime.datetime(2022, 5, 11, 17, 59, 59, 973607),\n", + " datetime.datetime(2022, 5, 11, 18, 3, 53, 802608),\n", + " datetime.datetime(2022, 5, 11, 18, 3, 53, 802608),\n", + " datetime.datetime(2022, 5, 11, 18, 6, 14, 855339),\n", + " datetime.datetime(2022, 5, 11, 18, 6, 14, 855339),\n", + " datetime.datetime(2022, 5, 11, 18, 11, 37, 557165),\n", + " datetime.datetime(2022, 5, 11, 18, 11, 37, 557165),\n", + " datetime.datetime(2022, 5, 11, 18, 15, 43, 36009),\n", + " datetime.datetime(2022, 5, 11, 18, 15, 43, 36009),\n", + " datetime.datetime(2022, 5, 11, 18, 19, 13, 21821),\n", + " datetime.datetime(2022, 5, 11, 18, 19, 13, 21821),\n", + " datetime.datetime(2022, 5, 11, 18, 23, 5, 25975),\n", + " datetime.datetime(2022, 5, 11, 18, 23, 5, 25975),\n", + " datetime.datetime(2022, 5, 11, 18, 25, 31, 374416),\n", + " datetime.datetime(2022, 5, 11, 18, 25, 31, 374416),\n", + " datetime.datetime(2022, 5, 11, 18, 28, 38, 201648),\n", + " datetime.datetime(2022, 5, 11, 18, 28, 38, 201648),\n", + " datetime.datetime(2022, 5, 11, 18, 31, 0, 569564),\n", + " datetime.datetime(2022, 5, 11, 18, 31, 0, 569564),\n", + " datetime.datetime(2022, 5, 11, 18, 33, 35, 806353),\n", + " datetime.datetime(2022, 5, 11, 18, 33, 35, 806353),\n", + " datetime.datetime(2022, 5, 11, 18, 36, 52, 516399),\n", + " datetime.datetime(2022, 5, 11, 18, 36, 52, 516399),\n", + " datetime.datetime(2022, 5, 11, 18, 40, 43, 448785),\n", + " datetime.datetime(2022, 5, 11, 18, 40, 43, 448785),\n", + " datetime.datetime(2022, 5, 11, 18, 44, 48, 699203),\n", + " datetime.datetime(2022, 5, 11, 18, 44, 48, 699203),\n", + " datetime.datetime(2022, 5, 11, 18, 48, 48, 782902),\n", + " datetime.datetime(2022, 5, 11, 18, 48, 48, 782902),\n", + " datetime.datetime(2022, 5, 11, 18, 51, 37, 308562),\n", + " datetime.datetime(2022, 5, 11, 18, 51, 37, 308562),\n", + " datetime.datetime(2022, 5, 11, 18, 56, 47, 252783),\n", + " datetime.datetime(2022, 5, 11, 18, 56, 47, 252783),\n", + " datetime.datetime(2022, 5, 11, 19, 0, 51, 573200),\n", + " datetime.datetime(2022, 5, 11, 19, 0, 51, 573200)],\n", + " 'Value': ['0',\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " '0'],\n", + " 'Geometry': [,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ]}" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "vessel.log" ] @@ -275,7 +1157,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.12" + "version": "3.9.10" } }, "nbformat": 4,