python/exercises/2. Basic Plotting.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this exercise, we will be plotting experimental data in Python using 'matplotlib'. (Explain what the purpose is of this exercise, why you will want this as an alternative to excel plots, and what some of the advantages are of using this method.)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Setup and preparing the data\n",
    "\n",
    "First we need to import some libraries to setup the script"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%pylab inline\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, we import the data from file to a numpy array using `np.loadtxt`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "results = np.loadtxt('datafiles/Labresults.csv',delimiter=',')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also separate the data in 3 seperate numpy arrays (one for each column):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "(conc,counts,run) = np.loadtxt('datafiles/Labresults.csv',delimiter=',',unpack=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Have a look at the data, what is in there?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, we need to split the data such that we have one list for each replicate. Have a look at the columns we have just loaded, identify the indices for each run and separate the columns (name them `counts_r1`, `counts_r2` and `counts_r3`). Remember that `a[i:j]` gives you items `i` to `j` (excluding `j`) from `a`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we have the counts per replicate, but `conc` still contains the concentrations for all values. Create a list of unique concentrations, named `cond_unique`, that matches `counts_r1` (or `counts_r2` or `counts_r3`). You can do this in the same way you created the lists for y-axis, or use `np.unique`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Basic line plotting"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First, we start by creating a plot for the first run."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig = plt.figure()\n",
    "ax = plt.gca()\n",
    "ax.plot(conc_unique,counts_r1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This plot is not very informative; we do not know that is on the axes or what is plotted. This can be changed with the `ax.set` function, for example, to add a title we do the following:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig = plt.figure()\n",
    "ax = plt.gca()\n",
    "ax.plot(conc_unique,counts_r1)\n",
    "ax.set(title='Labresults plot');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Use the arguments `xlabel` and `ylabel` to add labels to the x- and y-axis:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that the x-axis does not start at zero. The ranges of the axis are controlled with the arguments `xlim` and `ylim` which is set to a list of two values: `[min,max]`. Use the argument `xlim` for `ax.set` such that the x-axis starts at 0."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To adapt the markers on the axis, we need to modify the ticks. The position the ticks are controlled by `xticks` and `yticks`, the corresponding labels are controlled by `xticklabels` and `yticklabels`. If no tick labels are provides, these are identical to the tick values. Below we show an example of setting the ticks and tick labels for the y-axis:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig = plt.figure()\n",
    "ax = plt.gca()\n",
    "ax.plot(conc_unique,counts_r1)\n",
    "ax.set(title='Labresults plot',yticks=[0,4000],yticklabels=['min','max']);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Replace the current ticks on the x-axis with two ticks: one at 10, with the label *minimum concentration* and one at 60 with the label *maximum concentation*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Multiple lines in one plot"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, we want to plot the data for the three runs. Every time you run `plot` on the same axis object, a line is added to that axis:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig = plt.figure(figsize=(6,4))\n",
    "ax = plt.gca()\n",
    "ax.plot(conc_unique,counts_r1)\n",
    "ax.plot(conc_unique,counts_r2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Add the third line"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Matplotlib automatically gives a different color to each line. However, you may want to choose that yourself. For this, you can use the `color` argument which can be set to any of the following colors: \n",
    "\n",
    "<img src=\"https://matplotlib.org/_images/named_colors.png\">\n",
    "\n",
    "Use `color` to give the lines the following colors: blue, green, orange."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another way to distinguish lines is by using different line styles using the `linestyle` argument, which can be:\n",
    "\n",
    "<img src=\"https://matplotlib.org/_images/sphx_glr_line_styles_reference_001.png\">\n",
    "\n",
    "Adapt the plot such that:\n",
    "* the blue line is dotted\n",
    "* the green line is dash-dot\n",
    "* the orange line is dashed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, we add markers to the lines to make clear what the actual data is. Use the `marker` to add different markers to each line (possible markers can be found [here](https://matplotlib.org/api/markers_api.html)):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we have 3 clearly distinguished line, but we do not know which line represents which data; we net a legend. A legend is added with `ax.legend()`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig = plt.figure()\n",
    "ax = plt.gca()\n",
    "ax.plot(conc_unique,counts_r1)\n",
    "ax.plot(conc_unique,counts_r2)\n",
    "ax.plot(conc_unique,counts_r3)\n",
    "ax.legend()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "However, we need to provide the legend with labels for each line. This can be done with the `label` argument for `ax.plot`, which needs to be set to a string that describes the associated curve. Add a label to each line to create a legend:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Matplotlib automatically puts the label at the best position. This can be changes with the `loc` argument of `ax.legend()`. `loc` is a value between 0 and 10, where 0 results in the *best* position. Play with around with `loc` and place the legend in the bottom right corner."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Mean/SD plotting\n",
    "\n",
    "Next, we want to plot the mean count per concentration with the standard deviation as error bars. For this, we first need to collect the data in a 2D array, such that each row is one run. For this we use the function `np.reshape` which reshapes an array into a given new shape:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# shape (-1,) means 6 columns, and as many rows as needed\n",
    "cnts = reshape(counts,(-1,6))\n",
    "print(cnts)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, we can use `np.mean` the mean. Run the following code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.mean(cnts)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`np.mean` has an argument `axis` which specifies over which axis the mean should be computed. For a 2D array, axis can either be 0 or 1. Try both, and see which one gives the expected result."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The standard deviation can be computed with `np.std`, which works in the same way as `np.mean`. Use `np.std` to compute the standard deviation per concentration."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, we plot the mean:\n",
    "\n",
    "1. store the mean in a variable named `mu`\n",
    "2. create a figure and `ax`\n",
    "3. plot `mu` against the concentration\n",
    "4. annotate the plot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To add error bars, we to replace the `plot` function with the `errorbar` function. \n",
    "\n",
    "1. store the standard deviation in a variable named `sd`\n",
    "2. create a figure and `ax`\n",
    "3. plot `mu` against the concentration with errorbars: `ax.errorbar(conc_unique,mu,yerr=sd)`\n",
    "4. annotate the plot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Bar Charts\n",
    "\n",
    "We can plot this in a bar chart as well, using the function `plt.bar` which works similar to `plt.plot`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig = plt.figure()\n",
    "ax = plt.gca()\n",
    "ax.bar(conc_unique,mu)\n",
    "ax.set(title='mean',xlabel='Concentration',ylabel='Count');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "These bars are very narrow. The width of the bars can be changes with the `width`, use this to set the width to 8:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hideCode": true
   },
   "source": [
    "Next, use the `yerr` argument to add error bars:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Alternatively, you could put all data in one bar plot. Like with the plot command, this can be done by adding a `ax.bar` command for each run. Run the code below, what happens?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig = plt.figure()\n",
    "ax = plt.gca()\n",
    "ax.bar(conc_unique,counts_r1)\n",
    "ax.bar(conc_unique,counts_r2)\n",
    "ax.bar(conc_unique,counts_r3)\n",
    "ax.set(title='mean',xlabel='Concentration',ylabel='Count');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We need to define unique x-coordinates for each set of bars, which can be done by shifting the x-coordinates of each subsequent plot further to the right. Remember that you can add values to an array with `+` and that you can specify the width with the `width` argument. Use this to plot create a bar chart containing the 3 runs without overlapping bars. Use `label` and legend (like before) to add a legend."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exporting figures\n",
    "\n",
    "To finalize our plots and use them in future documents, we can save them using `plt.savefig`. This function has one mandatory argument, the filename, which must include the extension because matplotlib uses this to set the image format. Use `plt.savefig` to export a plot as a png and as a svg."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "hide_input": false,
  "kernelspec": {
   "display_name": "Python3 (BPiDD)",
   "language": "python",
   "name": "bpidd"
  },
  "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.0"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": false,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}