diff --git a/notebooks/.ipynb_checkpoints/1_Catch_Motion-checkpoint.ipynb b/notebooks/.ipynb_checkpoints/1_Catch_Motion-checkpoint.ipynb new file mode 100644 index 0000000..ef56f60 --- /dev/null +++ b/notebooks/.ipynb_checkpoints/1_Catch_Motion-checkpoint.ipynb @@ -0,0 +1,7834 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "###### Content under Creative Commons Attribution license CC-BY 4.0, code under BSD 3-Clause License © 2017 L.A. Barba, N.C. Clementi" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Catch things in motion\n", + "\n", + "This module of the _Engineering Computations_ course is our launching pad to investigate _change_, _motion_, _dynamics_, using computational thinking, Python, and Jupyter.\n", + "\n", + "The foundation of physics and engineering is the subject of **mechanics**: how things move around, when pushed around. Or pulled… in the beginning of the history of mechanics, Galileo and Newton seeked to understand how and why objects fall under the pull of gravity.\n", + "\n", + "This first lesson will explore motion by analyzing images and video, to learn about velocity and acceleration." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Acceleration of a falling ball\n", + "\n", + "Let's start at the beginning. Suppose you want to use video capture of a falling ball to _compute_ the acceleration of gravity. Could you do it? With Python, of course you can!\n", + "\n", + "Here is a neat video we found online, produced over at MIT several years ago [1]. It shows a ball being dropped in front of a metered panel, while lit by a stroboscopic light. Watch the video!" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "data": { + "image/jpeg": "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\n", + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from IPython.display import YouTubeVideo\n", + "vid = YouTubeVideo(\"xQ4znShlK5A\")\n", + "display(vid)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We learn from the video that the marks on the panel are every $0.25\\rm{m}$, and on the [website](http://techtv.mit.edu/collections/physicsdemos/videos/831-strobe-of-a-falling-ball) they say that the strobe light flashes at about 15 Hz (that's 15 times per second). The final [image on Flickr](https://www.flickr.com/photos/physicsdemos/3174207211), however, notes that the strobe fired 16.8 times per second. So we have some uncertainty already!\n", + "\n", + "Luckily, the MIT team obtained one frame with the ball visible at several positions as it falls. This, thanks to the strobe light and a long-enough exposure of that frame. What we'd like to do is use that frame to capture the ball positions digitally, and then obtain the velocity and acceleration from the distance over time. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You can find several toolkits for handling images and video with Python; we'll start with a simple one called [`imageio`](https://imageio.github.io). Import this library like any other, and let's load `numpy` and `pyplot` while we're at it." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import imageio\n", + "import numpy\n", + "from matplotlib import pyplot" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Read the video\n", + "\n", + "With the `get_reader()` method of `imageio`, you can read a video from its source into a _Reader_ object. You don't need to worry too much about the technicalities here—we'll walk you through it all—but check the type, the length (for a video, that's number of frames), and notice you can get info, like the frames-per-second, using `get_meta_data()`." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "reader = imageio.get_reader('https://go.gwu.edu/engcomp3vidmit', format='mp4')" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "imageio.plugins.ffmpeg.FfmpegFormat.Reader" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "type(reader)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1233" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "len(reader)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "29.97\n" + ] + } + ], + "source": [ + "fps = reader.get_meta_data()['fps']\n", + "print(fps)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### Note:\n", + "\n", + "You may get this error after calling `get_reader()`:\n", + " \n", + "```\n", + "NeedDownloadError: Need ffmpeg exe. You can obtain it with either:\n", + " - install using conda: conda install ffmpeg -c conda-forge\n", + " - download using the command: imageio_download_bin ffmpeg\n", + " - download by calling (in Python): imageio.plugins.ffmpeg.download()\n", + "```\n", + "\n", + "If you do, we suggest to install `imageio-ffmpeg` package, an ffmpeg wrapper for Python that includes the `ffmpeg` executable. You can install it via `pip` or `conda`:\n", + "\n", + "- `pip install --upgrade imageio-ffmpeg`\n", + "- `conda install imageio-ffmpeg -c conda-forge`" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Show a video frame in an interactive figure\n", + "\n", + "With `imageio`, you can grab one frame of the video, and then use `pyplot` to show it as an image. But we want to interact with the image, somehow.\n", + "\n", + "So far in this course, we have used the command `%matplotlib inline` to get our plots rendered _inline_ in a Jupyter notebook. There is an alternative command that gives you some interactivity on the figures: `%matplotlib notebook`. Execute this now, and you'll see what it does below, when you show the image in a new figure.\n", + "\n", + "Let's also set some font parameters for our plots in this notebook." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib notebook\n", + "\n", + "pyplot.rc('font', family='serif', size='18')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we can use the `get_data()` method on the `imageio` _Reader_ object, to grab one of the video frames, passing the frame number. Below, we use it to grab frame number 1100, and then print the `shape` attribute to see that it's an \"array-like\" object with three dimensions: they are the pixel numbers in the horizontal and vertical directions, and the number of colors (3 colors in RGB format). Check the type to see that it's an `imageio` _Image_ object." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(1080, 1440, 3)" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "image = reader.get_data(1100)\n", + "image.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "imageio.core.util.Array" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "type(image)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Naturally, `imageio` plays well with `pyplot`. You can use [`pyplot.imshow()`](https://matplotlib.org/devdocs/api/_as_gen/matplotlib.pyplot.imshow.html) to show the image in a figure. We chose to show frame 1100 after playing around a bit and finding that it gives a good view of the long-exposure image of the falling ball.\n", + "\n", + "##### Explore:\n", + "\n", + "Check out the neat interactive options that we get with `%matplotlib notebook`. Then go back and change the frame number above, and show it below. Notice that you can see the $(x,y)$ coordinates of your cursor tip while you hover on the image with the mouse." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "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": [ + "fig = pyplot.figure()\n", + "pyplot.imshow(image, interpolation='nearest')\n", + "\n", + "coords = []\n", + "connectId = fig.canvas.mpl_connect('button_press_event', onclick)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Notice that in the previous code cell, we created an empty list named `coords`, and inside the `onclick()` function, we are appending to it the $(x,y)$ coordinates of each mouse click on the figure. After executing the cell above, you have a connection to the figure, via the user interface: try clicking with your mouse on the endpoints of the white lines of the metered panel (click on the edge of the panel to get approximately equal $x$ coordinates), then print the contents of the `coords` list below." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[[607.5022321428571, 117.32366071428555],\n", + " [607.5022321428571, 242.97301136363626],\n", + " [610.4243100649351, 365.700284090909],\n", + " [607.5022321428571, 497.1937905844155],\n", + " [610.4243100649351, 616.9989853896103],\n", + " [610.4243100649351, 745.5704139610389],\n", + " [613.3463879870129, 862.4535308441557],\n", + " [613.3463879870129, 982.2587256493506]]" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "coords" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The $x$ coordinates are pretty close, but there is some variation due to our shaky hand (or bad eyesight), and perhaps because the metered panel is not perfectly vertical. We can cast the `coords` list to a NumPy array, then grab all the first elements of the coordinate pairs, then get the standard deviation as an indication of our error in the mouse-click captures." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([607.50223214, 607.50223214, 610.42431006, 607.50223214,\n", + " 610.42431006, 610.42431006, 613.34638799, 613.34638799])" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "numpy.array(coords)[:,0]" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "2.2810463468175857" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "numpy.array(coords)[:,0].std()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Depending how shaky _your_ hand was, you may get a different value, but we got a standard deviation of about one pixel. Pretty good!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now, let's grab all the second elements of the coordinate pairs, corresponding to the $y$ coordinates, i.e., the vertical positions of the white lines on the video frame." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([117.32366071, 242.97301136, 365.70028409, 497.19379058,\n", + " 616.99898539, 745.57041396, 862.45353084, 982.25872565])" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "y_lines = numpy.array(coords)[:,1]\n", + "y_lines" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Looking ahead, what we'll do is repeat the process of capturing mouse clicks on the image, but clicking on the ball positions. Then, we will want to have the vertical positions converted to physical length (in meters), from the pixel numbers on the image.\n", + "\n", + "You can get the scaling from pixels to meters via the distance between two white lines on the metered panel, which we know is $0.25\\rm{m}$. \n", + "\n", + "Let's get the average vertical distance between two while lines, which we can calculate as:\n", + "\n", + "\\begin{equation}\n", + "\\overline{\\Delta y} = \\sum_{i=0}^N \\frac{y_{i+1}-y_i}{N-1}\n", + "\\end{equation}" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "123.56215213358072" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "gap_lines = y_lines[1:] - y_lines[0:-1]\n", + "gap_lines.mean()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### Discuss with your neighbor\n", + "\n", + "* Why did we slice the `y_lines` array like that? If you can't explain it, write out the first few terms of the sum above and think!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Compute the acceleration of gravity\n", + "\n", + "We're making good progress! You'll repeat the process of showing the image on an interactive figure, and capturing the mouse clicks on the figure canvas: but this time, you'll click on the ball positions. \n", + "\n", + "Using the vertical displacements of the ball, $\\Delta y_i$, and the known time between two flashes of the strobe light, $1/16.8\\rm{s}$, you can get the velocity and acceleration of the ball! But first, to convert the vertical displacements to meters, you'll multiply by $0.25\\rm{m}$ and divide by `gap_lines.mean()`.\n", + "\n", + "Before clicking on the ball positions, you may want to inspect the high-resolution final [photograph on Flickr](https://www.flickr.com/photos/physicsdemos/3174207211)—notice that the first faint image of the falling ball is just \"touching\" the ring finger of Bill's hand. We decided _not_ to use that photograph in our lesson because the Flickr post says _\"All rights reserved\"_, while the video says specifically that it is licensed under a Creative Commons license. In other words, MIT has granted permission to use the video, but _not_ the photograph. _Sigh_.\n", + "\n", + "OK. Go for it: capture the clicks on the ball!" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "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": [ + "fig = pyplot.figure()\n", + "pyplot.imshow(image, interpolation='nearest')\n", + "\n", + "coords = []\n", + "connectId = fig.canvas.mpl_connect('button_press_event', onclick)" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[[723.8145161290322, 117.54032258064524],\n", + " [723.8145161290322, 169.1532258064516],\n", + " [723.8145161290322, 223.3467741935484],\n", + " [723.8145161290322, 277.5403225806451],\n", + " [723.8145161290322, 329.1532258064516],\n", + " [723.8145161290322, 385.92741935483866],\n", + " [723.8145161290322, 437.5403225806451],\n", + " [723.8145161290322, 489.1532258064516],\n", + " [723.8145161290322, 540.766129032258],\n", + " [723.8145161290322, 594.9596774193548],\n", + " [723.8145161290322, 651.7338709677418]]" + ] + }, + "execution_count": 32, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "coords" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([117.54032258, 169.15322581, 223.34677419, 277.54032258,\n", + " 329.15322581, 385.92741935, 437.54032258, 489.15322581,\n", + " 540.76612903, 594.95967742, 651.73387097])" + ] + }, + "execution_count": 33, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "y_lines2 = numpy.array(coords)[:,1]\n", + "y_lines2" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "53.41935483870966" + ] + }, + "execution_count": 34, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "gap_lines2 = y_lines2[1:] - y_lines2[0:-1]\n", + "gap_lines2.mean()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Above, we repeated the process to compute the vertical distance between the $10\\rm{cm}$ marks (averaging over our clicks): the scaling of distances from this video will need multiplying by $0.1$ to get meters, and dividing by `gap_lines2.mean()`." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now the fun part! Study the code below: we create a `selector` widget of the `BoundedIntText` type, taking the values from 52 to 77, and stepping by 1. We already played around a lot with the video and found this frame range to contain the portion shown at 50% speed. \n", + "\n", + "We re-use the `onclick()` function, appending to a list named `coords`, and we call it with an event connection from Matplotlib, just like before. But now we add a call to [`widgets.interact()`](http://ipywidgets.readthedocs.io/en/stable/examples/Using%20Interact.html), using a new function named `catchclick()` that reads a new video frame and refreshes the figure with it.\n", + "\n", + "Execute this cell, then click on the ball position, advance a frame, click on the new ball position, and so on, until frame 77. The mouse click positions will be saved in `coords`.\n", + "\n", + "We found it better to click on the bottom edge of the ball image, rather than attempt to aim at the ball's center." + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "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": [ + "# make a scatter plot of the projectile positions\n", + "fig = pyplot.figure()\n", + "pyplot.scatter(x,-y);" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Finally, compute the vertical displacements, then get the vertical velocity and acceleration. And why not repeat the process for the horizontal direction of motion. The time interval is $1/60$ seconds, according to the original video description, i.e., 60 frames per second." + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": {}, + "outputs": [], + "source": [ + "delta_y = (y[1:] - y[:-1])" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The acceleration in the y direction is: 10.14\n" + ] + } + ], + "source": [ + "vy = delta_y * 60\n", + "ay = (vy[1:] - vy[:-1]) * 60\n", + "print('The acceleration in the y direction is: {:.2f}'.format(ay.mean()))" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The acceleration in the x direction is: 0.72\n" + ] + } + ], + "source": [ + "delta_x = (x[1:] - x[:-1])\n", + "vx = delta_x * 60\n", + "ax = (vx[1:] - vx[:-1]) * 60\n", + "print('The acceleration in the x direction is: {:.2f}'.format(ax.mean()))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### Discuss\n", + "\n", + "* What did you get for the $x$ and $y$ accelerations? What did your neighbor get?\n", + "* Do the results make sense to you? Why or why not?" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Numerical derivatives\n", + "\n", + "We just computed the average velocity between two captured ball positions using _numerical derivative_. The velocity is the _derivative_ of position with respect to time, and we can approximate its instantaneous value with the average velocity between two close instants in time:\n", + "\n", + "\\begin{equation}\n", + "v(t) = \\frac{dy}{dt} \\approx \\frac{y(t_i+\\Delta t)-y(t_i)}{\\Delta t}\n", + "\\end{equation}\n", + "\n", + "And acceleration is the _derivative_ of velocity with respect to time; we can approximate it with the average acceleration within a time interval:\n", + "\n", + "\\begin{equation}\n", + "a(t) = \\frac{dv}{dt} \\approx \\frac{v(t_i+\\Delta t)-v(t_i)}{\\Delta t}\n", + "\\end{equation}\n", + "\n", + "As you can imagine, the quality of the approximation depends on the size of the time interval: as $\\Delta t$ gets smaller, the error also gets smaller." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Using high-resolution data\n", + "\n", + "Suppose we had some high-resolution experimental data of a falling ball. Might we be able to compute the acceleration of gravity, and get a value closer to the actual acceleration of $9.8\\rm{m/s}^2$?\n", + "\n", + "You're in luck! Physics professor Anders Malthe-Sørenssen of Norway has some high-resolution data on the website to accompany his book [3]. We contacted him by email to ask for permission to use the data set of a falling tennis ball, and he graciously agreed. _Thank you!_ His data was recorded with a motion detector on the ball, measuring the $y$ coordinate at tiny time intervals of $\\Delta t = 0.001\\rm{s}$. Pretty fancy.\n", + "\n", + "We have the data in our repository for this course, but you may have to download it first, if you got this Jupyter notebook by itself. If so, add a code cell below, and execute:\n", + "\n", + "```Python\n", + "filename = 'fallingtennisball02.txt'\n", + "url = 'http://go.gwu.edu/engcomp3data1'\n", + "urlretrieve(url, filename)\n", + "```\n", + "\n", + "You already imported `urlretrieve` above to get the video. Remember to then comment the assignment of the `filename` variable below. " + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": {}, + "outputs": [], + "source": [ + "filename = '../data/fallingtennisball02.txt'\n", + "t, y = numpy.loadtxt(filename, usecols=[0,1], unpack=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Okay! We should have two new arrays with the time and position data. Let's get a plot of the ball's vertical position." + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "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": [ + "fig = pyplot.figure(figsize=(6,4))\n", + "pyplot.plot(ay);" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### Discuss with your neighbor\n", + "\n", + "* What do you see in the plot of acceleration computed from the high-resolution data?\n", + "* Can you explain it? What do you think is causing this?" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## What we've learned\n", + "\n", + "* Work with images and videos in Python using `imageio`.\n", + "* Get interactive figures using the `%matplotlib notebook` command.\n", + "* Capture mouse clicks with Matplotlib's `mpl_connect()`.\n", + "* Observed acceleration of falling bodies is less than $9.8\\rm{m/s}^2$.\n", + "* Capture mouse clicks on several video frames using widgets!\n", + "* Projectile motion is like falling under gravity, plus a horizontal velocity.\n", + "* Compute numerical derivatives using differences via array slicing.\n", + "* Real data shows free-fall acceleration decreases in magnitude from $9.8\\rm{m/s}^2$." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## References\n", + "\n", + "1. Strobe of a Falling Ball (2008), MIT Department of Physics Technical Services Group, video under CC-BY-NC, available online on [MIT TechTV](http://techtv.mit.edu/collections/physicsdemos/videos/831-strobe-of-a-falling-ball).\n", + "\n", + "2. The Classic Bullet Projectile Motion Experiment with X & Y Axis Scales (2004), video by [Flipping Physics](http://www.flippingphysics.com/bullet-with-scales.html), Jon Thomas-Palmer. Used with permission.\n", + "\n", + "3. _Elementary Mechanics Using Python_ (2015), Anders Malthe-Sorenssen, Undergraduate Lecture Notes in Physics, Springer. Data at http://folk.uio.no/malthe/mechbook/" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 50, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Execute this cell to load the notebook's style sheet, then ignore it\n", + "from IPython.core.display import HTML\n", + "css_file = '../style/custom.css'\n", + "HTML(open(css_file, \"r\").read())" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.9" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/notebooks/.ipynb_checkpoints/2_Step_Future-checkpoint.ipynb b/notebooks/.ipynb_checkpoints/2_Step_Future-checkpoint.ipynb new file mode 100644 index 0000000..86ed457 --- /dev/null +++ b/notebooks/.ipynb_checkpoints/2_Step_Future-checkpoint.ipynb @@ -0,0 +1,927 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "###### Content under Creative Commons Attribution license CC-BY 4.0, code under BSD 3-Clause License © 2017 L.A. Barba, N.C. Clementi" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Step to the future\n", + "\n", + "Welcome to Lesson 2 of the course module \"Tour the dynamics of change and motion,\" in _Engineering Computations_. The previous lesson, [Catch things in motion](http://go.gwu.edu/engcomp3lesson1), showed you how to compute velocity and acceleration of a moving body whose positions were known. \n", + "\n", + "Time history of position can be captured on a long-exposure photograph (using a strobe light), or on video. But digitizing the positions from images can be a bit tedious, and error-prone. Luckily, we found online a data set from a fancy motion-capture experiment of a falling ball, with high resolution [1]. You computed acceleration and found that it was not only smaller than the theoretical value of $9.8 \\rm{m/s}^2$, but it _decreased_ over time. The effect is due to air resistance and is what leads to objects reaching a _terminal velocity_ in freefall.\n", + "\n", + "In general, not only is [motion capture](https://en.wikipedia.org/wiki/Motion_capture) (a.k.a., _mo-cap_) expensive, but it's inappropriate for many physical scenarios. Take a roller-coaster ride, for example: during design of the ride, it's more likely that the engineers will use an _accelerometer_. It really is the acceleration that makes a roller-coaster ride exciting, and they only rarely go faster than highway speeds (say, 60 mph) [2].\n", + "How would an engineer analyze data captured with an accelerometer?" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## A roller-coaster ride\n", + "\n", + "Prof. Anders Malthe-Sorenssen has a file with accelerometer data for a roller-coaster ride called \"The Rocket\" (we don't know if it's real or made up!). He has kindly given permission to use his data. So let's load it and have a look. We'll first need our favorite numerical Python libraries, of course." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "collapsed": true, + "jupyter": { + "outputs_hidden": true + } + }, + "outputs": [], + "source": [ + "import numpy\n", + "from matplotlib import pyplot" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "collapsed": true, + "jupyter": { + "outputs_hidden": true + } + }, + "outputs": [], + "source": [ + "%matplotlib inline\n", + "\n", + "pyplot.rc('font', family='serif', size='14')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "If you don't have the data file in the location we assume below, you can get it by adding a code cell and executing this code in it, then commenting or deleting the `filename` assignment before the call to `numpy.loadtxt()`.\n", + "\n", + "```Python\n", + "from urllib.request import urlretrieve\n", + "URL = 'http://go.gwu.edu/engcomp3data2?accessType=DOWNLOAD'\n", + "urlretrieve(URL, 'therocket.txt')\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": true, + "jupyter": { + "outputs_hidden": true + } + }, + "outputs": [], + "source": [ + "filename = '../data/therocket.txt'\n", + "t, a = numpy.loadtxt(filename, usecols=[0,1], unpack=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We'll take a peek at the data by printing the first five pairs of $(t, a)$ values, then plot the whole set below. Time is given in units of seconds, while acceleration is in $\\rm{m/s}^2$." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.0 0.2731644\n", + "0.1 1.4411079\n", + "0.2 2.6693138\n", + "0.3 4.2383806\n", + "0.4 5.6499504\n" + ] + } + ], + "source": [ + "for i in range(0,5): print(t[i],a[i])" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAg0AAAD/CAYAAABy3eWvAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nAABJRU5ErkJggg==\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# plot the acceleration over time\n", + "fig = pyplot.figure(figsize=(8, 3))\n", + "\n", + "pyplot.plot(t, a, color='#004065', linestyle='-', linewidth=1) \n", + "pyplot.title('Acceleration of roller-coster ride data, from [1]. \\n')\n", + "pyplot.xlabel('Time [s]')\n", + "pyplot.ylabel('[m/s$^2$]');" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Set things up to compute velocity and position\n", + "\n", + "Our challenge now is to find the motion description—the position $x(t)$—from the acceleration data. In the [previous lesson](http://go.gwu.edu/engcomp3lesson1), we did the opposite: with position data, get the velocity and acceleration, using _numerical derivatives_:\n", + "\n", + "\\begin{equation}\n", + "v(t_i) = \\frac{dx}{dt} \\approx \\frac{x(t_i+\\Delta t)-x(t_i)}{\\Delta t}\n", + "\\end{equation}\n", + "\n", + "\\begin{equation}\n", + "a(t_i) = \\frac{dv}{dt} \\approx \\frac{v(t_i+\\Delta t)-v(t_i)}{\\Delta t}\n", + "\\end{equation}\n", + "\n", + "Since this time we're dealing with horizontal acceleration, we swapped the position variable from $y$ to $x$ in the equation for velocity, above. \n", + "\n", + "The key to our problem is realizing that if we have the initial velocity, we can use the acceleration data to find the velocity after a short interval of time. And if we have the initial position, we can use the known velocity to find the new position after a short interval of time. Let's rearrange the equation for acceleration above, by solving for the velocity at $t_i + \\Delta t$:\n", + "\n", + "\\begin{equation}\n", + " v(t_i+\\Delta t) \\approx v(t_i) + a(t_i) \\Delta t\n", + "\\end{equation}\n", + "\n", + "We need to know the velocity and acceleration at some initial time, $t_0$, and then we can compute the velocity $v(t_i + \\Delta t)$. For the roller-coaster ride, it's natural to assume that the initial velocity is zero, and the initial position is zero with respect to a convenient reference system. We're actually ready to solve this!\n", + "\n", + "Let's save the time increment for our data set in a variable named `dt`, and compute the number of time increments in the data. Then, we'll initialize new arrays of velocity and position to all-zero values, with the intention of updating these to the computed values." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.10000000000000001" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#time increment\n", + "dt = t[1]-t[0]\n", + "dt" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "151" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#number of time increments\n", + "N = len(t)\n", + "N" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "collapsed": true, + "jupyter": { + "outputs_hidden": true + } + }, + "outputs": [], + "source": [ + "#initialize v and x arrays to zero\n", + "v = numpy.zeros(N)\n", + "x = numpy.zeros(N)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Step through time\n", + "\n", + "In the code cell below, we use a `for` statement to step through the sequence of acceleration values, each time computing the velocity and position at the subsequent time instant. We are applying the equation for $v(t_i + \\Delta t)$ above, and a similar equation for position:\n", + "\n", + "\\begin{equation}\n", + " x(t_i+\\Delta t) \\approx x(t_i) + v(t_i) \\Delta t\n", + "\\end{equation}" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "collapsed": true, + "jupyter": { + "outputs_hidden": true + } + }, + "outputs": [], + "source": [ + "for i in range(N-1):\n", + " v[i+1] = v[i] + a[i]*dt\n", + " x[i+1] = x[i] + v[i]*dt" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "And there you have it. You have computed the velocity and position over time from the acceleration data. We can now make plots of the computed variables. Note that we use the Matplotlib [`subplot()`](https://matplotlib.org/api/_as_gen/matplotlib.pyplot.subplot.html?highlight=matplotlib%20pyplot%20subplot#matplotlib.pyplot.subplot) function to get the two plots in one figure. The argument to `subplot()` is a set of three digits, corresponding to the number of rows, number of columns, and plot number in a matrix of sub-plots. " + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAnYAAAGiCAYAAABqE4tdAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# plot velocity and position over time\n", + "fig = pyplot.figure(figsize=(10,6))\n", + "\n", + "pyplot.subplot(211)\n", + "pyplot.plot(t, v, color='#0096d6', linestyle='-', linewidth=1) \n", + "pyplot.title('Velocity and position of roller-coster ride (data from [1]). \\n')\n", + "pyplot.ylabel('$v$ [m/s] ')\n", + "\n", + "pyplot.subplot(212)\n", + "pyplot.plot(t, x, color='#008367', linestyle='-', linewidth=1) \n", + "pyplot.xlabel('Time [s]')\n", + "pyplot.ylabel('$x$ [m]');" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Euler's method\n", + "\n", + "The method we used above to compute the velocity and position from acceleration data is known as _Euler's method_. The eminent Swiss mathematician Leonhard Euler presented it in his book _\"Institutionum calculi integralis,\"_ published around 1770 [3].\n", + "\n", + "You can understand why it works by writing out a Taylor expansion for $x(t)$:\n", + "\n", + "\\begin{equation}\n", + "x(t+\\Delta t) = x(t) + \\frac{d x}{dt}\\Delta t + \\frac{d^2 x}{dt^2}\\frac{\\Delta t^2}{2} + \\frac{d^3 x}{dt^3}\\frac{\\Delta t^3}{3!}+\\cdots\n", + "\\end{equation}\n", + "\n", + "With $v=dx/dt$, you can see that the first two terms on the right-hand side correspond to what we used in the code above. That means that Euler's method makes an approximation by throwing away the terms $\\frac{d^2 x}{dt^2}\\frac{\\Delta t^2}{2} + \\frac{d^3 x}{dt^3}\\frac{\\Delta t^3}{3!}+\\cdots$. So the error made in _one step_ of Euler's method is proportional to $\\Delta t^2$. Since we take $N=T/\\Delta t$ steps (for a final time instant $T$), we conclude that the error overall is proportional to $\\Delta t$. \n", + "\n", + "#### **Euler's method is a first-order method** because the error in the approximation goes with the first power of the time increment $\\Delta t$." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Initial-value problems\n", + "\n", + "To get velocity and position from the acceleration data, we needed to know the _initial values_ of the velocity and position. Then we could apply Euler's method to _step in time_ starting at $t_0$, with time increment $\\Delta t$. This setting corresponds to the numerical solution of _initial-value problems_. \n", + "(We follow here the presentation in [4], p.86.)\n", + "\n", + "Consider the differential equation corresponding to an object in free fall:\n", + "\n", + "\\begin{equation}\n", + "\\ddot{y}=-g,\n", + "\\end{equation}\n", + "\n", + "where the dot above a variable represents the time derivative, and $g$ is the acceleration of gravity. Introducing the velocity as intermediary variable, we can write:\n", + "\n", + "\\begin{eqnarray}\n", + "\\dot{y} &=& v \\nonumber\\\\\n", + "\\dot{v} &=& -g\n", + "\\end{eqnarray}\n", + "\n", + "The above is a system of two ordinary differential equations, with time as the independent variable. For its numerical solution, we need two initial conditions, and Euler's method:\n", + "\n", + "\\begin{eqnarray}\n", + "y(t_0) = y_0, \\qquad y_{i+1} &=& y_i + \\dot{y} \\Delta t \\nonumber\\\\\n", + "v(t_0) = v_0, \\qquad v_{i+1} &=& v_i + \\dot{v} \\Delta t\n", + "\\end{eqnarray}\n", + "\n", + "It's so neatly symmetrical that it's just asking for a vectorized equation! Combine the two dependent variables into a vector of unknowns, $\\mathbf{y}$:\n", + "\n", + "\\begin{equation}\n", + "\\mathbf{y} = \\begin{bmatrix}\n", + "y \\\\ v\n", + "\\end{bmatrix},\n", + "\\end{equation}\n", + "\n", + "and write the differential equation in vector form, as follows:\n", + "\n", + "\\begin{equation}\n", + "\\dot{\\mathbf{y}} = \\begin{bmatrix}\n", + "v \\\\ -g\n", + "\\end{bmatrix}.\n", + "\\end{equation}\n", + "\n", + "Equation (9) above represents the _state_ of the system, at any given instant in time. A code design for the numerical solution that generalizes to other changing systems (or _dynamical systems_) is to write one function that computes the right-hand side of the differential equation (the derivatives of the state variables), and another function that takes a state and applies the numerical method for each time increment. The solution is then computed in one `for` statement that calls these functions. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Study the code below: the function `freefall()` computes the right-hands side of the equation, and the function `eulerstep()` takes the state and applies Euler's method to update it one time increment." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "collapsed": true, + "jupyter": { + "outputs_hidden": true + } + }, + "outputs": [], + "source": [ + "def freefall(state):\n", + " '''Computes the right-hand side of the freefall differential \n", + " equation, in SI units.\n", + " \n", + " Arguments\n", + " ---------- \n", + " state : array of two dependent variables [y v]^T\n", + " \n", + " Returns\n", + " -------\n", + " derivs: array of two derivatives [v -g]^T\n", + " '''\n", + " \n", + " derivs = numpy.array([state[1], -9.8])\n", + " return derivs" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "collapsed": true, + "jupyter": { + "outputs_hidden": true + } + }, + "outputs": [], + "source": [ + "def eulerstep(state, rhs, dt):\n", + " '''Uses Euler's method to update a state to the next one. \n", + " \n", + " Arguments\n", + " ---------\n", + " state: array of two dependent variables [y v]^T\n", + " rhs : function that computes the right hand side of the \n", + " differential equation.\n", + " dt : float, time increment. \n", + " \n", + " Returns\n", + " -------\n", + " next_state: array, updated state after one time increment. \n", + " '''\n", + " \n", + " next_state = state + rhs(state) * dt\n", + " return next_state" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Numerical solution vs. experiment\n", + "\n", + "Here's an idea! Let's use the `freefall()` and `eulerstep()` functions to obtain a numerical solution with the same initial conditions as the falling-ball experiment from [Lesson 1](http://go.gwu.edu/engcomp3lesson1), and compare with the experimental data. \n", + "\n", + "You can grab the data from its location online running the following code in a new cell:\n", + "```Python\n", + "filename = 'fallingtennisball02.txt'\n", + "url = 'http://go.gwu.edu/engcomp3data1'\n", + "urlretrieve(url, filename)\n", + "```\n", + "\n", + "You already imported `urlretrieve` above. Remember to then comment the assignment of the `filename` variable below. We'll load it from our local copy." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "collapsed": true, + "jupyter": { + "outputs_hidden": true + } + }, + "outputs": [], + "source": [ + "filename = '../data/fallingtennisball02.txt'\n", + "t, y = numpy.loadtxt(filename, usecols=[0,1], unpack=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We'll need to use the same time increment, so let's compute it from two time samples. The initial position is the first value of the `y` array, while the initial velocity is zero. And we'll only look at the section of data before the ball bounces from the ground, which gives us the number of time steps." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "collapsed": true, + "jupyter": { + "outputs_hidden": true + } + }, + "outputs": [], + "source": [ + "#time increment\n", + "dt = t[1]-t[0]" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "collapsed": true, + "jupyter": { + "outputs_hidden": true + } + }, + "outputs": [], + "source": [ + "y0 = y[0] #initial position\n", + "v0 = 0 #initial velocity\n", + "N = 576 #number of steps" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now, let's create a new array, called `num_sol`, to hold the results of the numerical solution. The array has dimensions `Nx2`, with each two-element row holding the state variables, $(y,v)$, at a given time instant. After saving the initial conditions in the solution array, we are ready to start stepping in time in a `for` statement. Study the code below." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "collapsed": true, + "jupyter": { + "outputs_hidden": true + } + }, + "outputs": [], + "source": [ + "#initialize array\n", + "num_sol = numpy.zeros([N,2])" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "collapsed": true, + "jupyter": { + "outputs_hidden": true + } + }, + "outputs": [], + "source": [ + "#Set intial conditions\n", + "num_sol[0,0] = y0\n", + "num_sol[0,1] = v0" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": { + "collapsed": true, + "jupyter": { + "outputs_hidden": true + } + }, + "outputs": [], + "source": [ + "for i in range(N-1):\n", + " num_sol[i+1] = eulerstep(num_sol[i], freefall, dt)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Did it work? Exciting! Let's plot in the same figure both the numerical solution and the experimental data. " + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZkAAAE1CAYAAAA1e51bAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nAAAASUVORK5CYII=\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig = pyplot.figure(figsize=(6,4))\n", + "pyplot.plot(t[:N], num_sol[:,0], linewidth=2, linestyle='--', label='Numerical solution')\n", + "pyplot.plot(t[:N], y[:N], linewidth=2, alpha=0.8, label='Experimental data')\n", + "pyplot.xlabel('Time [s]')\n", + "pyplot.ylabel('$y$ [m]')\n", + "pyplot.title('Free fall tennis ball (no air resistance) \\n')\n", + "pyplot.legend();" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The two lines look very close… but let's plot the difference to get an idea of the error." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiMAAAE1CAYAAAA1TeCqAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nTkSuQmCC\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig = pyplot.figure(figsize=(6,4))\n", + "pyplot.plot(t[:N], y[:N]-num_sol[:,0])\n", + "pyplot.title('Difference between numerical solution and experimental data.\\n')\n", + "pyplot.xlabel('Time [s]')\n", + "pyplot.ylabel('$y$ [m]');" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Air resistance\n", + "\n", + "In [Lesson 1](http://go.gwu.edu/engcomp3lesson1) of this module, we computed the acceleration of gravity and got a value less than the theoretical $9.8 \\rm{m/s}^2$, even when using high-resolution experimental data. Did you figure out why?\n", + "\n", + "We were missing the effect of air resistance! When an object moves in a fluid, like air, it applies a force on the fluid, and consequently the fluid applies an equal and opposite force on the object (Newton's third law).\n", + "\n", + "This force is the *drag* of the fuid, and it opposes the direction of travel. The drag force depends on the object's geometry, and its velocity: for a sphere, its magnitude is given by:\n", + "\n", + "\\begin{equation}\n", + " F_d = \\frac{1}{2} \\pi R^2 \\rho C_d v^2,\n", + "\\end{equation}\n", + "\n", + "where $R$ is the radius of the sphere, $\\rho$ the density of the fluid, $C_d$ the drag coefficient of a sphere, and $v$ is the velocity." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Since we have another force involved, we'll have to rethink the problem formulation. The state variables are still the same (position and velocity):\n", + "\n", + "\\begin{equation}\n", + "\\mathbf{y} = \\begin{bmatrix}\n", + "y \\\\ v\n", + "\\end{bmatrix}.\n", + "\\end{equation}\n", + "\n", + "But we'll adjust the differential equation to add the effect of air resistance. In vector form, we can write it as follows:\n", + "\n", + "\\begin{equation}\n", + "\\dot{\\mathbf{y}} = \\begin{bmatrix}\n", + "v \\\\ a_y\n", + "\\end{bmatrix},\n", + "\\end{equation}\n", + "\n", + "where $a_y$ now includes the acceleration due to the drag force:\n", + "\n", + "\\begin{equation}\n", + " a_y = -g + a_{\\text{drag}} \n", + "\\end{equation}\n", + "\n", + "With $F_{\\text{drag}} = m a_{\\text{drag}}$:\n", + "\n", + "\\begin{equation}\n", + " a_{\\text{drag}} = \\frac{1}{2m} \\pi R^2 \\rho C_d v^2\n", + "\\end{equation}\n", + "\n", + "Finally, we can write our differential equation as:\n", + "\n", + "\n", + "\\begin{equation}\n", + "\\dot{\\mathbf{y}} = \\begin{bmatrix}\n", + "v \\\\ -g + a_{\\text{drag}}\n", + "\\end{bmatrix}.\n", + "\\end{equation}\n", + "\n", + "Let's write a new function for this modified right-hand side of a falling tennis ball with air resistance." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### Note:\n", + "\n", + "According to the International Tennis Federation, [ITF](http://www.itftennis.com/home.aspx), the diameter of a tennis ball has to be in the range of $6.54$–$6.86 \\rm{cm}$, and its mass in the range of $56.0$–$59.4 \\rm{g}$. We chose a value in the middle of the range for each quantity." + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": { + "collapsed": true, + "jupyter": { + "outputs_hidden": true + } + }, + "outputs": [], + "source": [ + "def fall_drag(state):\n", + " '''Computes the right-hand side of the differential equation\n", + " for the fall of a ball, with drag, in SI units.\n", + " \n", + " Arguments\n", + " ---------- \n", + " state : array of two dependent variables [y v]^T\n", + " \n", + " Returns\n", + " -------\n", + " derivs: array of two derivatives [v (-g+a_drag)]^T\n", + " '''\n", + " R = 0.0661/2 # radius in meters\n", + " m = 0.0577 # mass in kilograms\n", + " rho = 1.22 # air density kg/m^3\n", + " C_d = 0.47 # drag coefficient for a sphere\n", + " pi = numpy.pi\n", + " \n", + " a_drag = 1/(2*m) * pi * R**2 * rho * C_d * (state[1])**2\n", + " \n", + " derivs = numpy.array([state[1], -9.8 + a_drag])\n", + " return derivs" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Assume the same initial conditions as before:" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": { + "collapsed": true, + "jupyter": { + "outputs_hidden": true + } + }, + "outputs": [], + "source": [ + "y0 = y[0] # initial position\n", + "v0 = 0 # initial velocity\n", + "N = 576 # number of steps" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": { + "collapsed": true, + "jupyter": { + "outputs_hidden": true + } + }, + "outputs": [], + "source": [ + "# initialize array\n", + "num_sol_drag = numpy.zeros([N,2])" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": { + "collapsed": true, + "jupyter": { + "outputs_hidden": true + } + }, + "outputs": [], + "source": [ + "# Set intial conditions\n", + "num_sol_drag[0,0] = y0\n", + "num_sol_drag[0,1] = v0" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": { + "collapsed": true, + "jupyter": { + "outputs_hidden": true + } + }, + "outputs": [], + "source": [ + "for i in range(N-1):\n", + " num_sol_drag[i+1] = eulerstep(num_sol_drag[i], fall_drag, dt)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Time to plot and see how it looks! Would you expect the results to be better than in the previous case? Let's plot the three cases and check the differences." + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZkAAAE1CAYAAAA1e51bAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nQmCC\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig = pyplot.figure(figsize=(6,4))\n", + "pyplot.plot(t[:N], num_sol[:,0], linewidth=2, linestyle='--', label='Num-solution no drag')\n", + "pyplot.plot(t[:N], y[:N], linewidth=2, alpha=0.6, label='Experimental data')\n", + "pyplot.plot(t[:N], num_sol_drag[:,0], linewidth=2, linestyle='--', label='Num-solution drag')\n", + "\n", + "pyplot.title('Free fall tennis ball \\n')\n", + "\n", + "pyplot.xlabel('Time [s]')\n", + "pyplot.ylabel('$y$ [m]')\n", + "pyplot.legend();" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "All the lines look very close… but let's plot the differences with the experimental data in both cases, to get an idea of the error." + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiMAAAE1CAYAAAA1TeCqAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nzKxULkbMzMysVP8HpqMcurFJrC4AAAAASUVORK5CYII=\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig = pyplot.figure(figsize=(6,4))\n", + "pyplot.plot(t[:N], y[:N]-num_sol[:,0], label='No drag')\n", + "pyplot.plot(t[:N], y[:N]-num_sol_drag[:,0], label='With drag')\n", + "pyplot.title('Difference between numerical solution and experimental data.\\n')\n", + "pyplot.xlabel('Time [s]')\n", + "pyplot.ylabel('$y$ [m]')\n", + "pyplot.legend();" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### Discuss with your neighbor\n", + "\n", + "* What do you see in the plot of the difference between the numerical solution and the experimental data?" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## What we've learned\n", + "\n", + "* Integrating an equation of motion numerically.\n", + "* Drawing multiple plots in one figure,\n", + "* Solving initial-value problems numerically\n", + "* Using Euler's method.\n", + "* Euler's method is a first-order method.\n", + "* Freefall with air resistance is a more realistic model." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## References\n", + "\n", + "1. _Elementary Mechanics Using Python_ (2015), Anders Malthe-Sorenssen, Undergraduate Lecture Notes in Physics, Springer. Data at http://folk.uio.no/malthe/mechbook/\n", + "\n", + "2. _The Physics Hyptertextbook_ (n/a), Glenn Elert, [Acceleration](https://physics.info/acceleration/)\n", + "\n", + "3. Euler method. (2017, October 13). In Wikipedia, The Free Encyclopedia. Retrieved 01:21, November 10, 2017, from https://en.wikipedia.org/w/index.php?title=Euler_method&oldid=805120184\n", + "\n", + "4. _Computational Physics with Python_, lecture notes by Eric Ayars, California State University, Chico. Available online on the author's website: https://physics.csuchico.edu/ayars/312/handouts/comp-phys-python.pdf" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.5" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/notebooks/1_Catch_Motion.ipynb b/notebooks/1_Catch_Motion.ipynb index ef56f60..528aa33 100644 --- a/notebooks/1_Catch_Motion.ipynb +++ b/notebooks/1_Catch_Motion.ipynb @@ -7826,9 +7826,9 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.6.9" + "version": "3.7.5" } }, "nbformat": 4, - "nbformat_minor": 2 + "nbformat_minor": 4 } diff --git a/notebooks/2_Step_Future.ipynb b/notebooks/2_Step_Future.ipynb index 6035ca3..86ed457 100644 --- a/notebooks/2_Step_Future.ipynb +++ b/notebooks/2_Step_Future.ipynb @@ -34,7 +34,10 @@ "cell_type": "code", "execution_count": 1, "metadata": { - "collapsed": true + "collapsed": true, + "jupyter": { + "outputs_hidden": true + } }, "outputs": [], "source": [ @@ -46,7 +49,10 @@ "cell_type": "code", "execution_count": 2, "metadata": { - "collapsed": true + "collapsed": true, + "jupyter": { + "outputs_hidden": true + } }, "outputs": [], "source": [ @@ -72,7 +78,10 @@ "cell_type": "code", "execution_count": 3, "metadata": { - "collapsed": true + "collapsed": true, + "jupyter": { + "outputs_hidden": true + } }, "outputs": [], "source": [ @@ -211,7 +220,10 @@ "cell_type": "code", "execution_count": 8, "metadata": { - "collapsed": true + "collapsed": true, + "jupyter": { + "outputs_hidden": true + } }, "outputs": [], "source": [ @@ -237,7 +249,10 @@ "cell_type": "code", "execution_count": 9, "metadata": { - "collapsed": true + "collapsed": true, + "jupyter": { + "outputs_hidden": true + } }, "outputs": [], "source": [ @@ -286,9 +301,7 @@ }, { "cell_type": "markdown", - "metadata": { - "collapsed": true - }, + "metadata": {}, "source": [ "## Euler's method\n", "\n", @@ -364,7 +377,10 @@ "cell_type": "code", "execution_count": 11, "metadata": { - "collapsed": true + "collapsed": true, + "jupyter": { + "outputs_hidden": true + } }, "outputs": [], "source": [ @@ -389,7 +405,10 @@ "cell_type": "code", "execution_count": 12, "metadata": { - "collapsed": true + "collapsed": true, + "jupyter": { + "outputs_hidden": true + } }, "outputs": [], "source": [ @@ -434,7 +453,10 @@ "cell_type": "code", "execution_count": 13, "metadata": { - "collapsed": true + "collapsed": true, + "jupyter": { + "outputs_hidden": true + } }, "outputs": [], "source": [ @@ -453,7 +475,10 @@ "cell_type": "code", "execution_count": 14, "metadata": { - "collapsed": true + "collapsed": true, + "jupyter": { + "outputs_hidden": true + } }, "outputs": [], "source": [ @@ -465,7 +490,10 @@ "cell_type": "code", "execution_count": 15, "metadata": { - "collapsed": true + "collapsed": true, + "jupyter": { + "outputs_hidden": true + } }, "outputs": [], "source": [ @@ -485,7 +513,10 @@ "cell_type": "code", "execution_count": 16, "metadata": { - "collapsed": true + "collapsed": true, + "jupyter": { + "outputs_hidden": true + } }, "outputs": [], "source": [ @@ -497,7 +528,10 @@ "cell_type": "code", "execution_count": 17, "metadata": { - "collapsed": true + "collapsed": true, + "jupyter": { + "outputs_hidden": true + } }, "outputs": [], "source": [ @@ -510,7 +544,10 @@ "cell_type": "code", "execution_count": 18, "metadata": { - "collapsed": true + "collapsed": true, + "jupyter": { + "outputs_hidden": true + } }, "outputs": [], "source": [ @@ -658,7 +695,10 @@ "cell_type": "code", "execution_count": 21, "metadata": { - "collapsed": true + "collapsed": true, + "jupyter": { + "outputs_hidden": true + } }, "outputs": [], "source": [ @@ -697,7 +737,10 @@ "cell_type": "code", "execution_count": 22, "metadata": { - "collapsed": true + "collapsed": true, + "jupyter": { + "outputs_hidden": true + } }, "outputs": [], "source": [ @@ -710,7 +753,10 @@ "cell_type": "code", "execution_count": 23, "metadata": { - "collapsed": true + "collapsed": true, + "jupyter": { + "outputs_hidden": true + } }, "outputs": [], "source": [ @@ -722,7 +768,10 @@ "cell_type": "code", "execution_count": 24, "metadata": { - "collapsed": true + "collapsed": true, + "jupyter": { + "outputs_hidden": true + } }, "outputs": [], "source": [ @@ -735,7 +784,10 @@ "cell_type": "code", "execution_count": 25, "metadata": { - "collapsed": true + "collapsed": true, + "jupyter": { + "outputs_hidden": true + } }, "outputs": [], "source": [ @@ -849,180 +901,6 @@ "\n", "4. _Computational Physics with Python_, lecture notes by Eric Ayars, California State University, Chico. Available online on the author's website: https://physics.csuchico.edu/ayars/312/handouts/comp-phys-python.pdf" ] - }, - { - "cell_type": "code", - "execution_count": 28, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "\n", - "\n", - "\n", - "\n", - "\n" - ], - "text/plain": [ - "" - ] - }, - "execution_count": 28, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Execute this cell to load the notebook's style sheet, then ignore it\n", - "from IPython.core.display import HTML\n", - "css_file = '../style/custom.css'\n", - "HTML(open(css_file, \"r\").read())" - ] } ], "metadata": { @@ -1041,9 +919,9 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.6.2" + "version": "3.7.5" } }, "nbformat": 4, - "nbformat_minor": 2 + "nbformat_minor": 4 }