{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Measuring Synaptic Short Term Plasticity\n",
    "\n",
    "In this notebook we use the [Allen Institute synaptic physiology dataset](https://portal.brain-map.org/explore/connectivity/synaptic-physiology) to measure short term plasticity and its relationship to cell subclass.\n",
    "\n",
    "For an introduction to the Jupyter Notebook interface interface, try [Codeacademy: How To Use Jupyter Notebooks]( https://www.codecademy.com/articles/how-to-use-jupyter-notebooks) or [Jupyter Notebook Quick Start Guide](https://jupyter-notebook-beginner-guide.readthedocs.io/en/latest/what_is_jupyter.html).\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import scipy.stats\n",
    "from aisynphys.database import SynphysDatabase\n",
    "from aisynphys.cell_class import CellClass, classify_cells, classify_pairs\n",
    "from aisynphys.connectivity import measure_connectivity, pair_was_probed"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1. Load the data\n",
    "\n",
    "First, load up the \"small\" database from release 1.0 and query all cell `pairs` for mouse projects."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loaded 1368 synapses\n"
     ]
    }
   ],
   "source": [
    "# Download and cache the sqlite file for the requested database\n",
    "#   (for available versions, see SynphysDatabase.list_versions)\n",
    "db = SynphysDatabase.load_version('synphys_r1.0_2019-08-29_small.sqlite')\n",
    "\n",
    "# Load all synapses associated with mouse V1 projects\n",
    "pairs = db.pair_query(\n",
    "    project_name=[\"mouse V1 coarse matrix\", \"mouse V1 pre-production\"],\n",
    "    synapse=True,\n",
    ").all()\n",
    "\n",
    "print(\"loaded %d synapses\" % len(pairs))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Classify cells\n",
    "\n",
    "We will pick four simple class defintions for this analysis:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "cell_classes = {\n",
    "    'pyr': CellClass(cell_class='ex', name='pyr'),\n",
    "    'pvalb': CellClass(cre_type='pvalb', name='pvalb'),\n",
    "    'sst': CellClass(cre_type='sst', name='sst'),\n",
    "    'vip': CellClass(cre_type='vip', name='vip'),\n",
    "}   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# get a list of all cells in the selected pairs\n",
    "cells = set([pair.pre_cell for pair in pairs] + [pair.post_cell for pair in pairs])\n",
    "\n",
    "# Classify each cell. Note that, depending on the class definitions above, a cell could \n",
    "# belong to multiple classes. \n",
    "cell_class = {}\n",
    "for cell in cells:\n",
    "    # which of the classes defined above is this cell a member of?\n",
    "    cell_in_classes = [cls_name for cls_name, cls in cell_classes.items() if cell in cls]\n",
    "    cell_class[cell] = ','.join(cell_in_classes)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. Construct a dataframe\n",
    "\n",
    "Now we build a dataframe with one row per synapse that contains the pre/postsynaptic cell class names as well as a measure of short-term plasticity."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>pair</th>\n",
       "      <th>pre_class</th>\n",
       "      <th>post_class</th>\n",
       "      <th>stp</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>&lt;pair 1492460382.776 4 6&gt;</td>\n",
       "      <td>pyr</td>\n",
       "      <td>pyr</td>\n",
       "      <td>-0.084996</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>&lt;pair 1490997794.081 8 2&gt;</td>\n",
       "      <td>sst</td>\n",
       "      <td>vip</td>\n",
       "      <td>0.367114</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>&lt;pair 1490997794.081 8 7&gt;</td>\n",
       "      <td>sst</td>\n",
       "      <td>vip</td>\n",
       "      <td>0.323405</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>&lt;pair 1501101571.166 1 5&gt;</td>\n",
       "      <td>pyr</td>\n",
       "      <td>pyr</td>\n",
       "      <td>-0.114559</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>16</th>\n",
       "      <td>&lt;pair 1484862803.120 1 7&gt;</td>\n",
       "      <td>pvalb</td>\n",
       "      <td>pvalb</td>\n",
       "      <td>-0.347905</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                         pair pre_class post_class       stp\n",
       "2   <pair 1492460382.776 4 6>       pyr        pyr -0.084996\n",
       "7   <pair 1490997794.081 8 2>       sst        vip  0.367114\n",
       "8   <pair 1490997794.081 8 7>       sst        vip  0.323405\n",
       "9   <pair 1501101571.166 1 5>       pyr        pyr -0.114559\n",
       "16  <pair 1484862803.120 1 7>     pvalb      pvalb -0.347905"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import pandas\n",
    "\n",
    "# construct a pandas dataframe containing the pre/postsynaptic cell class names\n",
    "# and a measure of short-term plasticity\n",
    "pre_class = [cell_class[pair.pre_cell] for pair in pairs]\n",
    "post_class = [cell_class[pair.post_cell] for pair in pairs]\n",
    "stp = [None if pair.dynamics is None else pair.dynamics.stp_induction_50hz for pair in pairs]\n",
    "\n",
    "df = pandas.DataFrame(\n",
    "    zip(pairs, pre_class, post_class, stp), \n",
    "    columns=['pair', 'pre_class', 'post_class', 'stp']) \n",
    "\n",
    "# select out only cells that are a member of exactly 1 class\n",
    "mask = df.pre_class.isin(cell_classes) & df.post_class.isin(cell_classes)\n",
    "df = df[mask]\n",
    "\n",
    "# select only pairs with a measured stp\n",
    "df = df.dropna()\n",
    "\n",
    "df.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4. Calculate average STP metric for each pre/post pairing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th>post_class</th>\n",
       "      <th>pyr</th>\n",
       "      <th>pvalb</th>\n",
       "      <th>sst</th>\n",
       "      <th>vip</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>pre_class</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>pyr</th>\n",
       "      <td>-0.273996</td>\n",
       "      <td>-0.185856</td>\n",
       "      <td>0.165965</td>\n",
       "      <td>-0.007874</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>pvalb</th>\n",
       "      <td>-0.455301</td>\n",
       "      <td>-0.365362</td>\n",
       "      <td>-0.423736</td>\n",
       "      <td>-0.327010</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>sst</th>\n",
       "      <td>-0.137356</td>\n",
       "      <td>-0.130458</td>\n",
       "      <td>-0.147765</td>\n",
       "      <td>0.132345</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>vip</th>\n",
       "      <td>-0.008266</td>\n",
       "      <td>-0.066462</td>\n",
       "      <td>-0.096198</td>\n",
       "      <td>-0.128896</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "post_class       pyr     pvalb       sst       vip\n",
       "pre_class                                         \n",
       "pyr        -0.273996 -0.185856  0.165965 -0.007874\n",
       "pvalb      -0.455301 -0.365362 -0.423736 -0.327010\n",
       "sst        -0.137356 -0.130458 -0.147765  0.132345\n",
       "vip        -0.008266 -0.066462 -0.096198 -0.128896"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "stp = df.pivot_table('stp', 'pre_class', 'post_class', aggfunc=np.mean)\n",
    "\n",
    "# sort rows/cols into the expected order\n",
    "order = list(cell_classes)\n",
    "stp = stp[order].loc[order]\n",
    "\n",
    "stp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x432 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "%matplotlib inline\n",
    "\n",
    "fig,ax = plt.subplots(figsize=(8, 6))\n",
    "\n",
    "hm = sns.heatmap(stp, cmap='coolwarm', vmin=-0.4, vmax=0.4, square=True, ax=ax,\n",
    "                cbar_kws={\"ticks\":[-0.3, 0, 0.3], 'label': '<-- depressing       facilitating -->'})\n",
    "\n",
    "fig.suptitle(\"50 Hz Train-induced STP\", fontsize=16)\n",
    "hm.set_xlabel(\"postsynaptic\", fontsize=14)\n",
    "hm.set_ylabel(\"presynaptic\", fontsize=14);\n",
    "hm.figure.axes[-1].yaxis.label.set_size(14)\n",
    "hm.tick_params(labelsize=12)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}