1_Grid_cell_tutorial.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!pip install pynapple matplotlib dandi dandischema"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "Grid Cell Tutorial\n",
    "=========================\n",
    "\n",
    "*Author: Dhruv Mehrotra and Guillaume Viejo*\n",
    "\n",
    "\n",
    "This notebook demonstrates how we use Pynapple on various publicly available datasets in systems neuroscience to streamline analysis. In this notebook, we will examine the dataset from [Sargolini et al (2006)](https://www.science.org/doi/10.1126/science.1125572). The entire dataset can be downloaded  <a href=\"https://dandiarchive.org/dandiset/000582\" target=\"_blank\">here</a>. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***\n",
    "\n",
    "**Note:** This tutorial uses matplotlib for displaying the figure as well as the dandi package.\n",
    "\n",
    "You can install all with `pip install matplotlib dandi dandischema`\n",
    "\n",
    "***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "DANDI\n",
    "-----\n",
    "DANDI allows you to stream data without downloading all the files. In this case, the data extracted from the NWB file are stored in the nwb-cache folder. To do so, run the following lines of code:\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "from pynwb import NWBHDF5IO\n",
    "\n",
    "from dandi.dandiapi import DandiAPIClient\n",
    "import fsspec\n",
    "from fsspec.implementations.cached import CachingFileSystem\n",
    "import h5py\n",
    "\n",
    "\n",
    "# Ecephys\n",
    "dandiset_id, filepath = (\n",
    "    \"000582\",\n",
    "    \"sub-10073/sub-10073_ses-17010302_behavior+ecephys.nwb\",\n",
    ")\n",
    "\n",
    "\n",
    "with DandiAPIClient() as client:\n",
    "    asset = client.get_dandiset(dandiset_id, \"draft\").get_asset_by_path(filepath)\n",
    "    s3_url = asset.get_content_url(follow_redirects=1, strip_query=True)\n",
    "\n",
    "# First, create a virtual filesystem based on the http protocol\n",
    "fs = fsspec.filesystem(\"http\")\n",
    "\n",
    "# Create a cache to save downloaded data to disk (optional)\n",
    "fs = CachingFileSystem(\n",
    "    fs=fs,\n",
    "    cache_storage=\"nwb-cache\",  # Local folder for the cache\n",
    ")\n",
    "\n",
    "# Next, open the file\n",
    "file = h5py.File(fs.open(s3_url, \"rb\"))\n",
    "io = NWBHDF5IO(file=file, load_namespaces=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pynapple\n",
    "--------\n",
    "If opening the NWB works, you can start streaming data straight into pynapple with the `NWBFile` class.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "#Import matplotlib.pyplot, numpy, pynapple and seaborn libraries\n",
    "\n",
    "data = nap.NWBFile(io.read())\n",
    "\n",
    "print(data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can load the spikes as a TsGroup for inspection.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "# Get spike timings\n",
    "spikes = \n",
    "\n",
    "# What does this look like? \n",
    "print(spikes)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This dataset contains units recorded from layer 2 of the medial entorhinal cortex. This brain region has neurons that fire periodically in space, forming a grid-like pattern in the environment. These cells are called *grid cells*, and their discovery was the basis of the Nobel Prize in Physiology in the year 2014!\n",
    "\n",
    "To examine the activity of these cells, we plot their firing rate as a function of the animal's position. This plot is referred to as a 'tuning curve'. To plot tuning curves, we need the spike timings and the position information of the animal. \n",
    "\n",
    "Let's look at the position of the animal:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "position = data[\"SpatialSeriesLED1\"]\n",
    "\n",
    "# What does this look like? \n",
    "print(position)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Computing tuning curves in Pynapple takes just a single line of code! \n",
    "\n",
    "**Note**: Position is a 2-dimensional variable, so use the right tuning curve function! \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "# Compute the tuning curves \n",
    "\n",
    "tuning_curves, xybins = "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you print the variable above, you will discover a 2-dimensional histogram of spikes binned according to the X- and Y- positions, for each unit.\n",
    "\n",
    "Let's now visualize the tuning curves:\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "# Plot the tuning curves \n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "These units all have periodic firing patterns that span, or *tesselate* the square recording arena. They are typical examples of grid cells.\n",
    "\n",
    "Now, let's plot the trajectory of the animal, and overlay the spike timings of the second unit (which has a nice *grid field*). This way, we can appreciate the periodic firing patterns of grid cells just by visualizing the raw data!\n",
    "\n",
    "**Hint**: We need to use a Pynapple function that would help determine the closest position in the time support for each spike."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "#Plot the trajectory of the animal and overlay the spike timings of the second unit\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This plot verifies what we visualized in the grid cell tuning curves above, that this cell has a periodic firing pattern that tesselates the recording arena. Therefore, this is a grid cell!\n",
    "\n",
    "I hope this tutorial was helpful. If you have any questions, comments or suggestions, please feel free to reach out to the Pynapple Team!"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.10.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}