Updated day 1 stuff

Author: markschatza

.gitignore

@@ -1 +1,2 @@
-/data/*
+/data/*
+*.pyc

.ipynb_checkpoints/Main-checkpoint.ipynb

@@ -10,21 +10,26 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "metadata": {},
+   "metadata": {
+    "collapsed": false
+   },
    "outputs": [],
    "source": [
-    "# The following import commands are modules that have helpful functions. Don't worry about them.\n",
+    "# The following import commands are modules that have helpful functions. \n",
     "import numpy as np\n",
     "import matplotlib.pyplot as plt\n",
     "import time\n",
     "import scipy\n",
-    "import os"
+    "import os\n",
+    "print('Modules loaded!')"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
-   "metadata": {},
+   "metadata": {
+    "collapsed": false
+   },
    "outputs": [],
    "source": [
     "# Load in the data using the program provided by OpenEphys. \n",
@@ -49,27 +54,64 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "metadata": {},
+   "metadata": {
+    "collapsed": false
+   },
    "outputs": [],
    "source": [
     "# Lets check out what we got\n",
     "print(\"The Sampling rate is :\", data['header']['sampleRate'])\n",
     "\n",
-    "# There is a problem. The sampling rate is of type string even though we need it to be a float...\n",
-    "print(\"Sample rate is type :\", type(data['header']['sampleRate']))\n",
-    "\n",
+    "# There is a problem. The sampling rate is of type string(unicode) even though we need it to be a float...\n",
+    "print(\"Sample rate is type :\", type(data['header']['sampleRate']))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [],
+   "source": [
     "# So lets change it!\n",
     "sampleRate = float(data['header']['sampleRate'])\n",
     "print(\"The Sampling rate is still :\", sampleRate)\n",
     "print(\"But the type is now :\", type(sampleRate))\n",
-    "print('Notice the precision changed. It\\'s now 30000.0!')\n",
-    "print('') #Blank line\n",
-    "\n",
+    "print('Notice the precision changed. It\\'s now 30000.0!')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [],
+   "source": [
+    "# Compare this to an int?\n",
+    "sampleRate = int(sampleRate)\n",
+    "print('Still the same sampling rate : ', sampleRate)\n",
+    "print('But now the type is : ', type(sampleRate))\n",
+    "print('And once again the precision has changed!')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [],
+   "source": [
     "# The data is a little longer so we won't print it out. We can look at how many values are stored though.\n",
     "print('Number of data points :', len(data['data']))\n",
     "# The timestamps have a different number of values because there is only 1 timestamp per 1024 data samples.\n",
     "# This is taken care of for you in the next step so don't worry about it.\n",
-    "print('Number of timestamps :', len(data['timestamps']))"
+    "print('Number of timestamps :', len(data['timestamps']))\n",
+    "\n",
+    "dataPerTs = len(data['data'])/len(data['timestamps'])\n",
+    "print('Number of data samples per timestamp', dataPerTs)"
    ]
   },
   {
@@ -92,7 +134,9 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "metadata": {},
+   "metadata": {
+    "collapsed": true
+   },
    "outputs": [],
    "source": [
     "class Con:\n",
@@ -124,23 +168,30 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "metadata": {},
+   "metadata": {
+    "collapsed": false
+   },
    "outputs": [],
    "source": [
     "plt.plot(con.ts,con.data, 'r') # This also takes a bit as there is a lot of data.\n",
-    "# Now you have a plot of every voltage for every sample in the recording."
+    "# Now you have a plot of every voltage for every sample in the recording.\n",
+    "plt.show()"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
-   "metadata": {},
+   "metadata": {
+    "collapsed": false
+   },
    "outputs": [],
    "source": [
-    "# Now lets get only the first 2 seconds of data, we'll use the sampling rate we saved before\n",
+    "# Now lets get only the first 10 seconds of data, we'll use the sampling rate we saved before\n",
     "timeElapsed = int(10 * con.fs) # Feel free to change the 1 to as many seconds as you (needs to be an integer for later)\n",
     "timeStart = int(0 * con.fs) # Where do you want to start (0 is the start, can change to be as many seconds after as you want)\n",
-    "plt.plot(con.ts[timeStart:timeElapsed], con.data[timeStart:timeElapsed], 'r') # [startIndex:endIndex]"
+    "timeEnd = timeElapsed + timeStart # We need what timestamp the end is. It is the start index + how many have elapsed over 10 sec\n",
+    "plt.plot(con.ts[timeStart:timeEnd], con.data[timeStart:timeEnd], 'r') # [startIndex:endIndex]\n",
+    "plt.show()"
    ]
   },
   {
@@ -157,16 +208,19 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "metadata": {},
+   "metadata": {
+    "collapsed": false
+   },
    "outputs": [],
    "source": [
-    "timeElapsed = int(2 * con.fs) \n",
-    "timeStart = int(0 * con.fs)\n",
-    "\n",
+    "timeElapsed = int(10 * con.fs) # Feel free to change the 1 to as many seconds as you (needs to be an integer for later)\n",
+    "timeStart = int(0 * con.fs) # Where do you want to start (0 is the start, can change to be as many seconds after as you want)\n",
+    "timeEnd = timeElapsed + timeStart # We need what timestamp the end is. It is the start index + how many have elapsed over 10 sec\n",
     "# Put code here!\n",
     "# use matplotlib to create a vertical line (hint: use google!)\n",
     "\n",
-    "plt.plot(con.ts[timeStart:timeElapsed], con.data[timeStart:timeElapsed], 'r') "
+    "plt.plot(con.ts[timeStart:timeEnd], con.data[timeStart:timeEnd], 'r') \n",
+    "plt.show()"
    ]
   },
   {
@@ -181,16 +235,17 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "metadata": {},
+   "metadata": {
+    "collapsed": true
+   },
    "outputs": [],
    "source": [
-    "timeElapsed = int(2 * con.fs) \n",
-    "timeStart = int(0 * con.fs)\n",
-    "\n",
     "# Put code here!\n",
     "\n",
-    "plt.plot(con.ts[timeStart:timeElapsed], con.data[timeStart:timeElapsed], 'r') \n",
-    "# use matplotlib to create a horizontal line (hint: use google!)"
+    "plt.plot(con.ts[timeStart:timeEnd], con.data[timeStart:timeEnd], 'r') \n",
+    "# use matplotlib to create a horizontal line (hint: use google!)\n",
+    "\n",
+    "plt.show()"
    ]
   },
   {
@@ -199,43 +254,64 @@
    "source": [
     "## Third challenge\n",
     "\n",
-    "Use the following imported module (butter) to create a bandpass filter to extract only the theta band (8-12hz)! I recommend writing a few functions to help you this with as well.\n",
+    "Use the butter function from scipys signal library to create a bandpass filter to extract only the theta band (4-8hz)! If you want, writing a few functions may help you and be good practice. \n",
     "\n",
-    "Use google to understand how to use butter. Also examples are very helpful!"
+    "Use google to understand how to use butter. Examples are very helpful!"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
-   "metadata": {},
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [],
+   "source": [
+    "# If you want to use functions write them here."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": false
+   },
    "outputs": [],
    "source": [
-    "from scipy.signal import butter, lfilter, sosfilt # You will also need to use either lfilter or sosfilt. \n",
-    "                                                  # There are multiple ways of doing this\n",
+    "from scipy import signal \n",
+    "# Hints!\n",
+    "# butter function can be accessed by signal.butter\n",
+    "# You will also need to use lfilter function which is included in the signal library. \n",
+    "# Use a filter order of 2\n",
+    "# You will also need to normalize your band that you want to extract\n",
+    "#   by the nyquist frequency\n",
+    "\n",
     "\n",
     "# Put code here\n",
     "\n",
-    "plt.plot(con.ts[timeStart:timeElapsed], filteredData, 'r')"
+    "plt.plot(con.ts[timeStart:timeEnd], filteredData[timeStart:timeEnd], 'r')\n",
+    "plt.show()"
    ]
   }
  ],
  "metadata": {
+  "anaconda-cloud": {},
   "kernelspec": {
-   "display_name": "Python 3",
+   "display_name": "Python [conda root]",
    "language": "python",
-   "name": "python3"
+   "name": "conda-root-py"
   },
   "language_info": {
    "codemirror_mode": {
     "name": "ipython",
-    "version": 3
+    "version": 2
    },
    "file_extension": ".py",
    "mimetype": "text/x-python",
    "name": "python",
    "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.6.8"
+   "pygments_lexer": "ipython2",
+   "version": "2.7.12"
   }
  },
  "nbformat": 4,

Main.ipynb

@@ -1,28 +1,19 @@
-from scipy.signal import butter, lfilter
+from scipy import signal
 
 '''
-Option 1
-
 How Mark S did this.
+From "https://scipy-cookbook.readthedocs.io/items/ButterworthBandpass.html"
 '''
-def butter_bandpass(lowcut, highcut, fs, order=5):
+def butter_bandpass(lowcut, highcut, fs, order=2):
     nyq = 0.5 * fs
     low = lowcut / nyq
     high = highcut / nyq
-    b, a = butter(order, [low, high], btype='band')
+    b, a = signal.butter(order, [low, high], btype='band')
     return b, a
 
 
-def butter_bandpass_filter(data, lowcut, highcut, fs, order=5):
+def butter_bandpass_filter(data, lowcut, highcut, fs, order=2):
     b, a = butter_bandpass(lowcut, highcut, fs, order=order)
-    filteredData = lfilter(b, a, data)
+    filteredData = signal.lfilter(b, a, data)
     return filteredData
 
-
-'''
-Option 2
-
-Example from scipy.
-'''
-sos = signal.butter(10, 15, 'hp', fs=1000, output='sos')
-filtered = signal.sosfilt(sos, sig)