03_matplotlib.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Matplotlib](http://upload.wikimedia.org/wikipedia/en/5/56/Matplotlib_logo.svg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h1 id=\"tocheading\">Table of Contents</h1>\n",
    "<div id=\"toc\"></div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%javascript\n",
    "$.getScript('https://kmahelona.github.io/ipython_notebook_goodies/ipython_notebook_toc.js')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=setup></a>\n",
    "# Notebook Setup (run me first!)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First, we apply a \"magic command\" to make plots appear \"inline\" inside the notebook. Alternatively, we could allow plots to appear in a separate window."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# only for the notebook\n",
    "%matplotlib inline\n",
    "# only in the ipython shell\n",
    "# %matplotlib"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%config InlineBackend.figure_format='svg' #Makes the plots a vector graphic in the inline display"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In order to work with Matplotlib, the library must be imported first.\n",
    "\n",
    "To save time and money, we give it a shorter name:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Make the size and fonts larger for this presentation\n",
    "plt.rcParams['figure.figsize'] = (10, 8)\n",
    "plt.rcParams['font.size'] = 16\n",
    "plt.rcParams['lines.linewidth'] = 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Matplotlib works best with numpy arrays, so we import `numpy` as well"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=line_plots></a>\n",
    "# Basics\n",
    "\n",
    "## Line plots"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = np.linspace(0, 1, 250) # 250 numbers from 0 to 1\n",
    "\n",
    "plt.plot(x, x**2)\n",
    "# If not interactive, e.g. in a script: \n",
    "# plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Using different styles for plots"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "t = np.linspace(0, 2 * np.pi, 50)   # 50 points between 0 and 2π\n",
    "plt.plot(t, np.sin(t));"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot(t, np.sin(t), '--');"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot(t, np.sin(t), 'go')\n",
    "\n",
    "# same thing! But with better keywords\n",
    "# plt.plot(t, np.sin(t), color='green', marker='o', linestyle='');\n",
    "None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# new in matplotlib 2.0, all colors of the color rotation available as C<N>\n",
    "x = np.linspace(0, 1, 100)\n",
    "for n in range(9):\n",
    "    plt.plot(x**(n + 1), color=f'C{n}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "All styles and colors: [matplotlib.axes.Axes.plot](http://matplotlib.org/api/_as_gen/matplotlib.axes.Axes.plot.html#matplotlib.axes.Axes.plot)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=setting_limits></a>\n",
    "## Setting x and y limits"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot(t, np.sin(t))\n",
    "plt.xlim(0, 2*np.pi)\n",
    "plt.ylim(-1.2, 1.2)\n",
    "None # Do not show matplotlib return value in notebook"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Axes labels\n",
    "\n",
    "![XKCD comic on why you should label your axes.](http://imgs.xkcd.com/comics/convincing.png \"And if you labeled your axes, I could tell you exactly how MUCH better.\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "with plt.xkcd():\n",
    "    plt.title('Axes with labels')\n",
    "    plt.plot(t, np.sin(t))\n",
    "    plt.xlabel('t / s')\n",
    "    plt.ylabel('U / V')\n",
    "    plt.ylim(-1.1, 1.1)\n",
    "    plt.xlim(0, 2*np.pi)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### A side note on units\n",
    "\n",
    "\n",
    "Contrary to some customs in HEP or Astronomy, the BiPM has strict rules on how to typeset quantities, numbers and units in table headers and axis labels:\n",
    "\n",
    "> Symbols for units are treated as mathematical entities. In expressing the value of a\n",
    "quantity as the product of a numerical value and a unit, both the numerical value and\n",
    "the unit may be treated by the ordinary rules of algebra.\n",
    "It is often convenient to\n",
    "write the quotient of a quantity and a unit in this way for the heading of a column in a\n",
    "table, so that the entries in the table are all simply numbers. [...]\n",
    "The axes of a graph may also be labelled in this way, so that the tick marks are\n",
    "labelled only with numbers\n",
    "\n",
    "\n",
    "[Bureau International des Poids et Measures,  The International System of Units, Chapter 5, Section 4](https://www.bipm.org/utils/common/pdf/si-brochure/SI-Brochure-9-EN.pdf)\n",
    "\n",
    "A physical quantity is always a product of a number and a unit, so what is shown, is the quantity divided by the unit.\n",
    "\n",
    "Especially square brackets have a totally different meaning and are highly problematic if it comes to mathematical operations on quantities like $\\log_{10}(E  \\,/\\, 1\\,\\mathrm{GeV})$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=label_formatting></a>\n",
    "### Label formatting\n",
    "\n",
    "These options can be set globally in a matplotlibrc file,\n",
    "see https://matplotlib.org/users/customizing.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot(t, np.sin(t))\n",
    "\n",
    "title_font = {'fontsize': 24, 'fontweight': 'bold', 'family': 'serif'}\n",
    "axes_font = {'fontsize': 18}\n",
    "\n",
    "plt.xlabel('t / s', axes_font)\n",
    "plt.ylabel('U / V', axes_font)\n",
    "plt.title('Always label your plots!', title_font);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Using LaTeX\n",
    "\n",
    "Matplotlib can handle a rather complete subset of LaTeX in any text"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot(t, np.sin(t))\n",
    "plt.xlabel(r'$t \\,/\\, \\mathrm{s}$')   # leading r means \"raw\", so that '\\' is handled correctly\n",
    "plt.ylabel(r\"$\\int_0^t \\cos(t') \\, \\mathrm{d}t'$\");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With more `rc` options, you can configure the LaTeX you want to use, but it must be installed and linked to anaconda / matplotlib"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from matplotlib import rc, rcParams\n",
    "rc('text', usetex=True)\n",
    "rc('font',**{'family':'serif',\n",
    "             'serif':['Computer Modern Roman','cmu serif']+rcParams['font.serif']})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Takes more computation time because of the external $\\LaTeX$ type-setting but makes everything more beautiful"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot(t, np.sin(t))\n",
    "plt.xlabel(r'$t \\,/\\, \\mathrm{s}$')   # leading r means \"raw\", so that '\\' is handled correctly\n",
    "plt.ylabel(r\"$\\int_0^t \\cos(t') \\, \\mathrm{d}t'$\");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Legends"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Matplotlib can create legends automatically for plot objects that have a label."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot(t, np.sin(t), label=r'$\\sin(t)$')\n",
    "plt.plot(t, np.cos(t), label=r'$\\cos(t)$')\n",
    "plt.legend()\n",
    "# plt.legend(loc='upper center')\n",
    "\n",
    "None # only to avoid cluttering the notebook"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = np.linspace(0, 1)\n",
    "\n",
    "plt.plot(x, x**2, label=r'$x^2$')\n",
    "plt.plot(x, x**4)\n",
    "plt.plot(x, x**6, 'o', label=r'$x^6$')\n",
    "\n",
    "plt.legend(loc='best');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Remember**: Legend entries are only generated for plot objects that have a label (note x⁴ is missing)!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Legend outside the plot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot(t, np.sin(t), label=r'$\\sin(t)$')\n",
    "plt.plot(t, np.cos(t), label=r'$\\cos(t)$')\n",
    "plt.legend()\n",
    "\n",
    "# put the legend in the center above the plot\n",
    "# coordinates are relative to the axes size.\n",
    "plt.legend(\n",
    "    bbox_to_anchor=(0.5, 1.01),\n",
    "    loc='lower center',  # this no sets the anchor of the legend\n",
    "    ncol=2,\n",
    ")\n",
    "plt.tight_layout()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Grids"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot(t, np.sin(t))\n",
    "plt.grid()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Axis-Scales"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = np.linspace(0, 10)\n",
    "# x = np.logspace(-1, 2, 100)\n",
    "\n",
    "plt.plot(x, np.exp(-x))\n",
    "plt.yscale('log')\n",
    "# plt.xscale('log')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Ticks"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = np.linspace(0, 2*np.pi,100)\n",
    "\n",
    "plt.plot(x, np.sin(x))\n",
    "plt.xlim(0, 2*np.pi)\n",
    "plt.grid()\n",
    "# First argument: position, second argument: labels\n",
    "plt.xticks(\n",
    "    np.arange(0, 2*np.pi + 0.1, np.pi/2),\n",
    "    [r\"$0$\", r\"$\\frac{1}{2}\\pi$\", r\"$\\pi$\", r\"$\\frac{3}{2}\\pi$\", r\"$2\\pi$\"]\n",
    ")\n",
    "None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "months = ['January',\n",
    "          'February',\n",
    "          'March',\n",
    "          'April',\n",
    "          'May',\n",
    "          'June',\n",
    "          'July',\n",
    "          'August',\n",
    "          'September',\n",
    "          'October',\n",
    "          'November',\n",
    "          'December']\n",
    "\n",
    "plt.bar(np.arange(12), np.random.rand(12))\n",
    "plt.xticks(\n",
    "    np.arange(12),\n",
    "    months,\n",
    "    rotation=45,\n",
    "    rotation_mode='anchor',\n",
    "    horizontalalignment='right',  # or ha\n",
    "    verticalalignment='top',      # or va\n",
    ");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Error bars"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = np.linspace(0, 2*np.pi, 10)\n",
    "errX = np.random.normal(0, 0.4, 10)\n",
    "errY = np.random.normal(0, 0.4, 10)\n",
    "\n",
    "plt.errorbar(x + errX, x + errY, xerr=0.4, yerr=errY, linestyle='');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Asymmetrical errors\n",
    "\n",
    "Give 2 arrays to the `xerr` or `yerr` kwargs:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = np.linspace(0, 1, 10)\n",
    "plt.errorbar(\n",
    "    x, \n",
    "    np.sin(2 * np.pi * x),\n",
    "    yerr=[np.full_like(x, 0.5), np.full_like(x, 0.1)],\n",
    "    linestyle='',\n",
    "    marker='o',\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Upper and lower limits\n",
    "\n",
    "\n",
    "Often, we want to give uncertainties for some values, but upper or lower limits for others."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "bins = np.logspace(2, 4, 15)\n",
    "x = (bins[:-1] + bins[1:]) / 2\n",
    "\n",
    "y = x**(-2.7)\n",
    "yerr = y * 0.3\n",
    "y += np.random.normal(0, yerr)\n",
    "\n",
    "# mask for which points are upper limits\n",
    "uplims = np.full_like(x, False)\n",
    "\n",
    "# last points are only upper limits\n",
    "y[-3:] += 3 * y[-3:]\n",
    "yerr[-3:] = 0.3 * y[-3:] # yerr determines length of limit arrow\n",
    "uplims[-3:] = True \n",
    "\n",
    "plt.errorbar(\n",
    "    x,\n",
    "    y,\n",
    "    xerr=np.diff(bins/2),\n",
    "    yerr=yerr,\n",
    "    uplims=uplims,\n",
    "    ls='none',\n",
    ")\n",
    "\n",
    "plt.xlabel(r'$E \\ / \\ \\mathrm{GeV}$')\n",
    "plt.ylabel(r'$ \\mathrm{Flux} \\ / \\ \\mathrm{GeV}^{-1} \\mathrm{s}^{-1} \\mathrm{m}^{-2} \\mathrm{sr}^{-1}$')\n",
    "plt.xscale('log')\n",
    "plt.yscale('log')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Polar Plots"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "r = np.linspace(0, 10, 50)\n",
    "# r = np.linspace(0, 10, 1000)\n",
    "theta = 2*np.pi*r\n",
    "\n",
    "plt.polar(theta, r);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Histograms"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1D Histograms"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Generate random data:\n",
    "x = np.random.normal(0, 1, 1000)\n",
    "plt.hist(x, bins=25);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x1 = np.random.normal(-1, 1, 1000)\n",
    "x2 = np.random.normal(1, 1, 1000)\n",
    "\n",
    "bin_edges = np.linspace(-6, 6, 51)  # 50 bins between -6 and 6\n",
    "\n",
    "plt.hist(x1, bins=bin_edges, histtype='step', label='$x_1$')\n",
    "plt.hist(x2, bins=bin_edges, histtype='step', label='$x_2$')\n",
    "plt.legend();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Beware of binning effects, there should never be bins, that are always empty.\n",
    "\n",
    "E.g. for interger data, use bins of integer width that are centered around integers:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = np.random.poisson(5, size=500)\n",
    "\n",
    "\n",
    "plt.figure()\n",
    "plt.hist(x, bins=20)\n",
    "\n",
    "plt.figure()\n",
    "bin_edges = np.arange(-0.5, 15, 1)\n",
    "print(bin_edges)\n",
    "plt.hist(x, bins=bin_edges)\n",
    "None"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2D Histograms"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mean = [2, 1]\n",
    "cov = [[9, 2],\n",
    "       [2, 4]]\n",
    "\n",
    "x, y = np.random.multivariate_normal(mean, cov, size=10000).T\n",
    "\n",
    "plt.hist2d(x, y)\n",
    "# plt.hist2d(x, y, bins=50)\n",
    "# plt.hist2d(x, y, bins=[25, 50], range=[[-10, 14], [-5, 7]])\n",
    "\n",
    "plt.colorbar(label='Counts');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Using Norms – e.g. Logarithmic colorscale"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from matplotlib.colors import LogNorm, DivergingNorm, SymLogNorm\n",
    "\n",
    "plt.hist2d(x, y, bins=50, norm=LogNorm())\n",
    "plt.colorbar(label='Counts');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### SymLogNorm\n",
    "\n",
    "The SymLogNorm uses two logscales, one for the negative, one for the positive numbers.\n",
    "Around 0, a linear scale is used. The threshold value for the linear scale\n",
    "has to be given."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x2, y2 = np.random.multivariate_normal(mean, cov, size=10000).T\n",
    "\n",
    "\n",
    "hist1, xedges, yedges = np.histogram2d(x, y, bins=100)\n",
    "hist2, _, _ = np.histogram2d(x2, y2, bins=[xedges, yedges])\n",
    "\n",
    "\n",
    "plt.pcolormesh(\n",
    "    xedges,\n",
    "    yedges,\n",
    "    hist1 - hist2,\n",
    "    cmap='RdBu',\n",
    "    norm=SymLogNorm(0.1),\n",
    "    vmin=-15,\n",
    "    vmax=15,\n",
    ")\n",
    "\n",
    "plt.colorbar();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Colormaps\n",
    "\n",
    "* Can influence perception greatly\n",
    "* Physicists most beloved colormaps (rainbow, jet) objectively bad\n",
    "    * Do not work when printed black/white\n",
    "    * Not colorblind friendly\n",
    "    * Not perceptually uniform\n",
    "    \n",
    "* Use the modern colormaps in matplotlib\n",
    "    * `viridis` (default since 2.0)\n",
    "    * `inferno`\n",
    "    * `magma`\n",
    "    * `plasma`\n",
    "    * `cividis`\n",
    "    \n",
    "* Use domain specific colormaps where appropriate:   \n",
    "  sequential vs. diverging vs. qualitative vs.cyclic \n",
    "\n",
    "More here: \n",
    "* https://www.youtube.com/watch?v=xAoljeRJ3lU\n",
    "* https://matplotlib.org/3.1.0/tutorials/colors/colormaps.html"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"scatter\"></a>\n",
    "# Scatter Plots"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x1, y1 = np.random.multivariate_normal([1, 1], [[1, 0], [0, 1]], 1000).T\n",
    "x2, y2 = np.random.multivariate_normal([-1, -1], [[1, 0], [0, 1]], 1000).T\n",
    "\n",
    "plt.scatter(x1, y1)\n",
    "plt.scatter(x2, y2)\n",
    "\n",
    "None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = np.append(x1, x2)\n",
    "y = np.append(y1, y2)\n",
    "s = np.random.uniform(5, 50, len(x))\n",
    "label = np.append(np.ones_like(x1), np.zeros_like(x2))\n",
    "plt.scatter(x, y, c=label, s=s);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Multiple plots in the same figure"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = np.linspace(0, 2*np.pi)\n",
    "\n",
    "# subplot arguments: # of rows, # of columns, plot index (row * (#cols) + col)\n",
    "plt.subplot(2, 1, 1)\n",
    "plt.plot(x, x**2)\n",
    "plt.xlim(0, 2*np.pi)\n",
    "\n",
    "plt.subplot(2, 1, 2)\n",
    "plt.plot(x, np.sin(x))\n",
    "plt.xlim(0, 2*np.pi);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Spacing\n",
    "\n",
    "You should almost always call `plt.tight_layout()` (just works™) or `constrained_layout=True` (sometimes better but experimental)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = np.linspace(0, 2*np.pi)\n",
    "\n",
    "plt.figure()\n",
    "plt.subplot(2, 1, 1)\n",
    "plt.plot(x, x**2)\n",
    "plt.xlim(0, 2*np.pi)\n",
    "plt.xlabel('$x \\ / \\ \\mathrm{m}$')\n",
    "plt.title(r\"$f(x)=x^2$\")\n",
    "\n",
    "plt.subplot(2, 1, 2)\n",
    "plt.plot(x, np.sin(x))\n",
    "plt.xlim(0, 2*np.pi)\n",
    "plt.xlabel('$x \\ / \\ \\mathrm{m}$')\n",
    "plt.title(r\"$f(x)=\\sin(x)$\")\n",
    "\n",
    "plt.tight_layout()   # try commenting this line out!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Inset Plots (plot inside a plot)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot(x, x**2)\n",
    "plt.title(\"Outer Plot\")\n",
    "\n",
    "# axes coordinates: (0,0) is lower left, (1,1) upper right\n",
    "plt.axes([0.2, 0.45, 0.3, 0.3])\n",
    "plt.plot(x, x**3)\n",
    "plt.title(\"Inner Plot\");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Using the object orientated syntax\n",
    "\n",
    "Matplotlib has two APIs (yes, it's strange).\n",
    "\n",
    "* The matlab-like syntax we used until now:\n",
    "    * Easier to write\n",
    "    * Familiar for matlab users\n",
    "    * Frequently uses global states\n",
    "* Object-oriented syntax:\n",
    "    * More powerful\n",
    "    * More control over the plots\n",
    "    * Preferable for library code\n",
    "    * No (or at least very few) global states"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "\n",
    "t = np.linspace(0, 2*np.pi, 1000)\n",
    "\n",
    "fig, (ax1, ax2) = plt.subplots(2, 1)\n",
    "\n",
    "# note that plot is now a method of ax1, not the global plt object\n",
    "ax1.plot(t, np.sin(t), color='C0')\n",
    "ax1.set_title(r\"$f(t)=\\sin(t)$\")   # use object-oriented get/set syntax\n",
    "\n",
    "ax2.plot(t, np.cos(t), color='C1')\n",
    "ax2.set_title(r\"$f(t)=\\cos(t)$\")\n",
    "\n",
    "for ax in (ax1, ax2):\n",
    "    ax.set_xlabel(\"$t$\")\n",
    "    ax.set_xlim(0, 2*np.pi)\n",
    "    ax.set_ylim(-1.1, 1.1)\n",
    "\n",
    "fig.tight_layout()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Shared Axes and GridSpec"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def poisson(x, k):\n",
    "    return np.exp(-x)*x**k / np.math.factorial(k)\n",
    "\n",
    "x = np.linspace(0, 12, 40)\n",
    "y = poisson(x, 2)\n",
    "y_noise = y + np.random.normal(0, 0.01, len(y))\n",
    "z = np.linspace(0, 12, 100)\n",
    "\n",
    "gridspec = {'height_ratios': [2, 1]}\n",
    "\n",
    "fig, (ax1, ax2) = plt.subplots(2, sharex=True, gridspec_kw=gridspec)\n",
    "\n",
    "ax1.plot(x, y_noise, r'ko')\n",
    "ax1.plot(z, poisson(z, 2))\n",
    "ax1.set_ylim(-0.05, 0.30)\n",
    "ax1.set_ylabel('Flux')\n",
    "ax1.set_yticks(ax1.get_yticks()[1:])    # remove bottom y-tick\n",
    "\n",
    "ax2.plot(x, y_noise - y, 'ko')\n",
    "ax2.axhline(y=0, color='black', linestyle='--', linewidth=1)\n",
    "ax2.set_xlabel('Energy')\n",
    "ax2.set_ylim(-0.03, 0.04)\n",
    "ax2.set_ylabel('Residuals')\n",
    "ax2.set_yticks(ax2.get_yticks()[:-1])   # remove top y-tick\n",
    "\n",
    "fig.subplots_adjust(hspace=0)\n",
    "fig.suptitle(r'Fake Spectrum', fontweight='bold');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Secondary Axis\n",
    "\n",
    "Astronomers often use a data format called Modified Julian Date (MJD),\n",
    "continuously counting fractional days since 1858-11-17T00:00.\n",
    "\n",
    "\n",
    "* I am not able to convert MJD to normal date in my head\n",
    "* Your audience probably is also not able to do it\n",
    "* Solution: provide both a human readable and a MJD axis\n",
    "\n",
    "Matplotlib uses the ordinal date (days since 1.1.1) for internal datetime representation\n",
    "\n",
    "New in matplotlib 3.1, Secondary Axis: https://matplotlib.org/3.1.0/gallery/subplots_axes_and_figures/secondary_axis.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from datetime import datetime, timedelta\n",
    "\n",
    "# constants for ordinal and mjd date representation\n",
    "MJD_EPOCH = datetime(1858, 11, 17)\n",
    "ORDINAL_EPOCH = datetime(1, 1, 1)\n",
    "DELTA = (MJD_EPOCH - ORDINAL_EPOCH).total_seconds() / 86400\n",
    "\n",
    "\n",
    "# convert functions from one unit to the other\n",
    "\n",
    "def ordinal_to_mjd(ordinal):\n",
    "    ''' Converts ordinal date (days since 0001-01-01T00:00) to MJD (days since 1858-11-17T00:00)'''\n",
    "    return ordinal - DELTA\n",
    "\n",
    "def mjd_to_ordinal(mjd):\n",
    "    return mjd + DELTA\n",
    "\n",
    "\n",
    "# create some random data\n",
    "n_on = np.random.poisson(60, 25)\n",
    "n_off = np.random.poisson(30, 25)\n",
    "n_signal = n_on - 0.2 * n_off\n",
    "n_signal_err = np.sqrt(n_on + 0.2**2 * n_off)\n",
    "\n",
    "# create some dates\n",
    "dates = [datetime(2017, 1, 1) + timedelta(days=i) for i in range(25)]\n",
    "\n",
    "fig = plt.figure()\n",
    "ax = fig.add_subplot(1, 1, 1)\n",
    "\n",
    "ax.errorbar(dates, n_signal, yerr=n_signal_err, ls='')\n",
    "\n",
    "\n",
    "ax.set_ylim(0, 80)\n",
    "ax.set_ylabel(r'Signal Rate / $\\mathrm{h}^{-1}$')\n",
    "\n",
    "\n",
    "fig.autofmt_xdate()\n",
    "\n",
    "# create a second axis, using the same y-axis\n",
    "ax_mjd = ax.secondary_xaxis('top', functions=(ordinal_to_mjd, mjd_to_ordinal))\n",
    "ax_mjd.set_xlabel('MJD')\n",
    "\n",
    "fig.tight_layout()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Plots for Publications\n",
    "\n",
    "* Use fully blown LaTeX installation using the `pgf` backend\n",
    "* Same font and font sizes as in your publication\n",
    "* Really high quality, publication ready plots\n",
    "* See example in `matplotlib_pgf`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Styles"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "List available styles:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(plt.style.available)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from scipy import stats\n",
    "\n",
    "def plot_stuff():\n",
    "    plt.subplot(2, 2, 1)\n",
    "    x = np.linspace(-1, 1, 1000)\n",
    "    plt.plot(x, np.sin(50*x**3)/(x))\n",
    "    plt.grid()\n",
    "\n",
    "    plt.subplot(2, 2, 2)\n",
    "    x = np.linspace(-1, 1, 10)\n",
    "    y = np.exp(-2.2*x) + np.random.normal(0, 0.1, 10)\n",
    "    yerr = np.random.normal(0, 0.2, 10)\n",
    "    plt.errorbar(x, y, yerr, fmt='o', capsize=3)\n",
    "    plt.yscale('log')\n",
    "\n",
    "    plt.subplot(2, 2, 3)\n",
    "    x = stats.skewnorm.rvs(10, size=1000)\n",
    "    plt.hist(x, bins=50)\n",
    "\n",
    "    plt.subplot(2, 2, 4)\n",
    "    x, y = np.mgrid[-1:1:.01, -1:1:.01]\n",
    "    pos = np.dstack((x, y))\n",
    "    z = stats.multivariate_normal([0.1, 0.3], [[0.2, 0.3], [0.1, 0.4]])\n",
    "    plt.contourf(x, y, z.pdf(pos))\n",
    "\n",
    "for plot_style in ['classic', 'bmh', 'fivethirtyeight', 'ggplot', 'seaborn']:\n",
    "    plt.figure()\n",
    "    with plt.style.context(plot_style):   # use context manager so that changes are temporary\n",
    "        plot_stuff()\n",
    "        plt.suptitle('Plot Style: ' + plot_style, fontweight='bold')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Saving figures into files\n",
    "\n",
    "Use `plt.savefig` to save your figure.\n",
    "\n",
    "You can either give path relative to your working directory or an absolute path.\n",
    "Not sure what the current working directory is?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pwd()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = np.linspace(-5, 5)\n",
    "plt.plot(x, x**3, marker='s')\n",
    "plt.title(\"My Awesome Plot\")\n",
    "\n",
    "# save in current directory; extension determines file type\n",
    "plt.savefig('awesome_plot.pdf')\n",
    "plt.savefig('awesome_plot.svg')\n",
    "plt.savefig('awesome_plot.eps') # old vector graphics format required by some journals\n",
    "plt.savefig('awesome_plot.png', dpi=300)   # bitmap graphics; lossless compression; don't use me for publications!\n",
    "# plt.savefig('awesome_plot.jpg', dpi=300)   # bitmap graphics; lossy compression; don't use me either!\n",
    "\n",
    "# relative path with subdirectory\n",
    "# plt.savefig('build/awesome_plot.pdf')\n",
    "\n",
    "# absolute path\n",
    "# plt.saveig('/path/to/output/directory/awesome_plot.pdf')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Animations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from matplotlib.animation import FuncAnimation\n",
    "from tqdm.notebook import tqdm\n",
    "\n",
    "fps = 25\n",
    "frames = 400\n",
    "progress = tqdm(total=frames)\n",
    "\n",
    "fig = plt.figure(figsize=(19.2, 10.8), dpi=100)  # FullHD\n",
    "ax = fig.add_subplot(1, 1, 1)\n",
    "ax.set_ylim(-1.1, 1.1)\n",
    "ax.set_xlim(0, 1)\n",
    "ax.axvline(0.5, 0, 1, color='gray')\n",
    "fig.tight_layout()\n",
    "\n",
    "line, = ax.plot([], [])\n",
    "dot, = ax.plot([], [], 'o', ms=20)\n",
    "text = ax.text(0.05, 0.95, '', va='top', ha='left', transform=ax.transAxes, family='monospace', size=32)\n",
    "\n",
    "x = np.linspace(0, 1, 200)\n",
    "\n",
    "\n",
    "def wave(x, t, lamb=2 * np.pi * 3, omega=2* np.pi / 5):\n",
    "    return np.sin(omega * t - lamb * x)\n",
    "\n",
    "def init():\n",
    "    dot.set_xdata(0.5)\n",
    "    dot.set_ydata(wave(0.5, 0))\n",
    "    line.set_xdata(x)\n",
    "    line.set_ydata(wave(x, 0))\n",
    "    text.set_text(r't =  0.0 s')\n",
    "\n",
    "def update(frame):\n",
    "    progress.update()\n",
    "    \n",
    "    t = frame / fps\n",
    "    dot.set_ydata(wave(0.5, t))\n",
    "    line.set_ydata(wave(x, t))\n",
    "    text.set_text(f't = {t:4.1f}')\n",
    "    return dot, line, t # return all plot objects that changed\n",
    "\n",
    "\n",
    "ani = FuncAnimation(fig, update, init_func=init, frames=frames, interval=1000/fps)\n",
    "ani.save('sine_wave.mp4', writer='ffmpeg')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from IPython.display import Video\n",
    "Video('sine_wave.mp4', width=800)\n",
    "# you might need to reload without caches after you made changes, e.g. ctrl + shift + r in Firefox"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3D-Plots\n",
    "\n",
    "Just a teaser, see https://matplotlib.org/mpl_toolkits/mplot3d/tutorial.html for more"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from mpl_toolkits.mplot3d import Axes3D\n",
    "\n",
    "\n",
    "x, y, z = np.random.normal(0, 2, size=(3, 100))\n",
    "\n",
    "\n",
    "fig = plt.figure()\n",
    "ax = Axes3D(fig=fig)\n",
    "\n",
    "ax.scatter(x, y, z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python3",
   "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.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}