{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "$\n", "\\newcommand{\\norm}[1]{{\\left\\|#1\\right\\|}}\n", "\\newcommand{\\abs}[1]{{\\left\\vert#1\\right\\vert}}\n", "\\newcommand{\\ip}[2]{{\\left\\langle#1,#2\\right\\rangle}}\n", "\\newcommand{\\R}{\\mathbb{R}}\n", "\\newcommand{\\p}{\\ensuremath{\\partial}}$\n", "\n", "\n", "# Plotting Direction Fields \n", "\n", "Our primary computational tool will be Python using Jupyter notebooks. I'll point out at the beginning that this is not a \n", "programming class and I will often sacrifice good programming principles to make the things more clear. \n", "\n", "## Direction Fields\n", "A **direction field** is a particular type of **vector field**. Recall that a two dimensional vector field on $R^2$ is a \n", "function that assigns to each point $(t,x)$ in $\\R^2$ a vector denoted, for example, by $\\ip{u(t,x)}{v(t,x)}$. In the \n", "context of ODEs, the vector field is constructed in the following way: If $(t,\\varphi(t))$ is a solution to the ODE $x' = \n", "f(t,x)$, then the vector field is :\n", "$$\n", "\\ip{u(t,x)}{v(t,x)} \n", "= \\ip{1}{\\varphi'(t)} \n", "= \\ip{t}{f(t,x)}.\n", "$$\n", "\n", "Of course, when drawing a vector field using python (or any software) we're not going to draw a vector at every point of \n", "$\\R^2$. Instead, we'll do it at a regurlarly spaced set of points over a rectangular grid $[t_0,t_1]\\times[x_0,x_1]$. \n", "Decisions like what rectangular grid to choose and how many points to sample the direction field at are domain specific. \n", "For example, if $x(t)$ represents the population of field mice, we wouldn't want to include any negative values of \n", "$x$ in the sampling. \n", "\n", "The way numpy does this is using meshgrids. First, we define two arrays: " ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", "t = np.arange(0,10,1)\n", "x = np.arange(0,2,.5)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "To run a block of code, press Shift+Enter. The import numpy allows us to use the functionality of numpy. If this is\n", "all we did, then we would have to write \n", "things like numpy.arange(0,10,1). The as np allows us to refer to numpy as np. These import \n", "statements usually go at the top of the Jupyter notebook, and in the future this is what we will do. We will have other \n", "import statements below that would usually go at the top as well. \n", "\n", "To see the value of a variable you can use the print command:" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "t=[0 1 2 3 4 5 6 7 8 9]\n", "x=[0. 0.5 1. 1.5]\n" ] } ], "source": [ "print (f\"t={t}\")\n", "print(f\"x={x}\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The expression np.arange(0,10,1) gives an array from 0 to 10 (not including 10) that is evenly spaced \n", "with step size 1. In general np.arange(a,b,h) gives an evenly spaced array from a to b (but not including \n", "b) with step size equal to h.\n", "\n", "The array t has length $10$ and the array x has length $4$. The two arrays together encode $4\\times 10 = 40$ \n", "ordered pairs in the $(t,x)$ plane at which to draw a vector field. The way that numpy organizes this data is via a \n", "\"Meshgrid\":" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "T, X = np.meshgrid(t, x)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "This assigns to T and X a $4\\times 10$ matrix. Each **row** of the T matrix is the vector t\n", "and each **column** of the X matrix is the vector x. That is: " ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "T = \n", "[[0 1 2 3 4 5 6 7 8 9]\n", " [0 1 2 3 4 5 6 7 8 9]\n", " [0 1 2 3 4 5 6 7 8 9]\n", " [0 1 2 3 4 5 6 7 8 9]]\n", "X = \n", "[[0. 0. 0. 0. 0. 0. 0. 0. 0. 0. ]\n", " [0.5 0.5 0.5 0.5 0.5 0.5 0.5 0.5 0.5 0.5]\n", " [1. 1. 1. 1. 1. 1. 1. 1. 1. 1. ]\n", " [1.5 1.5 1.5 1.5 1.5 1.5 1.5 1.5 1.5 1.5]]\n" ] } ], "source": [ "print(f\"T = \\n{T}\")\n", "print(f\"X = \\n{X}\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Observe that we have used lower caseletters - t and x - for the arrays and uppercase letters -\n", "T and X - for the corresponding vectors. This is a good convention to use. \n", "\n", "If $T_{kj}$ represents the the $(k,j)$ entry of $T$ and similarly for $X_{kj}$, then as $k$ runs through $0$ to $3$ and \n", "$j$ runs through $0$ to $9$, the ordered pairs $(T_{kj}, X_{kj})$ run through all $40$ sample points." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "At this point we have an efficient way to store the coordinates in the $(t,x)$ plane at which we will draw our \n", "direction field. We now need to tell numpy which vectors are the ones to be drawn and then we need to get python to draw \n", "them. \n", "\n", "We'll assume that we are dealing with ODEs of the form: \n", "$$\n", "\\frac{dx}{dt} = f(t,x). \n", "$$\n", "\n", "And we will use the specific example: \n", "$$\n", "\\frac{dv}{dt} \n", "= -v - 9.8.\n", "$$\n", "\n", "We first define a function that we can use (this isn't necssary but it makes things much easier). The \n", "#... is a comment. The Python interpreter doesn't look at this when running the code. It is just for us to \n", "give a short description of what the code is doing. " ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [], "source": [ "# This represents the right hand side of the ODE\n", "def f(t,x): \n", " return -9.8-x/5" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Notice that we are using the variable x instead of v. This is because I prefer to keep things standardized \n", "throughout different problems (as a form of abstraction.) But this is mostly a personal choice and in your own code, \n", "you could have done: \n", "\n", "def f(t,v): \n", " return -v-9.8.\n", "\n", "And instead of using x and X you can use v and V. However, u, U, v, V are \n", "used for the vector field as you will see below. " ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [], "source": [ "dXdT = f(T,X)\n", "U = (1 / (1 + dXdT**2)**.5)*np.ones(T.shape)\n", "V = (1 / (1 + dXdT**2)**.5)*dXdT" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "There is a lot going on here. Let's look at dXdT: " ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "dXdT = \n", "[[ -9.8 -9.8 -9.8 -9.8 -9.8 -9.8 -9.8 -9.8 -9.8 -9.8]\n", " [ -9.9 -9.9 -9.9 -9.9 -9.9 -9.9 -9.9 -9.9 -9.9 -9.9]\n", " [-10. -10. -10. -10. -10. -10. -10. -10. -10. -10. ]\n", " [-10.1 -10.1 -10.1 -10.1 -10.1 -10.1 -10.1 -10.1 -10.1 -10.1]]\n" ] } ], "source": [ "print(f\"dXdT = \\n{dXdT}\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "This is a $4 \\times 10$ matrix. The $(k,j)$ entry is: \n", "$$\n", "f(T_{kj}, X_{kj}).\n", "$$\n", "This is why the rows are constant (because $f(t,x)$ really only depends on $x$ in the sense that \n", "$\\frac{\\partial f}{\\partial t}\\equiv 0$). The fact that this works is a minor miracle and is both liberating and somewhat\n", "alarming for those who are familiar with a language like C. \n", "\n", "To explain the lines: \n", "\n", "U = (1 / (1 + dXdT**2)**.5)*np.ones(T.shape)\n", "V = (1 / (1 + dXdT**2)**.5)*dXdT\n", "\n", "recall that our vector field is $\\ip{1}{f(t,x)}$. We actually don't care about the lengths too much, and especially for \n", "display purposes we want to pick lengths that make things easier to see. So instead of plotting this vector field, \n", "we will plot a normalized version: \n", "$$\n", "\\frac{1}{\\norm{\\ip{1}{f(t,x)}}} \\ip{1}{f(t,x)}\n", "=\\ip{\\frac{1}{\\sqrt{1 + f(t,x)^2}}}{\\frac{f(t,x)}{\\sqrt{1 + f(t,x)^2}}}. \n", "$$\n", "\n", "U and V will both be $4\\times 10$ matrices and the vector drawn at the point $(T_{kj}, X_{kj})$ will be \n", "$\\ip{U(k,j)}{V(k,j)}$. Note that this means dimensions need to be consistent among T, X, dXdT, U, \n", "and V. \n", "\n", "The expression T.shape returns a $2\\times 1$ array containg the dimensions of T:" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "(4, 10)\n" ] } ], "source": [ "print(T.shape)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The expression np.ones(T.shape) creates a matrix of dimension equal to T.shape:" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[[1. 1. 1. 1. 1. 1. 1. 1. 1. 1.]\n", " [1. 1. 1. 1. 1. 1. 1. 1. 1. 1.]\n", " [1. 1. 1. 1. 1. 1. 1. 1. 1. 1.]\n", " [1. 1. 1. 1. 1. 1. 1. 1. 1. 1.]]\n" ] } ], "source": [ "print(np.ones(T.shape))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "In python, the expression a**b raises a to the power of b:" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "8\n" ] } ], "source": [ "print(2**3)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "So multplying np.ones(T.shape) by (1 / (1 + dXdT**2)**.5) has the effect of dividing\n", "np.ones(T.shape) by $\\norm{\\ip{1}{f(t,x)}}$. Similarly, the expression V = (1 / (1 + dXdT**2)**.5)*dXdT\n", "divides the matrix representing $f(t,x)$ by $\\norm{\\ip{1}{f(t,x)}}$. Overall, as discussed above, $(U,V)$ represents \n", "the vector field: \n", "$$\n", "\\ip{\\frac{1}{\\sqrt{1 + f(t,x)^2}}}{\\frac{f(t,x)}{\\sqrt{1 + f(t,x)^2}}}.\n", "$$\n", "\n", "Next we need to get python to plot the vector field $\\ip{U}{V}$ ad the points $\\ip{T}{X}$. The matplotlib library \n", "is a library of plotting functions. " ] }, { "cell_type": "code", "execution_count": 11, "metadata": { "scrolled": true }, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "