diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..3c72f47 --- /dev/null +++ b/.gitignore @@ -0,0 +1,3 @@ +.ipynb_checkpoints/ +utility_functions/__pycache__ +utility_functions/__pycache__/* diff --git a/Project.ipynb b/Project.ipynb index 266d5e3..6616f73 100644 --- a/Project.ipynb +++ b/Project.ipynb @@ -12,7 +12,7 @@ "\n", "### Assignments\n", "\n", - "1. Generate a series of patterns of trasmissions on a network represented as a graph. In such graph the edges are weighted accordingly to the delay between transmittion and reception.\n", + "1. Generate a series of patterns of transmissions on a network represented as a graph. In such graph the edges are weighted accordingly to the delay between transmittion and reception.\n", "2. Implement euristic algorithms to lower the potential of the network, i.e. aiming at minimizing the distance of the communications from their final destination.\n", "3. Find out the most efficient algorithm\n", "\n", @@ -20,6 +20,3916 @@ "Leonardo Badia " ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Introduction to Delay Tolerant Networks\n", + "\n", + "Delay Tolerant Networking (DTN) is a relatively new area of research which \n", + "is rapidly becoming the focus of considerable effort. DTN is an approach\n", + "to computer architecture that seeks to address the technical issues in \n", + "heterogeneus networks that may lack continuos network connectivity. The\n", + "final aim of this developing study area is to tackle problems which the \n", + "Internet is not able to face. \n", + "\n", + "There's a great variety among the different DTNs: they range from deep \n", + "space networks to buses driving around mobile wireless hotspots in \n", + "villages to provide Internet service to kiosks. \n", + "\n", + "The big difference from the regular Internet Protocol (IP) is that IP\n", + "assumes a seamless end-to-end data path instead DTNs are built to account\n", + "for errors and disconnections. Unlike IP, where heterogeneus networks are \n", + "connected by assigning each node a common network-layer identifier (IP address),\n", + "a DTN uses \"naming, layering, encapsulation and persistent storage\".\n", + "\n", + "The situations in which we use DTNs are pretty challenging:\n", + "\n", + "* The throughput is generally low (we can think for instance about the acoustic in underwater modems) and may \n", + "be highly asymmetric or in the worse scenario a return channel might not \n", + "exist\n", + "\n", + "* These networks are frequently disconnected, not only by faults but due\n", + "to motion for instance\n", + "\n", + "* These systems frequently operate with a low duty cycle and the queuing \n", + "time can be very large; with these conditions TCP would time out the session\n", + "instead UDP would lose all the packets.\n", + "\n", + "We decided to use 2 different approaches in order to face to routing problem with DTNs. The first one is a greedy\n", + "algorithm while the second is an epidemic algorithm. \n", + "\n", + "We decided to model the DTN as a wireless network where at each time step a link has a certain probability of being shut down for a certain amount of time. \n", + "\n", + "Before going into the details of the two different algorithms there are some assumptions that need to be pointed out:\n", + "\n", + "* We are working with infinite buffers \n", + "\n", + "* There are no errors in transmission\n", + "\n", + "* There's a maximum distance between two satellites beyond which they can't communicate\n", + "\n", + "* We keep the same size for every packet and the same bandwidth for each link\n", + "\n", + "* This is a centralized system, in the sense that Earth knows all the topology of the network\n", + "\n", + "The simulated network is a satellitar network where the nodes need to send data to the main station on Earth, for the sake of semplicity all of them have a direct link to the the destination. This is not an oversemplification because given the fact that links often shut down the overall behaviour is similar to the one we would have in case of indirect communications.\n", + "\n", + "We repeated the tests done below also for the latter case but they were not kept. This is due to the fact that since some satellites are too far to directly communicate with the base station it is necessary to increase the number of nodes in order to have a meaningful configuration.\n", + "Increasing the total number of nodes is prohibitive because both the algorithms are superlinear in the number of nodes, meaning that it takes too much time to execute them in this particular case.\n", + "In most cases the results were very similar to the one obtained by the simulation, if not it will be specified below." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "#used to import the utility functions\n", + "import sys\n", + "sys.path.insert(1, \"utility_functions/\")\n", + "\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from mpl_toolkits.mplot3d import Axes3D\n", + "from matplotlib.lines import Line2D\n", + "import matplotlib.animation as animation\n", + "import math\n", + "import pylab as pl\n", + "from matplotlib import collections as mc\n", + "import mpl_toolkits.mplot3d.axes3d as p3\n", + "from network_utilities import generate_network, plot_network, disable_links, adjacency_matrix\n", + "from greedy_routing import greedy_routing\n", + "from graphics import plot_idle\n", + "from metrics import throughput, delay, deviations\n", + "from animation_utilities import get_links, check_active, update_lines, get_vel, update_graph\n", + "import pandas as pd\n", + "from epidemics import epidemic, remove_duplicates\n", + "from tqdm.notebook import tqdm\n", + "import copy\n", + "\n", + "#MAIN PARAMETERS\n", + "################################################\n", + "n = 10 #\n", + "c = 3e8 #\n", + "T_tx = 10 # da regolare #\n", + "r_max = 60e9 # Marte #\n", + "tau_max = 200 #\n", + "delta_time = 10 #\n", + "n_configurations = 10 #\n", + "network_seed = 17363720 #\n", + "################################################" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "nodes = generate_network(n,r_max,seed=17363720)\n", + "A = adjacency_matrix(nodes,tau_max)\n", + "sorted_nodes = np.argsort(A[0,:]) #sorting based on distance from Earth\n", + "A = A[sorted_nodes,:][:,sorted_nodes]\n", + "nodes = nodes[sorted_nodes]" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "application/javascript": [ + "/* Put everything inside the global mpl namespace */\n", + "window.mpl = {};\n", + "\n", + "\n", + "mpl.get_websocket_type = function() {\n", + " if (typeof(WebSocket) !== 'undefined') {\n", + " return WebSocket;\n", + " } else if (typeof(MozWebSocket) !== 'undefined') {\n", + " return MozWebSocket;\n", + " } else {\n", + " alert('Your browser does not have WebSocket support. ' +\n", + " 'Please try Chrome, Safari or Firefox ≥ 6. ' +\n", + " 'Firefox 4 and 5 are also supported but you ' +\n", + " 'have to enable WebSockets in about:config.');\n", + " };\n", + "}\n", + "\n", + "mpl.figure = function(figure_id, websocket, ondownload, parent_element) {\n", + " this.id = figure_id;\n", + "\n", + " this.ws = websocket;\n", + "\n", + " this.supports_binary = (this.ws.binaryType != undefined);\n", + "\n", + " if (!this.supports_binary) {\n", + " var warnings = document.getElementById(\"mpl-warnings\");\n", + " if (warnings) {\n", + " warnings.style.display = 'block';\n", + " warnings.textContent = (\n", + " \"This browser does not support binary websocket messages. \" +\n", + " \"Performance may be slow.\");\n", + " }\n", + " }\n", + "\n", + " this.imageObj = new Image();\n", + "\n", + " this.context = undefined;\n", + " this.message = undefined;\n", + " this.canvas = undefined;\n", + " this.rubberband_canvas = undefined;\n", + " this.rubberband_context = undefined;\n", + " this.format_dropdown = undefined;\n", + "\n", + " this.image_mode = 'full';\n", + "\n", + " this.root = $('
');\n", + " this._root_extra_style(this.root)\n", + " this.root.attr('style', 'display: inline-block');\n", + "\n", + " $(parent_element).append(this.root);\n", + "\n", + " this._init_header(this);\n", + " this._init_canvas(this);\n", + " this._init_toolbar(this);\n", + "\n", + " var fig = this;\n", + "\n", + " this.waiting = false;\n", + "\n", + " this.ws.onopen = function () {\n", + " fig.send_message(\"supports_binary\", {value: fig.supports_binary});\n", + " fig.send_message(\"send_image_mode\", {});\n", + " if (mpl.ratio != 1) {\n", + " fig.send_message(\"set_dpi_ratio\", {'dpi_ratio': mpl.ratio});\n", + " }\n", + " fig.send_message(\"refresh\", {});\n", + " }\n", + "\n", + " this.imageObj.onload = function() {\n", + " if (fig.image_mode == 'full') {\n", + " // Full images could contain transparency (where diff images\n", + " // almost always do), so we need to clear the canvas so that\n", + " // there is no ghosting.\n", + " fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n", + " }\n", + " fig.context.drawImage(fig.imageObj, 0, 0);\n", + " };\n", + "\n", + " this.imageObj.onunload = function() {\n", + " fig.ws.close();\n", + " }\n", + "\n", + " this.ws.onmessage = this._make_on_message_function(this);\n", + "\n", + " this.ondownload = ondownload;\n", + "}\n", + "\n", + "mpl.figure.prototype._init_header = function() {\n", + " var titlebar = $(\n", + " '
');\n", + " var titletext = $(\n", + " '
');\n", + " titlebar.append(titletext)\n", + " this.root.append(titlebar);\n", + " this.header = titletext[0];\n", + "}\n", + "\n", + "\n", + "\n", + "mpl.figure.prototype._canvas_extra_style = function(canvas_div) {\n", + "\n", + "}\n", + "\n", + "\n", + "mpl.figure.prototype._root_extra_style = function(canvas_div) {\n", + "\n", + "}\n", + "\n", + "mpl.figure.prototype._init_canvas = function() {\n", + " var fig = this;\n", + "\n", + " var canvas_div = $('
');\n", + "\n", + " canvas_div.attr('style', 'position: relative; clear: both; outline: 0');\n", + "\n", + " function canvas_keyboard_event(event) {\n", + " return fig.key_event(event, event['data']);\n", + " }\n", + "\n", + " canvas_div.keydown('key_press', canvas_keyboard_event);\n", + " canvas_div.keyup('key_release', canvas_keyboard_event);\n", + " this.canvas_div = canvas_div\n", + " this._canvas_extra_style(canvas_div)\n", + " this.root.append(canvas_div);\n", + "\n", + " var canvas = $('');\n", + " canvas.addClass('mpl-canvas');\n", + " canvas.attr('style', \"left: 0; top: 0; z-index: 0; outline: 0\")\n", + "\n", + " this.canvas = canvas[0];\n", + " this.context = canvas[0].getContext(\"2d\");\n", + "\n", + " var backingStore = this.context.backingStorePixelRatio ||\n", + "\tthis.context.webkitBackingStorePixelRatio ||\n", + "\tthis.context.mozBackingStorePixelRatio ||\n", + "\tthis.context.msBackingStorePixelRatio ||\n", + "\tthis.context.oBackingStorePixelRatio ||\n", + "\tthis.context.backingStorePixelRatio || 1;\n", + "\n", + " mpl.ratio = (window.devicePixelRatio || 1) / backingStore;\n", + "\n", + " var rubberband = $('');\n", + " rubberband.attr('style', \"position: absolute; left: 0; top: 0; z-index: 1;\")\n", + "\n", + " var pass_mouse_events = true;\n", + "\n", + " canvas_div.resizable({\n", + " start: function(event, ui) {\n", + " pass_mouse_events = false;\n", + " },\n", + " resize: function(event, ui) {\n", + " fig.request_resize(ui.size.width, ui.size.height);\n", + " },\n", + " stop: function(event, ui) {\n", + " pass_mouse_events = true;\n", + " fig.request_resize(ui.size.width, ui.size.height);\n", + " },\n", + " });\n", + "\n", + " function mouse_event_fn(event) {\n", + " if (pass_mouse_events)\n", + " return fig.mouse_event(event, event['data']);\n", + " }\n", + "\n", + " rubberband.mousedown('button_press', mouse_event_fn);\n", + " rubberband.mouseup('button_release', mouse_event_fn);\n", + " // Throttle sequential mouse events to 1 every 20ms.\n", + " rubberband.mousemove('motion_notify', mouse_event_fn);\n", + "\n", + " rubberband.mouseenter('figure_enter', mouse_event_fn);\n", + " rubberband.mouseleave('figure_leave', mouse_event_fn);\n", + "\n", + " canvas_div.on(\"wheel\", function (event) {\n", + " event = event.originalEvent;\n", + " event['data'] = 'scroll'\n", + " if (event.deltaY < 0) {\n", + " event.step = 1;\n", + " } else {\n", + " event.step = -1;\n", + " }\n", + " mouse_event_fn(event);\n", + " });\n", + "\n", + " canvas_div.append(canvas);\n", + " canvas_div.append(rubberband);\n", + "\n", + " this.rubberband = rubberband;\n", + " this.rubberband_canvas = rubberband[0];\n", + " this.rubberband_context = rubberband[0].getContext(\"2d\");\n", + " this.rubberband_context.strokeStyle = \"#000000\";\n", + "\n", + " this._resize_canvas = function(width, height) {\n", + " // Keep the size of the canvas, canvas container, and rubber band\n", + " // canvas in synch.\n", + " canvas_div.css('width', width)\n", + " canvas_div.css('height', height)\n", + "\n", + " canvas.attr('width', width * mpl.ratio);\n", + " canvas.attr('height', height * mpl.ratio);\n", + " canvas.attr('style', 'width: ' + width + 'px; height: ' + height + 'px;');\n", + "\n", + " rubberband.attr('width', width);\n", + " rubberband.attr('height', height);\n", + " }\n", + "\n", + " // Set the figure to an initial 600x600px, this will subsequently be updated\n", + " // upon first draw.\n", + " this._resize_canvas(600, 600);\n", + "\n", + " // Disable right mouse context menu.\n", + " $(this.rubberband_canvas).bind(\"contextmenu\",function(e){\n", + " return false;\n", + " });\n", + "\n", + " function set_focus () {\n", + " canvas.focus();\n", + " canvas_div.focus();\n", + " }\n", + "\n", + " window.setTimeout(set_focus, 100);\n", + "}\n", + "\n", + "mpl.figure.prototype._init_toolbar = function() {\n", + " var fig = this;\n", + "\n", + " var nav_element = $('
');\n", + " nav_element.attr('style', 'width: 100%');\n", + " this.root.append(nav_element);\n", + "\n", + " // Define a callback function for later on.\n", + " function toolbar_event(event) {\n", + " return fig.toolbar_button_onclick(event['data']);\n", + " }\n", + " function toolbar_mouse_event(event) {\n", + " return fig.toolbar_button_onmouseover(event['data']);\n", + " }\n", + "\n", + " for(var toolbar_ind in mpl.toolbar_items) {\n", + " var name = mpl.toolbar_items[toolbar_ind][0];\n", + " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", + " var image = mpl.toolbar_items[toolbar_ind][2];\n", + " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", + "\n", + " if (!name) {\n", + " // put a spacer in here.\n", + " continue;\n", + " }\n", + " var button = $('');\n", + " button.click(method_name, toolbar_event);\n", + " button.mouseover(tooltip, toolbar_mouse_event);\n", + " nav_element.append(button);\n", + " }\n", + "\n", + " // Add the status bar.\n", + " var status_bar = $('');\n", + " nav_element.append(status_bar);\n", + " this.message = status_bar[0];\n", + "\n", + " // Add the close button to the window.\n", + " var buttongrp = $('
');\n", + " var button = $('');\n", + " button.click(function (evt) { fig.handle_close(fig, {}); } );\n", + " button.mouseover('Stop Interaction', toolbar_mouse_event);\n", + " buttongrp.append(button);\n", + " var titlebar = this.root.find($('.ui-dialog-titlebar'));\n", + " titlebar.prepend(buttongrp);\n", + "}\n", + "\n", + "mpl.figure.prototype._root_extra_style = function(el){\n", + " var fig = this\n", + " el.on(\"remove\", function(){\n", + "\tfig.close_ws(fig, {});\n", + " });\n", + "}\n", + "\n", + "mpl.figure.prototype._canvas_extra_style = function(el){\n", + " // this is important to make the div 'focusable\n", + " el.attr('tabindex', 0)\n", + " // reach out to IPython and tell the keyboard manager to turn it's self\n", + " // off when our div gets focus\n", + "\n", + " // location in version 3\n", + " if (IPython.notebook.keyboard_manager) {\n", + " IPython.notebook.keyboard_manager.register_events(el);\n", + " }\n", + " else {\n", + " // location in version 2\n", + " IPython.keyboard_manager.register_events(el);\n", + " }\n", + "\n", + "}\n", + "\n", + "mpl.figure.prototype._key_event_extra = function(event, name) {\n", + " var manager = IPython.notebook.keyboard_manager;\n", + " if (!manager)\n", + " manager = IPython.keyboard_manager;\n", + "\n", + " // Check for shift+enter\n", + " if (event.shiftKey && event.which == 13) {\n", + " this.canvas_div.blur();\n", + " event.shiftKey = false;\n", + " // Send a \"J\" for go to next cell\n", + " event.which = 74;\n", + " event.keyCode = 74;\n", + " manager.command_mode();\n", + " manager.handle_keydown(event);\n", + " }\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_save = function(fig, msg) {\n", + " fig.ondownload(fig, null);\n", + "}\n", + "\n", + "\n", + "mpl.find_output_cell = function(html_output) {\n", + " // Return the cell and output element which can be found *uniquely* in the notebook.\n", + " // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n", + " // IPython event is triggered only after the cells have been serialised, which for\n", + " // our purposes (turning an active figure into a static one), is too late.\n", + " var cells = IPython.notebook.get_cells();\n", + " var ncells = cells.length;\n", + " for (var i=0; i= 3 moved mimebundle to data attribute of output\n", + " data = data.data;\n", + " }\n", + " if (data['text/html'] == html_output) {\n", + " return [cell, data, j];\n", + " }\n", + " }\n", + " }\n", + " }\n", + "}\n", + "\n", + "// Register the function which deals with the matplotlib target/channel.\n", + "// The kernel may be null if the page has been refreshed.\n", + "if (IPython.notebook.kernel != null) {\n", + " IPython.notebook.kernel.comm_manager.register_target('matplotlib', mpl.mpl_figure_comm);\n", + "}\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "At = disable_links(A,5000,1,mode=\"unstable\") #demonstration with unstable mode\n", + "\n", + "n_updates = At.shape[2]\n", + "links = get_links(A,nodes)\n", + "active_links = [get_links(At[:,:,t],nodes) for t in range(n_updates)]\n", + "\n", + "fig = plt.figure()\n", + "ax = p3.Axes3D(fig)\n", + "\n", + "data = links\n", + "lines = [ax.plot(dat[0, :], dat[1, :], dat[2, :],alpha=0.5)[0] for dat in links]\n", + "\n", + "# Setting the axes properties\n", + "ax.set_xlim3d([-4e10, 4e10])\n", + "ax.set_xlabel('X(m)')\n", + "\n", + "ax.set_ylim3d([-4e10, 4e10])\n", + "ax.set_ylabel('Y(m)')\n", + "\n", + "ax.set_zlim3d([-4e10,4e10])\n", + "ax.set_zlabel('Z(m)')\n", + "\n", + "title = ax.set_title(\"Time = s\")\n", + "snodes = [100] + [50 for x in nodes[1:]]\n", + "cnodes = [\"green\"] + [\"black\" for x in nodes[1:]]\n", + "ax.scatter(nodes[:,0], nodes[:,1], nodes[:,2],s=snodes,color=cnodes,alpha=0.8)\n", + "\n", + "legend_lines = [Line2D([0], [0], color=\"black\", lw=2),\n", + " Line2D([0], [0], color=\"red\", lw=2)]\n", + "ax.legend(legend_lines, (\"Active links\",\"Disabled links\"))\n", + "\n", + "# Creating the Animation object\n", + "line_ani = animation.FuncAnimation(fig, update_lines, n_updates, fargs=(data, lines,active_links,title),\n", + " interval=10, blit=False)\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Greedy Routing\n", + "\n", + "In every network where data is generated from a node and needs to be delivered to a different one, may it be the postal network or the internet, it is necessary to find out the route that the data should follow in order to reach its destination.\n", + "\n", + "This is usually done by a routing algorithm, in the internet the most widely used ones are the Dijikstra and the Bellman-Ford algorithms, these two are used in order to find the shortest path from the source to the destination according to some metric that could be the number of hops, the end to end delay etc.\n", + "\n", + "\n", + "
\n", + " \n", + "
\n", + " \n", + " Path obtained by applying routing between the two nodes\n", + " \n", + "
\n", + "
\n", + "\n", + "Classical routing algorithms do not work on DTNs (Delay Tolerant Networks) because they were thought for systems where links are supposed to fail very rarely and where the end to end delay is relatively small.\n", + "\n", + "In the internet the chance of a link failing is low and even if it does the end to end delay is small, so in case a packet is lost because of link failure sending the packet again is not too expensive.\n", + "In DTNs this is not true because:\n", + "\n", + "* The propagation time is very high, expecially if we are considering satellite communication\n", + "\n", + "* The chance of link failure is very high.\n", + "\n", + "On top of that it is not even possible to find the best routing algorithm for networks, this is because if also the traffic generated by other nodes is taken into consideration the problem becomes NP.\n", + "By analyzing the state of the art in DTN it is possible to see that the best results are mostly obtained by using greedy algorithms, i. e. algorithms that take a decision by choosing the best choice at each iteration without considering long term planning.\n", + "\n", + "The main underliying assumptions used in the implementation of the greedy algorithm are:\n", + "* Full knowledge of the topology and evolution of the network is given. This is not a very strict requirement as it might happen in real life, for example for satellite networks, where usually link failure is caused by the interference of a celestial body, the requirement can be easily satisfied.\n", + "* One central station (Earth), that fully knows the topology evolution of the network, calculates all the optimal routes beforehand and communicates them to each node. The fact that a central node perfoms all the computations allows for accurate scheduling that avoids collisions so no method has to be emplyed in order to detect them.\n", + "\n", + "The implemented greedy algorithm chooses the best next hop by using a slightly modified version of the dijkstra algorithm that allows to compute the best path from the source to the destination at a specific point in time.\n", + "\n", + "Since it is also necessary to take collisions into account, if sending one packet causes one, the sender needs to wait until it is sure that no collision will occur. After the idle time waited in order to avoid collisions the optimal path needs to be recomputed because, due to topology changes, it might not be optimal anymore.\n", + "\n", + "## Modified Dijkstra\n", + "\n", + "In general the Dijkstra algorithm is used to find the best path between two nodes in weighted graphs with positive weights.\n", + "\n", + "
\n", + " \n", + "
\n", + " \n", + " Dijkstra algorithm in action\n", + " \n", + "
\n", + "
\n", + "\n", + "Usually the algorithm is run on graphs that have fixed topology, unfortunately for DNTs this is not the case, hence a link that was active when the packet was sent might not be active when the packet reaches its destination.\n", + "\n", + "This has to be taken into account because a link failing while a message is being sent through the link will result in packet loss.\n", + "\n", + "An implementation of the Dijkstra algorithm for DTNs that solved this problem was proposed in [1].\n", + "With this approach the weight of a node is considered equal to $t_p + t_{tr} + t_w$ where $t_p$ is the propagation time, $t_{tr}$ is the transmission time and $t_w$ is the total time that the sender needs to wait before sending because of link failures.\n", + "\n", + "The pseudo code for the algorithm is:\n", + "```\n", + "Input = G=(E, V), s, T, w(e,t)\n", + "Q = V\n", + "L[s]=0\n", + "L[v]=inf for every v != s\n", + "while Q != {} do\n", + " u = u in Q that minimizes L[u]\n", + " Q = Q - u\n", + " for each edge e in E between u and another vertex v do\n", + " if L[v] > L[u] + w(e, T + L[u]) then\n", + " L[v] = L[u] + w(e, T + L[u])\n", + " end if\n", + " end for\n", + "end while\n", + "```\n", + "Where G is the graph representing the network, s is the starting node, T is the starting time, w(e,t) is the weight of edge e at time t.\n", + "The only difference from the standard algorithm is that in the standard case w(e,t) is constant in t, meaning that by correctly computing the function w(e,t) the algorithm will be able to find shortest paths also in the case of changing topology.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Algorithmic Analysis\n", + "\n", + "In order to get a basic understanding on how the algorithm is working we decided to draw the following plots:\n", + "\n", + "1) The first plot represents the number of packets that passed through a certain node during their trip from source to destination. The nodes are indicated as a number and they are ordered from the closest (node 1) to the farthest from Earth (node 9).\n", + "\n", + "2) The second plot shows the occupation of the Earth, in particular the orange zone represent moments when the Earth is not receiving any data, while the teal one identifies moments when Earth is receiving a packet." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "1d702f6ff0bc41a18dabd77e1919fe25", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HBox(children=(FloatProgress(value=0.0, max=2000.0), HTML(value='')))" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "np.random.seed(10)\n", + "#generating some random packets with earth as destination\n", + "packets = np.random.randint(1, n, (2000, 2))\n", + "packets[:,1] = 0\n", + "\n", + "ttr = T_tx\n", + "At = disable_links(A, 1000000, delta_time ,mode=\"unstable\")\n", + "#performing the routing algorithm\n", + "results = greedy_routing(At, packets, ttr, delta_time, with_tqdm =True)\n", + "\n", + "#finding out how many packets transited in one node\n", + "packet_distribution = np.zeros(n)\n", + "\n", + "#for each packet\n", + "for packet in results:\n", + " #for each node in the route\n", + " for node in packet.route:\n", + " #if the node is not the destination\n", + " if node != packet.destination:\n", + " packet_distribution[node] += 1\n", + " \n", + "#keep copies of the original data for later\n", + "initial_nodes = np.copy(nodes)\n", + "initial_A = np.copy(A)\n", + "packets_greedy = copy.deepcopy(results) " + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "%matplotlib inline\n", + "_, axs = plt.subplots(1, 2, figsize = (15, 5))\n", + "axs[0].bar(np.arange(n), packet_distribution)\n", + "axs[0].set_title(\"Number of packets that passed through a node\")\n", + "axs[0].set_xlabel(\"Nodes id ordered by distance from earth\")\n", + "axs[0].set_ylabel(\"# of packets\")\n", + "axs[0].set_xticks(np.arange(n))\n", + "plot_idle(results, ttr, axs[1]) " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "1) From the first plot we notice a very intuitive fact, which is that packets tend to pass through nodes that are closer to earth. The two peaks in 8 and 9 are due to the fact that with this specific configuration the two exchange some packets because of link failure as can be seen in the final animation.\n", + "\n", + "2) The key observation for the second plot is that Earth is almost always receiving packets, this means that the algorithm is very efficient.\n", + "\n", + "### Transmission Time effect on the algorithm\n", + "\n", + "In next section the outcome of the algorithm is tested in case the transmission time greatly changes, this value is related to the dimension of the packet (L) and to the bandwidth of the channel (B), in particular $t_{tr} = \\frac{L}{B}$.\n", + "This helps us understand how the algorithm answers to low bandwidth networks or when it is necessary to send very big packets.\n", + "\n", + "The following plots show how the arrival time, the throughput and the number of optimal routes changes as the transmission time increases.\n", + "\n", + "In order to reduce the effect of noise we ran the algorithm multiple times with different network configurations and we averaged the outcome. The whole procedure was repeated with two different link deactivation probabilities in order to see how this impacts on the algorithm." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "b604a68d36e7428b9e0f1ff106c61264", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HBox(children=(FloatProgress(value=0.0, max=10.0), HTML(value='')))" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "062d9b359c8346a0815ff5bb3114db6f", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HBox(children=(FloatProgress(value=0.0, max=10.0), HTML(value='')))" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig = plt.figure(figsize=(10, 10))\n", + "\n", + "#generating the axes as wanted\n", + "gs = fig.add_gridspec(2, 2)\n", + "axs = []\n", + "axs.append(fig.add_subplot(gs[0, :]))\n", + "axs.append(fig.add_subplot(gs[1, 0]))\n", + "axs.append(fig.add_subplot(gs[1, 1]))\n", + "\n", + "#generating some random packets with earth as destination\n", + "packets = np.random.randint(1, n, (100, 2))\n", + "packets[:,1] = 0\n", + "\n", + "#trying out the outcomes with two different link deactivation modes\n", + "for mode in [\"light\", \"unstable\"]:\n", + "\n", + " #choosing the color to be used in the plot\n", + " color = [\"blue\", \"red\"]\n", + " color = color[mode == \"light\"]\n", + "\n", + " #defining the transmission times that will be tested\n", + " ttrs = range(1, 200, 20)\n", + "\n", + " #outputs of the routing algorithm for each configuration and ttr\n", + " outputs = np.zeros((len(ttrs), n_configurations))\n", + " deviation_arr = np.zeros((len(ttrs), n_configurations))\n", + "\n", + " for rand_iter in tqdm(range(n_configurations)):\n", + "\n", + " #generate a new configuration\n", + " nodes = generate_network(n, r_max)\n", + " A = adjacency_matrix(nodes,tau_max)\n", + " At = disable_links(A,500000, delta_time, mode=mode)\n", + "\n", + " #for each transmission time\n", + " for ttr_ind in range(len(ttrs)):\n", + "\n", + " #calculate the route of each packet\n", + " results = greedy_routing(At, packets, ttrs[ttr_ind], delta_time)\n", + " #finding out the arrival times of each packet\n", + " arrival_times = np.array([packet.arrival_times[-1] for packet in results])\n", + " #the overall transmission time is the maximum of the arrival times\n", + " outputs[ttr_ind, rand_iter] = np.max(arrival_times)\n", + " #getting the number of packets that followed a route different from the ideal one\n", + " deviation_arr[ttr_ind, rand_iter] = deviations(A, results)\n", + "\n", + " #finding the mean over the different configurations of the arrival times\n", + " arrival_times = np.mean(outputs, axis = 1)\n", + "\n", + " #plotting\n", + " axs[0].plot(ttrs, arrival_times, linestyle = \"-\", c = color)\n", + " axs[0].plot(ttrs, arrival_times - packets.shape[0] * np.array(ttrs), linestyle = \"-.\", c = color)\n", + " axs[1].plot(ttrs, throughput(packets.shape[0], arrival_times) * np.array(ttrs), linestyle = \"--\", c = color)\n", + " axs[2].plot(ttrs, np.mean(deviation_arr, axis = 1), linestyle=\"--\", c = color)\n", + "\n", + "axs[0].plot(ttrs, packets.shape[0] * np.array(ttrs), linestyle = \"--\", c=\"black\")\n", + "axs[0].set_ylabel(\"Time(s)\")\n", + "axs[0].set_xlabel(\"Transmission Time(s)\")\n", + "axs[0].set_title(\"Mean arrival time vs mean idle time\")\n", + "\n", + "axs[0].legend([\n", + " \"Arrival time(light)\", \n", + " \"Idle time(light)\",\n", + " \"Arrival time(unst)\",\n", + " \"Idle time(unst)\",\n", + " \"Total Transmission Time\",\n", + "])\n", + "\n", + "axs[1].set_title(\"Throughput of the system\")\n", + "axs[1].set_ylabel(\"Normalized Throughput\")\n", + "axs[1].set_xlabel(\"Transmission Time(s)\")\n", + "axs[1].legend([\n", + " \"Throughput(light)\",\n", + " \"Throughput(unstable)\"\n", + "])\n", + "\n", + "axs[2].set_title(\"Percentage of packets that followed unoptimal route\")\n", + "axs[2].set_ylabel(\"Percentage\")\n", + "axs[2].set_xlabel(\"Transmission Time(s)\")\n", + "axs[2].legend([\n", + " \"Percentage(light)\",\n", + " \"Percentage(unstable)\"\n", + "])\n", + "plt.tight_layout()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Some insights on the plots\n", + "\n", + "1) What we get in the first plot is that the idle time remains almost equal to zero even if we increase the transmission time a \n", + "lot. The total transmission time can be expressed as $T_{tot} = t_{tx}n_{packets}$ and is the lower bound for the arrival time $t_a = T_{tot} + t_{idle}$. If we consider the light and unstable mode we can see that the results are very similar, the arrival time though is always higher for the unstable mode as expected; this is because if more links are being shut down it is reasonable to expect a longer arrival time.\n", + "\n", + "2) With the second plot it is possible to see that for small values of the transmission time the normalized throughput is very small, this is due to the fact that the arrival time is dominated by the propagation time.\n", + "In other words since $t_{tx}$ is small it means that the Earth has a lot of idle time, meaning that the normalized throughput is not too high.\n", + "With $t_{tx}>50s$ we can see that the throughput is basically unaffected by the transmission time.\n", + "Also in this case as expected the light mode curve is above the unstable mode one.\n", + "\n", + "\n", + "3) In the third plot we can observe something very intuitive: the bigger the transmission time, the \n", + "higher the percentage of non optimal routes will be; this is due to the fact that as $t_{tx}$ increase so does the queueing time, meaning that it is more likely that the path will be changed.\n", + "Here instead we can spot a big difference between light and unstable mode, given by the \n", + "fact that with unstable mode we are shutting down many more links than with light mode so the number of unoptimal routes must be higher.\n", + "\n", + "### Propagation time effects\n", + "The next plots investigate how the arrival time, throughput and percentage of optimal routes changes as functions of the distance between nodes. The distance between nodes is actually proportional to the propagation time $t_p = \\frac{dist}{c}$ where c is the speed of light so the two analisys will yield the same result." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "17561aca9c58434d9fd2398284d92f8d", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HBox(children=(FloatProgress(value=0.0, max=10.0), HTML(value='')))" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "8ad85e9502d342e79540bbb35eeab326", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HBox(children=(FloatProgress(value=0.0, max=10.0), HTML(value='')))" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "ttr = T_tx\n", + "fig = plt.figure(figsize=(10, 10))\n", + "\n", + "#generating the axes as wanted\n", + "gs = fig.add_gridspec(2, 2)\n", + "axs = []\n", + "axs.append(fig.add_subplot(gs[0, :]))\n", + "axs.append(fig.add_subplot(gs[1, 0]))\n", + "axs.append(fig.add_subplot(gs[1, 1]))\n", + "\n", + "#iterating over two different modes\n", + "for mode in [\"light\", \"unstable\"]:\n", + "\n", + " color = [\"blue\", \"red\"]\n", + " color = color[mode == \"light\"]\n", + "\n", + " #constants that multiplied by the propagation times simulate the expansion of the configuration\n", + " r_maxes = np.array([2**((i-4)/2) for i in range(10)])\n", + "\n", + " #temporary variables used to store \n", + " outputs = np.zeros((len(r_maxes), n_configurations))\n", + " deviation_arr = np.zeros((len(r_maxes), n_configurations))\n", + "\n", + " #for each different configuration\n", + " for rand_iter in tqdm(range(n_configurations)):\n", + "\n", + " #generating a configuration\n", + " nodes = generate_network(n, r_max)\n", + " A = adjacency_matrix(nodes, tau_max)\n", + " At = disable_links(A,200000, delta_time, mode=mode)\n", + "\n", + " #for each constant\n", + " for i in range(len(r_maxes)):\n", + "\n", + " #keeping the same configuration but rescaling the proagation times\n", + " results = greedy_routing(At*r_maxes[i], packets, ttr, delta_time)\n", + "\n", + " #getting the overall transmission time and the number of unoptimal routes\n", + " arrival_times = np.array([packet.arrival_times[-1] for packet in results])\n", + " outputs[i, rand_iter] = np.max(arrival_times)\n", + " deviation_arr[i, rand_iter] = deviations(A*r_maxes[i], results)\n", + "\n", + " arrival_times = np.mean(outputs, axis = 1)\n", + " axs[0].semilogx(r_maxes * r_max, arrival_times, linestyle = \"-\", c = color)\n", + " axs[0].semilogx(r_maxes * r_max, arrival_times - packets.shape[0] * ttr, linestyle = \"-.\", c = color)\n", + " axs[1].semilogx(r_maxes * r_max, throughput(packets.shape[0], arrival_times)*ttr, linestyle=\"--\", c = color)\n", + " axs[2].plot(r_maxes * r_max, np.mean(deviation_arr, axis = 1), linestyle = \"--\", c = color)\n", + "\n", + "axs[0].semilogx(r_maxes * r_max, np.ones(len(r_maxes)) * packets.shape[0] * ttr, linestyle = \"--\", c = \"black\")\n", + "axs[0].set_ylabel(\"Time(s)\")\n", + "axs[0].set_xlabel(\"Radius(m)\")\n", + "axs[0].set_title(\"Mean arrival time vs mean idle time\")\n", + "axs[0].legend([\n", + " \"Arrival time(light)\", \n", + " \"Idle time(light)\",\n", + " \"Arrival time(unst)\",\n", + " \"Idle time(unst)\",\n", + " \"Total Transmission Time\"\n", + "])\n", + "\n", + "axs[1].set_title(\"Throughput of the system\")\n", + "axs[1].set_ylabel(\"Normalized Throughput\")\n", + "axs[1].set_xlabel(\"Radius(m)\")\n", + "axs[1].legend([\n", + " \"Throughput(light)\", \n", + " \"Throughput(unstable)\",\n", + "])\n", + "\n", + "axs[2].set_title(\"Percentage of packets that followed unoptimal route\")\n", + "axs[2].set_ylabel(\"Percentage\")\n", + "axs[2].set_xlabel(\"Radius(m)\")\n", + "axs[2].legend([\n", + " \"Percentage(light)\",\n", + " \"Percentage(unstable)\"\n", + "])\n", + "plt.tight_layout() \n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Some insights on the plots \n", + "\n", + "1) With the first plot we are visualizing the arrival time, the idle time and the total transmission \n", + "time as a function of the maximum radius under light and unstable mode.\n", + "What we see is that:\n", + " \n", + "* Either with light and unstable mode the idle time is almost constant up to a certain radius. This\n", + " constant is close to zero for light mode whereas for unstable mode it is about 300 seconds. Then from \n", + " a certain radius on we see an increse which for light mode is very slow and instead for the unstable \n", + " mode is very fast but in both case the trend is linear with the propagation time.\n", + " The fact that at the beginning the arrival time is almost constant is due to the fact that the \n", + " transmission time dominates the transmission while after $t_{tx}$ becomes negligible with respect to\n", + " $t_p$ then the arrival time starts to become proportional with the maximum radius.\n", + "\n", + "\n", + "2) With the second plot we're pointing out the throughput as a function of the maximum radius;\n", + "what we observe is that the behaviour under light and unstable mode is similar but of course light mode gives us a higher throughput. Anyway for both modes the throughput is almost constant (for the unstable mode the constant is centered at 0.08 instead for the light mode it is centered at 0.09) like before when the transmission time becomes negligible with respect to the propagation time the transmission becomes dominated by the latter resulting in a lower normalized throughput.\n", + " \n", + "\n", + "3) In the last image we can observe the percentage of packets that followed unoptimal routes as a function of the maximum\n", + "radius. What we get for the two different modes is a similar behaviour and they don't express a clear relation with the maximum radius as it looks like it is more or less constant.\n", + "\n", + "### Effect of the number of packets\n", + "Finally with the next plots we want to see how the various metrics change as the number of packets, and thus the network load, increases." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "d62f9ae6e2f54ceab8da66ccb1081c30", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HBox(children=(FloatProgress(value=0.0, max=10.0), HTML(value='')))" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "b47ad03b56f746bd914061c1a4e283ff", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HBox(children=(FloatProgress(value=0.0, max=10.0), HTML(value='')))" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig = plt.figure(figsize=(10, 10))\n", + "#generating the axes as wanted\n", + "gs = fig.add_gridspec(2, 2)\n", + "axs = []\n", + "axs.append(fig.add_subplot(gs[0, :]))\n", + "axs.append(fig.add_subplot(gs[1, 0]))\n", + "axs.append(fig.add_subplot(gs[1, 1]))\n", + "ttr = T_tx\n", + "\n", + "for mode in [\"light\", \"unstable\"]:\n", + "\n", + " color = [\"blue\", \"red\"]\n", + " color = color[mode == \"light\"]\n", + "\n", + " #changing the number of packets\n", + " packet_numbers = [2**i for i in range(1,13)]\n", + "\n", + " outputs = np.zeros((len(packet_numbers), n_configurations))\n", + " deviation_arr = np.zeros((len(packet_numbers), n_configurations))\n", + "\n", + " for rand_iter in tqdm(range(n_configurations)):\n", + "\n", + " nodes = generate_network(n, r_max)\n", + " A = adjacency_matrix(nodes, tau_max)\n", + " At = disable_links(A,200000, delta_time, mode = mode)\n", + "\n", + " for i in range(len(packet_numbers)):\n", + "\n", + " #generating new packets every time since their number changes at every iteration\n", + " packets = np.random.randint(1, n, (packet_numbers[i], 2))\n", + " packets[:,1] = 0\n", + "\n", + " results = greedy_routing(At, packets, ttr, delta_time)\n", + " arrival_times = np.array([packet.arrival_times[-1] for packet in results])\n", + " outputs[i, rand_iter] = np.max(arrival_times)\n", + " deviation_arr[i, rand_iter] = deviations(A, results)\n", + "\n", + " arrival_times = np.mean(outputs, axis = 1)\n", + "\n", + " axs[0].semilogx(packet_numbers, arrival_times, linestyle=\"-\", c = color)\n", + " axs[0].semilogx(packet_numbers, arrival_times - np.array(packet_numbers) * ttr, linestyle=\"-.\", c=color)\n", + " axs[1].semilogx(\n", + " packet_numbers, \n", + " throughput(np.array(packet_numbers), arrival_times)*ttr, \n", + " linestyle=\"--\",\n", + " c=color\n", + " )\n", + " axs[2].semilogx(packet_numbers, np.mean(deviation_arr, axis = 1), linestyle=\"--\", c=color)\n", + "\n", + "axs[0].semilogx(packet_numbers, np.array(packet_numbers) * ttr, linestyle = \"--\", c=\"black\")\n", + "axs[0].set_ylabel(\"Time(s)\")\n", + "axs[0].set_xlabel(\"#Packets\")\n", + "axs[0].set_title(\"Mean arrival time vs mean idle time\")\n", + "axs[0].legend([\n", + " \"Arrival time(light)\", \n", + " \"Idle time(light)\",\n", + " \"Arrival time(unst)\",\n", + " \"Idle time(unst)\",\n", + " \"Total Transmission Time\"\n", + "])\n", + "\n", + "\n", + "axs[1].set_title(\"Throughput of the system\")\n", + "axs[1].set_ylabel(\"Normalized Throughput\")\n", + "axs[1].set_xlabel(\"# Packets\")\n", + "axs[1].legend([\n", + " \"Throughput(light)\", \n", + " \"Throughput(unstable)\",\n", + "])\n", + "\n", + "axs[2].set_title(\"Percentage of packets that followed unoptimal route\")\n", + "axs[2].set_ylabel(\"Percentage\")\n", + "axs[2].set_xlabel(\"# Packets\")\n", + "axs[2].legend([\n", + " \"Percentage(light)\",\n", + " \"Percentage(unstable)\"\n", + "])\n", + "\n", + "plt.tight_layout()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# An insight on the plots\n", + "\n", + "1) With the first plot we are visualizing the arrival time, the idle time and the total transmission \n", + "time as a function of the maximum radius under light and unstable mode.\n", + "We observe a very similar behaviour under light and unstable mode indicating that even if the load of the network is increased the arrival time is not really affected by the number of disabled links.\n", + "One interesting thing to notice is that as the number of packets increses so does the idle time, this was expected because increasing the number of packets obviously increases the chances that Earth spends some time without receiving data.\n", + "\n", + "\n", + "2) With the second image we're pointing out the throughput as a function of the number of packets; what we observe is that \n", + "the behaviour under light and unstable mode is similar but of course light mode gives us a higher throughput.\n", + "Initially the throughput is low because, with a small amount of packets, the percentage of time in which the Earth is idle is very high since it takes time for the first packet to reach it.\n", + "When the number of packets in the network becomes big enough the two curves tend to overlap this is most likely due to the fact that with so many packets even if some links are deactivated some other nodes will still be able to send packets so the overall performance in both cases is similar.\n", + "We can still see that the unstable curve is always below the light one.\n", + " \n", + "\n", + "3) In the last image we can observe the percentage of packets that followed unoptimal routes as a function of the number of packets. What we get for the two different modes is a similar behaviour. \n", + "As the plot shows the more the packets, the higher the percentage of packets that follows\n", + "unoptimal routes. Anyway as we could expect the percentage is always higher with unstable mode.\n", + "For both modes this value tends to increase because with high load also the queuing time is high, meaning that the chance of a packet following an unoptimal path because of topological changes increases." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Epidemic Algorithm\n", + "A key problem affecting DTNs is the fact that the topology of network changes a lot over time. In some cases, it is not possible to predict these network changes.
\n", + "The epidemic algorithm suggests an approach that we can use to solve these types of problems,because it does not require a complete previous knowledge of the network topology. The algorithm works like an epidemic; if it is not possible to send packets to Earth, each node spreads the packets to all nearby nodes. So this procedure creates many copies of the same packet, in fact pure Epidemic routing has usually a high message delivery ratio. We can see below the main phases of the algorithm.
\n", + "\n", + " * 1) If the link is up the packets are sent from the node to the Earth, if the link is down the packets are sent to all nearby nodes that they can reach(the topology of network is locally fully-connected, but it is possible that some links are temporarily interrupted)

\n", + " \n", + " * 2) This procedure is repeated for all nodes over time, until all the packets have arrived to Earth. But if a node has already sent a copy of the packets to its neighbour, it doesn't need to send it back.

\n", + " \n", + " * 3) It is possible that the packet is discarded. This happens when: the packet is sent but during the propagation time the link breaks or when the packet arrives but there are some collisions on the receiver because other packets arrive in the same moment. In both cases this is implemented by checking beforehand if it is possible to send the packet, if it is not then the packet is just not sent which is equivalent to discarding the packet midair. In case of collision one of the colliding packets is kept because by using CDMA (Code Division Multiple Access) it is actually possible to distinguish between the different signals even if there is interference.

\n", + " \n", + "Using Epidemic algorithm, unless a node always remains isolated, we are sure that all packets arrive to Earth. The problem is that many copies of the same packet can create a congestion in the network and an increase of total energy consumption for data transmission.\n", + "In this algorithm we assume to know the topology of network, namely if the links are active or not, only in the current moment in which we are. We have no information about the future, so we cannot route efficiently the packets, like it happens in the algorithms above.\n", + "\n", + "Obviously as the number of nodes and of packets increases the load of the network does too and it does exponentially, this means that in case of sensors networks, that contain many nodes, or other extreme cases this might not be the best algorithmic choice.\n", + "### Earth occupation\n", + "Like we did for the greedy algorithm we would like to find out when the Earth is occupied receiving useful data.\n", + "Unlike in the greedy case though here we need to take into consideration also duplicate packets as they can not be called useful.\n", + "\n", + "In the following section the Earth occupation is represented, in particular teal slots correspond to the reception of a useful packet while orange slots correspond to the reception of a duplicate or nothing at all." + ] + }, + { + "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": [ + "transmission_time = T_tx\n", + "slot_time = delta_time\n", + "\n", + "#generating new packets with earth as a destination\n", + "packets = np.random.randint(1, n, (250, 2))\n", + "packets[:, 1] = 0\n", + "\n", + "#generating the new configuration\n", + "At = disable_links(A, 100000, slot_time, mode=\"unstable\")\n", + "\n", + "#performing the routing algorithm\n", + "packet_arrive, packet_time, vulnerable, anim_packets = epidemic(\n", + " At,\n", + " transmission_time,\n", + " slot_time,\n", + " packets,\n", + " return_anim=True\n", + ")\n", + "\n", + "#filtering packets that arrived to earth and removing duplicates\n", + "packets_to_earth = remove_duplicates(list(filter(lambda x: x.route[0] == 0, anim_packets)))\n", + "\n", + "plot_idle(packets_to_earth, transmission_time)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Some insights on the plot\n", + "\n", + "It is immediately possible to notice that, in contrast with the greedy algorithm, the idle time is dominant in the representation meaning that the algorithm is taking a lot more time to send all the packets that are needed.\n", + "A thing that can be noticed straight away is that most of the idle time is concentrated in final part of the transmission because a lot more duplicates are present in the network at that time.\n", + "\n", + "Just this graph shows that the greedy algorithm is probabily more robust to extreme situations and probably performs better in all cases. This is obviously mainly due to the knowledge advantage that it has if compared with the epidemic algorithm.\n", + "\n", + "\n", + "## Metrics analysis\n", + "Also in this case different metrics values are displayed in order to try and understand how the algorithm behaves in different situations. All the computations were repeated for 10 different configurations and the results averaged out in order to reduce the noise and the algorithm was tested both with light and unstable mode.\n", + "\n", + "### Effects of the number of packets\n", + "In the next section the dependence of the arrival time, throughput and packet fraction from the number of packets is investigated.\n", + "The packet fraction is a quantity that we defined that represents the ratio between the number of useful packets received by Earth and the total number of packets received.\n", + "\n", + "This is an important metric for this algorithm because it approximately shows how much useless information reaches Earth." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "40ff32437c3447ffb9c446b00c1228bf", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HBox(children=(FloatProgress(value=0.0, max=10.0), HTML(value='')))" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "2e540a44a1284544b2ac9d1375e38f32", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HBox(children=(FloatProgress(value=0.0, max=10.0), HTML(value='')))" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "#generate figure\n", + "fig = plt.figure(figsize=(15, 7))\n", + " \n", + "gs = fig.add_gridspec(1, 2)\n", + "axs = []\n", + "axs.append(fig.add_subplot(gs[0, 0]))\n", + "axs.append(fig.add_subplot(gs[0, 1]))\n", + "\n", + "#seeing how the system behaves as number of packets increases\n", + "max_rand = 10\n", + "\n", + "#plots and analysis with 10 nodes and r_max\n", + "for mode in [\"light\", \"unstable\"]:\n", + "\n", + " color = [\"blue\", \"red\"]\n", + " color = color[mode == \"light\"]\n", + "\n", + " #number packet that we want to send to earth\n", + " packet_numbers = [2**i for i in range(10)]\n", + "\n", + " #temp variables used to store data that will be used for the plots\n", + " arrival_times = np.zeros((len(packet_numbers), n_configurations))\n", + " packet_fraction = np.zeros((len(packet_numbers), n_configurations))\n", + "\n", + " for sample in tqdm(range(n_configurations)):\n", + "\n", + " #generating a new network configuration\n", + " nodes = generate_network(n, r_max)\n", + " A = adjacency_matrix(nodes, tau_max)\n", + " At = disable_links(A, 100000, slot_time, mode = mode)\n", + "\n", + " for i in range(len(packet_numbers)):\n", + "\n", + " #generating new packets with earth as a destination\n", + " packets = np.random.randint(1, n, (packet_numbers[i], 2))\n", + " packets[:, 1] = 0\n", + "\n", + " #performing the routing algorithm\n", + " packet_arrive, _, vulnerable = epidemic(At, transmission_time, slot_time, packets)\n", + " arrival_times[i, sample] = vulnerable[0] + transmission_time\n", + " packet_fraction[i, sample] = len(set(packet_arrive))/len(packet_arrive)\n", + " axs[0].semilogx(packet_numbers, np.mean(arrival_times, axis = 1), c = color)\n", + " axs[1].semilogx(packet_numbers, np.mean(packet_fraction, axis = 1), c = color, linestyle=\"--\")\n", + "\n", + "ttx_tot = np.array(packet_numbers)*transmission_time\n", + "axs[0].semilogx(packet_numbers, ttx_tot, linestyle=\"--\", c = \"black\")\n", + "axs[0].set_ylabel(\"Time(s)\")\n", + "axs[0].set_xlabel(\"#Packets\")\n", + "axs[0].set_title(\"Mean arrival time\")\n", + "axs[0].legend([\n", + " \"Arrival time(light)\",\n", + " \"Arrival time(unstable)\",\n", + " \"Total transmission time\"\n", + "])\n", + "\n", + "axs[1].set_ylabel(\"packet fraction\")\n", + "axs[1].set_xlabel(\"#Packets\")\n", + "axs[1].set_title(\"Packet delivery ratio\")\n", + "axs[1].legend([\n", + " \"Packet fraction(light)\",\n", + " \"Packet fraction(unstable)\"\n", + "])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "1) We can see that the mean arrival time in both cases increases linearly (the x axis is in logarithmical scale) with the number of packets. Normally one would expect to see an exponential trend, what is probably preventing this to happen is the fact that if a node knows that it can send the packet directly to Earth it doesn't send copies around. Even if the number of disabled links is higher than in the unstable case we do not see the exponential trend because the number of nodes that effectively receive the packet is lower since most connections are disabled.\n", + "It is possible to see that with a bigger number of nodes the arrival time becomes exponential, the analysis was not presented in this notebook because it takes more than one hour just to run one simulation.\n", + "This though shows that this algorithm can actually be used if the number of nodes in the network is contained.\n", + "As expected the light mode curve is below the unstable one.\n", + "\n", + "2)From the second plot we can see that the packet fraction value decreses as the number of packets increases. This was obvious because more packets means more copies in the network meaning more congestion and thus more useless packets reaching Earth.\n", + "\n", + "### Effects of the transmission time\n", + "The following cell wants to show the dependence of the various metrics from the transmission time, since the outcome of these measurements were very noisy the number of configurations used was increased to 30." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "e988427a44ca421b842815512b7717d8", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HBox(children=(FloatProgress(value=0.0, max=30.0), HTML(value='')))" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "21f2cdbd665941f08064811368119e80", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HBox(children=(FloatProgress(value=0.0, max=30.0), HTML(value='')))" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "#generate figure\n", + "fig = plt.figure(figsize=(15, 7))\n", + " \n", + "gs = fig.add_gridspec(1, 2)\n", + "axs = []\n", + "axs.append(fig.add_subplot(gs[0, 0]))\n", + "axs.append(fig.add_subplot(gs[0, 1]))\n", + "\n", + "#seeing how the system behaves as the transmission time increases\n", + "n_configurations = 30\n", + "\n", + "packet_numbers = 100\n", + "\n", + "for mode in [\"light\", \"unstable\"]:\n", + "\n", + " color = [\"blue\", \"red\"]\n", + " color = color[mode == \"light\"]\n", + "\n", + " transm_time = np.arange(1, 200, 20)\n", + " arrival_times = np.zeros((len(transm_time), n_configurations))\n", + " packet_fraction = np.zeros((len(transm_time), n_configurations))\n", + "\n", + " for sample in tqdm(range(n_configurations)):\n", + "\n", + " nodes = generate_network(n, r_max)\n", + " A = adjacency_matrix(nodes, tau_max)\n", + " At = disable_links(A, 100000, slot_time, mode = mode)\n", + "\n", + " for i in range(len(transm_time)):\n", + "\n", + " packets = np.random.randint(1, n, (packet_numbers, 2))\n", + " packet_arrive, _, vulnerable = epidemic(At, transm_time[i], slot_time, packets)\n", + " arrival_times[i, sample] = vulnerable[0] + transm_time[i]\n", + " packet_fraction[i, sample] = len(set(packet_arrive))/len(packet_arrive)\n", + " ttx_tot = np.array(transm_time*packet_numbers)\n", + " axs[0].plot(transm_time, np.mean(arrival_times, axis = 1), c = color)\n", + "\n", + " axs[1].plot(transm_time, np.mean(packet_fraction, axis = 1), c = color, linestyle = \"--\")\n", + "\n", + "\n", + "axs[0].plot(transm_time, ttx_tot, c=\"black\", linestyle=\"--\")\n", + "axs[0].set_ylabel(\"Time(s)\")\n", + "axs[0].set_xlabel(\"Transmission time(s)\")\n", + "axs[0].set_title(\"Mean arrival time\")\n", + "axs[0].legend([\n", + " \"Arrival time(light)\",\n", + " \"Arrival time(unstable)\",\n", + " \"Total transmission time\"\n", + "])\n", + "\n", + "axs[1].set_ylabel(\"packet fraction\")\n", + "axs[1].set_xlabel(\"Transmission time(s)\")\n", + "axs[1].set_title(\"Packet delivery ratio\")\n", + "axs[1].legend([\n", + "\"Packet fraction(light)\",\n", + "\"Packet fraction(unstable)\"\n", + "])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "From the plots it is possible to notice some very awkward behaviours, in particular it looks like that when the transmission time becomes comparable with the propagation time the number of deactivated links becomes ininfluent.\n", + "This can be seen in both plots as from a certain point the two lines tend to overlap which is an unexpected behaviour.\n", + "The second plot looks strange because the packet fraction increases after a certain point, this is probably due to the fact that with very high transmission rate it is very likely that a link is deactivated before the packet reaches its destination meaning that not too many packets are forwarded epidemically reducing the number of useless packets that reach Earth.\n", + "\n", + "## Algorithm comparison\n", + "From the Earth occupation plots it is already clear that the the greedy algorithm is more performing. The opposite would have been quite strange since it relies on more information than the epidemic one.\n", + "\n", + "It is still important to compare the two performances in case the same conditions are used for both, on the plots below the arrival times are confronted. Only the unstable mode was used and the performances were compared firstly as functions of the transmission times and later as functions of the number of packets." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "14ea5634a79c4a539ec7d64f216b9adf", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HBox(children=(FloatProgress(value=0.0, max=10.0), HTML(value='')))" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "#generate figure\n", + "fig = plt.figure(figsize=(15, 7))\n", + " \n", + "gs = fig.add_gridspec(1, 2)\n", + "axs = []\n", + "axs.append(fig.add_subplot(gs[0]))\n", + "axs.append(fig.add_subplot(gs[1]))\n", + "max_rand = 10\n", + " \n", + "#different transmission times\n", + "transm_time = np.arange(1, 200, 20)\n", + "\n", + "#number packet that we want to send to earth\n", + "packet_numbers = [2**i for i in range(10)]\n", + "\n", + "#temp variables needed for plots\n", + "arrival_times = np.zeros((len(packet_numbers), max_rand))\n", + "outputs = np.zeros((len(packet_numbers), max_rand))\n", + "outputs_ttr = np.zeros((len(packet_numbers), max_rand))\n", + "arrival_times_ttr = np.zeros((len(packet_numbers), max_rand))\n", + "\n", + "for sample in tqdm(range(max_rand)):\n", + "\n", + " #generating a new configuration\n", + " nodes = generate_network(n, r_max)\n", + " A = adjacency_matrix(nodes, tau_max)\n", + " At = disable_links(A, 100000, slot_time, mode = \"unstable\")\n", + "\n", + " #getting the arrival times as the number of packets changes\n", + " for i in range(len(packet_numbers)):\n", + "\n", + " packets = np.random.randint(1, n, (packet_numbers[i], 2))\n", + " packets[:, 1] = 0\n", + "\n", + " #greedy routing results\n", + " results = greedy_routing(At, packets, transmission_time, delta_time)\n", + "\n", + " #epidemic routing results\n", + " packet_arrive, _, vulnerable = epidemic(At, transmission_time, slot_time, packets)\n", + "\n", + " arrival_times_greedy = np.array([packet.arrival_times[-1] for packet in results])\n", + " outputs[i, sample] = np.max(arrival_times_greedy)\n", + " arrival_times[i, sample] = vulnerable[0] + transmission_time\n", + "\n", + " #getting the arrival times as the transmission time changes\n", + " for i in range(len(transm_time)):\n", + "\n", + " packets = np.random.randint(1, n, (100, 2))\n", + " packets[:, 1] = 0\n", + "\n", + " #greedy routing results\n", + " results = greedy_routing(At, packets, transm_time[i], delta_time)\n", + "\n", + " #epidemic routing results\n", + " packet_arrive, _, vulnerable = epidemic(At, transm_time[i], slot_time, packets)\n", + "\n", + " arrival_times_greedy = np.array([packet.arrival_times[-1] for packet in results])\n", + " outputs_ttr[i, sample] = np.max(arrival_times_greedy)\n", + " arrival_times_ttr[i, sample] = vulnerable[0] + transm_time[i]\n", + "\n", + "ttx_tot = np.array(packet_numbers)*transmission_time\n", + "arrival_times_greedy = np.mean(outputs, axis = 1)\n", + "axs[0].semilogx(packet_numbers, np.mean(arrival_times, axis = 1), c= \"blue\")\n", + "axs[0].semilogx(packet_numbers, arrival_times_greedy, c=\"red\")\n", + "\n", + "axs[0].semilogx(packet_numbers, ttx_tot, linestyle=\"--\", color=\"black\")\n", + "axs[0].set_ylabel(\"Time(s)\")\n", + "axs[0].set_xlabel(\"#Packets\")\n", + "axs[0].set_title(\"Mean arrival time\")\n", + "axs[0].legend([\n", + " \"Arrival time(epidemic)\",\n", + " \"Arrival time(greedy)\",\n", + " \"Total transmission time\"\n", + "])\n", + "\n", + "arrival_times_greedy = np.mean(outputs_ttr, axis = 1)\n", + "ttx_tot = np.array(transm_time)*100\n", + "axs[1].plot(transm_time, np.mean(arrival_times_ttr, axis = 1), color = \"blue\")\n", + "axs[1].plot(transm_time, arrival_times_greedy, color = \"red\")\n", + "axs[1].plot(transm_time, ttx_tot, color=\"black\" ,linestyle=\"--\")\n", + "axs[1].set_ylabel(\"Time(s)\")\n", + "axs[1].set_xlabel(\"Transmission time(s)\")\n", + "axs[1].set_title(\"Mean arrival time\")\n", + "axs[1].legend([\n", + " \"Arrival time (epidemics)\",\n", + " \"Arrival time (greedy)\",\n", + " \"Total transmission time\",\n", + "])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As we can observe the arrival time with the epidemic approach increases much faster than with the greedy one in both cases. This confirms our expectations, because since the beginning we knew that the greedy algorithm was the one with the strictest hypothesis but also the most efficient. \n", + "\n", + "In particular, as expected the epidemic algorithm performs really poorly in case many packets need to be forwarded because more packets generate a lot of duplicates this does not happen for the greedy algorithm so even if some packets might follow a better path (in the epidemic case), the extra load generated by the network is too much for the algorithm to compete with the greedy one.\n", + "\n", + "# Conclusions\n", + "\n", + "Here we want to sum up the results of our efforts by recapping which were the initial objectives and how the two \n", + "different approaches tackled the problem. \n", + "\n", + "So our goal was to find an effective routing algorithm in the scenario of Delay Tolerant Networks, where nodes are \n", + "located very far from each other and the links are not always working. \n", + "\n", + "The first strategy which we studied and implemented is a greedy algorithm which turned out to be very efficient and \n", + "probably the best type of approach when dealing with DTNs.\n", + "We can say that this algorithm is very efficient because Earth (which is the destination node) is always busy in the\n", + "sense that there are almost no idle times for the destination node which is always receiving packets.\n", + "\n", + "\n", + "The two main reasons why we also tested the epidemic algorithm were\n", + "\n", + "1) It needs much less information about the system to work properly.\n", + "\n", + "2) We thought that because packets are sent everywhere some packets would arrive to Earth faster than they would with the greedy algorithm, this because the greedy algorithm does not keep queues in consideration when computing the best path meaning that some packets may be forced to take strange routes.\n", + "Unfortunately the amount of duplicate packets was more than enough to overcome this effect making the epidemic algorithm actually way worse.\n", + "\n", + "In [1] the authors actually express very clearly the fact that in many cases the epidemic algorithm becomes unfeasible because it fills up the buffers and it generates too many packets.\n", + "From the simulations though we saw that for small networks where the topology can not be known in advance, this approach might actually work decently well as it takes all the packets to destination." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "packets = packets_greedy\n", + "A = initial_A\n", + "coord_nodes = np.copy(initial_nodes)\n", + "\n", + "n_pkt = len(packets)\n", + "coord = coord_nodes[[pkt.source for pkt in packets]]\n", + "path = [[pkt.source] + pkt.route for pkt in packets]\n", + "arrival_times = [pkt.arrival_times for pkt in packets]\n", + "start_times = [[pkt.arrival_times[j] - A[path[i][j],path[i][j+1]] for j in range(len(pkt.route))] for i,pkt in enumerate(packets)]\n", + "\n", + "delay = max([pkt.arrival_time for pkt in packets])\n", + "\n", + "next_hop = coord_nodes[[x.route[0] for x in packets]]\n", + "diff = next_hop - coord\n", + "dist = np.linalg.norm(diff,axis=1)\n", + "times = dist/c\n", + "vel = (diff.T / times).T\n", + "\n", + "#keep a fixed copy to be able to run the animation multiple times\n", + "fixed_coord = np.copy(coord) \n", + "fixed_vel = np.copy(vel)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "application/javascript": [ + "/* Put everything inside the global mpl namespace */\n", + "window.mpl = {};\n", + "\n", + "\n", + "mpl.get_websocket_type = function() {\n", + " if (typeof(WebSocket) !== 'undefined') {\n", + " return WebSocket;\n", + " } else if (typeof(MozWebSocket) !== 'undefined') {\n", + " return MozWebSocket;\n", + " } else {\n", + " alert('Your browser does not have WebSocket support. ' +\n", + " 'Please try Chrome, Safari or Firefox ≥ 6. ' +\n", + " 'Firefox 4 and 5 are also supported but you ' +\n", + " 'have to enable WebSockets in about:config.');\n", + " };\n", + "}\n", + "\n", + "mpl.figure = function(figure_id, websocket, ondownload, parent_element) {\n", + " this.id = figure_id;\n", + "\n", + " this.ws = websocket;\n", + "\n", + " this.supports_binary = (this.ws.binaryType != undefined);\n", + "\n", + " if (!this.supports_binary) {\n", + " var warnings = document.getElementById(\"mpl-warnings\");\n", + " if (warnings) {\n", + " warnings.style.display = 'block';\n", + " warnings.textContent = (\n", + " \"This browser does not support binary websocket messages. \" +\n", + " \"Performance may be slow.\");\n", + " }\n", + " }\n", + "\n", + " this.imageObj = new Image();\n", + "\n", + " this.context = undefined;\n", + " this.message = undefined;\n", + " this.canvas = undefined;\n", + " this.rubberband_canvas = undefined;\n", + " this.rubberband_context = undefined;\n", + " this.format_dropdown = undefined;\n", + "\n", + " this.image_mode = 'full';\n", + "\n", + " this.root = $('
');\n", + " this._root_extra_style(this.root)\n", + " this.root.attr('style', 'display: inline-block');\n", + "\n", + " $(parent_element).append(this.root);\n", + "\n", + " this._init_header(this);\n", + " this._init_canvas(this);\n", + " this._init_toolbar(this);\n", + "\n", + " var fig = this;\n", + "\n", + " this.waiting = false;\n", + "\n", + " this.ws.onopen = function () {\n", + " fig.send_message(\"supports_binary\", {value: fig.supports_binary});\n", + " fig.send_message(\"send_image_mode\", {});\n", + " if (mpl.ratio != 1) {\n", + " fig.send_message(\"set_dpi_ratio\", {'dpi_ratio': mpl.ratio});\n", + " }\n", + " fig.send_message(\"refresh\", {});\n", + " }\n", + "\n", + " this.imageObj.onload = function() {\n", + " if (fig.image_mode == 'full') {\n", + " // Full images could contain transparency (where diff images\n", + " // almost always do), so we need to clear the canvas so that\n", + " // there is no ghosting.\n", + " fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n", + " }\n", + " fig.context.drawImage(fig.imageObj, 0, 0);\n", + " };\n", + "\n", + " this.imageObj.onunload = function() {\n", + " fig.ws.close();\n", + " }\n", + "\n", + " this.ws.onmessage = this._make_on_message_function(this);\n", + "\n", + " this.ondownload = ondownload;\n", + "}\n", + "\n", + "mpl.figure.prototype._init_header = function() {\n", + " var titlebar = $(\n", + " '
');\n", + " var titletext = $(\n", + " '
');\n", + " titlebar.append(titletext)\n", + " this.root.append(titlebar);\n", + " this.header = titletext[0];\n", + "}\n", + "\n", + "\n", + "\n", + "mpl.figure.prototype._canvas_extra_style = function(canvas_div) {\n", + "\n", + "}\n", + "\n", + "\n", + "mpl.figure.prototype._root_extra_style = function(canvas_div) {\n", + "\n", + "}\n", + "\n", + "mpl.figure.prototype._init_canvas = function() {\n", + " var fig = this;\n", + "\n", + " var canvas_div = $('
');\n", + "\n", + " canvas_div.attr('style', 'position: relative; clear: both; outline: 0');\n", + "\n", + " function canvas_keyboard_event(event) {\n", + " return fig.key_event(event, event['data']);\n", + " }\n", + "\n", + " canvas_div.keydown('key_press', canvas_keyboard_event);\n", + " canvas_div.keyup('key_release', canvas_keyboard_event);\n", + " this.canvas_div = canvas_div\n", + " this._canvas_extra_style(canvas_div)\n", + " this.root.append(canvas_div);\n", + "\n", + " var canvas = $('');\n", + " canvas.addClass('mpl-canvas');\n", + " canvas.attr('style', \"left: 0; top: 0; z-index: 0; outline: 0\")\n", + "\n", + " this.canvas = canvas[0];\n", + " this.context = canvas[0].getContext(\"2d\");\n", + "\n", + " var backingStore = this.context.backingStorePixelRatio ||\n", + "\tthis.context.webkitBackingStorePixelRatio ||\n", + "\tthis.context.mozBackingStorePixelRatio ||\n", + "\tthis.context.msBackingStorePixelRatio ||\n", + "\tthis.context.oBackingStorePixelRatio ||\n", + "\tthis.context.backingStorePixelRatio || 1;\n", + "\n", + " mpl.ratio = (window.devicePixelRatio || 1) / backingStore;\n", + "\n", + " var rubberband = $('');\n", + " rubberband.attr('style', \"position: absolute; left: 0; top: 0; z-index: 1;\")\n", + "\n", + " var pass_mouse_events = true;\n", + "\n", + " canvas_div.resizable({\n", + " start: function(event, ui) {\n", + " pass_mouse_events = false;\n", + " },\n", + " resize: function(event, ui) {\n", + " fig.request_resize(ui.size.width, ui.size.height);\n", + " },\n", + " stop: function(event, ui) {\n", + " pass_mouse_events = true;\n", + " fig.request_resize(ui.size.width, ui.size.height);\n", + " },\n", + " });\n", + "\n", + " function mouse_event_fn(event) {\n", + " if (pass_mouse_events)\n", + " return fig.mouse_event(event, event['data']);\n", + " }\n", + "\n", + " rubberband.mousedown('button_press', mouse_event_fn);\n", + " rubberband.mouseup('button_release', mouse_event_fn);\n", + " // Throttle sequential mouse events to 1 every 20ms.\n", + " rubberband.mousemove('motion_notify', mouse_event_fn);\n", + "\n", + " rubberband.mouseenter('figure_enter', mouse_event_fn);\n", + " rubberband.mouseleave('figure_leave', mouse_event_fn);\n", + "\n", + " canvas_div.on(\"wheel\", function (event) {\n", + " event = event.originalEvent;\n", + " event['data'] = 'scroll'\n", + " if (event.deltaY < 0) {\n", + " event.step = 1;\n", + " } else {\n", + " event.step = -1;\n", + " }\n", + " mouse_event_fn(event);\n", + " });\n", + "\n", + " canvas_div.append(canvas);\n", + " canvas_div.append(rubberband);\n", + "\n", + " this.rubberband = rubberband;\n", + " this.rubberband_canvas = rubberband[0];\n", + " this.rubberband_context = rubberband[0].getContext(\"2d\");\n", + " this.rubberband_context.strokeStyle = \"#000000\";\n", + "\n", + " this._resize_canvas = function(width, height) {\n", + " // Keep the size of the canvas, canvas container, and rubber band\n", + " // canvas in synch.\n", + " canvas_div.css('width', width)\n", + " canvas_div.css('height', height)\n", + "\n", + " canvas.attr('width', width * mpl.ratio);\n", + " canvas.attr('height', height * mpl.ratio);\n", + " canvas.attr('style', 'width: ' + width + 'px; height: ' + height + 'px;');\n", + "\n", + " rubberband.attr('width', width);\n", + " rubberband.attr('height', height);\n", + " }\n", + "\n", + " // Set the figure to an initial 600x600px, this will subsequently be updated\n", + " // upon first draw.\n", + " this._resize_canvas(600, 600);\n", + "\n", + " // Disable right mouse context menu.\n", + " $(this.rubberband_canvas).bind(\"contextmenu\",function(e){\n", + " return false;\n", + " });\n", + "\n", + " function set_focus () {\n", + " canvas.focus();\n", + " canvas_div.focus();\n", + " }\n", + "\n", + " window.setTimeout(set_focus, 100);\n", + "}\n", + "\n", + "mpl.figure.prototype._init_toolbar = function() {\n", + " var fig = this;\n", + "\n", + " var nav_element = $('
');\n", + " nav_element.attr('style', 'width: 100%');\n", + " this.root.append(nav_element);\n", + "\n", + " // Define a callback function for later on.\n", + " function toolbar_event(event) {\n", + " return fig.toolbar_button_onclick(event['data']);\n", + " }\n", + " function toolbar_mouse_event(event) {\n", + " return fig.toolbar_button_onmouseover(event['data']);\n", + " }\n", + "\n", + " for(var toolbar_ind in mpl.toolbar_items) {\n", + " var name = mpl.toolbar_items[toolbar_ind][0];\n", + " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", + " var image = mpl.toolbar_items[toolbar_ind][2];\n", + " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", + "\n", + " if (!name) {\n", + " // put a spacer in here.\n", + " continue;\n", + " }\n", + " var button = $('