Intro2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Loading and using modules/libraries\n",
    "\n",
    "### Python has been extended with modules developed by a massive community to enable you to do pretty much any kind of analysis or data visualisation that you need \n",
    "##### Note on terminology: Libraries are collections of packages which are collections of modules \n",
    "\n",
    "## We are going to use 3 different libararies in this note book\n",
    "1) NumPy which enables numerical computing on arrays (i.e. maths of arrays of numbers)  \n",
    "2) matplotlib a plotting/graphical library  \n",
    "3) and later in the notebook you will also use SciPy whcih enables further fancy maths\n",
    "\n",
    "\n",
    "### To use any of these modules you normally need to install the package/module:\n",
    "- for this workshop I have already installed what you require\n",
    "- once libraries/packages have been installed you need to import them into the note book\n",
    "- run the cell below to do this\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np \n",
    "# the line above imports all of the numpy package which you will now refer to as 'np'\n",
    "from matplotlib import pyplot as plt \n",
    "# the line above imports the pyplot package from the matplotlib library which you will \n",
    "# now refer to as plt, it is useful for plotting data\n",
    "\n",
    "plt.rcParams.update({'font.size': 14, 'figure.figsize': [12, 8]})\n",
    "# sets some default parameters for the size and font size of all plots\n",
    "# You do not need to understand this line\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Recall that you can not do maths with lists of numbers\n",
    "- run the below cell to recreate the list of numbers from Intro1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "numbersInList=[0,1,2,3,4,5,6,7,8,9]  # this is our numbers in list from Intro1 "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### We will now use NumPy to convert the list of numbers to an NumPy array. This is done with np.asarray( )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "arrayOfNumbers=np.asarray(numbersInList)\n",
    "\n",
    "print(arrayOfNumbers)   #we have now converted the list of numbers to an array"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Now try multiplying this arrayOfNumbers by 3\n",
    "- make a new variable result =  arrayOfNumbers * 3\n",
    "- then print result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Similar to a list you can use indexing [ ] to refer to particular places in the array\n",
    "- try print(arrayOfNumbers[3])\n",
    "- you can also specify a range using start:stop, e.g. try print(arrayOfNumbers[2:5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "********\n",
    "---------\n",
    "#### You can think of arrays a bit like an excel sheet. Our \"arrayOfNumbers\" is equivalent to a single column with 10 rows \n",
    "- run the next cell to create an array with 2 columns of 10 rows"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "twoColumns =np.vstack((arrayOfNumbers,arrayOfNumbers+10)).T\n",
    "# you do not need to understand the above line. I have just used it to create some test data\n",
    "print(twoColumns)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### A very useful query is what shape an array has, i.e. how may rows and how many columns\n",
    "- you can do this by simply using .shape\n",
    "- in the cell below type print(twoColumns.shape) and run it\n",
    "- this will return 2 numbers the **first is the number of rows**, the **second is the number of columns**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- You can use indexing with .shape to just get the number of columns\n",
    "- try print(twoColumns.shape[1]) to get just the number of columns, [0] would give you just the number of rows"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Indexing arrays\n",
    "- you can index arrays with multiple columns using the same square bracket syntax [ ]\n",
    "- when there is more than 1 column you have an index for the row and a seperate index for the column seperated by a comma\n",
    "- in the cell below print(twoColumns[4,1]) to print the value at position 4 in column 1 (remember counting starts from zero)\n",
    "- You can get all of a dimension using :\n",
    "- try print(twoColumns[:,1])\n",
    "- then try print(twoColumns[3,:])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### You have now learnt how to index/slice arrays!\n",
    "You can get tips/reminders of this important syntax on the numpy-cheat-sheet in the prework folder"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "----------------------------\n",
    "***************************\n",
    "---------------------------\n",
    "# Now we will load some real data using numpy\n",
    "- The data we will load is a current clamp recording from a mitral cell in the olfactory bulb, a current injection is given to evoke action potential firing\n",
    "- we are going to plot the raw data, use peak detection to automatically identify spikes.\n",
    "- run the cell below to load the data using **np.loadtxt( )**\n",
    "- note that you have to provide the full file name as a **string**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = np.loadtxt('mitralSpikes.txt');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Now we can use some of NumPy features to measure things\n",
    "1) make a variable called <code>dataPoints = data.shape[0]</code> \n",
    "    - this is the number of rows i.e. data points in this file\n",
    "2) make a variable called <code>peak = np.max(data)</code> \n",
    "    - peak will contain the maximum value in data\n",
    "3) make a variable called <code>AHP = np.min(data)</code> \n",
    "    - AHP will contain the minimum value\n",
    "4) print some text that informs us of the number of data points, what the peak was and what the minimum e.g.\n",
    "```Python\n",
    "print(\"this data has\",dataPoints,'data points, with a peak of',peak,'mV and a minimum of',AHP, 'mV')\n",
    "    ```\n",
    "   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Now we will visualise it using matplotlib which we have called plt\n",
    "\n",
    "- first you create a figure and axes with plt.subplots(1), this creates a new figure and 1 set or axes\n",
    "- ax.plot(data) will then plot the data \n",
    "- run the cell below to do this"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots(1) # fig = the figure window in which axes are plotted, ax = the axes that we will plot in\n",
    "ax.plot(data); # this plots the data on the axes created in the line above\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Note the x axis is just displayed as point number rather than seconds\n",
    "- we need an array of the same length that contains the corresponding time points \n",
    "- we can use np.arange( ) to generate the appropriate range of time points\n",
    "- You need to provide the start time, stop time and interval (time step)\n",
    "- whenever you need to find out how to do or use something in python google is your friend! (https://numpy.org/doc/stable/reference/generated/numpy.arange.html)\n",
    "\n",
    ">#### How to determine the end time and interval. You need to know the sample rate\n",
    "The sample rate was 15 kHz, i.e. 15000 points a second  \n",
    "If the start time is zero the time of the last point is the number of points divided by the sample rate  \n",
    "The interval in seconds is simply 1/sample rate\n",
    ">- create a variable called sampleRate=15000\n",
    ">- then create a variable called xScale = np.arange( )\n",
    ">- input the appropriate parameters\n",
    ">- hint you can do calculations in the input e.g. np.arange(0, data.shape[0]/sampleRate, __________ )\n",
    ">- you just need to fill in the blank."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Now we can plot the graph with the correct xScale\n",
    "- Make a new figure and axes\n",
    "- use ax.plot(xScale,data) to plot data against your new xScale\n",
    "- now label the axis using ax.set_xlabel('Time (s)')\n",
    "- have a go at doing the ylabel yourself\n",
    "- the range of your x axis should be from 0 to 1.0 seconds"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Next we will automate counting of acition potentials\n",
    "- We will do this using the signal package of SciPy (a library for sciencey stuff)\n",
    "- Run the cell below to import the signal package as signal"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import scipy.signal as signal"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### signal has a find_peaks function which we will use\n",
    "- you need to give two inputs to signal.find_peaks:\n",
    "    - 1st you give the array in which you want to find peaks, in our case this is **data**\n",
    "    - next you specify the height the signal needs to be, as we are detecting action potentials the peaks should cross 0. We specify this using **height = 0**\n",
    "- signal.find_peaks will return two objects, that means we have to have 2 variables before **= signal.find_peaks**\n",
    "    - the first is an array with the location of each peak in sample points, this is what we want. Below I have called this **peaks**\n",
    "    - The second object is a \"dictionary\" containing other information about the peaks. We will ignore this.  \n",
    "    \n",
    "If you want to find out more, the full documentation can be found here: https://docs.scipy.org/doc/scipy/reference/generated/scipy.signal.find_peaks.html\n",
    "\n",
    "- run the cell below"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "peaks, props = signal.find_peaks(data,height=0) #this function returns two things: 1) peaks\n",
    "# which is the location of the spike in sample points and 2) props which contains other details about the peaks"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**peaks** now contains the location in points of all the detected spikes  \n",
    "- peaks is the location of the peaks in sample points, we need to fist convert it to time\n",
    "- to do this add <code>peaks = peaks/sampleRate</code> on the last line of the cell above and run it again (remember we made sampleRate earlier)\n",
    "- in the cell below print the length of peaks and some text to indicate this is how may spikes were detected"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Finally we will plot the location of the detected peaks ontop of the raw data to verify it has worked well\n",
    "- peaks is our x data (i.e. time points) for our detected spikes, we next need y data\n",
    "- as we detected spikes by defining them as anything with a height of 0 let us use 0 for the y data\n",
    "- make peaksY = np.zeros(len(peaks))\n",
    "    - this creates an array of 0s that is the same length as our time points "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### We now have everything to plot the final graph\n",
    "- use ax.plot to plot the data with its xScale as before, though this time include **label='raw data'** inside the brackets. This is required for adding a legend\n",
    "- next use <code>ax.plot(peaks,peaksY,'.',label='detected spikes')</code> to add points where spikes were detected\n",
    "- inside this ax.plot brackect you have included **'.'**, this changes the plot to display only dots rather than the default 'line between points'\n",
    "- Then add lables for the x and y axis as before\n",
    "- use ax.legend() to add the legend\n",
    "- finally print(len(peaks),'spikes were detected') \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## All done with this one. This is what you have learnt:\n",
    "   - how to import extra modules into python for use in your analysis\n",
    "   - how to load text files into numpy arrays\n",
    "   - numpy arrays allow maths on lists of numbers\n",
    "   - how to query the dimesions of numpy arrays\n",
    "   - how to quickly plot data to examine it using matplotlib\n",
    "   - with matplotlib you can make sophisticated graphs to display any kind of data. You can see examples of these and the the code to reproduce them here: https://matplotlib.org/gallery/index.html\n",
    "   - how to label axis of matplotlib graphs\n",
    "   - you used a module of scipy to detect action potentials\n",
    "   \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.7.6"
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "position": {
    "height": "510px",
    "left": "762px",
    "right": "20px",
    "top": "109px",
    "width": "340px"
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}