NetPyNE_tut1_simple_network.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "NetPyNE_EBRAINS_tut1.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "toc_visible": true
    },
    "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.8.2"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HZFPWWNxEozc"
      },
      "source": [
        "# NetPyNE EBRAINS Tutorial 1: Simulating a simple network"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EsSKL_dRE6_0"
      },
      "source": [
        "In this tutorial, we will create a simple network model we can simulate. The model will consist of 40 pyramidal-like, two-compartment neurons with standard Hodgkin-Huxley dynamics in the somas and passive dynamics in the dendrites. We will connect the neurons randomly with a 10% probability of connection using a standard double-exponential synapse model. Finally, we will add a current clamp stimulus to one cell to activate the network. Then we will explore the model."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LIhuiXkEEOaJ"
      },
      "source": [
        "## Install NEURON and NetPyNE"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Gq9ZnXtlPjub"
      },
      "source": [
        "We will use **pip** to install NEURON and NetPyNE."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mYV8uF8sEVRR"
      },
      "source": [
        "!pip install neuron\n",
        "!pip install netpyne"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jl2nrc-uEK4J"
      },
      "source": [
        "## Instantiate network parameters and simulation configuration"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ALX9AcIxELkk"
      },
      "source": [
        "You need two things to define a model/simulation in NetPyNE: 1) the parameters of the network and all its components (**netParams**) and 2) the configuration of the simulation (**simConfig**).  These requirements exist as objects in NetPyNE.  Let's instantiate them now."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "b3u6onuhNMCy"
      },
      "source": [
        "from netpyne import specs, sim\n",
        "netParams = specs.NetParams()\n",
        "simConfig = specs.SimConfig()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "m4W4av8nNXNR"
      },
      "source": [
        "Now we are going to specify our model: a simple network of 40 pyramidal-like two-compartment neurons with standard Hodgkin-Huxley dynamics in the soma and passive dynamics in the dendrite."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "j8KLTVVxNkXv"
      },
      "source": [
        "## Specify a cell model"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bOPkiH7dNonu"
      },
      "source": [
        "First we will add a cell type to our model by adding a dictionary named **pyr** to the *Cell Parameters* dictionary (**cellParams**) in the *Network Parameters* dictionary (**netParams**).  We will then add an empty dictionary named **secs** to hold our compartments."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_JoTgRmhNRm6"
      },
      "source": [
        "netParams.cellParams['pyr'] = {}\n",
        "netParams.cellParams['pyr']['secs'] = {}"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rlex7LioN1fu"
      },
      "source": [
        "### Specify the soma compartment properties\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wpV-7o4NN2YN"
      },
      "source": [
        "Now we will define our **soma**, by adding a **geom** dictionary defining the geometry of the soma and a **mechs** dictionary defining the biophysical mechanics being added to the soma."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qrEjGWwwNxPA"
      },
      "source": [
        "netParams.cellParams['pyr']['secs']['soma'] = {}"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "o1NQacsIN9Uc"
      },
      "source": [
        "netParams.cellParams['pyr']['secs']['soma']['geom'] = {\n",
        "    \"diam\": 12,\n",
        "    \"L\": 12,\n",
        "    \"Ra\": 100.0,\n",
        "    \"cm\": 1\n",
        "    }"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZEc3mV_UOASS"
      },
      "source": [
        "netParams.cellParams['pyr']['secs']['soma']['mechs'] = {\"hh\": {\n",
        "    \"gnabar\": 0.12,\n",
        "    \"gkbar\": 0.036,\n",
        "    \"gl\": 0.0003,\n",
        "    \"el\": -54.3\n",
        "    }}"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "djBCFHzrOJ9i"
      },
      "source": [
        "The **hh** mechanism is builtin to NEURON, but you can see its *.mod* file here:\n",
        "https://github.com/neuronsimulator/nrn/blob/master/src/nrnoc/hh.mod\n",
        "\n",
        "It is the original Hodgkin-Huxley treatment for the set of sodium, potassium, and leakage channels found in the squid giant axon membrane."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8QJuWmfaOOJP"
      },
      "source": [
        "### Specify the dendrite compartment properties\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mI2lIZtjOPGY"
      },
      "source": [
        "Next will do the same thing for the dendrite compartment, but we will do it slightly differently.  We will first build up a **dend** dictionary and then add it to the cell model dictionary **pyr** when we are done."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QnUvVve2OE-L"
      },
      "source": [
        "dend = {}"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "uLC6urqEOUKm"
      },
      "source": [
        "dend['geom'] = {\"diam\": 1.0,\n",
        "                \"L\": 200.0,\n",
        "                \"Ra\": 100.0,\n",
        "                \"cm\": 1,\n",
        "               }"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VuNCZNFNOW4m"
      },
      "source": [
        "dend['mechs'] = {\"pas\": \n",
        "                    {\"g\": 0.001,\n",
        "                     \"e\": -70}\n",
        "                }"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SyhGANVhOgR5"
      },
      "source": [
        "The **pas** mechanim is a simple leakage channel and is builtin to NEURON.  Its *.mod* file is available here:\n",
        "https://github.com/neuronsimulator/nrn/blob/master/src/nrnoc/passive.mod\n",
        "\n",
        "In order to connect the dendrite compartment to the soma compartment, we must add a **topol** dictionary to our **dend** dictionary."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Gm5p0r8kOZsy"
      },
      "source": [
        "dend['topol'] = {\"parentSec\": \"soma\",\n",
        "                 \"parentX\": 1.0,\n",
        "                 \"childX\": 0,\n",
        "                }"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9PaXF7DAOnip"
      },
      "source": [
        "With our **dend** section dictionary complete, we must now add it to the **pyr** cell dictionary."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1veMTubgOj6g"
      },
      "source": [
        "netParams.cellParams['pyr']['secs']['dend'] = dend"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "67JEURREOr6B"
      },
      "source": [
        "Our two-compartment cell model is now completely specified.  Our next step is to create a population of these cells."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KCWwp0wWOuSh"
      },
      "source": [
        "## Specify a population of cells\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4ywQnIPoOvOT"
      },
      "source": [
        "NetPyNE uses *populations* of cells to specify connectivity.  In this tutorial, we will create just one population which we will call **E** (for excitatory).  It will be made of the **pyr** cells we just specified, and we want 40 of them."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-wggC6nyOp1I"
      },
      "source": [
        "netParams.popParams['E'] = {\n",
        "    \"cellType\": \"pyr\",\n",
        "    \"numCells\": 40,\n",
        "}"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2AH2dJPPO2ag"
      },
      "source": [
        "## Specify a synaptic model\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YDynbArYO3hJ"
      },
      "source": [
        "We need a synaptic mechanism to connect our cells with.  We will create one called **exc** by adding a dictionary to the *synaptic mechanism parameters* dictionary (**synMechParams**).  The synapse *mod* used (**Exp2Syn**) is a simple double-exponential which is builtin to NEURON.  It's *.mod* file is available here:\n",
        "https://github.com/neuronsimulator/nrn/blob/master/src/nrnoc/exp2syn.mod"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "eyx8AZk5O0JW"
      },
      "source": [
        "netParams.synMechParams['exc'] = {\n",
        "    \"mod\": \"Exp2Syn\",\n",
        "    \"tau1\": 0.1,\n",
        "    \"tau2\": 1.0,\n",
        "    \"e\": 0\n",
        "}"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ms7OJIcTPCgQ"
      },
      "source": [
        "## Specify the connectivity\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0tRNXK9lPDNz"
      },
      "source": [
        "Now we will specify the connectivity in our model by adding an entry to the **connParams** dictionary.  We will call our connectivity rule **E->E** as it will define connectivity from our **E** population to our **E** population.\n",
        "\n",
        "We will use the *synMech* **exc**, which we defined above.  For this synaptic mechanism, a *weight* of about **0.005** is appropriate.  These cells will have a 10% probability of getting connected, and will be activated five milliseconds after an action potential occurs in the presynaptic cell.  Synapses will occur on the **dend** *section* at its very end (*location* **1.0**)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "s3YGPtw1PAHy"
      },
      "source": [
        "netParams.connParams['E->E'] = {\n",
        "    \"preConds\": {\"pop\": \"E\"},\n",
        "    \"postConds\": {\"pop\": \"E\"},\n",
        "    \"weight\": 0.005,\n",
        "    \"probability\": 0.1,\n",
        "    \"delay\": 5.0,\n",
        "    \"synMech\": \"exc\",\n",
        "    \"sec\": \"dend\",\n",
        "    \"loc\": 1.0,\n",
        "}"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZMkGcFHDPLzU"
      },
      "source": [
        "## Set up the simulation configuration"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vUit_vcvPI9Q"
      },
      "source": [
        "simConfig.filename = \"netpyne_tut1\"\n",
        "simConfig.duration = 200.0\n",
        "simConfig.dt = 0.1"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "k99wj1rfPSBR"
      },
      "source": [
        "We will record from from the first cell (**0**) and we will record the voltage in the middle of the soma and the end of the dendrite."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hnySg4EnPQPm"
      },
      "source": [
        "simConfig.recordCells = [0]\n",
        "simConfig.recordTraces = {\n",
        "    \"V_soma\": {\n",
        "        \"sec\": \"soma\",\n",
        "        \"loc\": 0.5,\n",
        "        \"var\": \"v\",\n",
        "    },\n",
        "    \"V_dend\": {\n",
        "        \"sec\": \"dend\",\n",
        "        \"loc\": 1.0,\n",
        "        \"var\": \"v\",\n",
        "    }\n",
        "}"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "90JxAxiOPXiP"
      },
      "source": [
        "Finally we will set up some plots to be automatically generated and saved."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZlGE85YUPVWT"
      },
      "source": [
        "simConfig.analysis = {\n",
        "    \"plotTraces\": {\n",
        "        \"include\": [0],\n",
        "        \"saveFig\": True,\n",
        "    },\n",
        "    \"plotRaster\": {\n",
        "        \"saveFig\": True,\n",
        "    }\n",
        "}"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bov32kaoP2Vz"
      },
      "source": [
        "## Create, simulate, and analyze the model\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "U8dG1xMi5SNy"
      },
      "source": [
        "The command `%matplotlib inline` allows figures to be shown in this notebook."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6TOOw3g55aF_"
      },
      "source": [
        "%matplotlib inline"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "j81xP_F_P3mK"
      },
      "source": [
        "Use one simple command to create, simulate, and analyze the model."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lNrM2UmtPbiT"
      },
      "source": [
        "sim.createSimulateAnalyze(netParams=netParams, simConfig=simConfig)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "t3DDYDY1QxGz"
      },
      "source": [
        "We can see that there was no spiking in the network, and thus the spike raster was not plotted.  But there should be one new file in your directory: **netpyne_tut1_traces.png**.  Take a look.  Not too interesting, the cell just settles into its resting membrane potential.\n",
        "\n",
        "Let's overlay the traces.  You can see all the options available for **plotTraces** here: http://netpyne.org/netpyne.analysis.traces.html#netpyne.analysis.traces.plotTraces\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "E98_BnQ8P7Xu"
      },
      "source": [
        "sim.analysis.plotTraces(overlay=True);"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FFCgpfXnQ_0A"
      },
      "source": [
        "## Explore the model"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lb2CL6KLRDeK"
      },
      "source": [
        "### Plot the 2D connectivity of the network"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Uk3USecxRGjB"
      },
      "source": [
        "Now we can take a look at the physical layout of our network model.  You can see all the options available for **plot2Dnet** here:\n",
        "http://netpyne.org/netpyne.analysis.network.html#netpyne.analysis.network.plot2Dnet"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9XTkQE1wQ38e"
      },
      "source": [
        "sim.analysis.plot2Dnet();"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uro0E4o1RScq"
      },
      "source": [
        "### Plot the connectivity matrix\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4hgKkReTRTR8"
      },
      "source": [
        "You can see all the options available for **plotConn** here:\n",
        "http://netpyne.org/netpyne.analysis.network.html#netpyne.analysis.network.plotConn"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8LGEpe5gRNCP"
      },
      "source": [
        "sim.analysis.plotConn();"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yik3rBcmRbKu"
      },
      "source": [
        "Not very interesting with just one population, but we can also look at the cellular level connectivity."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DzgzP7weRYlC"
      },
      "source": [
        "sim.analysis.plotConn(feature='weight', groupBy='cell');"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZuDnPRgnRnrv"
      },
      "source": [
        "## Add a stimulation\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VkP-GCicRofc"
      },
      "source": [
        "We'll need to kickstart this network to see some activity -- let's inject current into one of the cells.  First we need to add an entry to the *Stimulation Source Parameters* dictionary (**stimSourceParams**).  We'll call our stimulation **IClamp1**, and we'll use the standard NEURON *type*: **IClamp**.  The current injection will last for a *duration* of 20 ms, it will start at a *delay* of 5 ms, and it will have an *amplitude* of 0.1 nanoAmps. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VYud_OWPRd4_"
      },
      "source": [
        "netParams.stimSourceParams['IClamp1'] = {\n",
        "    \"type\": \"IClamp\",\n",
        "    \"dur\": 5,\n",
        "    \"del\": 20,\n",
        "    \"amp\": 0.1,\n",
        "}"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nhWVRby-RyPR"
      },
      "source": [
        "Now we need to add a target for our stimulation.  We do that by adding a dictionary to the *Stimulation Target Parameters* dictionary (**stimTargetParams**).  We'll call this connectivity rule **IClamp1->cell0**, because it will go from the source we just created (**IClamp1**) and the first cell in our population.  The stimulation (current injection in this case) will occur in our **dend** *section* at the very tip (*location* of **1.0**)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nCQDb148Ruck"
      },
      "source": [
        "netParams.stimTargetParams['IClamp1->cell0'] = {\n",
        "    \"source\": \"IClamp1\",\n",
        "    \"conds\": {\"cellList\": [0]},\n",
        "    \"sec\": \"dend\",\n",
        "    \"loc\": 1.0,\n",
        "}"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_PbhoEk2SErC"
      },
      "source": [
        "Now we can re-run the simulation."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MM-WlZP-R0XA"
      },
      "source": [
        "sim.createSimulateAnalyze(netParams=netParams, simConfig=simConfig)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TNN1Tb7RSR0s"
      },
      "source": [
        "Now we see spiking in the network, and the raster plot appears.  Let's improve the plots a little bit."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GciqodwiSG1G"
      },
      "source": [
        "sim.analysis.plotTraces(overlay=True);"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vabK1mCWSVUq"
      },
      "source": [
        "sim.analysis.plotRaster(marker='o', markerSize=50);"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "N8vACernS6vB"
      },
      "source": [
        "## Record and plot a variety of traces\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "12NOAp6uTDfm"
      },
      "source": [
        "Now let's explore the model by recording and plotting a variety of traces.  First let's clear our **recordTraces** dictionary and turn off the automatic raster plot."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "W03sHekMShTD"
      },
      "source": [
        "simConfig.recordTraces = {}\n",
        "simConfig.analysis['plotRaster'] = False"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RiACDbsSTK-E"
      },
      "source": [
        "### Record and plot the somatic conductances\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "okha2e6qTM2H"
      },
      "source": [
        "Let's record and plot the somatic conductances.  We need to take a look at the **hh** mod file to see what the variables are called.  The file is available here: https://github.com/neuronsimulator/nrn/blob/master/src/nrnoc/hh.mod\n",
        "\n",
        "We can see that the conductances are called *gna*, *gk*, and *gl*.  Let's set up recording for these conductances in the middle of the soma."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "h6ujyVeiTIR1"
      },
      "source": [
        "simConfig.recordTraces['gNa'] = {'sec': 'soma', 'loc': 0.5, 'mech': 'hh', 'var': 'gna'}\n",
        "simConfig.recordTraces['gK'] = {'sec': 'soma', 'loc': 0.5, 'mech': 'hh', 'var': 'gk'}\n",
        "simConfig.recordTraces['gL'] = {'sec': 'soma', 'loc': 0.5, 'mech': 'hh', 'var': 'gl'}"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "n2asw_OGTTvJ"
      },
      "source": [
        "Then we can re-run the simulation."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VNBf-o3kTTEy"
      },
      "source": [
        "sim.createSimulateAnalyze(netParams=netParams, simConfig=simConfig)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Fmy-PVTNTe0l"
      },
      "source": [
        "Let's zoom in on one spike and overylay the traces."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WBUXgh2cTXNV"
      },
      "source": [
        "sim.analysis.plotTraces(timeRange=[90, 110], overlay=True);"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ED_WB0-VTpFz"
      },
      "source": [
        "### Record from synapses"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7mWPDfhxTroO"
      },
      "source": [
        "Our synapses are set up to use **Exp2Syn**, which is builtin to NEURON.  Its mod file is available here: https://github.com/neuronsimulator/nrn/blob/master/src/nrnoc/exp2syn.mod\n",
        "\n",
        "Looking in the file, we can see that its current variable is called **i**.  Let's record that and the voltages in the dendrite and soma."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9pccQhfAThpz"
      },
      "source": [
        "simConfig.recordTraces = {}\n",
        "simConfig.recordTraces['iSyn0'] = {'sec': 'dend', 'loc': 1.0, 'synMech': 'exc', 'var': 'i'}\n",
        "simConfig.recordTraces['V_dend'] = {'sec': 'dend', 'loc': 1.0, 'var': 'v'}\n",
        "simConfig.recordTraces['V_soma'] = {'sec': 'soma', 'loc': 0.5, 'var': 'v'}"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "e2dXHf_VTx7e"
      },
      "source": [
        "sim.createSimulateAnalyze(netParams=netParams, simConfig=simConfig)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dzPOoU_qDyAe"
      },
      "source": [
        "That's the first synapse created in that location, but there are likely multiple synapses.  Let's plot all the synaptic currents entering cell 0.  First we need to see what they are.  The network is defined in **sim.net**.  Type in *sim.net.* and then push *Tab* to see what's available.\n",
        "\n",
        "The data for cell 0 is in **sim.net.allCells[0]**."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yuaxU0Z8T2fc"
      },
      "source": [
        "sim.net.allCells[0].keys()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3ZRJp8v8D-Qy"
      },
      "source": [
        "The connections coming onto the cell are in the **conns** dictionary."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "go8gYRqHD4Yt"
      },
      "source": [
        "sim.net.allCells[0]['conns']"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pemVfeg7EMUl"
      },
      "source": [
        "So we want to record six synaptic currents.  Lets do that in a *for loop* at the same time creating a dictionary to hold the synaptic trace names as keys (and later the trace arrays as values)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fz-lgK7BECcv"
      },
      "source": [
        "simConfig.recordTraces = {}\n",
        "simConfig.recordTraces['V_soma'] = {'sec': 'soma', 'loc': 0.5, 'var': 'v'}\n",
        "simConfig.recordTraces['V_dend'] = {'sec': 'dend', 'loc': 1.0, 'var': 'v'}\n",
        "\n",
        "syn_plots = {}\n",
        "for index, presyn in enumerate(sim.net.allCells[0]['conns']):    \n",
        "    trace_name = 'i_syn_' + str(presyn['preGid'])\n",
        "    syn_plots[trace_name] = None \n",
        "    simConfig.recordTraces[trace_name] = {'sec': 'dend', 'loc': 1.0, 'synMech': 'exc', 'var': 'i', 'index': index}"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Ed7ol9_0EhHb"
      },
      "source": [
        "Let's take a look at our **recordTraces** dictionary now."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WtKSCwjwERl1"
      },
      "source": [
        "simConfig.recordTraces"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5xCF2e8GEto2"
      },
      "source": [
        "Now we'll run the simulation again so that these traces get recorded."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qyVTLamiEWmy"
      },
      "source": [
        "sim.createSimulateAnalyze(netParams=netParams, simConfig=simConfig)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "heaQJJrhE8Y6"
      },
      "source": [
        "## Extracting recorded data\n",
        "\n",
        "Let's make our synaptic currents plot nicer.  We'll make a figure with two plots, the top one will be the somatic and dendritic voltage and the bottom plot will be all of the synaptic currents overlaid.\n",
        "\n",
        "First we'll have to extract the data.  Simulation data gets stored in the dictionary **sim.allSimData**."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "P87eEEtTEy4_"
      },
      "source": [
        "sim.allSimData.keys()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ybgQdEtQFHvL"
      },
      "source": [
        "**spkt** is an array of the times of all spikes in the network.  **spkid** is an array of the universal index (GID) of the cell spiking.   **t** is an array of the time for traces.  Our traces appear as we named them, and each is a dictionary with its key being **cell_GID** and its value being the array of the trace."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IqSWZYRzFBN4"
      },
      "source": [
        "sim.allSimData.V_soma.keys()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NgRZqz5gFTuS"
      },
      "source": [
        "So let's extract our data."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FiXRLSS6FQT-"
      },
      "source": [
        "time = sim.allSimData['t']\n",
        "v_soma = sim.allSimData['V_soma']['cell_0']\n",
        "v_dend = sim.allSimData['V_dend']['cell_0']\n",
        "\n",
        "for syn_plot in syn_plots:\n",
        "    syn_plots[syn_plot] = sim.allSimData[syn_plot]['cell_0']"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eeR0rZhhFb3E"
      },
      "source": [
        "And now we can make our custom plot."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "H0RBievCFWh8"
      },
      "source": [
        "import matplotlib.pyplot as plt\n",
        "fig = plt.figure(figsize=[10, 8])\n",
        "\n",
        "plt.subplot(211)\n",
        "plt.plot(time, v_soma, label='v_soma')\n",
        "plt.plot(time, v_dend, label='v_dend')\n",
        "plt.legend()\n",
        "plt.xlabel('Time (ms)')\n",
        "plt.ylabel('Membrane potential (mV)')\n",
        "\n",
        "plt.subplot(212)\n",
        "for syn_plot in syn_plots:\n",
        "    plt.plot(time, syn_plots[syn_plot], label=syn_plot)\n",
        "plt.legend()\n",
        "plt.xlabel('Time (ms)')\n",
        "plt.ylabel('Synaptic current (nA)')\n",
        "\n",
        "plt.savefig('syn_currents.jpg', dpi=600)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6B2Idoo9GNL8"
      },
      "source": [
        "Congratulations!  You have simulated a network model by specifying parameters for cells, populations, synapses, connectivity, stimulations, and recording.  You explored some basic analyses and extracted data to make a custom plot.  "
      ]
    }
  ]
}