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": [
    "In order to work with Matplotlib, the library must be imported first. So we do not have to type so much, we give it a shorter name:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We apply a \"magic command\" to have interactive plots in the notebook.\n",
    "\n",
    "This is using the `ipympl` package. \n",
    "\n",
    "Without this, you will only get non-interactive versions of the plots."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "# only for the notebook\n",
    "%matplotlib widget\n",
    "\n",
    "# only in the ipython shell\n",
    "# %matplotlib"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Matplotlib works best with numpy arrays, so we import `numpy` as well"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# this is a matplotlib tutorial, we are going to open lots of figures ;-)\n",
    "plt.rcParams['figure.max_open_warning'] = 100"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=line_plots></a>\n",
    "# Basics\n",
    "\n",
    "## Line plots"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "x = np.linspace(0, 1, 250) # 250 numbers from 0 to 1\n",
    "\n",
    "# create a new plot, this is required when using ipympl\n",
    "# as otherwise, code in a new cell will affect a previously \n",
    "# created plot\n",
    "plt.figure()\n",
    "\n",
    "# plot some data\n",
    "plt.plot(x, x**2)\n",
    "\n",
    "\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": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "t = np.linspace(0, 2 * np.pi, 50)   # 50 points between 0 and 2π\n",
    "\n",
    "# constrained_layout is a new feature in matplotlib, \n",
    "# to automatically adjust items in a plot to best use the available space\n",
    "plt.figure(constrained_layout=True)\n",
    "plt.plot(t, np.sin(t));"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "plt.figure(constrained_layout=True)\n",
    "plt.plot(t, np.sin(t), '--');"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "plt.figure(constrained_layout=True)\n",
    "\n",
    "# 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",
    "\n",
    "None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = np.linspace(0, 1, 100)\n",
    "\n",
    "plt.figure(constrained_layout=True)\n",
    "for n in range(9):\n",
    "    \n",
    "    # C<N> is the nth color of the current color cycle\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": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "plt.figure(constrained_layout=True)\n",
    "\n",
    "plt.plot(t, np.sin(t))\n",
    "plt.xlim(0, 2*np.pi)\n",
    "plt.ylim(-1.2, 1.2)\n",
    "\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": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "with plt.xkcd():\n",
    "    \n",
    "    plt.figure(constrained_layout=True)\n",
    "    plt.title('Axes with labels')\n",
    "    plt.plot(t, np.sin(t))\n",
    "    \n",
    "    plt.xlabel('t / s')\n",
    "    plt.ylabel('U / V')\n",
    "    \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 are preferably set outside the script in a matplotlibrc file,\n",
    "see https://matplotlib.org/users/customizing.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "plt.figure(constrained_layout=True)\n",
    "\n",
    "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": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "plt.figure(constrained_layout=True)\n",
    "\n",
    "plt.plot(t, np.sin(t))\n",
    "\n",
    "# leading r means \"raw string\", so that '\\' does not need to be escaped\n",
    "plt.xlabel(r'$t \\,/\\, \\mathrm{s}$')\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": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "plt.figure(constrained_layout=True)\n",
    "\n",
    "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": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "plt.figure(constrained_layout=True)\n",
    "\n",
    "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.figure(constrained_layout=True)\n",
    "\n",
    "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",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Grids"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "plt.figure(constrained_layout=True)\n",
    "plt.plot(t, np.sin(t))\n",
    "plt.grid()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Axis-Scales"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "plt.figure(constrained_layout=True)\n",
    "\n",
    "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": [
    "## Custom Ticks"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "x = np.linspace(0, 2*np.pi)\n",
    "\n",
    "plt.figure(constrained_layout=True)\n",
    "\n",
    "plt.plot(x, np.sin(x))\n",
    "plt.xlim(0, 2*np.pi)\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}{4}\\tau$\", r\"$\\frac{1}{2}\\tau$\", r\"$\\frac{3}{4}\\tau$\", r\"$\\tau$\"]\n",
    ")\n",
    "plt.title(r\"$\\tau$ FTW!\")   # https://tauday.com/tau-manifesto\n",
    "None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "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.figure(constrained_layout=True)\n",
    "\n",
    "rng = np.random.default_rng(0)\n",
    "\n",
    "plt.bar(np.arange(12), rng.uniform(0, 1, 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": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "x = np.linspace(0, 2*np.pi, 10)\n",
    "\n",
    "rng = np.random.default_rng(0)\n",
    "errX = rng.normal(0, 0.4, 10)\n",
    "errY = rng.normal(0, 0.4, 10)\n",
    "\n",
    "plt.figure(constrained_layout=True)\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",
    "\n",
    "plt.figure(constrained_layout=True)\n",
    "\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": [
    "# create some random \"spectrum\"\n",
    "bins = np.logspace(2, 4, 15)\n",
    "x = (bins[:-1] + bins[1:]) / 2\n",
    "\n",
    "rng = np.random.default_rng(0)\n",
    "\n",
    "y = x**(-2.7)\n",
    "yerr = y * 0.3\n",
    "y += rng.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 "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we can plot the data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.figure(constrained_layout=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('$E \\ / \\ \\mathrm{GeV}$')\n",
    "plt.ylabel('$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": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "r = np.linspace(0, 10, 50)\n",
    "# r = np.linspace(0, 10, 1000)\n",
    "theta = 2*np.pi*r\n",
    "\n",
    "plt.figure(constrained_layout=True)\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": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "# Generate random data:\n",
    "\n",
    "rng = np.random.default_rng(0)\n",
    "x = rng.normal(0, 1, 1000)\n",
    "\n",
    "plt.figure(constrained_layout=True)\n",
    "plt.hist(x, bins=25);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Whe  comparing two distributions, make sure to use the same binning for both:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "x1 = rng.normal(-1, 1, 1000)\n",
    "x2 = rng.normal(1, 1, 1000)\n",
    "\n",
    "bin_edges = np.linspace(-6, 6, 51)  # 50 bins between -6 and 6\n",
    "\n",
    "plt.figure(constrained_layout=True)\n",
    "\n",
    "plt.hist(x1, bins=bin_edges, histtype='step', label='x1')\n",
    "plt.hist(x2, bins=bin_edges, histtype='step', label='x2')\n",
    "\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 = rng.poisson(5, size=500)\n",
    "\n",
    "\n",
    "plt.figure(constrained_layout=True)\n",
    "\n",
    "plt.subplot(2, 1, 1)\n",
    "plt.hist(x, bins=20)\n",
    "\n",
    "plt.subplot(2, 1, 2)\n",
    "bin_edges = np.arange(-0.5, 15, 1)\n",
    "\n",
    "plt.hist(x, bins=bin_edges, edgecolor='w', linewidth=2)\n",
    "\n",
    "bin_edges"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2D Histograms"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "mean = np.array([2, 1])\n",
    "cov = np.array(\n",
    "    [[9, 2],\n",
    "     [2, 4]]\n",
    ")\n",
    "\n",
    "x, y = rng.multivariate_normal(mean, cov, size=10000).T\n",
    "\n",
    "plt.figure(constrained_layout=True)\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, SymLogNorm, TwoSlopeNorm\n",
    "\n",
    "plt.figure(constrained_layout=True)\n",
    "\n",
    "\n",
    "plt.hist2d(\n",
    "    x,\n",
    "    y,\n",
    "    bins=50,\n",
    "    norm=LogNorm(),\n",
    ")\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": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "x1, y1 = rng.multivariate_normal(mean, cov / 3, size=100000).T\n",
    "x2, y2 = rng.multivariate_normal(mean, cov, size=100000).T\n",
    "\n",
    "\n",
    "hist1, xedges, yedges = np.histogram2d(x1, y1, bins=100, range=[[-8, 13], [-7, 9]])\n",
    "hist2, _, _ = np.histogram2d(x2, y2, bins=[xedges, yedges])\n",
    "\n",
    "plt.figure(constrained_layout=True)\n",
    "\n",
    "plt.pcolormesh(\n",
    "    xedges,\n",
    "    yedges,\n",
    "    hist1 - hist2,\n",
    "    cmap='RdBu_r',\n",
    "    norm=SymLogNorm(10),\n",
    ")\n",
    "\n",
    "plt.colorbar();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Colormaps\n",
    "\n",
    "* Can influence perception greatly\n",
    "* Physicists most beloved colormaps (rainbow, jet) are 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": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "x1, y1 = rng.multivariate_normal([1, 1], [[1, 0], [0, 1]], 1000).T\n",
    "x2, y2 = rng.multivariate_normal([-1, -1], [[1, 0], [0, 1]], 1000).T\n",
    "\n",
    "plt.figure(constrained_layout=True)\n",
    "\n",
    "plt.scatter(x1, y1)\n",
    "plt.scatter(x2, y2)\n",
    "\n",
    "None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "# we can also set the size and colors of each point individually\n",
    "x = np.append(x1, x2)\n",
    "y = np.append(y1, y2)\n",
    "\n",
    "s = np.random.uniform(5, 50, 2000)\n",
    "label = np.append(np.ones_like(x1), np.zeros_like(x2))\n",
    "\n",
    "plt.figure(constrained_layout=True)\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": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "x = np.linspace(0, 2*np.pi)\n",
    "\n",
    "plt.figure(constrained_layout=True)\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 use `constrained_layout=True` (still a bit experimental)\n",
    "or in the end all `plt.tight_layout()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "x = np.linspace(0, 2*np.pi)\n",
    "\n",
    "plt.figure(constrained_layout=False)\n",
    "\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": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "plt.figure(constrained_layout=True)\n",
    "\n",
    "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": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "\n",
    "t = np.linspace(0, 2*np.pi, 1000)\n",
    "\n",
    "\n",
    "fig, (ax1, ax2) = plt.subplots(2, 1, constrained_layout=True)\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"
   ]
  },
  {
   "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(\n",
    "    2, 1,\n",
    "    sharex=True,\n",
    "    gridspec_kw=gridspec,\n",
    "    constrained_layout=True,\n",
    ")\n",
    "\n",
    "ax1.plot(x, y_noise, '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.suptitle('\\nFake 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 dates 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 days since 1970-01-01T00:00:00 by default since version 3.3 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\n",
    "\n",
    "Note: this can also be done using `astropy.time.Time`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from datetime import datetime, timedelta\n",
    "from matplotlib.dates import get_epoch\n",
    "\n",
    "# constants for ordinal and mjd date representation\n",
    "MJD_EPOCH = datetime(1858, 11, 17)\n",
    "MPL_EPOCH = datetime.fromisoformat(get_epoch())\n",
    "DELTA = (MJD_EPOCH - MPL_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 mpl epoch) 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(2022, 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": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "from scipy import stats\n",
    "\n",
    "def plot_stuff():\n",
    "    plt.figure(constrained_layout=True)\n",
    "    \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",
    "\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",
    "\n",
    "plt.figure(constrained_layout=True)\n",
    "\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.auto import tqdm\n",
    "\n",
    "fps = 25\n",
    "frames = 400\n",
    "progress = tqdm(total=frames)\n",
    "\n",
    "fig = plt.figure(figsize=(12.8, 7.2), dpi=100)  # 720p\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(\n",
    "    fig,\n",
    "    update,\n",
    "    init_func=init,\n",
    "    frames=frames, \n",
    "    interval=1000/fps,\n",
    "    repeat=False,\n",
    ")\n",
    "\n",
    "plt.close(fig)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from IPython.display import Video\n",
    "\n",
    "Video('sine_wave.mp4', width=640)\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": [
    "x, y, z = rng.normal(0, 2, size=(3, 100))\n",
    "\n",
    "\n",
    "fig = plt.figure()\n",
    "ax = fig.add_subplot(projection='3d')\n",
    "\n",
    "ax.scatter(x, y, z)"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.10.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}