Extra_02_Plotting_Demo.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Demos - Plotting\n",
    "\n",
    "## Animate Decay"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "%matplotlib notebook\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.animation as animation\n",
    "\n",
    "def data_gen():\n",
    "    t = data_gen.t\n",
    "    cnt = 0\n",
    "    while cnt < 1000:\n",
    "        cnt+=1\n",
    "        t += 0.05\n",
    "        yield t, np.sin(2*np.pi*t) * np.exp(-t/10.)\n",
    "\n",
    "\n",
    "data_gen.t = 0\n",
    "fig = plt.figure()\n",
    "ax = fig.add_subplot(111)\n",
    "line, = ax.plot([], [], lw=2)\n",
    "ax.set_ylim(-1.1, 1.1)\n",
    "ax.set_xlim(0, 5)\n",
    "ax.grid()\n",
    "xdata, ydata = [], []\n",
    "def run(data):\n",
    "    # update the data\n",
    "    t,y = data\n",
    "    xdata.append(t)\n",
    "    ydata.append(y)\n",
    "    xmin, xmax = ax.get_xlim()\n",
    "\n",
    "    if t >= xmax:\n",
    "        ax.set_xlim(xmin, 2*xmax)\n",
    "        ax.figure.canvas.draw()\n",
    "    line.set_data(xdata, ydata)\n",
    "\n",
    "    return line,\n",
    "\n",
    "ani = animation.FuncAnimation(fig, run, data_gen, blit=True, interval=10,\n",
    "    repeat=False)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Contour Plot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "%matplotlib notebook\n",
    "from mpl_toolkits.mplot3d import axes3d\n",
    "import matplotlib.pyplot as plt\n",
    "from matplotlib import cm\n",
    "\n",
    "fig = plt.figure()\n",
    "ax = fig.gca(projection='3d')\n",
    "X, Y, Z = axes3d.get_test_data(0.05)\n",
    "ax.plot_surface(X, Y, Z, rstride=8, cstride=8, alpha=0.3)\n",
    "cset = ax.contour(X, Y, Z, zdir='z', offset=-100, cmap=cm.coolwarm)\n",
    "cset = ax.contour(X, Y, Z, zdir='x', offset=-40, cmap=cm.coolwarm)\n",
    "cset = ax.contour(X, Y, Z, zdir='y', offset=40, cmap=cm.coolwarm)\n",
    "\n",
    "ax.set_xlabel('X')\n",
    "ax.set_xlim(-40, 40)\n",
    "ax.set_ylabel('Y')\n",
    "ax.set_ylim(-40, 40)\n",
    "ax.set_zlabel('Z')\n",
    "ax.set_zlim(-100, 100)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Box plot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "%matplotlib notebook\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# fake data\n",
    "np.random.seed(937)\n",
    "data = np.random.lognormal(size=(37, 4), mean=1.5, sigma=1.75)\n",
    "labels = list('ABCD')\n",
    "fs = 10  # fontsize\n",
    "\n",
    "# demonstrate how to toggle the display of different elements:\n",
    "fig, axes = plt.subplots(nrows=2, ncols=3, figsize=(6, 6))\n",
    "axes[0, 0].boxplot(data, labels=labels)\n",
    "axes[0, 0].set_title('Default', fontsize=fs)\n",
    "\n",
    "axes[0, 1].boxplot(data, labels=labels, showmeans=True)\n",
    "axes[0, 1].set_title('showmeans=True', fontsize=fs)\n",
    "\n",
    "axes[0, 2].boxplot(data, labels=labels, showmeans=True, meanline=True)\n",
    "axes[0, 2].set_title('showmeans=True,\\nmeanline=True', fontsize=fs)\n",
    "\n",
    "axes[1, 0].boxplot(data, labels=labels, showbox=False, showcaps=False)\n",
    "axes[1, 0].set_title('Tufte Style \\n(showbox=False,\\nshowcaps=False)', fontsize=fs)\n",
    "\n",
    "axes[1, 1].boxplot(data, labels=labels, notch=True, bootstrap=10000)\n",
    "axes[1, 1].set_title('notch=True,\\nbootstrap=10000', fontsize=fs)\n",
    "\n",
    "axes[1, 2].boxplot(data, labels=labels, showfliers=False)\n",
    "axes[1, 2].set_title('showfliers=False', fontsize=fs)\n",
    "\n",
    "for ax in axes.flatten():\n",
    "    ax.set_yscale('log')\n",
    "    ax.set_yticklabels([])\n",
    "\n",
    "fig.subplots_adjust(hspace=0.4)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Curvilinear Grid"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "%matplotlib notebook\n",
    "\n",
    "def curvelinear_test2(fig):\n",
    "    \"\"\"\n",
    "    polar projection, but in a rectangular box.\n",
    "    \"\"\"\n",
    "    global ax1\n",
    "    import numpy as np\n",
    "    import  mpl_toolkits.axisartist.angle_helper as angle_helper\n",
    "    from matplotlib.projections import PolarAxes\n",
    "    from matplotlib.transforms import Affine2D\n",
    "\n",
    "    from mpl_toolkits.axisartist import SubplotHost\n",
    "\n",
    "    from mpl_toolkits.axisartist import GridHelperCurveLinear\n",
    "\n",
    "    # see demo_curvelinear_grid.py for details\n",
    "    tr = Affine2D().scale(np.pi/180., 1.) + PolarAxes.PolarTransform()\n",
    "\n",
    "    extreme_finder = angle_helper.ExtremeFinderCycle(20, 20,\n",
    "                                                     lon_cycle = 360,\n",
    "                                                     lat_cycle = None,\n",
    "                                                     lon_minmax = None,\n",
    "                                                     lat_minmax = (0, np.inf),\n",
    "                                                     )\n",
    "\n",
    "    grid_locator1 = angle_helper.LocatorDMS(12)\n",
    "\n",
    "    tick_formatter1 = angle_helper.FormatterDMS()\n",
    "\n",
    "    grid_helper = GridHelperCurveLinear(tr,\n",
    "                                        extreme_finder=extreme_finder,\n",
    "                                        grid_locator1=grid_locator1,\n",
    "                                        tick_formatter1=tick_formatter1\n",
    "                                        )\n",
    "\n",
    "\n",
    "    ax1 = SubplotHost(fig, 1, 1, 1, grid_helper=grid_helper)\n",
    "\n",
    "    fig.add_subplot(ax1)\n",
    "\n",
    "    # Now creates floating axis\n",
    "\n",
    "    #grid_helper = ax1.get_grid_helper()\n",
    "    # floating axis whose first coordinate (theta) is fixed at 60\n",
    "    ax1.axis[\"lat\"] = axis = ax1.new_floating_axis(0, 60)\n",
    "    axis.label.set_text(r\"$\\theta = 60^{\\circ}$\")\n",
    "    axis.label.set_visible(True)\n",
    "\n",
    "    # floating axis whose second coordinate (r) is fixed at 6\n",
    "    ax1.axis[\"lon\"] = axis = ax1.new_floating_axis(1, 6)\n",
    "    axis.label.set_text(r\"$r = 6$\")\n",
    "\n",
    "    ax1.set_aspect(1.)\n",
    "    ax1.set_xlim(-5, 12)\n",
    "    ax1.set_ylim(-5, 10)\n",
    "\n",
    "    ax1.grid(True)\n",
    "\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "fig = plt.figure(1, figsize=(5, 5))\n",
    "fig.clf()\n",
    "\n",
    "curvelinear_test2(fig)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Animate Double Pendulum"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "%matplotlib notebook\n",
    "from numpy import sin, cos, pi, array\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import scipy.integrate as integrate\n",
    "import matplotlib.animation as animation\n",
    "\n",
    "G =  9.8 # acceleration due to gravity, in m/s^2\n",
    "L1 = 1.0 # length of pendulum 1 in m\n",
    "L2 = 1.0 # length of pendulum 2 in m\n",
    "M1 = 1.0 # mass of pendulum 1 in kg\n",
    "M2 = 1.0 # mass of pendulum 2 in kg\n",
    "\n",
    "\n",
    "def derivs(state, t):\n",
    "    dydx = np.zeros_like(state)\n",
    "    dydx[0] = state[1]\n",
    "\n",
    "    del_ = state[2]-state[0]\n",
    "    den1 = (M1+M2)*L1 - M2*L1*cos(del_)*cos(del_)\n",
    "    dydx[1] = (M2*L1*state[1]*state[1]*sin(del_)*cos(del_)\n",
    "               + M2*G*sin(state[2])*cos(del_) + M2*L2*state[3]*state[3]*sin(del_)\n",
    "               - (M1+M2)*G*sin(state[0]))/den1\n",
    "\n",
    "    dydx[2] = state[3]\n",
    "\n",
    "    den2 = (L2/L1)*den1\n",
    "    dydx[3] = (-M2*L2*state[3]*state[3]*sin(del_)*cos(del_)\n",
    "               + (M1+M2)*G*sin(state[0])*cos(del_)\n",
    "               - (M1+M2)*L1*state[1]*state[1]*sin(del_)\n",
    "               - (M1+M2)*G*sin(state[2]))/den2\n",
    "\n",
    "    return dydx\n",
    "\n",
    "# create a time array from 0..100 sampled at 0.1 second steps\n",
    "dt = 0.05\n",
    "t = np.arange(0.0, 20, dt)\n",
    "\n",
    "# th1 and th2 are the initial angles (degrees)\n",
    "# w10 and w20 are the initial angular velocities (degrees per second)\n",
    "th1 = 120.0\n",
    "w1 = 0.0\n",
    "th2 = -10.0\n",
    "w2 = 0.0\n",
    "\n",
    "rad = pi/180\n",
    "\n",
    "# initial state\n",
    "state = np.array([th1, w1, th2, w2])*pi/180.\n",
    "\n",
    "# integrate your ODE using scipy.integrate.\n",
    "y = integrate.odeint(derivs, state, t)\n",
    "\n",
    "x1 = L1*sin(y[:,0])\n",
    "y1 = -L1*cos(y[:,0])\n",
    "\n",
    "x2 = L2*sin(y[:,2]) + x1\n",
    "y2 = -L2*cos(y[:,2]) + y1\n",
    "\n",
    "fig = plt.figure()\n",
    "ax = fig.add_subplot(111, autoscale_on=False, xlim=(-2, 2), ylim=(-2, 2))\n",
    "ax.grid()\n",
    "\n",
    "line, = ax.plot([], [], 'o-', lw=2)\n",
    "time_template = 'time = %.1fs'\n",
    "time_text = ax.text(0.05, 0.9, '', transform=ax.transAxes)\n",
    "\n",
    "def init():\n",
    "    line.set_data([], [])\n",
    "    time_text.set_text('')\n",
    "    return line, time_text\n",
    "\n",
    "def animate(i):\n",
    "    thisx = [0, x1[i], x2[i]]\n",
    "    thisy = [0, y1[i], y2[i]]\n",
    "\n",
    "    line.set_data(thisx, thisy)\n",
    "    time_text.set_text(time_template%(i*dt))\n",
    "    return line, time_text\n",
    "\n",
    "ani = animation.FuncAnimation(fig, animate, np.arange(1, len(y)),\n",
    "    interval=25, blit=True, init_func=init)\n",
    "\n",
    "#ani.save('double_pendulum.mp4', fps=15, clear_temp=True)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Multiple Ellipse Plot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "%matplotlib notebook\n",
    "from pylab import figure, show, rand\n",
    "from matplotlib.patches import Ellipse\n",
    "\n",
    "NUM = 250\n",
    "ells = [Ellipse(xy=rand(2)*10, width=rand(), height=rand(), angle=rand()*360)\n",
    "        for i in range(NUM)]\n",
    "\n",
    "fig = figure()\n",
    "ax = fig.add_subplot(111, aspect='equal')\n",
    "for e in ells:\n",
    "    ax.add_artist(e)\n",
    "    e.set_clip_box(ax.bbox)\n",
    "    e.set_alpha(rand())\n",
    "    e.set_facecolor(rand(3))\n",
    "\n",
    "ax.set_xlim(0, 10)\n",
    "ax.set_ylim(0, 10)\n",
    "show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Subplot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "%matplotlib notebook\n",
    "import matplotlib.mlab as mlab\n",
    "from matplotlib.pyplot import figure, show\n",
    "import numpy as np\n",
    "\n",
    "x = np.arange(0.0, 2, 0.01)\n",
    "y1 = np.sin(2*np.pi*x)\n",
    "y2 = 1.2*np.sin(4*np.pi*x)\n",
    "\n",
    "fig = figure()\n",
    "ax1 = fig.add_subplot(311)\n",
    "ax2 = fig.add_subplot(312, sharex=ax1)\n",
    "ax3 = fig.add_subplot(313, sharex=ax1)\n",
    "\n",
    "ax1.fill_between(x, 0, y1)\n",
    "ax1.set_ylabel('between y1 and 0')\n",
    "\n",
    "ax2.fill_between(x, y1, 1)\n",
    "ax2.set_ylabel('between y1 and 1')\n",
    "\n",
    "ax3.fill_between(x, y1, y2)\n",
    "ax3.set_ylabel('between y1 and y2')\n",
    "ax3.set_xlabel('x')\n",
    "\n",
    "# now fill between y1 and y2 where a logical condition is met.  Note\n",
    "# this is different than calling\n",
    "#   fill_between(x[where], y1[where],y2[where]\n",
    "# because of edge effects over multiple contiguous regions.\n",
    "fig = figure()\n",
    "ax = fig.add_subplot(211)\n",
    "ax.plot(x, y1, x, y2, color='black')\n",
    "ax.fill_between(x, y1, y2, where=y2>=y1, facecolor='green', interpolate=True)\n",
    "ax.fill_between(x, y1, y2, where=y2<=y1, facecolor='red', interpolate=True)\n",
    "ax.set_title('fill between where')\n",
    "\n",
    "# Test support for masked arrays.\n",
    "y2 = np.ma.masked_greater(y2, 1.0)\n",
    "ax1 = fig.add_subplot(212, sharex=ax)\n",
    "ax1.plot(x, y1, x, y2, color='black')\n",
    "ax1.fill_between(x, y1, y2, where=y2>=y1, facecolor='green', interpolate=True)\n",
    "ax1.fill_between(x, y1, y2, where=y2<=y1, facecolor='red', interpolate=True)\n",
    "ax1.set_title('Now regions with y2>1 are masked')\n",
    "\n",
    "# This example illustrates a problem; because of the data\n",
    "# gridding, there are undesired unfilled triangles at the crossover\n",
    "# points.  A brute-force solution would be to interpolate all\n",
    "# arrays to a very fine grid before plotting.\n",
    "\n",
    "# show how to use transforms to create axes spans where a certain condition is satisfied\n",
    "fig = figure()\n",
    "ax = fig.add_subplot(111)\n",
    "y = np.sin(4*np.pi*x)\n",
    "ax.plot(x, y, color='black')\n",
    "\n",
    "# use the data coordinates for the x-axis and the axes coordinates for the y-axis\n",
    "import matplotlib.transforms as mtransforms\n",
    "trans = mtransforms.blended_transform_factory(ax.transData, ax.transAxes)\n",
    "theta = 0.9\n",
    "ax.axhline(theta, color='green', lw=2, alpha=0.5)\n",
    "ax.axhline(-theta, color='red', lw=2, alpha=0.5)\n",
    "ax.fill_between(x, 0, 1, where=y>theta, facecolor='green', alpha=0.5, transform=trans)\n",
    "ax.fill_between(x, 0, 1, where=y<-theta, facecolor='red', alpha=0.5, transform=trans)\n",
    "show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Random Histogram"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "%matplotlib notebook\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.patches as patches\n",
    "import matplotlib.path as path\n",
    "import matplotlib.animation as animation\n",
    "\n",
    "fig = plt.figure()\n",
    "ax = fig.add_subplot(111)\n",
    "\n",
    "# histogram our data with numpy\n",
    "data = np.random.randn(1000)\n",
    "n, bins = np.histogram(data, 100)\n",
    "\n",
    "# get the corners of the rectangles for the histogram\n",
    "left = np.array(bins[:-1])\n",
    "right = np.array(bins[1:])\n",
    "bottom = np.zeros(len(left))\n",
    "top = bottom + n\n",
    "nrects = len(left)\n",
    "\n",
    "# here comes the tricky part -- we have to set up the vertex and path\n",
    "# codes arrays using moveto, lineto and closepoly\n",
    "\n",
    "# for each rect: 1 for the MOVETO, 3 for the LINETO, 1 for the\n",
    "# CLOSEPOLY; the vert for the closepoly is ignored but we still need\n",
    "# it to keep the codes aligned with the vertices\n",
    "nverts = nrects*(1+3+1)\n",
    "verts = np.zeros((nverts, 2))\n",
    "codes = np.ones(nverts, int) * path.Path.LINETO\n",
    "codes[0::5] = path.Path.MOVETO\n",
    "codes[4::5] = path.Path.CLOSEPOLY\n",
    "verts[0::5,0] = left\n",
    "verts[0::5,1] = bottom\n",
    "verts[1::5,0] = left\n",
    "verts[1::5,1] = top\n",
    "verts[2::5,0] = right\n",
    "verts[2::5,1] = top\n",
    "verts[3::5,0] = right\n",
    "verts[3::5,1] = bottom\n",
    "\n",
    "barpath = path.Path(verts, codes)\n",
    "patch = patches.PathPatch(barpath, facecolor='green', edgecolor='yellow', alpha=0.5)\n",
    "ax.add_patch(patch)\n",
    "\n",
    "ax.set_xlim(left[0], right[-1])\n",
    "ax.set_ylim(bottom.min(), top.max())\n",
    "\n",
    "def animate(i):\n",
    "    # simulate new data coming in\n",
    "    data = np.random.randn(1000)\n",
    "    n, bins = np.histogram(data, 100)\n",
    "    top = bottom + n\n",
    "    verts[1::5,1] = top\n",
    "    verts[2::5,1] = top\n",
    "\n",
    "ani = animation.FuncAnimation(fig, animate, 100, repeat=False)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Lorenz Attractor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "%matplotlib notebook\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from mpl_toolkits.mplot3d import Axes3D\n",
    "\n",
    "def lorenz(x, y, z, s=10, r=28, b=2.667) :\n",
    "    x_dot = s*(y - x)\n",
    "    y_dot = r*x - y - x*z\n",
    "    z_dot = x*y - b*z\n",
    "    return x_dot, y_dot, z_dot\n",
    "\n",
    "\n",
    "dt = 0.01\n",
    "stepCnt = 10000\n",
    "\n",
    "# Need one more for the initial values\n",
    "xs = np.empty((stepCnt + 1,))\n",
    "ys = np.empty((stepCnt + 1,))\n",
    "zs = np.empty((stepCnt + 1,))\n",
    "\n",
    "# Setting initial values\n",
    "xs[0], ys[0], zs[0] = (0., 1., 1.05)\n",
    "\n",
    "# Stepping through \"time\".\n",
    "for i in range(stepCnt) :\n",
    "    # Derivatives of the X, Y, Z state\n",
    "    x_dot, y_dot, z_dot = lorenz(xs[i], ys[i], zs[i])\n",
    "    xs[i + 1] = xs[i] + (x_dot * dt)\n",
    "    ys[i + 1] = ys[i] + (y_dot * dt)\n",
    "    zs[i + 1] = zs[i] + (z_dot * dt)\n",
    "\n",
    "fig = plt.figure()\n",
    "ax = fig.gca(projection='3d')\n",
    "\n",
    "ax.plot(xs, ys, zs)\n",
    "ax.set_xlabel(\"X Axis\")\n",
    "ax.set_ylabel(\"Y Axis\")\n",
    "ax.set_zlabel(\"Z Axis\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Polar Bar"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "%matplotlib notebook\n",
    "import numpy as np\n",
    "import matplotlib.cm as cm\n",
    "from matplotlib.pyplot import figure, show, rc\n",
    "\n",
    "# force square figure and square axes looks better for polar, IMO\n",
    "fig = figure(figsize=(8,8))\n",
    "ax = fig.add_axes([0.1, 0.1, 0.8, 0.8], polar=True)\n",
    "\n",
    "N = 20\n",
    "theta = np.arange(0.0, 2*np.pi, 2*np.pi/N)\n",
    "radii = 10*np.random.rand(N)\n",
    "width = np.pi/4*np.random.rand(N)\n",
    "bars = ax.bar(theta, radii, width=width, bottom=0.0)\n",
    "for r,bar in zip(radii, bars):\n",
    "    bar.set_facecolor( cm.jet(r/10.))\n",
    "    bar.set_alpha(0.5)\n",
    "show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Vector Field"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "%matplotlib notebook\n",
    "from pylab import *\n",
    "from numpy import ma\n",
    "\n",
    "X,Y = meshgrid( arange(0,2*pi,.2),arange(0,2*pi,.2) )\n",
    "U = cos(X)\n",
    "V = sin(Y)\n",
    "\n",
    "#1\n",
    "figure()\n",
    "Q = quiver( U, V)\n",
    "qk = quiverkey(Q, 0.5, 0.92, 2, r'$2 \\frac{m}{s}$', labelpos='W',\n",
    "               fontproperties={'weight': 'bold'})\n",
    "l,r,b,t = axis()\n",
    "dx, dy = r-l, t-b\n",
    "axis([l-0.05*dx, r+0.05*dx, b-0.05*dy, t+0.05*dy])\n",
    "\n",
    "title('Minimal arguments, no kwargs')\n",
    "\n",
    "#2\n",
    "figure()\n",
    "Q = quiver( X, Y, U, V, units='width')\n",
    "qk = quiverkey(Q, 0.9, 0.95, 2, r'$2 \\frac{m}{s}$',\n",
    "               labelpos='E',\n",
    "               coordinates='figure',\n",
    "               fontproperties={'weight': 'bold'})\n",
    "axis([-1, 7, -1, 7])\n",
    "title('scales with plot width, not view')\n",
    "\n",
    "#3\n",
    "figure()\n",
    "Q = quiver( X[::3, ::3], Y[::3, ::3], U[::3, ::3], V[::3, ::3],\n",
    "            pivot='mid', color='r', units='inches' )\n",
    "qk = quiverkey(Q, 0.5, 0.03, 1, r'$1 \\frac{m}{s}$', fontproperties={'weight': 'bold'})\n",
    "plot( X[::3, ::3], Y[::3, ::3], 'k.')\n",
    "axis([-1, 7, -1, 7])\n",
    "title(\"pivot='mid'; every third arrow; units='inches'\")\n",
    "\n",
    "#4\n",
    "figure()\n",
    "M = sqrt(pow(U, 2) + pow(V, 2))\n",
    "Q = quiver( X, Y, U, V, M, units='x', pivot='tip', width=0.022, scale=1/0.15)\n",
    "qk = quiverkey(Q, 0.9, 1.05, 1, r'$1 \\frac{m}{s}$',\n",
    "                            labelpos='E',\n",
    "                            fontproperties={'weight': 'bold'})\n",
    "plot(X, Y, 'k.')\n",
    "axis([-1, 7, -1, 7])\n",
    "title(\"scales with x view; pivot='tip'\")\n",
    "\n",
    "#5\n",
    "figure()\n",
    "Q = quiver( X[::3, ::3], Y[::3, ::3], U[::3, ::3], V[::3, ::3],\n",
    "             color='r', units='x',\n",
    "            linewidths=(2,), edgecolors=('k'), headaxislength=5 )\n",
    "qk = quiverkey(Q, 0.5, 0.03, 1, r'$1 \\frac{m}{s}$', fontproperties={'weight': 'bold'})\n",
    "axis([-1, 7, -1, 7])\n",
    "title(\"triangular head; scale with x view; black edges\")\n",
    "\n",
    "#6\n",
    "figure()\n",
    "M = zeros(U.shape, dtype='bool')\n",
    "M[U.shape[0]//3:2*U.shape[0]//3,U.shape[1]//3:2*U.shape[1]//3] = True\n",
    "U = ma.masked_array(U, mask=M)\n",
    "V = ma.masked_array(V, mask=M)\n",
    "Q = quiver( U, V)\n",
    "qk = quiverkey(Q, 0.5, 0.92, 2, r'$2 \\frac{m}{s}$', labelpos='W',\n",
    "               fontproperties={'weight': 'bold'})\n",
    "l,r,b,t = axis()\n",
    "dx, dy = r-l, t-b\n",
    "axis([l-0.05*dx, r+0.05*dx, b-0.05*dy, t+0.05*dy])\n",
    "title('Minimal arguments, no kwargs - masked values')\n",
    "show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Random Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "%matplotlib notebook\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.animation as animation\n",
    "\n",
    "fig = plt.figure()\n",
    "ax = fig.add_subplot(111)\n",
    "line, = ax.plot(np.random.rand(10))\n",
    "ax.set_ylim(0, 1)\n",
    "\n",
    "def update(data):\n",
    "    line.set_ydata(data)\n",
    "    return line,\n",
    "\n",
    "def data_gen():\n",
    "    while True: yield np.random.rand(10)\n",
    "\n",
    "ani = animation.FuncAnimation(fig, update, data_gen, interval=100)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Streamline Plot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "%matplotlib notebook\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "Y, X = np.mgrid[-3:3:100j, -3:3:100j]\n",
    "U = -1 - X**2 + Y\n",
    "V = 1 + X - Y**2\n",
    "speed = np.sqrt(U*U + V*V)\n",
    "\n",
    "plt.streamplot(X, Y, U, V, color=U, linewidth=2, cmap=plt.cm.autumn)\n",
    "plt.colorbar()\n",
    "\n",
    "f, (ax1, ax2) = plt.subplots(ncols=2)\n",
    "ax1.streamplot(X, Y, U, V, density=[0.5, 1])\n",
    "\n",
    "lw = 5*speed/speed.max()\n",
    "ax2.streamplot(X, Y, U, V, density=0.6, color='k', linewidth=lw)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Sphere Plot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "%matplotlib notebook\n",
    "from mpl_toolkits.mplot3d import Axes3D\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "\n",
    "fig = plt.figure()\n",
    "ax = fig.add_subplot(111, projection='3d')\n",
    "\n",
    "u = np.linspace(0, 2 * np.pi, 100)\n",
    "v = np.linspace(0, np.pi, 100)\n",
    "\n",
    "x = 10 * np.outer(np.cos(u), np.sin(v))\n",
    "y = 10 * np.outer(np.sin(u), np.sin(v))\n",
    "z = 10 * np.outer(np.ones(np.size(u)), np.cos(v))\n",
    "ax.plot_surface(x, y, z,  rstride=4, cstride=4, color='b')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Radial Surface Plot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "%matplotlib notebook\n",
    "from mpl_toolkits.mplot3d import Axes3D\n",
    "import matplotlib\n",
    "import numpy as np\n",
    "from matplotlib import cm\n",
    "from matplotlib import pyplot as plt\n",
    "step = 0.04\n",
    "maxval = 1.0\n",
    "fig = plt.figure()\n",
    "ax = fig.add_subplot(111, projection='3d')\n",
    "\n",
    "# create supporting points in polar coordinates\n",
    "r = np.linspace(0,1.25,50)\n",
    "p = np.linspace(0,2*np.pi,50)\n",
    "R,P = np.meshgrid(r,p)\n",
    "# transform them to cartesian system\n",
    "X,Y = R*np.cos(P),R*np.sin(P)\n",
    "\n",
    "Z = ((R**2 - 1)**2)\n",
    "ax.plot_surface(X, Y, Z, rstride=1, cstride=1, cmap=cm.YlGnBu_r)\n",
    "ax.set_zlim3d(0, 1)\n",
    "ax.set_xlabel(r'$\\phi_\\mathrm{real}$')\n",
    "ax.set_ylabel(r'$\\phi_\\mathrm{im}$')\n",
    "ax.set_zlabel(r'$V(\\phi)$')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Triangular Elements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "%matplotlib notebook\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.tri as tri\n",
    "import numpy as np\n",
    "import math\n",
    "\n",
    "# Creating a Triangulation without specifying the triangles results in the\n",
    "# Delaunay triangulation of the points.\n",
    "\n",
    "# First create the x and y coordinates of the points.\n",
    "n_angles = 36\n",
    "n_radii = 8\n",
    "min_radius = 0.25\n",
    "radii = np.linspace(min_radius, 0.95, n_radii)\n",
    "\n",
    "angles = np.linspace(0, 2*math.pi, n_angles, endpoint=False)\n",
    "angles = np.repeat(angles[...,np.newaxis], n_radii, axis=1)\n",
    "angles[:,1::2] += math.pi/n_angles\n",
    "\n",
    "x = (radii*np.cos(angles)).flatten()\n",
    "y = (radii*np.sin(angles)).flatten()\n",
    "\n",
    "# Create the Triangulation; no triangles so Delaunay triangulation created.\n",
    "triang = tri.Triangulation(x, y)\n",
    "\n",
    "# Mask off unwanted triangles.\n",
    "xmid = x[triang.triangles].mean(axis=1)\n",
    "ymid = y[triang.triangles].mean(axis=1)\n",
    "mask = np.where(xmid*xmid + ymid*ymid < min_radius*min_radius, 1, 0)\n",
    "triang.set_mask(mask)\n",
    "\n",
    "# Plot the triangulation.\n",
    "plt.figure()\n",
    "plt.gca().set_aspect('equal')\n",
    "plt.triplot(triang, 'bo-')\n",
    "plt.title('triplot of Delaunay triangulation')\n",
    "\n",
    "\n",
    "# You can specify your own triangulation rather than perform a Delaunay\n",
    "# triangulation of the points, where each triangle is given by the indices of\n",
    "# the three points that make up the triangle, ordered in either a clockwise or\n",
    "# anticlockwise manner.\n",
    "\n",
    "xy = np.asarray([\n",
    "    [-0.101,0.872],[-0.080,0.883],[-0.069,0.888],[-0.054,0.890],[-0.045,0.897],\n",
    "    [-0.057,0.895],[-0.073,0.900],[-0.087,0.898],[-0.090,0.904],[-0.069,0.907],\n",
    "    [-0.069,0.921],[-0.080,0.919],[-0.073,0.928],[-0.052,0.930],[-0.048,0.942],\n",
    "    [-0.062,0.949],[-0.054,0.958],[-0.069,0.954],[-0.087,0.952],[-0.087,0.959],\n",
    "    [-0.080,0.966],[-0.085,0.973],[-0.087,0.965],[-0.097,0.965],[-0.097,0.975],\n",
    "    [-0.092,0.984],[-0.101,0.980],[-0.108,0.980],[-0.104,0.987],[-0.102,0.993],\n",
    "    [-0.115,1.001],[-0.099,0.996],[-0.101,1.007],[-0.090,1.010],[-0.087,1.021],\n",
    "    [-0.069,1.021],[-0.052,1.022],[-0.052,1.017],[-0.069,1.010],[-0.064,1.005],\n",
    "    [-0.048,1.005],[-0.031,1.005],[-0.031,0.996],[-0.040,0.987],[-0.045,0.980],\n",
    "    [-0.052,0.975],[-0.040,0.973],[-0.026,0.968],[-0.020,0.954],[-0.006,0.947],\n",
    "    [ 0.003,0.935],[ 0.006,0.926],[ 0.005,0.921],[ 0.022,0.923],[ 0.033,0.912],\n",
    "    [ 0.029,0.905],[ 0.017,0.900],[ 0.012,0.895],[ 0.027,0.893],[ 0.019,0.886],\n",
    "    [ 0.001,0.883],[-0.012,0.884],[-0.029,0.883],[-0.038,0.879],[-0.057,0.881],\n",
    "    [-0.062,0.876],[-0.078,0.876],[-0.087,0.872],[-0.030,0.907],[-0.007,0.905],\n",
    "    [-0.057,0.916],[-0.025,0.933],[-0.077,0.990],[-0.059,0.993] ])\n",
    "x = xy[:,0]*180/3.14159\n",
    "y = xy[:,1]*180/3.14159\n",
    "\n",
    "triangles = np.asarray([\n",
    "    [67,66, 1],[65, 2,66],[ 1,66, 2],[64, 2,65],[63, 3,64],[60,59,57],\n",
    "    [ 2,64, 3],[ 3,63, 4],[ 0,67, 1],[62, 4,63],[57,59,56],[59,58,56],\n",
    "    [61,60,69],[57,69,60],[ 4,62,68],[ 6, 5, 9],[61,68,62],[69,68,61],\n",
    "    [ 9, 5,70],[ 6, 8, 7],[ 4,70, 5],[ 8, 6, 9],[56,69,57],[69,56,52],\n",
    "    [70,10, 9],[54,53,55],[56,55,53],[68,70, 4],[52,56,53],[11,10,12],\n",
    "    [69,71,68],[68,13,70],[10,70,13],[51,50,52],[13,68,71],[52,71,69],\n",
    "    [12,10,13],[71,52,50],[71,14,13],[50,49,71],[49,48,71],[14,16,15],\n",
    "    [14,71,48],[17,19,18],[17,20,19],[48,16,14],[48,47,16],[47,46,16],\n",
    "    [16,46,45],[23,22,24],[21,24,22],[17,16,45],[20,17,45],[21,25,24],\n",
    "    [27,26,28],[20,72,21],[25,21,72],[45,72,20],[25,28,26],[44,73,45],\n",
    "    [72,45,73],[28,25,29],[29,25,31],[43,73,44],[73,43,40],[72,73,39],\n",
    "    [72,31,25],[42,40,43],[31,30,29],[39,73,40],[42,41,40],[72,33,31],\n",
    "    [32,31,33],[39,38,72],[33,72,38],[33,38,34],[37,35,38],[34,38,35],\n",
    "    [35,37,36] ])\n",
    "\n",
    "# Rather than create a Triangulation object, can simply pass x, y and triangles\n",
    "# arrays to triplot directly.  It would be better to use a Triangulation object\n",
    "# if the same triangulation was to be used more than once to save duplicated\n",
    "# calculations.\n",
    "plt.figure()\n",
    "plt.gca().set_aspect('equal')\n",
    "plt.triplot(x, y, triangles, 'go-')\n",
    "plt.title('triplot of user-specified triangulation')\n",
    "plt.xlabel('Longitude (degrees)')\n",
    "plt.ylabel('Latitude (degrees)')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Animate Wireframe Plot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "%matplotlib notebook\n",
    "from mpl_toolkits.mplot3d import axes3d\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import time\n",
    "\n",
    "def generate(X, Y, phi):\n",
    "    R = 1 - np.sqrt(X**2 + Y**2)\n",
    "    return np.cos(2 * np.pi * X + phi) * R\n",
    "\n",
    "plt.ion()\n",
    "fig = plt.figure()\n",
    "ax = fig.add_subplot(111, projection='3d')\n",
    "\n",
    "xs = np.linspace(-1, 1, 50)\n",
    "ys = np.linspace(-1, 1, 50)\n",
    "X, Y = np.meshgrid(xs, ys)\n",
    "Z = generate(X, Y, 0.0)\n",
    "\n",
    "wframe = None\n",
    "tstart = time.time()\n",
    "for phi in np.linspace(0, 360 / 2 / np.pi, 100):\n",
    "\n",
    "    oldcol = wframe\n",
    "\n",
    "    Z = generate(X, Y, phi)\n",
    "    wframe = ax.plot_wireframe(X, Y, Z, rstride=2, cstride=2)\n",
    "\n",
    "    # Remove old line collection before drawing\n",
    "    if oldcol is not None:\n",
    "        ax.collections.remove(oldcol)\n",
    "\n",
    "    plt.draw()\n",
    "\n",
    "print ('FPS: %f' % (100 / (time.time() - tstart)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "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.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}