python_advanced/matplotlib_intro.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "view-in-github"
   },
   "source": [
    "<a href=\"https://colab.research.google.com/github/makagan/SSI_Projects/blob/main/python_advanced/matplotlib_intro.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "su_wcVMKs_z3"
   },
   "source": [
    "# Introduction to Matplotlib\n",
    "\n",
    "Based on [Wuhan DL Lab notebook](https://github.com/farakiko/wuhan_DL_labs/blob/master/general/Matplotlib_Cheatsheet.ipynb).\n",
    "\n",
    "**What is Matplotlib?**\n",
    "\n",
    "[Matplotlib](https://github.com/matplotlib/matplotlib) is a low level graph plotting library in python that serves as a visualization utility. It was created by John D. Hunter and it is open source and we can use it freely. It is mostly written in python, a few segments are written in C, Objective-C and Javascript for Platform compatibility."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "hKpZmJqRtnGt"
   },
   "source": [
    "### Import packages and check version\n",
    "\n",
    "Most of the Matplotlib utilities lies under the `pyplot` submodule, and are usually imported under the `plt` alias as below. After the `import` command the `pyplot` package can be referred to as `plt`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "DQgIynS7tcaN"
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib as mpl\n",
    "import matplotlib.pyplot as plt\n",
    "import sys\n",
    "\n",
    "print('Matplotlib Version: ' + mpl.__version__)\n",
    "print('NumPy Version: ' + np.version.full_version)\n",
    "print('Python Version: ' + sys.version)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "tMl7TgCXurpY"
   },
   "source": [
    "### A basic plot\n",
    "\n",
    "The `plot()` function of `plt` can be used to draw points (markers) in a diagram. By default, the function draws a line from point to point. It takes parameters that specify points in the diagram:\n",
    "\n",
    "*   Parameter 1 is an array containing the points on the x-axis.\n",
    "*   Parameter 2 is an array containing the points on the y-axis."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "gM-bEySyubv9"
   },
   "outputs": [],
   "source": [
    "x = np.linspace(0,2*np.pi,10**3)\n",
    "y = np.sin(x) + np.cos(x)\n",
    "\n",
    "plt.plot(x,y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "jluX4-TutLW-"
   },
   "source": [
    "**Labels and title**\n",
    "\n",
    "With `pyplot`, you can use the `xlabel()` and `ylabel()` functions to set a label for the x- and y-axis."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "V8c0JduUtaSW"
   },
   "outputs": [],
   "source": [
    "plt.xlabel('My x label')\n",
    "plt.ylabel('My y label')\n",
    "plt.plot(x,y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "oMyi-1tXtlXF"
   },
   "source": [
    "You can also write mathematical expressions. You can do so by using a subset of mathematical TeX markup in any Matplotlib text. You should use raw strings (precede the quotes with an `r`), and surround the math text with dollar signs (`$`), as in TeX:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "UF-ZKe4LtUd7"
   },
   "outputs": [],
   "source": [
    "plt.xlabel(r'x label with math (ex: $\\alpha^2$)')\n",
    "plt.ylabel(r'y label with math (ex: $\\sqrt{2}$)')\n",
    "plt.plot(x,y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "MBo9of60ugKO"
   },
   "source": [
    "You can use the `title()` function to set a title for the plot:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "CrInYfEbuirY"
   },
   "outputs": [],
   "source": [
    "plt.title('My physics analysis')\n",
    "plt.plot(x,y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "crgzgcCJrR9-"
   },
   "source": [
    "### The `Axes` object (multiple plots)\n",
    "\n",
    "When we draw a graph using the `plot()` function of `pyplot`:\n",
    "\n",
    "1.   A [`Figure`](https://matplotlib.org/3.3.4/api/_as_gen/matplotlib.figure.Figure.html) object is generated.\n",
    "2.   An [`Axes`](https://matplotlib.org/stable/api/axes_api.html) object is generated corresponding to the \"box\" in which the graph will be drawn.\n",
    "3.   All the elements of the graph such as the x and y-axis are rendered inside the `Axes` object.\n",
    "\n",
    "To use a metaphor:\n",
    "\n",
    "* `Figure` is like a paper where you can draw anything you want.\n",
    "* We have to draw the graph in a \"box\", which is `Axes` in this context.\n",
    "* If we’re drawing only one graph, we don’t have to draw a \"box\" first, just simply draw on the paper . So, we can use `plt.plot(...)` function as in the examples above.\n",
    "\n",
    "Of course, even in such case, we can still explicitly draw a \"box\" on the \"paper\", to tell Matplotlib that we are going to draw a graph inside it using the `subplot()` function:\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "Zbfls9hezV40"
   },
   "outputs": [],
   "source": [
    "x = np.linspace(0,2*np.pi,10**3)\n",
    "y = np.sin(x) + np.cos(x)\n",
    "\n",
    "fig,ax = plt.subplots()\n",
    "ax.plot(x,y)\n",
    "ax.set_xlabel('My x label')\n",
    "ax.set_ylabel('My y label')\n",
    "ax.set_title('My physics analysis')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "AVXD9fW1wyKO"
   },
   "source": [
    "When we just want to plot one graph, it is not necessary to \"draw\" this cell. However, you must be noticed that we have to do this when we want to draw multiple graphs in one plot.\n",
    "\n",
    "With the [`subplot()`](https://matplotlib.org/stable/api/_as_gen/matplotlib.pyplot.subplots.html) function you can draw multiple plots in one figure. It takes at least two arguments that describe the layout of the figure. The layout is organized in rows and columns, which are represented by the first and second argument."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "1C0pgq0iroR7"
   },
   "outputs": [],
   "source": [
    "fig,(ax1,ax2) = plt.subplots(1,2)\n",
    "                             \n",
    "#plot 1:\n",
    "x = np.linspace(0,2*np.pi,10**3)\n",
    "y = np.sin(x) + np.cos(x)\n",
    "ax1.plot(x,y)\n",
    "\n",
    "#plot 2:\n",
    "x = np.linspace(0,2*np.pi,10**3)\n",
    "y = np.exp(x)\n",
    "ax2.plot(x,y)\n",
    "\n",
    "#adjust formatting for cleaner visualization\n",
    "fig.tight_layout()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "G4WQPEky3AsP"
   },
   "source": [
    "For more examples of what can be done with `subplots()` you can have a look at [this notebook](https://github.com/Jwink3101/matplotlib_tips_examples/blob/master/subplots.ipynb)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "zo2Eny68qnku"
   },
   "source": [
    "### Scientific Notation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "PzE9ZYHLrF9E"
   },
   "outputs": [],
   "source": [
    "fig,(ax1,ax2) = plt.subplots(1,2,figsize=(7,3),dpi=100,num=1)\n",
    "\n",
    "# Regular\n",
    "ax1.plot(x,1e4*y)\n",
    "\n",
    "# Scientific\n",
    "ax2.plot(x,1e4*y)\n",
    "\n",
    "from matplotlib import ticker\n",
    "formatter = ticker.ScalarFormatter(useMathText=True)\n",
    "formatter.set_scientific(True) \n",
    "formatter.set_powerlimits((-1,1))\n",
    "\n",
    "ax2.yaxis.set_major_formatter(formatter)\n",
    "\n",
    "fig.tight_layout()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "s3FPBNnA4N1A"
   },
   "source": [
    "### Ticks, Grids, Labels, and Legends\n",
    "\n",
    "**Ticks**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "R1_CHGCN4Ro7"
   },
   "outputs": [],
   "source": [
    "fig,axes = plt.subplots(2,2,figsize=(7,5),dpi=100)\n",
    "\n",
    "X = np.linspace(0,2*np.pi,1000)\n",
    "Y = np.sin(X)\n",
    "\n",
    "for ax in axes.ravel(): #loop over axes objects and plot the data in each of them\n",
    "    ax.plot(X,Y)\n",
    "\n",
    "#example 1: leave default\n",
    "ax = axes[0,0]\n",
    "\n",
    "#example 2: add ticks labels (but no actual ticks) only at the top\n",
    "ax = axes[0,1]\n",
    "ax.tick_params(labeltop=True,labelbottom=False)\n",
    "\n",
    "#example 3: add ticks labels (but no actual ticks) only at the right\n",
    "ax = axes[1,0]\n",
    "ax.tick_params(labelright=True,labelbottom=False,labelleft=False)\n",
    "\n",
    "#example 4: add ticks labels (but no actual ticks) everywhere\n",
    "ax = axes[1,1]\n",
    "ax.tick_params(labeltop=True,labelbottom=True,labelright=True,labelleft=True)\n",
    "\n",
    "# Now also add the actual ticks\n",
    "ax.tick_params(axis='both',bottom=True,top=True,left=True,right=True)\n",
    "\n",
    "fig.tight_layout()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "YyH0RfoF54TW"
   },
   "source": [
    "Below is one more example but you can consult the [`tick_params()` function documentation](https://matplotlib.org/stable/api/_as_gen/matplotlib.axes.Axes.tick_params.html) to learn more on how to costumize the ticks."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "_yY14DTI6DtI"
   },
   "outputs": [],
   "source": [
    "x = np.logspace(0,3,600)\n",
    "y = 1.2**(0.04*x)\n",
    "fig,ax = plt.subplots(dpi=100)\n",
    "ax.plot(x,y)\n",
    "ax.set(xscale='log',yscale='log')\n",
    "ax.tick_params(axis='both',bottom=True,top=True,left=True,right=True,direction='in',which='both')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "iSNb8EY47_qU"
   },
   "source": [
    "**Grids**\n",
    "\n",
    "Note that this is the same with and without a log scale but the log scale shows it better. The `zorder` makes sure the plot is in front of the grid lines."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "4FeJbVaA8Bxs"
   },
   "outputs": [],
   "source": [
    "fig,(ax1,ax2) = plt.subplots(1,2,sharey=True,figsize=(10,5))\n",
    "x = np.logspace(0,3,600)\n",
    "y = 1.2**(0.04*x)\n",
    "\n",
    "for ax in (ax1,ax2):\n",
    "    ax.plot(x,y)\n",
    "    ax.set(xscale='log',yscale='log')\n",
    "    ax.tick_params(axis='both',bottom=True,top=True,left=True,right=True,direction='in',which='both',zorder=10)\n",
    "ax1.grid(which='major')\n",
    "ax2.grid(which='both')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "BLcHl3Dc9J0y"
   },
   "source": [
    "**Labels**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "gildMl-T9LpK"
   },
   "outputs": [],
   "source": [
    "fig,axes = plt.subplots(2,2,figsize=(5,4),dpi=100)\n",
    "\n",
    "x = np.linspace(-10,10,100)\n",
    "y = np.sin(x)/(x + np.spacing(1))\n",
    "\n",
    "labs = ['neg ten','neg five','zero','pos five','pos ten']\n",
    "\n",
    "for ax in axes.ravel():\n",
    "    ax.plot(x,y)\n",
    "    ax.set_xticks([-10,-5,0,5,10])\n",
    "\n",
    "#example 1: leave defaults\n",
    "axes[0,0].set_xticklabels(labs)\n",
    "\n",
    "#example 2: rotate x ticks labels by -45 deg\n",
    "axes[0,1].set_xticklabels(labs,rotation=-45)\n",
    "axes[0,1].set_title('rotated')\n",
    "\n",
    "#example 3: rotate x ticks labels by -45 deg and align to the right of actual ticks\n",
    "axes[1,0].set_xticklabels(labs,rotation=-45,ha='left')\n",
    "axes[1,0].set_title('rotated, left')\n",
    "\n",
    "#example 4: rotate x ticks labels by -45 deg and align to center with the actual ticks\n",
    "axes[1,1].set_xticklabels(labs,rotation=-45,ha='left',rotation_mode='anchor')\n",
    "axes[1,1].set_title('rotated, anchored')\n",
    "\n",
    "fig.tight_layout()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "1A3SrU_VEp3-"
   },
   "source": [
    "One more example on cleaner ticks labels formatting: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "CoK_CHqQEvIB"
   },
   "outputs": [],
   "source": [
    "x = np.linspace(0,2*np.pi,1000)\n",
    "y = np.cos(x)**2\n",
    "\n",
    "fig,(ax1,ax2,ax3) = plt.subplots(1,3,figsize=(8,3),dpi=100,num=1)\n",
    "for ax in (ax1,ax2,ax3):\n",
    "    ax.plot(x,y)\n",
    "    ax.set_yticks([0, 0.25, 0.5,0.75,1])\n",
    "    ax.set_xticks(np.linspace(0,2*np.pi,5))\n",
    "    ax.set_xticklabels([r'$0$',r'$\\frac{\\pi}{2}$',r'$\\pi$',r'$\\frac{3\\pi}{2}$',r'$2\\pi$'])\n",
    "\n",
    "ax1.set_title('Default')\n",
    "\n",
    "#g formatting choses the shorter notation\n",
    "ax2.set_title('g formatting')\n",
    "ax2.set_yticklabels( ['{:0.2g}'.format(l) for l in ax2.get_yticks()] )\n",
    "\n",
    "ax3.set_title('g formatting, force decimal')\n",
    "ax3.set_yticklabels( ['{:0.2g}'.format(l) if int(l)!=float(l) else '{:0.1f}'.format(l) \n",
    "                      for l in ax3.get_yticks()] )\n",
    "\n",
    "fig.tight_layout()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "3KP1WxsdGRpa"
   },
   "source": [
    "**Legends**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "7T8r3GiLG-Pe"
   },
   "source": [
    "There are a few ways to work a legend. And there is a lot more that can be found on the web. The main takeaway is to have `label=` in the respective plot:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "2raZl8crGltH"
   },
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots()\n",
    "\n",
    "x = np.linspace(0,2*np.pi,1000)\n",
    "y = np.sin(x)\n",
    "ax.plot(x,y,label='Sin(x)')\n",
    "\n",
    "y = np.cos(x)\n",
    "ax.plot(x,y,label='Cos(x)')\n",
    "\n",
    "y = np.sin(np.cos(x))\n",
    "ax.plot(x,y,label='Sin(Cos(x))')\n",
    "\n",
    "ax.legend()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "i1beT8jrJmEL"
   },
   "source": [
    "With the `loc` function you can decide the position of the legend. See all possible options in [Matplotlib legend documentation](https://matplotlib.org/stable/api/_as_gen/matplotlib.pyplot.legend.html). We can try one below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "lmcGAKqmJ-qs"
   },
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots()\n",
    "\n",
    "x = np.linspace(0,2*np.pi,1000)\n",
    "y = np.sin(x)\n",
    "ax.plot(x,y,label='Sin(x)')\n",
    "\n",
    "y = np.cos(x)\n",
    "ax.plot(x,y,label='Cos(x)')\n",
    "\n",
    "y = np.sin(np.cos(x))\n",
    "ax.plot(x,y,label='Sin(Cos(x))')\n",
    "\n",
    "ax.legend(loc='lower left')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "tvttlcYhHvOJ"
   },
   "source": [
    "Sometimes it is useful to add a dummy legend if you want certain entries that are not to be plotted:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "0tj24d3DH1Kq"
   },
   "outputs": [],
   "source": [
    "fig,ax = plt.subplots()\n",
    "\n",
    "x = np.linspace(0,2*np.pi,1000)\n",
    "\n",
    "# Real Lines\n",
    "plot_lines = []\n",
    "l1, = ax.plot(x,np.sin(X),'-')\n",
    "l2, = ax.plot(x,np.cos(X),'-')\n",
    "l3, = ax.plot(x,np.sin(np.cos(X)),'-')\n",
    "plot_lines.append([l1, l2, l3])\n",
    "leg1 = ax.legend(plot_lines[0], [\"Sin(x)\", \"Cos(x)\", \"Sin(Cos(x))\"], loc='upper right')\n",
    "\n",
    "# Dummy lines\n",
    "ax.plot([],'-rs',label='Dummy1')\n",
    "ax.plot([],'k',label='Dummy2')\n",
    "leg2 = ax.legend()\n",
    "\n",
    "plt.gca().add_artist(leg1)\n",
    "plt.gca().add_artist(leg2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "bLLqmqvfmVyD"
   },
   "source": [
    "### Colorbars and colormaps\n",
    "\n",
    "**Colormaps**\n",
    "\n",
    "Matplotlib comes with lots of colormaps. See [colormap reference](https://matplotlib.org/3.1.1/gallery/color/colormap_reference.html)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "Vc6JbmSxnFxr"
   },
   "outputs": [],
   "source": [
    "np.random.seed(362423)\n",
    "A = np.random.uniform(size=(6,8))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "ESzUrzapm9ep"
   },
   "outputs": [],
   "source": [
    "fig,(ax1,ax2,ax3,ax4) = plt.subplots(1,4,figsize=(9,3),dpi=100,sharex=True,sharey=True)\n",
    "\n",
    "ax1.pcolormesh(A)\n",
    "ax2.pcolormesh(A,cmap=plt.cm.Spectral_r)\n",
    "ax3.pcolormesh(A,cmap=plt.cm.Purples)\n",
    "ax4.pcolormesh(A,cmap=plt.cm.RdBu)\n",
    "fig.tight_layout()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "GO7YSUhim8lq"
   },
   "source": [
    "**Colorbars**\n",
    "\n",
    "The first example below shows how to add the colorbar. However, when the plot size is scaled with the `ax.axis()` method, the colorbar does not automatically scale to match the new plot size."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "5wx0qY7RnhqB"
   },
   "outputs": [],
   "source": [
    "fig,ax = plt.subplots(1,1,figsize=(3,5),dpi=100)\n",
    "pl = ax.pcolormesh(A,edgecolor='k')\n",
    "ax.axis('image') # see options at: https://matplotlib.org/stable/api/_as_gen/matplotlib.axes.Axes.axis.html\n",
    "fig.colorbar(pl)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "WZsqN9rdo9SA"
   },
   "source": [
    "This second example shows how to also scale the colorbar. This method also works nicely with subplots (not demoed)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "As_MYYX9oP2c"
   },
   "outputs": [],
   "source": [
    "fig,ax = plt.subplots(1,1,figsize=(3,5),dpi=100)\n",
    "pl = ax.pcolormesh(A,cmap = plt.cm.Spectral_r,edgecolor='k')\n",
    "ax.axis('image')\n",
    "\n",
    "from mpl_toolkits.axes_grid1 import make_axes_locatable\n",
    "divider = make_axes_locatable(ax)\n",
    "cax = divider.append_axes(\"right\", size=\"5%\", pad=0.05)\n",
    "cbar = fig.colorbar(pl,cax=cax)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "wtZcesXTpa78"
   },
   "source": [
    "You can also set the ranges of the colormap and bar:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "QJPJ7HGIpfAE"
   },
   "outputs": [],
   "source": [
    "fig,ax = plt.subplots(1,1,figsize=(3,5),dpi=100)\n",
    "pl = ax.pcolormesh(A,cmap = plt.cm.Spectral_r,edgecolor='k',vmin=-1,vmax=2.2)\n",
    "ax.axis('image')\n",
    "\n",
    "from mpl_toolkits.axes_grid1 import make_axes_locatable\n",
    "divider = make_axes_locatable(ax)\n",
    "cax = divider.append_axes(\"right\", size=\"5%\", pad=0.05)\n",
    "cbar = fig.colorbar(pl,cax=cax)\n",
    "cbar.set_ticks(np.linspace(-1,2.2,6))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "B9DoTNDGpwEi"
   },
   "source": [
    "### Multiple y-axes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "5Pjfjvtjp-uQ"
   },
   "outputs": [],
   "source": [
    "fig, ax1 = plt.subplots(1,1,figsize=(5,3),dpi=100)\n",
    "\n",
    "X = np.linspace(-3*np.pi,3*np.pi,1000)\n",
    "Y1 = np.sin(X)/(X+0.0001)\n",
    "Y2 = 1e3 * np.cos(X)\n",
    "Y3 =  np.exp(np.abs(X))\n",
    "\n",
    "# Create a twin Axes sharing the x-axis.\n",
    "ax2 = ax1.twinx()\n",
    "\n",
    "# Plotting\n",
    "ax1.plot(X,Y1,'-r')\n",
    "ax2.plot(X,Y2,':b')\n",
    "\n",
    "# Color the axis and add labels\n",
    "ax1.set_ylabel('Y1',color='r')\n",
    "ax2.set_ylabel('Y2',color='b')\n",
    "\n",
    "ax1.tick_params(axis='y', colors='r')\n",
    "ax2.tick_params(axis='y', colors='b')\n",
    "\n",
    "# Set the spine colors\n",
    "for ax in (ax1,ax2):\n",
    "    ax.spines['left'].set_color('r')\n",
    "    ax.spines['right'].set_color('b')\n",
    "\n",
    "from matplotlib import ticker\n",
    "formatter = ticker.ScalarFormatter(useMathText=True)\n",
    "formatter.set_scientific(True) \n",
    "formatter.set_powerlimits((-1,1)) \n",
    "ax2.yaxis.set_major_formatter(formatter)\n",
    "ax2.yaxis.get_offset_text().set_color('b') # Set the color of the power\n",
    "\n",
    "# Better X-Ticks\n",
    "ax1.set_xlim((X.min(),X.max()))\n",
    "ax1.set_xticks(np.arange(-3,4)*np.pi)\n",
    "xticklabs = [r'$\\mathregular{{{0:d}\\pi}}$'.format(i) for i in np.arange(-3,4)]; xticklabs[3]='0'\n",
    "ax1.set_xticklabels(xticklabs) \n",
    "\n",
    "fig.tight_layout()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "TXM4nHHorWF3"
   },
   "outputs": [],
   "source": [
    "fig, ax1 = plt.subplots(1,1,figsize=(6,4),dpi=100)\n",
    "\n",
    "# Twin the x-axis twice to make independent y-axes.\n",
    "ax2 = ax1.twinx()\n",
    "ax3 = ax1.twinx()\n",
    "\n",
    "# Make some space on the right side for the extra y-axis.\n",
    "fig.subplots_adjust(right=0.75)\n",
    "\n",
    "# Move the last y-axis spine over to the right by 20% of the width of the axes\n",
    "ax3.spines['right'].set_position(('axes', 1.2))\n",
    "\n",
    "# To make the border of the right-most axis visible, we need to turn the frame\n",
    "# on. This hides the other plots, however, so we need to turn its fill off.\n",
    "ax3.set_frame_on(True)\n",
    "ax3.patch.set_visible(False)\n",
    "\n",
    "# Plot\n",
    "ax1.plot(X,Y1,'-r')\n",
    "ax2.plot(X,Y2,'-b')\n",
    "ax3.plot(X,Y3,'-g')\n",
    "\n",
    "colors = ['r','b','g']\n",
    "axes = [ax1,ax2,ax3]\n",
    "names = ['Y1','Y2','Y3']\n",
    "\n",
    "for ax in (ax1,ax2,ax3):\n",
    "    ax.spines['left'].set_color(colors[0])\n",
    "    ax.spines['right'].set_color(colors[1])\n",
    "ax3.spines['right'].set_color('g') # reset\n",
    "    \n",
    "for ax,color,name in zip(axes,colors,names):\n",
    "    ax.set_ylabel(name,color=color)\n",
    "    ax.tick_params(axis='y', colors=color)\n",
    "\n",
    "# Nicer ax2 y axis\n",
    "from matplotlib import ticker\n",
    "formatter = ticker.ScalarFormatter(useMathText=True)\n",
    "formatter.set_scientific(True) \n",
    "formatter.set_powerlimits((-1,1)) \n",
    "ax2.yaxis.set_major_formatter(formatter)\n",
    "ax2.yaxis.get_offset_text().set_color('b') # Set the color of the power\n",
    "\n",
    "# Set ax3 to log\n",
    "ax3.set_yscale('log')\n",
    "\n",
    "# Better X-Ticks\n",
    "ax1.set_xlim((X.min(),X.max()))\n",
    "ax1.set_xticks(np.arange(-3,4)*np.pi)\n",
    "xticklabs = [r'$\\mathregular{{{0:d}\\pi}}$'.format(i) for i in np.arange(-3,4)]; xticklabs[3]='0'\n",
    "ax1.set_xticklabels(xticklabs)\n",
    "\n",
    "fig.tight_layout()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "IDATLljprm6r"
   },
   "source": [
    "### Three Dimensional Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "dFU6rvfVrpW6"
   },
   "outputs": [],
   "source": [
    "X1,X2 = np.meshgrid(*[np.linspace(-1,1,100)]*2) #meshgrid crates a grid of coordinate\n",
    "F = (1.0 + (1.0/3.0)/(2.0 * X1 + X2 + 7.0/2.0) ) * np.exp(- (0.5 * (X2-1.0/5.0) * (X1 + 1.0))**2)\n",
    "\n",
    "def _set_axis(ax,z=True):\n",
    "    r =0.01\n",
    "    if z:\n",
    "        ax.set_zlim([0.25, 1.67])\n",
    "    ax.set_xlim([-1-2*r, 1+2*r])\n",
    "    ax.set_ylim([-1-2*r, 1+2*r])\n",
    "    ax.set_xlabel('x1');ax.set_ylabel('x2')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "_zQMh3REsQI8"
   },
   "source": [
    "**Countours**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "L8H8jYsgpvQl"
   },
   "outputs": [],
   "source": [
    "fig,axes = plt.subplots(2,2,figsize=(9,7))\n",
    "\n",
    "axes[0,0].contour(X1,X2,F,35)\n",
    "axes[0,0].set_title('Defaults + N=35')\n",
    "\n",
    "axes[0,1].contourf(X1,X2,F,35)\n",
    "axes[0,1].set_title('Defaults filled + N=35')\n",
    "\n",
    "axes[1,0].contourf(X1,X2,F,35)\n",
    "axes[1,0].contour(X1,X2,F,35,colors='k',linewidths =0.5 )\n",
    "axes[1,0].set_title('Filled + lines + N=35')\n",
    "\n",
    "axes[1,1].contourf(X1,X2,F,35,cmap=plt.cm.Greys)\n",
    "axes[1,1].contour(X1,X2,F,35,colors='k',linewidths =0.5 )\n",
    "axes[1,1].set_title('Filled + lines + N=35, greys')\n",
    "\n",
    "for ax in axes.ravel():\n",
    "    _set_axis(ax,z=False)\n",
    "\n",
    "fig.tight_layout()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "DtbeOIdNuszc"
   },
   "outputs": [],
   "source": [
    "fig,ax = plt.subplots()\n",
    "obj = ax.contourf(X1,X2,F,35,cmap=plt.cm.Spectral_r)\n",
    "ax.contour(X1,X2,F,35,colors='k',linewidths =0.5 )\n",
    "\n",
    "from mpl_toolkits.axes_grid1 import make_axes_locatable\n",
    "divider = make_axes_locatable(ax)\n",
    "cax = divider.append_axes(\"right\", size=\"5%\", pad=0.05)\n",
    "cbar = fig.colorbar(obj,cax=cax)\n",
    "#fig.colorbar(obj)\n",
    "_set_axis(ax,z=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ELT4JrINveXO"
   },
   "source": [
    "**Surface**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Fk9E3N4ywcGV"
   },
   "source": [
    "You can grid the surface and use `cstride` and `rstride` to control the resolution. In this example, I set with 100 points but use `cstride=4` to only plot a line every 4 spaces and `rstride=3` to plot a line every 3 in the other direction."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "RJwA5BkGvgxe"
   },
   "outputs": [],
   "source": [
    "#from mpl_toolkits.mplot3d import Axes3D\n",
    "fig = plt.figure(num=1)\n",
    "ax = fig.add_subplot(111,projection='3d')\n",
    "SF = ax.plot_surface(X1,X2,F,rstride=4,cstride=3,cmap=plt.cm.Spectral_r)\n",
    "_set_axis(ax)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "CBU1jayfwBNf"
   },
   "outputs": [],
   "source": [
    "fig = plt.figure(num=1)\n",
    "ax = fig.add_subplot(111,projection='3d')\n",
    "SF = ax.plot_surface(X1,X2,F,rstride=4,cstride=3,cmap=plt.cm.Spectral_r,\n",
    "                     linewidth=0.5, edgecolors='k')\n",
    "_set_axis(ax)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "KbjTqzNc2NcO"
   },
   "outputs": [],
   "source": [
    "fig = plt.figure(num=1)\n",
    "ax = fig.add_subplot(111,projection='3d')\n",
    "SF = ax.plot_wireframe(X1,X2,F,rstride=4,cstride=3,color='k')\n",
    "_set_axis(ax)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "KNPyQE-U2lWG"
   },
   "outputs": [],
   "source": [
    "fig = plt.figure(num=1)\n",
    "ax = fig.add_subplot(111,projection='3d')\n",
    "SF = ax.plot_surface(X1,X2,F,rstride=4,cstride=3,cmap=plt.cm.Spectral_r,\n",
    "                     linewidth=0.5, edgecolors='k')\n",
    "\n",
    "_set_axis(ax)\n",
    "\n",
    "# Rotate\n",
    "ax.view_init(35,49)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "9bSOcDto3KGr"
   },
   "source": [
    "### Box and Violin Plots\n",
    "\n",
    "A [**Box Plot**](https://en.wikipedia.org/wiki/Box_plot) is a standardized way of displaying the dataset based on the five-number summary: the minimum, the maximum, the sample median, and the first and third quartiles.\n",
    "\n",
    "* **Minimum (Q0 or 0th percentile)**: the lowest data point in the data set excluding any outliers;\n",
    "* **Maximum (Q4 or 100th percentile)**: the highest data point in the data set excluding any outliers;\n",
    "* **Median (Q2 or 50th percentile)**: the middle value in the data set\n",
    "* **First quartile (Q1 or 25th percentile)**: also known as the lower quartile, it is the median of the lower half of the dataset;\n",
    "* **Third quartile (Q3 or 75th percentile)**: also known as the upper quartile, it is the median of the upper half of the dataset.\n",
    "\n",
    "In addition to the minimum and maximum values used to construct a box-plot, another important element that can also be employed to obtain a box-plot is the **interquartile range (IQR)**, defined as the distance between the upper and lower quartiles.\n",
    "\n",
    "A box-plot usually includes a box drawn from Q1 to Q3 with a horizontal line drawn in the middle to denote the median. In addition to the box, there can be lines (which are called *whiskers*) extending from the box indicating variability outside the upper and lower quartiles, thus, the plot is also called **Whisker Plot**.\n",
    "\n",
    "In the most straight-forward method, the boundary of the lower whisker is the minimum value of the data set, and the boundary of the upper whisker is the maximum value of the data set. Another popular choice for the boundaries of the whiskers is `Q1-1.5IQR` and `Q3+1.5IQR` for the lower and upper whisker, respectively. This is the default for `boxplot` in Matplotlib and points that are above the end of such whiskers are visible."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "lqTttyIN3Hxv"
   },
   "outputs": [],
   "source": [
    "from collections import OrderedDict\n",
    "samples = OrderedDict()\n",
    "np.random.seed(100)\n",
    "\n",
    "samples['normal_1'] = np.random.normal(100, 10, 200)\n",
    "samples['normal_2'] = np.random.normal(80, 30, 200)\n",
    "samples['normal_3'] = np.random.normal(90, 20, 200)\n",
    "samples['normal_4'] = np.random.normal(70, 25, 200)\n",
    "\n",
    "fig,ax = plt.subplots()\n",
    "\n",
    "for ii,x in enumerate(samples.values()):\n",
    "    ax.boxplot(x,positions=[ii])\n",
    "    \n",
    "ax.set_xticks(np.arange(len(samples)))\n",
    "ax.set_xticklabels(list(samples.keys()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "UTWhq0v595K1"
   },
   "outputs": [],
   "source": [
    "fig,ax = plt.subplots()\n",
    "\n",
    "for ii,x in enumerate(samples.values()):\n",
    "    ax.boxplot(x,positions=[ii],whis=(0,100)) # now set the whiskers at the min and max of the dataset\n",
    "    \n",
    "ax.set_xticks(np.arange(len(samples)))\n",
    "ax.set_xticklabels(list(samples.keys()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "q8lX2a9j94uw"
   },
   "source": [
    "A **Violin Plot** are similar to box plots, except that they also show the probability density of the data at different values. The \"width\" of each curve corresponds with the approximate frequency of data points in each region. Densities are frequently accompanied by an overlaid chart type, such as box plot, to provide additional information."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "K-rPf4wg3PSK"
   },
   "outputs": [],
   "source": [
    "fig,ax = plt.subplots()\n",
    "\n",
    "for ii,x in enumerate(samples.values()):\n",
    "    vp = ax.violinplot(x,positions=[ii],showextrema=True, showmedians=True)\n",
    "    color = vp['cbars'].get_color()[0]\n",
    "    \n",
    "    #plot the IQR\n",
    "    w = 0.075\n",
    "    xx = ii + np.array([-1,1])*w - 0.005 # these are the vertical edges of each box\n",
    "    ax.fill_between(xx,*np.percentile(x,[25,75]),color=color,alpha=0.5) #Fill the area between two horizontal curves corresponding to Q1 and Q3 quartiles\n",
    "    \n",
    "ax.set_xticks(np.arange(len(samples)))\n",
    "ax.set_xticklabels(list(samples.keys()))\n",
    "\n",
    "ax.fill_between([],[],color='k',label='IQR')\n",
    "ax.plot([],[],color='k',label='median')\n",
    "ax.legend()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "83PTYaS43UKs"
   },
   "source": [
    "### Bar Charts"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "vZECTK-E3S0j"
   },
   "outputs": [],
   "source": [
    "fig,ax = plt.subplots(1,1,figsize=(6,3),dpi=100,num=1)\n",
    "\n",
    "Nbins = 5\n",
    "Nbars = 4 # Number of bars (items) per bin\n",
    "\n",
    "width = 1.0 /(Nbars+2)\n",
    "ind = np.arange(Nbins)\n",
    "\n",
    "# generate random data for now\n",
    "np.random.seed(44328)\n",
    "Data = [np.random.uniform(size=Nbins) for i in range(Nbars)]\n",
    "labels = ['x','y','z','w']\n",
    "\n",
    "#per each iteration fill the same bar of each bin\n",
    "for ii,dat_item in enumerate(Data):\n",
    "    ax.bar(ind + (ii+1)*width,dat_item,width,label=labels[ii])\n",
    "\n",
    "ax.set_xticks(ind+0.5)\n",
    "ax.set_xticklabels(['a','b','c','d','e'])\n",
    "ax.legend(loc=2,ncol=2)  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "KcOGxG7a3Yxe"
   },
   "source": [
    "### Fancy Boxes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "2be2wmJC3aT6"
   },
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots()\n",
    "\n",
    "ax.text(0.5, 0.8, 'Test', color='red', \n",
    "        bbox=dict(facecolor='none', edgecolor='red'))\n",
    "ax.text(0.5, 0.6, 'Test', color='blue', \n",
    "        bbox=dict(facecolor='none', edgecolor='blue', pad=10.0))\n",
    "ax.text(0.5, 0.4, 'Test', color='green', \n",
    "        bbox=dict(facecolor='none', edgecolor='green', \n",
    "                  boxstyle='round'))\n",
    "ax.text(0.5, 0.2, 'Test', color='black', \n",
    "        bbox=dict(facecolor='none', edgecolor='black', \n",
    "                  boxstyle='round,pad=1'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Xhmb1cIC3ifF"
   },
   "source": [
    "### Customize Style\n",
    "\n",
    "There are three ways to customize Matplotlib:\n",
    "\n",
    "1.   Setting `rcParams` at runtime\n",
    "2.   Using style sheets\n",
    "3.   Changing your `matplotlibrc` file\n",
    "\n",
    "Setting `rcParams` at runtime takes precedence over style sheets, style sheets take precedence over `matplotlibrc` files.\n",
    "\n",
    "**Runtime rc settings**\n",
    "\n",
    "You can dynamically change the default *runtime configuration* (rc) settings. All rc settings are stored in a dictionary-like variable called [`matplotlib.rcParams`](https://matplotlib.org/stable/api/matplotlib_configuration_api.html#matplotlib.rcParams), which is global to the matplotlib package. `rcParams` can be modified directly, for example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "SREOXgnCH_-A"
   },
   "outputs": [],
   "source": [
    "#default rc settings\n",
    "print(mpl.rcParams)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "yPCz5VaHIM21"
   },
   "outputs": [],
   "source": [
    "#Too many parameters... let's print only two\n",
    "print(mpl.rcParams['lines.linewidth'])\n",
    "print(mpl.rcParams['lines.linestyle'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "pPZtCjK9IuYZ"
   },
   "outputs": [],
   "source": [
    "#Now plot with default style\n",
    "data = np.random.randn(50)\n",
    "plt.plot(data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "0HRgACO6IyTN"
   },
   "outputs": [],
   "source": [
    "#Now change two parameters of the default style\n",
    "mpl.rcParams['lines.linewidth'] = 2\n",
    "mpl.rcParams['lines.linestyle'] = '--'\n",
    "data = np.random.randn(50)\n",
    "plt.plot(data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "_DXutlrPJFxH"
   },
   "source": [
    "In order to change the default sequence of colors you have to change the `prop_cycle` property of `axes`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "yxiCYjG7JGGJ"
   },
   "outputs": [],
   "source": [
    "from cycler import cycler\n",
    "\n",
    "#default\n",
    "print(mpl.rcParams['axes.prop_cycle'])\n",
    "\n",
    "#custom\n",
    "mpl.rcParams['axes.prop_cycle'] = cycler(color=['r', 'g', 'b', 'y'])\n",
    "print(mpl.rcParams['axes.prop_cycle'])\n",
    "plt.plot(data)  # now the first color is red"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "QFKxsbD7KJWG"
   },
   "outputs": [],
   "source": [
    "#reset to default\n",
    "mpl.rcParams.update(mpl.rcParamsDefault)\n",
    "plt.plot(data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Fdo1tSKdKiwC"
   },
   "source": [
    "Matplotlib also provides a couple of convenience functions for modifying rc settings. The [`matplotlib.rc`](https://matplotlib.org/stable/api/matplotlib_configuration_api.html#matplotlib.rc) method can be used to modify multiple settings in a single group at once, using keyword arguments:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "Qo9PiNybKlZD"
   },
   "outputs": [],
   "source": [
    "mpl.rcParams['lines.linewidth'] = 2\n",
    "mpl.rcParams['lines.linestyle'] = '--'\n",
    "mpl.rcParams['axes.prop_cycle'] = cycler(color=['r', 'g', 'b', 'y'])\n",
    "\n",
    "mpl.rc('lines', linewidth=4, linestyle='-.')\n",
    "plt.plot(data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "YnZO9Y8GLB39"
   },
   "source": [
    "The `matplotlib.rcParams` object can also be changed temporarily using the [`matplotlib.rc_context`](https://matplotlib.org/stable/api/matplotlib_configuration_api.html#matplotlib.rc_context) context manager:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "Vsne-sd-LHFM"
   },
   "outputs": [],
   "source": [
    "with mpl.rc_context({'lines.linewidth': 2, 'lines.linestyle': ':'}):\n",
    "    plt.plot(data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "drcjsYRXLl5X"
   },
   "source": [
    "**Using style sheets**\n",
    "\n",
    "Another way to change the visual appearance of plots is to set the `rcParams` in a so-called style sheet and import that style sheet with `matplotlib.style.use`. In this way you can switch easily between different styles by simply changing the imported style sheet. A style sheets looks the same as a [`matplotlibrc`](https://matplotlib.org/stable/tutorials/introductory/customizing.html#matplotlibrc-sample) file, but in a style sheet you can only set `rcParams` that are related to the actual style of a plot. Other `rcParams`, like *backend*, will be ignored. The `matplotlibrc` file support all `rcParams`. The rationale behind this is to make style sheets portable between different machines without having to worry about dependencies which might or might not be installed on another machine. For a list of `rcParams` that are ignored in style sheets see [`matplotlib.style.use`](https://matplotlib.org/stable/api/style_api.html#matplotlib.style.use).\n",
    "\n",
    "There are a number of pre-defined styles provided by Matplotlib:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "APM1jS0W3hdM"
   },
   "outputs": [],
   "source": [
    "mpl.rcParams.update(mpl.rcParamsDefault)\n",
    "X = np.linspace(0,2*np.pi,100)\n",
    "Y1 = np.sin(X)\n",
    "Y2 = np.sin(X**2)\n",
    "for ii,style in enumerate(sorted(plt.style.available)):\n",
    "    fig,ax = plt.subplots(figsize=(3,2),num=ii)\n",
    "    plt.style.use(style)\n",
    "    ax.plot(X,Y1,label='Y1')\n",
    "    ax.plot(X,Y2,label='Y2')\n",
    "    ax.set_title(style)\n",
    "\n",
    "plt.style.use('default')\n",
    "mpl.rcParams.update(mpl.rcParamsDefault)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "5GhSsN6UM8v2"
   },
   "source": [
    "**Defining your own style**\n",
    "\n",
    "You can create custom styles and use them by calling style.use with the path or URL to the style sheet.\n",
    "\n",
    "For example, here is a file created for you to be fetched from github:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "i6TN5U_7NT-f"
   },
   "outputs": [],
   "source": [
    "!curl https://raw.githubusercontent.com/jngadiub/ML_course_Pavia_23/main/python_advance/example.mplstyle -o example.mplstyle\n",
    "!cat example.mplstyle"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "kkHtbXjZOqgc"
   },
   "source": [
    "You can import it in Matplotlib as:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "BwAFNvvAOtf8"
   },
   "outputs": [],
   "source": [
    "plt.style.use('example.mplstyle')\n",
    "plt.plot(data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "CTn-Gt9dPLOv"
   },
   "source": [
    "Alternatively, you can make your style known to Matplotlib by placing your `<style-name>.mplstyle` file into `mpl_configdir/stylelib`. You can then load your custom style sheet with a call to `style.use(<style-name>)`. By default `mpl_configdir` should be `~/.config/matplotlib`, but you can check where yours is with `matplotlib.get_configdir()`; you may need to create this directory. You also can change the directory where Matplotlib looks for the `stylelib/` folder by setting the `MPLCONFIGDIR` environment variable, see [matplotlib configuration and cache directory locations](https://matplotlib.org/stable/users/faq/troubleshooting_faq.html#locating-matplotlib-config-dir).\n",
    "\n",
    "Note that a custom style sheet in `mpl_configdir/stylelib` will override a style sheet defined by Matplotlib if the styles have the same name.\n",
    "\n",
    "Once your `<style-name>.mplstyle` file is in the appropriate `mpl_configdir` you can specify your style with:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "yJq804gXPjzG"
   },
   "outputs": [],
   "source": [
    "#find the matplotlib config folder\n",
    "mpl.get_configdir()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "tDPnsLRiOihs"
   },
   "outputs": [],
   "source": [
    "#copy your mplstyle file\n",
    "!cp example.mplstyle /root/.config/matplotlib/.\n",
    "!ls /root/.config/matplotlib/"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "-r-GiBT2PyWT"
   },
   "outputs": [],
   "source": [
    "#use your style\n",
    "plt.style.use('example.mplstyle')\n",
    "plt.plot(data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "SRWfKsKcQ-oR"
   },
   "source": [
    "**MPLHEP Style**\n",
    "\n",
    "A set of helpers for Matplotlib to more easily produce plots typically needed in HEP as well as style them in way that's compatible with current collaboration requirements (ROOT-like plots for CMS, ATLAS, LHCb, ALICE). Source code and documentation can be found at [this link](https://github.com/scikit-hep/mplhep)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "tOeZqSDFRWlH"
   },
   "outputs": [],
   "source": [
    "#can be installed with pip -- do it only once unless you disconnect runtime\n",
    "!pip install mplhep"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "tp2GGGQtRUdZ"
   },
   "outputs": [],
   "source": [
    "import mplhep as hep\n",
    "hep.style.use(hep.style.ROOT) # For now ROOT defaults to CMS\n",
    "# Or choose one of the experiment styles\n",
    "hep.style.use(hep.style.ATLAS)\n",
    "# or\n",
    "hep.style.use(\"ATLAS\") # string aliases work too\n",
    "# {\"ALICE\" | \"ATLAS\" | \"CMS\" | \"LHCb1\" | \"LHCb2\"}\n",
    "\n",
    "#or use matplotlib API directly\n",
    "plt.style.use(hep.style.ROOT) # For now ROOT defaults to CMS"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "NFNcfyzwTfdN"
   },
   "outputs": [],
   "source": [
    "#Example plot\n",
    "x = np.random.uniform(0, 10, 240)\n",
    "y = np.random.normal(512, 112, 240)\n",
    "z = np.random.normal(0.5, 0.1, 240)\n",
    "\n",
    "plt.style.use([hep.style.ROOT, hep.style.firamath])\n",
    "\n",
    "f, ax = plt.subplots()\n",
    "ax.scatter(x, y, c=z, label=\"XSX\")\n",
    "hep.cms.label(loc=0)\n",
    "\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "authorship_tag": "ABX9TyN6rS3AdUJOZVOQdQK5lBR/",
   "include_colab_link": true,
   "provenance": []
  },
  "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.8.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}