NetPyNE_tut2_importing_cell_models.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "NetPyNE_EBRAINS_tut2.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "toc_visible": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HZFPWWNxEozc"
      },
      "source": [
        "# NetPyNE EBRAINS Tutorial 2: Importing cell models\n",
        "\n",
        "***BEFORE RUNNING THIS NOTEBOOK, PLEASE SELECT THE 'EBRAINS_release_v0.1_202109' KERNEL FROM THE 'KERNEL -> CHANGE KERNEL' MENU***\n\n",
        "NetPyNE allows the importation of cell models previously defined in external files using the `importCellParams()` method. This method will convert all the cell information into the required NetPyNE format. This is also a way to make use of cell models which have been implemented separately.\n",
        "\n",
        "The `cellRule = netParams.importCellParams(label, conds, fileName, cellName, cellArgs={}, importSynMechs=False)` method takes as arguments the (arbitrary)label of the new cell rule, the name of the file where the cell is defined (`.py`, `.hoc`, or `.swc` files), and the name of the cell template (hoc) or cell class (Python).  If you wish to import the synaptic mechanisms parameters, you can set the `importSynMechs=True`.  The method returns the new cell rule so that it can be further modified.\n",
        "\n",
        "There are many existing cell models available for use, for example, at [ModelDB](hhttps://senselab.med.yale.edu/ModelDB/)).  In this tutorial, we will import a variety of cell models from different file types."
      ]
    },
    {
      "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": [
        "import matplotlib\n",
        "%matplotlib inline\n",
        "!pip install netpyne"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BjLSlJvvJfmp"
      },
      "source": [
        "## Get cells repository and compile mechanisms"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VCtcG6CtJnyn"
      },
      "source": [
        "First we need to get a local copy of the files defining our cell models.  We will do so by cloning a GitHub repository and then changing into that directory."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CgHiT9m7J03t"
      },
      "source": [
        "!git clone https://github.com/Neurosim-lab/netpyne_tutorials"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LHW7LGKDKem4"
      },
      "source": [
        "cd netpyne_tutorials"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0gHOeQnjJ-l5"
      },
      "source": [
        "The cell models require membrane mechanisms (e.g. channel models) that are not built-in to NEURON.  So, now we will compile the necessary mechanisms (in the `mod` directory) using `nrnivmodl`.  You can learn more about mechanisms and `.mod` files in the [NEURON documentation](https://www.neuron.yale.edu/neuron/static/py_doc/modelspec/programmatic/mechanisms/nmodl.html). "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HzRiVxt4Nk8M"
      },
      "source": [
        "!nrnivmodl mod"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IITT46g4NyFi"
      },
      "source": [
        "This should have created a new directory: `x86_64` which contains the compiled mechanisms NEURON can use."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jl2nrc-uEK4J"
      },
      "source": [
        "## Instantiate network parameters and simulation configuration\n",
        "\n"
      ]
    },
    {
      "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": "UslyhWdazxhG"
      },
      "source": [
        "The following line allows figures to be shown in this notebook:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UlmteR8dz2ii"
      },
      "source": [
        "%matplotlib inline"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "j8KLTVVxNkXv"
      },
      "source": [
        "## Import cell models\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bOPkiH7dNonu"
      },
      "source": [
        "### Import a NEURON cell model from a Python file\n",
        "\n",
        "Please open the file `HHCellFile.py` in the `cells` directory to see how this cell model is defined in NEURON/Python.  In particular, note that the cell model is defined in a class named `HHCellClass`.  This must be included as the `cellName` so that NetPyNE knows how to instantiate the model.\n",
        "\n",
        "Now we will import it into NetPyNE:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_JoTgRmhNRm6"
      },
      "source": [
        "cellRule = netParams.importCellParams(\n",
        "    label='python_model', \n",
        "    fileName='cells/HHCellFile.py', \n",
        "    cellName='HHCellClass', \n",
        "    importSynMechs=True,\n",
        "    )"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ftmrl7MlRogA"
      },
      "source": [
        "### Import a cell morphology from a HOC file"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "t1Tih4_G1h6S"
      },
      "source": [
        "Please open the file `geom.hoc` in the `cells` directory in a text-editor to see how this morphology is defined in a template named `E21`.  This must be included as the `cellName` so that NetPyNE knows how to instantiate the model.\n",
        "\n",
        "Note that this file just defines the morphology of a cell, not any membrane mechanisms."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QamR3wIcRt8o"
      },
      "source": [
        "cellRule = netParams.importCellParams(\n",
        "    label='hoc_morph', \n",
        "    fileName='cells/geom.hoc', \n",
        "    cellName='E21', \n",
        "    importSynMechs=False,\n",
        "    )"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yNvWTucZ2W_z"
      },
      "source": [
        "Because the file we are importing contains no mechanisms, just the cell's morphology, we will add the default NEURON Hodgkin-Huxley mechanism into the soma section and a passive leak current in all sections. \n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "W7SvEPDP2D3U"
      },
      "source": [
        "cellRule['secs']['soma']['mechs']['hh'] = {'gnabar': 0.12, 'gkbar': 0.036, 'gl': 0.003, 'el': -70}\n",
        "for secName in cellRule['secs']:\n",
        "    cellRule['secs'][secName]['mechs']['pas'] = {'g': 0.0000357, 'e': -70}\n",
        "    cellRule['secs'][secName]['geom']['cm'] = 1"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jjgdY2I0Pq13"
      },
      "source": [
        "### Import a cell morphology from an SWC file"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ghbsl13VSZxJ"
      },
      "source": [
        "Please open the file `BS0284.swc` in the `cells` directory in a text-editor to see how this morphology is defined.  SWC is a common file format for neuron morphology, but SWC files do not specify a complete cell model, they only define the morphology of a cell.  There are many experimentally reconstructed neuron morphologies available for download at [NeuroMorpho](https://neuromorpho.org)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AhdKorY_RGDe"
      },
      "source": [
        "cellRule = netParams.importCellParams(\n",
        "        label='swc_morph',\n",
        "        fileName='cells/BS0284.swc',\n",
        "        cellName='',\n",
        "        importSynMechs=False,\n",
        "        )"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vhGKlSkz4gN8"
      },
      "source": [
        "Because the file we are importing contains no mechanisms, just the cell's morphology, we will add the default NEURON Hodgkin-Huxley mechanism into the soma section and a passive leak current in all sections."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VsusUj2o4q_E"
      },
      "source": [
        "for secName in cellRule['secs']:\n",
        "    cellRule['secs'][secName]['mechs']['pas'] = {'g': 0.0000357, 'e': -70}\n",
        "    cellRule['secs'][secName]['geom']['cm'] = 1\n",
        "    if secName.startswith('soma'):\n",
        "        cellRule['secs'][secName]['mechs']['hh'] = {'gnabar': 0.12, 'gkbar': 0.036, 'gl': 0.003, 'el': -70}"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NINXSIof4xmh"
      },
      "source": [
        "If a morphology has multiple sections defining the soma, it is convenient for recording and analysis to rename the first soma section to just `soma`."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6M7Igi1D5ZbZ"
      },
      "source": [
        "netParams.renameCellParamsSec('swc_morph', 'soma_0', 'soma')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hNFLEyIR6N0B"
      },
      "source": [
        "### Import a complete cell model from a HOC file"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pbcscddf6mVa"
      },
      "source": [
        "Please open the file `pyr3_traub.hoc` in the `cells` directory in a text-editor to see how this model is defined in a template named `pyr3`.  This must be included as the `cellName` so that NetPyNE knows how to instantiate the model. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "liBgMVCc7ME9"
      },
      "source": [
        "cellRule = netParams.importCellParams(\n",
        "    label='hoc_model', \n",
        "    fileName='cells/pyr3_traub.hoc', \n",
        "    cellName='pyr3',\n",
        "    )"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AtG1MwBP4bh_"
      },
      "source": [
        "Looking in the file, we can see that the soma compartment is `comp[1]`, which becomes `comp_1` in NetPyNE.  We will rename this section for convenience."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "80fRbGDk4vgS"
      },
      "source": [
        "netParams.renameCellParamsSec('hoc_model', 'comp_1', 'soma')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_DBqHb-h7glx"
      },
      "source": [
        "## Make populations from the imported cell models"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "z7nT8Z9b0QGq"
      },
      "source": [
        "We'll make a population for each cell type, consisting of just one cell."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OL9UAoKr7vxv"
      },
      "source": [
        "netParams.popParams['python_pop'] = {'cellType': 'python_model', 'numCells': 1}\n",
        "netParams.popParams['hoc_morph_pop'] = {'cellType': 'hoc_morph', 'numCells': 1}\n",
        "netParams.popParams['swc_morph_pop'] = {'cellType': 'swc_morph', 'numCells': 1}\n",
        "netParams.popParams['hoc_model_pop'] = {'cellType': 'hoc_model', 'numCells': 1}"
      ],
      "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_tut2\"\n",
        "simConfig.duration = 200.0\n",
        "simConfig.dt = 0.1"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "k99wj1rfPSBR"
      },
      "source": [
        "We will record the voltage in the middle of the soma compartment for all cells."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hnySg4EnPQPm"
      },
      "source": [
        "simConfig.recordCells = ['all']\n",
        "simConfig.recordTraces = {\n",
        "    \"V_soma\": {\n",
        "        \"sec\": \"soma\",\n",
        "        \"loc\": 0.5,\n",
        "        \"var\": \"v\",\n",
        "    },\n",
        "}"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "90JxAxiOPXiP"
      },
      "source": [
        "Finally we will set up the traces plots to be automatically generated and saved."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZlGE85YUPVWT"
      },
      "source": [
        "simConfig.analysis = {\n",
        "    \"plotTraces\": {\n",
        "        \"include\": ['all'],\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": "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": "IX70EJYA-huW"
      },
      "source": [
        "## Visualize the cell models\n",
        "\n",
        "We can use the `plotShape` function to visualize the cells.  You can see all the options available for **plotShape** here:\n",
        "http://netpyne.org/reference.html#netpyne.analysis.plotShape"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "T8KenOky5Ebh"
      },
      "source": [
        "sim.analysis.plotShape(includePre=['python_pop'], includePost=['python_pop'], showFig=True)\n",
        "sim.analysis.plotShape(includePre=['hoc_morph_pop'], includePost=['hoc_morph_pop'], showFig=True)\n",
        "sim.analysis.plotShape(includePre=['swc_morph_pop'], includePost=['swc_morph_pop'], showFig=True)\n",
        "sim.analysis.plotShape(includePre=['hoc_model_pop'], includePost=['hoc_model_pop'], showFig=True)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6B2Idoo9GNL8"
      },
      "source": [
        "Congratulations!  You have imported existing cell models of a variety of types for use in simulations.\n",
        "\n",
        "There are several other NetPyNE tutorials available."
      ]
    }
  ]
}