{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction to Python\n",
    "\n",
    "## Using the tdt Package\n",
    "\n",
    "This primer walks through installing the tdt Python package, shows how to convert existing Matlab code to Python, and highlights some of the differences when working in Python.\n",
    "\n",
    "## Installation\n",
    "\n",
    "1. Make sure that you have [**Miniconda**](https://docs.conda.io/en/latest/miniconda.html) or [**Anaconda**](https://www.anaconda.com/distribution/) installed. You can choose the Python 3.7 64-bit version for your operating system (Linux, Windows, or OS X).\n",
    "2. **Open a terminal** (on Windows, `cmd`, not Powershell) and type:\n",
    "```\n",
    "pip install tdt\n",
    "```\n",
    "4. **Done**!\n",
    "\n",
    "\n",
    "## Converting Existing Matlab Code to Python\n",
    "\n",
    "The tdt Python library for reading TDT data is one-to-one compatible with the Matlab library, however the function names and parameter names are different.\n",
    "\n",
    "### Extracting Block Data\n",
    "\n",
    "**TDTbin2mat** extracts block data into a Matlab structure.  \n",
    "```\n",
    "data = TDTbin2mat(BLOCK_PATH);\n",
    "```\n",
    "The Python equivalent is **read_block**.\n",
    "```\n",
    "from tdt import read_block\n",
    "data = read_block(BLOCK_PATH)\n",
    "```\n",
    "**TDTbin2mat** and **read_block** share parameters, but the parameters have different names.\n",
    "\n",
    "#### Parameter Name Translation Table\n",
    "\n",
    "| Matlab | Python | Description |\n",
    "|----------|----------|----------------------------------------------------------------------------------------------------------------------------------------|\n",
    "| T1 | t1 | scalar, retrieve data starting at t1 (default = 0 for beginning of recording) |\n",
    "| T2 | t2 | scalar, retrieve data ending at t2 (default = 0 for end of recording) |\n",
    "| TYPE | evtype | array of strings, specifies what type of data stores to retrieve from the tank |\n",
    "| SORTNAME | sortname | string, specify sort ID to use when extracting snippets<br>(default = 'TankSort') |\n",
    "| RANGES | ranges | array of valid time range column vectors |\n",
    "| NODATA | nodata | bool, only return timestamps, channels, and sort codes for snippets<br>(default = false) |\n",
    "| STORE | store | string or list of strings, specify specific store(s) to extract |\n",
    "| CHANNEL | channel | integer, choose a single channel to extract from stream or snippet events |\n",
    "| BITWISE | bitwise | string, specify an epoc store or scalar store that contains a 32-bit integer.<br>Onsets/offsets from individual bits will be extracted |\n",
    "| HEADERS | headers | var, set to 1 to return only the headers for this block, if you need to<br>make fast consecutive calls to read_block |\n",
    "| COMBINE | combine | list, specify store(s) that were saved by the Strobed Data Storage gizmo<br> in Synapse. It will intelligently combine data into snippets. |\n",
    "\n",
    "### Epoc Filtering\n",
    "\n",
    "**TDTfilter** filters events around epoc events in Matlab.\n",
    "```\n",
    "data = TDTbin2mat(BLOCK_PATH);\n",
    "data = TDTfilter(data, 'Tick', 'TIME', [-0.3, 0.8], 'VALUES', [5, 10, 15]);\n",
    "```\n",
    "The Python equivalent is **epoc_filter**.\n",
    "```\n",
    "from tdt import read_block, epoc_filter\n",
    "data = read_block(BLOCK_PATH)\n",
    "data = epoc_filter(data, 'Tick', t=[-0.3, 0.8], values=[5, 10, 15])\n",
    "```\n",
    "**TDTbin2mat** and **read_block** share parameters, but the parameters have different names.\n",
    "\n",
    "#### Parameter Name Translation Table\n",
    "\n",
    "| Matlab | Python | Description |\n",
    "|-----------|-----------|------------------------------------------------------------------------------------------------------------------------------------------------------------------|\n",
    "| VALUES | values | array of allowed epoc values |\n",
    "| MODIFIERS | modifiers | array of allowed modifier values. For example, only allow time ranges<br>when allowed modifier occurred sometime during that event, <br>e.g. a correct animal response. |\n",
    "| TIME | t | onset/offset pair, extracts events around epoc onsets only |\n",
    "| TIMEREF | tref | boolean, set to True to use the epoc event onset as a time reference |\n",
    "| KEEPDATA | keepdata | boolean, keep the original stream data array and add a field<br>called'filtered' that holds the data from each valid time range |\n",
    "\n",
    "### Extracting SEV Data\n",
    "\n",
    "**SEV2mat** extracts SEV files from a given directory into a Matlab structure. These files are created on the RS4 Data Streamer or by enabling the Discrete Files option in the Synapse Stream Data Storage gizmo. Each SEV file contains a header and the raw binary data from a single channel.\n",
    "```\n",
    "data = SEV2mat(BLOCK_PATH);\n",
    "```\n",
    "The Python equivalent is **read_sev**.\n",
    "```\n",
    "from tdt import read_sev\n",
    "data = read_sev(BLOCK_PATH)\n",
    "```\n",
    "**SEV2mat** and **read_sev** share parameters, but the parameters have different names.\n",
    "\n",
    "#### Parameter Name Translation Table\n",
    "| Matlab | Python | Description |\n",
    "|-----------|------------|-----------------------------------------------------------------------------------------------------------------------------|\n",
    "| T1 | t1 | scalar, retrieve data starting at t1<br>(default = 0 for beginning of recording) |\n",
    "| T2 | t2 | scalar, retrieve data ending at t2<br>(default = 0 for end of recording) |\n",
    "| CHANNEL | channel | integer, returns the SEV data from specified channel only<br>(default = 0 for all channels) |\n",
    "| RANGES | ranges | array of valid time range column vectors |\n",
    "| JUSTNAMES | just_names | boolean, retrieve only the valid event names |\n",
    "| EVENTNAME | event_name | string, specific event name to retrieve data from |\n",
    "| VERBOSE | verbose | boolean, set to false to disable console output |\n",
    "| FS | fs | float, sampling rate override. Useful for lower sampling rate<br>recordings that aren't correctly written into the SEV header. |\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Walkthrough\n",
    "Let's look at some basic concepts for working with Python and the tdt library.  \n",
    "\n",
    "***Python Tips!**\n",
    "\n",
    "Use `print` in Python in place of `disp` in Matlab.  \n",
    "`%` is a special command used mainly in Python notebooks  \n",
    "`#` creates a single-line comment in Python  \n",
    "Use `'''` to make a multi-line comment  \n",
    "\n",
    "First we'll import the critical libraries."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# this is a single line comment\n",
    "\n",
    "''' this is a comment\n",
    "spanning multiple lines'''\n",
    "\n",
    "# special call that tells notebook to show matlplotlib figures inline\n",
    "%matplotlib inline\n",
    "\n",
    "import matplotlib.pyplot as plt  # standard Python plotting library\n",
    "import numpy as np  # fundamental package for scientific computing, handles arrays and maths\n",
    "\n",
    "# import the primary functions from the tdt library only\n",
    "from tdt import read_block, read_sev, epoc_filter, download_demo_data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***Python Tip!**\n",
    "\n",
    "Use the **\\_\\_doc\\_\\_** function to get help on a function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "TDT tank data extraction.\n",
      "    \n",
      "    data = read_block(block_path), where block_path is a string, retrieves\n",
      "    all data from specified block directory in struct format. This reads\n",
      "    the binary tank data and requires no Windows-based software.\n",
      "\n",
      "    data.epocs      contains all epoc store data (onsets, offsets, values)\n",
      "    data.snips      contains all snippet store data (timestamps, channels,\n",
      "                    and raw data)\n",
      "    data.streams    contains all continuous data (sampling rate and raw\n",
      "                    data)\n",
      "    data.scalars    contains all scalar data (samples and timestamps)\n",
      "    data.info       contains additional information about the block\n",
      "    \n",
      "    optional keyword arguments:\n",
      "        t1          scalar, retrieve data starting at t1 (default = 0 for\n",
      "                        beginning of recording)\n",
      "        t2          scalar, retrieve data ending at t2 (default = 0 for end\n",
      "                        of recording)\n",
      "        sortname    string, specify sort ID to use when extracting snippets\n",
      "                        (default = 'TankSort')\n",
      "        evtype      array of strings, specifies what type of data stores to\n",
      "                        retrieve from the tank. Can contain 'all' (default),\n",
      "                        'epocs', 'snips', 'streams', or 'scalars'.\n",
      "                      example:\n",
      "                          data = read_block(block_path, evtype=['epocs','snips'])\n",
      "                              > returns only epocs and snips\n",
      "        ranges      array of valid time range column vectors.\n",
      "                      example:\n",
      "                          tr = np.array([[1,3],[2,4]])\n",
      "                          data = read_block(block_path, ranges=tr)\n",
      "                              > returns only data on t=[1,2) and [3,4)\n",
      "        nodata      boolean, only return timestamps, channels, and sort \n",
      "                        codes for snippets, no waveform data (default = false).\n",
      "                        Useful speed-up if not looking for waveforms\n",
      "        store       string, specify a single store to extract\n",
      "                    list of strings, specify multiple stores to extract\n",
      "        channel     integer, choose a single channel to extract from\n",
      "                        stream or snippet events. Default is 0, to extract\n",
      "                        all channels.\n",
      "        bitwise     string, specify an epoc store or scalar store that \n",
      "                        contains individual bits packed into a 32-bit \n",
      "                        integer. Onsets/offsets from individual bits will\n",
      "                        be extracted.\n",
      "        headers     var, set to 1 to return only the headers for this\n",
      "                        block, so that you can make repeated calls to read\n",
      "                        data without having to parse the TSQ file every\n",
      "                        time, for faster consecutive reads. Once created,\n",
      "                        pass in the headers using this parameter.\n",
      "                      example:\n",
      "                        heads = read_block(block_path, headers=1)\n",
      "                        data = read_block(block_path, headers=heads, evtype=['snips'])\n",
      "                        data = read_block(block_path, headers=heads, evtype=['streams'])\n",
      "        combine     list, specify one or more data stores that were saved \n",
      "                        by the Strobed Data Storage gizmo in Synapse (or an\n",
      "                        Async_Stream_store macro in OpenEx). By default,\n",
      "                        the data is stored in small chunks while the strobe\n",
      "                        is high. This setting allows you to combine these\n",
      "                        small chunks back into the full waveforms that were\n",
      "                        recorded while the strobe was enabled.\n",
      "                      example:\n",
      "                        data = read_block(block_path, combine=['StS1'])\n",
      "    \n"
     ]
    }
   ],
   "source": [
    "print(read_block.__doc__)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "TDT tank data filter. Extract data around epoc events.\n",
      "    data = epoc_filter(data, epoc) where data is the output of read_block,\n",
      "    epoc is the name of the epoc to filter on, and parameter value pairs\n",
      "    define the filtering conditions.\n",
      "    \n",
      "    If no parameters are specified, then the time range of the epoc event\n",
      "    is used as a time filter.\n",
      "    \n",
      "    Also creates data.filter, a string that describes the filter applied.\n",
      "    Optional keyword arguments:\n",
      "        values      specify array of allowed values\n",
      "                      ex: tempdata = epoc_filter(data, 'Freq', values=[9000, 10000])\n",
      "                        > retrieves data when Freq = 9000 or Freq = 10000\n",
      "        modifiers   specify array of allowed modifier values.  For example,\n",
      "                      only allow time ranges when allowed modifier occurred\n",
      "                      sometime during that event, e.g. a correct animal response.\n",
      "                      ex: tempdata = epoc_filter(data, 'Resp', modifiers=[1])\n",
      "                        > retrieves data when Resp = 1 sometime during the allowed\n",
      "                        time range.\n",
      "        t           specify onset/offset pairs relative to epoc onsets. If the\n",
      "                      offset is not provided, the epoc offset is used.\n",
      "                      ex: tempdata = epoc_filter(data, 'Freq', t=[-0.1, 0.5])\n",
      "                        > retrieves data from 0.1 seconds before Freq onset to 0.4\n",
      "                          seconds after Freq onset. Negative time ranges are discarded.\n",
      "        tref        use the epoc event onset as a time reference. All timestamps for\n",
      "                      epoc, snippet, and scalar events are then relative to epoc onsets.\n",
      "                      ex: tempdata = epoc_filter(data, 'Freq', tref=True)\n",
      "                        > sets snippet timestamps relative to Freq onset\n",
      "        keepdata    keep the original stream data array and add a field called\n",
      "                      'filtered' that holds the data from each valid time range. \n",
      "                      Defaults to True.\n",
      "    \n",
      "    IMPORTANT! Use a time filter (t argument) only after all value filters have been set.\n",
      "    \n"
     ]
    }
   ],
   "source": [
    "print(epoc_filter.__doc__)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "TDT sev file data extraction.\n",
      "    \n",
      "    data = read_sev(sev_dir), where sev_dir is a string, retrieves\n",
      "    all sev data from specified directory in struct format. sev_dir can\n",
      "    also be a single file. SEV files are generated by an RS4 Data Streamer,\n",
      "    or by enabling the Discrete Files option in the Synapse Stream Data\n",
      "    Storage gizmo, or by setting the Unique Channel Files option in \n",
      "    Stream_Store_MC or Stream_Store_MC2 macro to Yes in OpenEx.\n",
      "\n",
      "    data    contains all continuous data (sampling rate and raw data)\n",
      "    \n",
      "    optional keyword arguments:\n",
      "        t1          scalar, retrieve data starting at t1 (default = 0 for\n",
      "                        beginning of recording)\n",
      "        t2          scalar, retrieve data ending at t2 (default = 0 for end\n",
      "                        of recording)\n",
      "        channel     integer, returns the sev data from specified channel\n",
      "                        only (default = 0 for all channels)\n",
      "        ranges      array of valid time range column vectors\n",
      "        just_names  boolean, retrieve only the valid event names\n",
      "        event_name  string, specific event name to retrieve data from\n",
      "        verbose     boolean, set to false to disable console output\n",
      "        fs          float, sampling rate override. Useful for lower\n",
      "                        sampling rates that aren't correctly written into\n",
      "                        the SEV header.\n",
      "    \n"
     ]
    }
   ],
   "source": [
    "print(read_sev.__doc__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Download demo data from the TDT website"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "demo data ready\n"
     ]
    }
   ],
   "source": [
    "download_demo_data()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This example uses our [example data sets](https://www.tdt.com/files/examples/TDTExampleData.zip). To import your own data, replace BLOCK_PATH with the full path to your own data block.\n",
    "\n",
    "In Synapse, you can find the block path in the database. Go to Menu > History. Find your block, then Right-Click > Copy path to clipboard."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "read from t=0s to t=61.23s\n"
     ]
    }
   ],
   "source": [
    "BLOCK_PATH = 'data/Algernon-180308-130351'\n",
    "data = read_block(BLOCK_PATH)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epocs\t[struct]\n",
      "snips\t[struct]\n",
      "streams\t[struct]\n",
      "scalars\t[struct]\n",
      "info\t[struct]\n",
      "time_ranges:\tarray([[ 0.],\n",
      "       [inf]])\n"
     ]
    }
   ],
   "source": [
    "print(data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**read_block** returns a structured object. It is a Python dictionary but also allows you to use the dot syntax like in Matlab, so you can access fields within the structure with either method. These two ways of looking at the block info field are equivalent:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tankpath:\t'data'\n",
       "blockname:\t'Algernon-180308-130351'\n",
       "start_date:\tdatetime.datetime(2018, 3, 8, 13, 3, 53)\n",
       "utc_start_time:\t'13:03:53'\n",
       "stop_date:\tdatetime.datetime(2018, 3, 8, 13, 4, 55)\n",
       "utc_stop_time:\t'13:04:55'\n",
       "duration:\tdatetime.timedelta(seconds=62)\n",
       "stream_channel:\t0\n",
       "snip_channel:\t0"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.info"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tankpath:\t'data'\n",
       "blockname:\t'Algernon-180308-130351'\n",
       "start_date:\tdatetime.datetime(2018, 3, 8, 13, 3, 53)\n",
       "utc_start_time:\t'13:03:53'\n",
       "stop_date:\tdatetime.datetime(2018, 3, 8, 13, 4, 55)\n",
       "utc_stop_time:\t'13:04:55'\n",
       "duration:\tdatetime.timedelta(seconds=62)\n",
       "stream_channel:\t0\n",
       "snip_channel:\t0"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data['info']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "These three methods to access the 'Wav1' store sampling rate are equivalent:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "24414.0625"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.streams.Wav1.fs # dot syntax"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "24414.0625"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data['streams']['Wav1']['fs'] # dict keys only"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "24414.0625"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data['streams'].Wav1['fs'] # mix of dot syntax and dict keys"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***Python Tip!**\n",
    "\n",
    "Spaces are important in python. Commands like `for`, `if`, `elif`, `while`, and others require indents to track their nests\n",
    "```\n",
    "for foo in foo_list:\n",
    "    something\n",
    "    if foo == check:\n",
    "        conditional_something\n",
    "    elif:\n",
    "        still_in_for_loop\n",
    "    else:\n",
    "        still_in_for_loop\n",
    "\n",
    "out_of_loop\n",
    "```\n",
    "\n",
    "Accessing a field with the string dictionary key method is useful when using a variable name, such as this example which loops through all the stream store names and prints their sampling rates."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sampling rates in Algernon-180308-130351\n",
      "pNe1 498.2462 Hz\n",
      "Wav1 24414.0625 Hz\n",
      "LFP1 3051.7578 Hz\n"
     ]
    }
   ],
   "source": [
    "print('Sampling rates in', data.info.blockname)\n",
    "for store in data.streams.keys():\n",
    "    print(store, '{:.4f} Hz'.format(data.streams[store].fs))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Explore Stream events"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's look at the contents of the stream event structures"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "all stream stores\n",
      "pNe1\t[struct]\n",
      "Wav1\t[struct]\n",
      "LFP1\t[struct]\n"
     ]
    }
   ],
   "source": [
    "print('all stream stores')\n",
    "print(data.streams)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "name:\t'Wav1'\n",
      "code:\t829841751\n",
      "size:\t2058\n",
      "type:\t33025\n",
      "type_str:\t'streams'\n",
      "ucf:\tFalse\n",
      "fs:\t24414.0625\n",
      "dform:\t0\n",
      "start_time:\t-4.000632568359375e-05\n",
      "data:\tarray([[ 1.0028159e-03,  1.0012799e-03,  9.9590386e-04, ...,\n",
      "        -1.5983999e-03, -1.5984639e-03, -1.5852799e-03],\n",
      "       [ 5.5667193e-04,  5.6723197e-04,  5.6083198e-04, ...,\n",
      "        -1.4531199e-03, -1.4584319e-03, -1.4480639e-03],\n",
      "       [-4.6534397e-04, -4.5804796e-04, -4.6521597e-04, ...,\n",
      "        -1.2184319e-03, -1.2098559e-03, -1.2177919e-03],\n",
      "       ...,\n",
      "       [ 2.9247998e-05,  2.3295999e-05,  3.2191998e-05, ...,\n",
      "        -2.2208637e-03, -2.2241918e-03, -2.2300798e-03],\n",
      "       [ 7.2191993e-04,  7.1571197e-04,  7.2358397e-04, ...,\n",
      "        -2.1401597e-03, -2.1399679e-03, -2.1494399e-03],\n",
      "       [ 2.3078399e-04,  2.3590398e-04,  2.4435198e-04, ...,\n",
      "        -1.3180159e-03, -1.3103359e-03, -1.3012479e-03]], dtype=float32)\n"
     ]
    }
   ],
   "source": [
    "print(data.streams.Wav1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The actual data is store in numpy arrays.  For a multi-channel stream store, each row is a channel. Python uses 0-based indexing, so we have to subtract 1 from our channel number when accessing the array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "channel 1: [ 0.00100282  0.00100128  0.0009959  ... -0.0015984  -0.00159846\n",
      " -0.00158528]\n"
     ]
    }
   ],
   "source": [
    "print('channel 1:', data.streams.Wav1.data[0,:])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "number of samples: 1490944\n"
     ]
    }
   ],
   "source": [
    "num_samples = len(data.streams.Wav1.data[0])\n",
    "print('number of samples:', num_samples)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create time vector for plotting by dividing the number of samples in the array by the sampling rate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "Wav1_time = np.linspace(1, num_samples, num_samples) / data.streams.Wav1.fs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Plot the first 2 seconds from a single channel"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "t = int(2 * data.streams.Wav1.fs) # int rounds it to the nearest integer\n",
    "\n",
    "# declare the figure size\n",
    "fig1 = plt.subplots(figsize=(10, 6))\n",
    "\n",
    "channel = 1 \n",
    "\n",
    "# plot the line using slices\n",
    "plt.plot(Wav1_time[0:t], data.streams.Wav1.data[channel-1,0:t], color='cornflowerblue')\n",
    "\n",
    "# Some matplotlib stuff\n",
    "# add an annotation mark to the figure\n",
    "plt.annotate('Point Here',\n",
    "             xy=(0.8,0.002),\n",
    "             xytext=(.88,.003),\n",
    "             arrowprops=dict(arrowstyle='->', color='k')\n",
    "            )\n",
    "\n",
    "# create title, axis labels, and legend\n",
    "plt.title('Wav1 Data', fontsize=16)\n",
    "plt.xlabel('Seconds', fontsize=14)\n",
    "plt.ylabel('Volts', fontsize=14)\n",
    "plt.legend(('Channel {}'.format(channel),),\n",
    "           loc='lower right', \n",
    "           bbox_to_anchor=(1.0,1.01)\n",
    "          )\n",
    "plt.autoscale(tight=True)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***Python Tip!**\n",
    "\n",
    "Array slices in Python have some notable differences.\n",
    "1. Zero-based indexing\n",
    "2. Omit 'end' and just use a negative index to index starting from the end of the array\n",
    "3. Omit the starting index if you want to include the first element\n",
    "\n",
    "Matlab array slices\n",
    "```\n",
    "arr = 1:10;          % arr = [1 2 3 4 5 6 7 8 9 10]\n",
    "b = arr(3:5);        % b = [3 4 5]\n",
    "c = arr(1:end-2);    % c = [1 2 3 4 5 6 7 8]\n",
    "d = arr(end-1:end);  % d = [9 10]\n",
    "```\n",
    "\n",
    "Python equivalent\n",
    "```\n",
    "arr = np.arange(1,11)  # arr = [1 2 3 4 5 6 7 8 9 10]\n",
    "b = arr[2:5]           # b = [3 4 5]\n",
    "c = arr[:-2]           # c = [1 2 3 4 5 6 7 8]\n",
    "d = arr[-2:]           # d = [9 10]\n",
    "```\n",
    "\n",
    "For reference, here are some matplotlib colors originally from [this stackoverflow answer](https://stackoverflow.com/a/37232760)\n",
    "![originally from https://stackoverflow.com/questions/22408237/named-colors-in-matplotlib](https://i.stack.imgur.com/lFZum.png)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## Explore Epoc Events"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's look at the contents of the epoc event structures."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "all epoc events\n",
      "Pu1e\t[struct]\n",
      "PC0_\t[struct]\n"
     ]
    }
   ],
   "source": [
    "print('all epoc events')\n",
    "print(data.epocs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "name:\t'Pu1e'\n",
      "onset:\tarray([1.23739243e-04, 3.50011492e+00, 7.00010586e+00, 1.05000970e+01,\n",
      "       1.40000880e+01, 1.75000789e+01, 2.10000701e+01, 2.45000610e+01,\n",
      "       2.80000522e+01, 3.15000432e+01, 3.50000343e+01, 3.85000253e+01,\n",
      "       4.20000162e+01, 4.55000074e+01, 4.89999983e+01, 5.24999895e+01,\n",
      "       5.59999804e+01, 5.94999716e+01])\n",
      "offset:\tarray([ 0.30011487,  3.80010581,  7.30009699, 10.80008793, 14.30007911,\n",
      "       17.80007005, 21.30006123, 24.80005217, 28.30004311, 31.80003428,\n",
      "       35.30002522, 38.8000164 , 42.30000734, 45.79999828, 49.29998946,\n",
      "       52.7999804 , 56.29997158, 59.79996252])\n",
      "type:\t'onset'\n",
      "type_str:\t'epocs'\n",
      "data:\tarray([ 1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10., 11., 12., 13.,\n",
      "       14., 15., 16., 17., 18.])\n",
      "dform:\t4\n",
      "size:\t10\n"
     ]
    }
   ],
   "source": [
    "print(data.epocs.Pu1e)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# a simple plot\n",
    "fig1 = plt.subplots(figsize=(10, 6))\n",
    "plt.stem(data.epocs.Pu1e.onset, data.epocs.Pu1e.data)\n",
    "plt.show()"
   ]
  }
 ],
 "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}