2 - make plots.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Plots\n",
    "\n",
    "Python is a great programming langauge for data visualization! We can create line graphs from lists of data using the matplotlib.pyplot library (which we will import as plt)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = [1, 2, 3,  4,  5,   6] # x-axis\n",
    "y = [4, 8, 12, 16, 20, 24] # y-axis"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Think of these two lists as sets of x and y coordinates. To plot these, simply use the plot method as shown below. The first argument in the plot method is the list of x-axis values and the second argument is the list of y-axis values. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot(x,y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Numpy Sidenote\n",
    "\n",
    "The numpy library can be used to make certain list operations easier! For instance, the **np.arrange** function generates a list of incremented values. Here are the function's arguments:\n",
    "\n",
    "1. The beginning of the list (0)\n",
    "2. The maximum value of the list (100; this is an exclusive maximum, so it will not be included in the list)\n",
    "3. The incrementing value (1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# creating the t list\n",
    "t = np.arange(0, 100, 1)\n",
    "print(\"t list: \\n\", t)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you can see above, a list of integers 0 - 99 were created. \n",
    "\n",
    "Now we want to multiply each value in the t list by the acceleration variable (9.8 m / s$^2$). Python's computations are very flexible, so all we need to do it multiply the list t by the acceleration variable and add the initial velocity ($v0$)! We are going to store it in the velocity variable $v$.\n",
    "\n",
    "We'll assume that we're starting from rest, $v0$=0 m/s. But feel free to try a different initial velocity and see how it changes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# creating the new x-list\n",
    "acceleration = 9.8 # m/s^2\n",
    "v0 = 0.\n",
    "v = v0 + acceleration * t  # m/s\n",
    "print(\"\\nv list: \\n\", v)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### <span style=\"color:blue\"> Exercise 2.1 </span>\n",
    "\n",
    "Now try plotting $v$ versus $t$ so that velocity is on the y-axis and time is on the x-axis"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# make a plot here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Labels\n",
    " \n",
    "The graph above is nice, but it could be a lot more descriptive! We should add labels to this plot using the plt.xlabel and plt.ylabel methods! The arguments for each method is a string describing their coresponding axis."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot(t, v)\n",
    "plt.xlabel(\"time (s)\")\n",
    "plt.ylabel(\"velocity (m/s)\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### <span style=\"color:blue\"> Exercise 2.2 </span>\n",
    "\n",
    "Now try calculating the position, x, from the velocity list you created above and starting from an initial x-position, x0. Make a plot of the position versus time with appropriate labels.\n",
    "\n",
    "If you don't remember how to calculate position from velocities check this out :\n",
    "http://hyperphysics.phy-astr.gsu.edu/hbase/mot.html#motcon\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# insert your code here!\n",
    "# feel free to make multiptle cells."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Multiple Plots\n",
    "\n",
    "What if we want to compare two different speeds on the same graph? Simply plot the two line graphs in the same cell! "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# creation of v1 and v2 lists (two different velocities, )\n",
    "t = np.arange(0, 100, 1)\n",
    "\n",
    "# initial velocity\n",
    "v10 = 0\n",
    "# acceleration\n",
    "acceleration1 = 10\n",
    "v1 = acceleration1 * t + v10\n",
    "\n",
    "# initial velocity\n",
    "v20 = 100\n",
    "# acceleration\n",
    "acceleration2 = 20\n",
    "v2 = acceleration2 * t + v20"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Try playing with the initial velocities and acceleartions above to see how it modifies the graph."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# our new plot!\n",
    "plt.plot(t, v1)\n",
    "plt.plot(t, v2)\n",
    "\n",
    "plt.xlabel(\"time (s)\")\n",
    "plt.ylabel(\"velocity (m/s)\")\n",
    "plt.title(\"v1 vs. v2\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Legends\n",
    "\n",
    "Now that both line graphs are plotted, how do we distinguish one line graph from another? We can add a label each plot that describes what each line graph represents. \n",
    "\n",
    "To display a legend of these labels, include the plt.legend() function in the code cell."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# plot the line graphs with labels\n",
    "plt.plot(t, v1, label='v1')\n",
    "plt.plot(t, v2, label='v2')\n",
    "\n",
    "plt.xlabel(\"time (s)\")\n",
    "plt.ylabel(\"velocity (m/s)\")\n",
    "plt.title(\"v1 vs. v2\")\n",
    "\n",
    "plt.legend()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### <span style=\"color:blue\"> Exercise 2.3 </span>\n",
    "\n",
    "Now add another curve. And for bonus points try to change the line colors or line styles by [reading the documentation](https://matplotlib.org/api/_as_gen/matplotlib.pyplot.plot.html#matplotlib.pyplot.plot)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# add a third curve and make a plot."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data with Errorbars\n",
    "Often our data has some uncertainty and we can use an errorbar plot to reflect that.\n",
    "\n",
    "Let's start by making some data that oscillates sinusoidally, like the position, $x = A cos(\\omega t)$, of a mass on a spring. We will use the [sin()](https://docs.scipy.org/doc/numpy/reference/generated/numpy.sin.html) function from numpy. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "t = np.arange( 0, 100, 5) # seconds\n",
    "amplitude = 1.0 # meters\n",
    "omega = np.pi/30. # radians/second\n",
    "\n",
    "x = amplitude * np.sin(omega * t)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let's assume that we can only measure the position of the mass on the spring to a certain precision, given by $\\sigma$. So any value that we record will be uncertain by that number.\n",
    "\n",
    "For instance, if I use a (not so great) ruler to measure the position of the mass on the spring that only has 0.2 m increments."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sigma = 0.2 # meters"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now I can make a plot with error bars that include that uncertainty. Review the [matplotlib.errorbar](https://matplotlib.org/api/_as_gen/matplotlib.pyplot.errorbar.html) documentation to learn more about the function we will use to make the plot."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.errorbar(t,x,yerr=sigma)\n",
    "\n",
    "# Labels\n",
    "plt.xlabel(\"time (s)\")\n",
    "plt.ylabel(\"amplitude (m)\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The default plotting style isn't my favorite. I'd rather have the points show up like markers. The cell below does that. \n",
    "\n",
    "There are many plotting styles available and often looking at examples helps. For instance, here's an [example](https://matplotlib.org/1.2.1/examples/pylab_examples/errorbar_demo.html) of different ways to plot errorbars. \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.errorbar(t,x,yerr=sigma, fmt='o')\n",
    "\n",
    "# Labels\n",
    "plt.xlabel(\"time (s)\")\n",
    "plt.ylabel(\"amplitude (m)\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### <span style=\"color:blue\"> Exercise 2.4 </span>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "Now assume that the uncertainty on each point is changing. For instance, you measure one point at x=0.5 m with a precision of 0.2 m and another point with a precision of 0.1 m. Then you would have to use a list of errors associated with each point.\n",
    "\n",
    "Make up a list of uncertainties associated with each point, and review the [example](https://matplotlib.org/1.2.1/examples/pylab_examples/errorbar_demo.html) to try to include the list in your plot."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details> <summary> <b>Click For Hint!<b> </summary> Don't want to make up 20 error values on your own? Why not use <b>np.arrange</b> to assist you?</details>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Make a plot where the errors are different for each point.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The plot styles in matplotlib are controlled by **kwargs. read about them in the [plot documenation](https://matplotlib.org/api/_as_gen/matplotlib.pyplot.plot.html) and try to make the plot look how you want it to look."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# try to make the plot look how you want it to!\n",
    "# You can change the colors, the types of markers, the types of errors.\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}