Course.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "b34a40b5",
   "metadata": {},
   "source": [
    "# 1. Introduction\n",
    "\n",
    "In this part of the course you have to run numerical computations.\n",
    "This notebook contains cells of text (like this one) and also code-cells. You can execute\n",
    "them by selecting and then pressing \n",
    " - SHIFT+ENTER to execute the cell and jump to the next cell\n",
    " - or CTRL+ENTER to execute and stay in the cell.\n",
    " \n",
    "Run the Course from top to bottom by pressing SHIFT-ENTER. \n",
    "\n",
    "The parts of the code that you are supposed to change are surrounded by a lines of hashes (######).\n",
    "Subsequent code cells are folded into little dots and contain code that you do not need to inspect. (The code appears if you click on the dots. It can be collapsed again by clicking the colored bar left of the cell.)\n",
    "\n",
    "After editing the target cell, press SHIFT-ENTER twice to set your parameters and then run the computation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f518d1f2",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-01-16T16:18:45.172216Z",
     "start_time": "2022-01-16T16:18:45.159723Z"
    },
    "hide_input": false,
    "tags": []
   },
   "outputs": [],
   "source": [
    "# This code-cell always need to be excetuted first\n",
    "from brian2 import *\n",
    "from matplotlib import pyplot as plt\n",
    "%matplotlib ipympl\n",
    "print('Ok')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "82de8dd4",
   "metadata": {},
   "source": [
    "The Course contains the following sections:\n",
    "\n",
    "2. The Goldman (or GHK) equation determines a trans-membrane equilibrium potential. The GHK potential depends on ion specific conductances.\n",
    "   - Explore the GHK equation and how it relates to the individual Nernst potentials.\n",
    "   - Inspect the development of conductances in the HH model and estimate the GHK potential.\n",
    "3. The Cable model\n",
    "   - Compute a constant current injection in an axon.\n",
    "   - Explore the parameters and corresponding length constant of the model.\n",
    "4. The HH model\n",
    "   - Calculate the AP velocity for different parameters.\n",
    "   - Does the velocity relate to the length constant $\\lambda$ ?\n",
    "5. HH to investigate ion channels\n",
    "\n",
    "   \n",
    "# 2. Goldman equation"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b102457e",
   "metadata": {},
   "source": [
    "The transmembrane potential of a semipermeable membrane is dependent on the concentration [X] and permitivity $g_X$ of ions.\n",
    "When more than one ion species is considered around a semipermeable membrane the equilibrium potential is given by the Goldmann equation. Considering Sodium and Potassium, the Goldmann eq. is:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fd12665d",
   "metadata": {},
   "source": [
    "$$\n",
    "V_{m, GHK} ={\\frac  {RT}{F}}\\ln {\\left({\\frac  {g_{{{\\text{Na}}}}[{\\text{Na}}^{{+}}]_{{\\mathrm  {out}}}+g_{{{\\text{K}}}}[{\\text{K}}^{{+}}]_{{\\mathrm  {out}}}}{g_{{{\\text{Na}}}}[{\\text{Na}}^{{+}}]_{{\\mathrm  {in}}}+g_{{{\\text{K}}}}[{\\text{K}}^{{+}}]_{{{\\mathrm  {in}}}}}}\\right)}\n",
    "$$\n",
    "$$\n",
    "%V_m ={\\frac  {RT}{F}}\\ln {\\left({\\frac  {P_{{{\\text{Na}}}}[{\\text{Na}}^{{+}}]_{{\\mathrm  {out}}}+P_{{{\\text{K}}}}[{\\text{K}}^{{+}}]_{{\\mathrm  {out}}}+P_{{{\\text{Cl}}}}[{\\text{Cl}}^{{-}}]_{{\\mathrm  {in}}}}{P_{{{\\text{Na}}}}[{\\text{Na}}^{{+}}]_{{\\mathrm  {in}}}+P_{{{\\text{K}}}}[{\\text{K}}^{{+}}]_{{{\\mathrm  {in}}}}+P_{{{\\text{Cl}}}}[{\\text{Cl}}^{{-}}]_{{\\mathrm  {out}}}}}\\right)}\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "abda5872",
   "metadata": {},
   "source": [
    "## 2.1 Effect of opening channels\n",
    "In a HH model the membrane potential is controlled by the conductivities. The idea is that there are channels that open and allow specific ions to pass. When conductances change, the membrane strives towards a new equilibrium value, which is given by the GHK potential. \n",
    "\n",
    "First we define commen standard values for the conductivities and concentrations.\n",
    "Then you have to insert increasing conductance values. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f3d362e0",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-01-15T16:10:18.814468Z",
     "start_time": "2022-01-15T16:10:18.808181Z"
    },
    "code_folding": [],
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Common conductance values of a nerve fiber in the resting state\n",
    "g_Na_standard = 0.05\n",
    "g_K_standard = 1.0\n",
    "\n",
    "# Common values for ion concentrations (Arbitrary Units, the units cancel out in the GHK equation)\n",
    "Na_in_standard = 15\n",
    "Na_out_standard = 145\n",
    "K_in_standard = 140\n",
    "K_out_standard = 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d2c61311",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-01-15T16:07:47.074177Z",
     "start_time": "2022-01-15T16:07:47.069754Z"
    }
   },
   "outputs": [],
   "source": [
    "############################################## TODO ############################################## \n",
    "# The following values are plotted in the cell below.\n",
    "# Add more values to see how Vm changes.\n",
    "g_na_values = [0.05, 0.5]\n",
    "g_k_values = [1.0, 10]\n",
    "\n",
    "# Here you can overwrite the standard values for the concentrations\n",
    "# When no values are given, the standard values are used\n",
    "Ion_Concentrations = [\n",
    "    {'label': 'Standard'\n",
    "    },\n",
    "    #{'label': 'Decreased K_in',\n",
    "    # 'K_in': 1,\n",
    "    #},\n",
    "]\n",
    "##################################################################################################"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "22aa2ef7",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-01-15T16:10:18.814468Z",
     "start_time": "2022-01-15T16:10:18.808181Z"
    },
    "code_folding": [
     9,
     15
    ],
    "hide_input": true,
    "jupyter": {
     "source_hidden": true
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "def vm_goldmann(g_Na=g_Na_standard,\n",
    "                g_K=g_K_standard,\n",
    "                Na_in=Na_in_standard,\n",
    "                Na_out=Na_out_standard,\n",
    "                K_in=K_in_standard,\n",
    "                K_out=K_out_standard):\n",
    "    \"\"\"The Goldman-Hodgkin-Katz equation.\n",
    "       input: Conductivities and concentrations in arbitrary units.\n",
    "       returns: Vm in volt.\"\"\"\n",
    "\n",
    "    # RT/F at room temperature\n",
    "    prefactor = 26.7e-3  # Volt\n",
    "\n",
    "    # the conductivity weighted concentration ratio sum\n",
    "    gc_ratio = (g_Na*Na_out + g_K * K_out)/(g_Na*Na_in + g_K * K_in)\n",
    "\n",
    "    # Return the transmembrane potential\n",
    "    vm = prefactor * np.log(gc_ratio)\n",
    "    return vm\n",
    "\n",
    "fig, axs = plt.subplots(1, 2, figsize=(9, 5))\n",
    "g_Na_list = np.array(g_na_values)\n",
    "g_K_list = np.array(g_k_values) #np.logspace(np.log10(1), 3)\n",
    "\n",
    "for Ion_Concentration in Ion_Concentrations:\n",
    "    label = Ion_Concentration.pop('label')\n",
    "    axs[0].plot(g_Na_list, 1e3*vm_goldmann(g_Na=g_Na_list, **Ion_Concentration), 'o', label=label)\n",
    "    axs[1].plot(g_K_list, 1e3*vm_goldmann(g_K=g_K_list, **Ion_Concentration), 'o', label=label)\n",
    "\n",
    "axs[0].semilogx()\n",
    "axs[0].set_ylabel(\"$V_m (mV)$\")\n",
    "axs[0].set_title(\"$V_m$ with increasing $g_{Na}$\")\n",
    "axs[0].set_xlabel(\"$g_{Na}$\")\n",
    "axs[0].set_ylim(-100, 100)\n",
    "axs[0].grid()\n",
    "axs[0].legend()\n",
    "\n",
    "axs[1].semilogx()\n",
    "axs[1].set_ylabel(\"$V_m (mV)$\")\n",
    "axs[1].set_title(\"$V_m$ with increasing $g_{K}$\")\n",
    "axs[1].set_xlabel(\"$g_{K}$\")\n",
    "axs[1].set_ylim(-100, 100)\n",
    "axs[1].grid()\n",
    "axs[1].legend()\n",
    "\n",
    "fig.tight_layout()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "35112dfb-e056-47c0-b280-2d8ed9b3f742",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-01-15T16:07:49.186624Z",
     "start_time": "2022-01-15T16:07:48.858340Z"
    },
    "hide_input": false,
    "tags": []
   },
   "source": [
    "## 2.2 The full range of the Goldman equation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9eb32c02-2f86-4272-82ff-a967b3093826",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-01-15T16:07:49.186624Z",
     "start_time": "2022-01-15T16:07:48.858340Z"
    },
    "hide_input": false,
    "jupyter": {
     "source_hidden": true
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "g_Na_list = np.logspace(-3, 3)\n",
    "g_ratio_list = g_Na_list/g_K_standard\n",
    "fig, ax = plt.subplots(1,1,figsize=(9,5))\n",
    "ax.plot(g_ratio_list, 1e3*vm_goldmann(g_Na=g_ratio_list))\n",
    "\n",
    "ax.semilogx()\n",
    "ax.set_ylabel(\"$V_m (mV)$\")\n",
    "ax.set_title(\"$V_m$ as a continous function of $g_{Na} / g_K$\")\n",
    "ax.grid()\n",
    "ax.set_xlabel(\"$g_{Na}/g_K$\");\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1d56c39e-9b3a-4f5a-9d8b-6bd0abf5a4f8",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-01-15T16:51:50.434373Z",
     "start_time": "2022-01-15T16:51:46.248700Z"
    },
    "heading_collapsed": true,
    "hide_input": false,
    "tags": []
   },
   "source": [
    "## 2.3 Time course of conductivities in the HH model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0a8fda92-1c42-4065-9c04-0db1a1f60dbe",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-01-15T16:51:50.434373Z",
     "start_time": "2022-01-15T16:51:46.248700Z"
    },
    "hidden": true,
    "hide_input": false,
    "jupyter": {
     "source_hidden": true
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "from scipy import stats\n",
    "\n",
    "start_scope()\n",
    "defaultclock.dt = 0.02*ms\n",
    "\n",
    "morpho = Cylinder(length=10*cm, diameter=2*238*um, n=100)\n",
    "\n",
    "El = 10.613*mV\n",
    "\n",
    "ENa = 115*mV\n",
    "EK = -12*mV\n",
    "\n",
    "gl = 0.4*msiemens/cm**2\n",
    "gNa0 = 120*msiemens/cm**2\n",
    "gK = 36*msiemens/cm**2\n",
    "\n",
    "# HH equations\n",
    "eqs = '''\n",
    "Im = gl * (El-v) + gNa * m**3 * h * (ENa-v) + gK * n**4 * (EK-v) : amp/meter**2\n",
    "I : amp (point current) # applied current\n",
    "dm/dt = alpham * (1-m) - betam * m : 1\n",
    "dn/dt = alphan * (1-n) - betan * n : 1\n",
    "dh/dt = alphah * (1-h) - betah * h : 1\n",
    "alpham = (0.1/mV) * 10.0*mV/exprel((-v+25.0*mV)/(10.0*mV))/ms : Hz\n",
    "betam = 4 * exp(-v/(18.0*mV))/ms : Hz\n",
    "alphah = 0.07 * exp(-v/(20.0*mV))/ms : Hz\n",
    "betah = 1/(exp((-v+30.0*mV) / (10.0*mV)) + 1)/ms : Hz\n",
    "alphan = (0.01/mV) * 10.0*mV/exprel((-v+10.0*mV)/(10.0*mV))/ms : Hz\n",
    "betan = 0.125*exp(-v/(80.0*mV))/ms : Hz\n",
    "gNa : siemens/meter**2\n",
    "gNaTotal = gNa * m**3 *h : siemens/meter**2\n",
    "gKTotal = gK * n**4 : siemens/meter**2\n",
    "'''\n",
    "\n",
    "neuron = SpatialNeuron(morphology=morpho, model=eqs, method=\"exponential_euler\",\n",
    "                       #refractory=\"m > 0.4\", threshold=\"m > 0.5\",\n",
    "                       Cm=1*uF/cm**2, Ri=35.4*ohm*cm)\n",
    "neuron.v = 0*mV\n",
    "neuron.h = 1\n",
    "neuron.m = 0\n",
    "neuron.n = .5\n",
    "neuron.I = 0*amp\n",
    "neuron.gNa = gNa0\n",
    "\n",
    "M = StateMonitor(neuron, ('v', 'gNaTotal', 'gKTotal'), record=[50])\n",
    "\n",
    "la = neuron.space_constant[0]\n",
    "print('------------------- Running simulation ---------------------')\n",
    "print(\"Length constante: %s\" % la.in_best_unit(2))\n",
    "print(\"Time constante:\", (neuron.Cm[0]/gl).in_best_unit(2))\n",
    "print('------------------------  Start ----------------------------')\n",
    "\n",
    "run(20*ms, report='text')\n",
    "neuron.I[0] = 1*uA # current injection at one end\n",
    "run(3*ms)\n",
    "neuron.I = 0*amp\n",
    "run(30*ms, report='text')\n",
    "\n",
    "\n",
    "fig, ax = plt.subplots(1,1,figsize=(9,5))\n",
    "i = 0#50\n",
    "gNatot = M.gNaTotal.T[:, i]\n",
    "ax.plot(M.t/ms, M.gNaTotal.T[:, i]/(siemens/meter**2), label = '$g_{Na}$')\n",
    "ax.plot(M.t/ms, M.gKTotal.T[:, i]/(siemens/meter**2), label = '$g_{K}$')\n",
    "ax.set_ylabel('conductivity [siemens/m$^2$]')\n",
    "ax.set_xlabel('time')\n",
    "ax.legend()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "354c38c7",
   "metadata": {
    "hide_input": true
   },
   "source": [
    "# 3. Current injection at passive Cable"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "60a0ce7e",
   "metadata": {},
   "source": [
    "What happens when current is injected in a thin nerve fiber, how does the current spread?\n",
    "\n",
    "The answer is given by the core-conductor- or cable-model. \n",
    "It is a very general model that can be dated back to Lord Kelvin who derived it to describe transatlatic communication cables. Bioelectricity, e.g. in nerve fibers, obeys the same physical laws.\n",
    "\n",
    "In this model the ion species are not distinguished, there is just one current (of course still with a capacitive and a resistive component). We use a library called Brian to numerically solve the equations.\n",
    "\n",
    "The following code inject current at one end of a finite (not infinite) passive fiber. \n",
    "You may change capacity, Radius, leak conductivity etc.\n",
    "\n",
    "- Run the next code-cell to create a new figure. (SHIFT+ENTER)\n",
    "- Run the subsequent code-cell multiple times with different parameters and labels. (preferably use CTRL+ENTER)\n",
    "  (Run the first code-cell again) by selecting (click on it) and then pressing SHIFT+ENTER or CTRL+ENTER"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "804200e8",
   "metadata": {},
   "outputs": [],
   "source": [
    "# This code-cell creates a new empty figure\n",
    "# Re-run to clear figure\n",
    "fig, ax = plt.subplots(1,1, figsize=(9, 5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e1cb8208",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-01-15T16:16:56.907182Z",
     "start_time": "2022-01-15T16:16:56.904386Z"
    },
    "hide_input": false,
    "jupyter": {
     "source_hidden": true
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "############################################## TODO ##############################################\n",
    "# Define the list of parameters that are used\n",
    "# The following parameter pairs are used in the simulation below.\n",
    "# Add more value pairs to explore the cable model.\n",
    "# Format:    [Cm        , gL]\n",
    "label = 'standard'\n",
    "Cm = 1*uF/cm**2\n",
    "gL = 1e-4*siemens/cm**2\n",
    "diameter = 1*um\n",
    "##################################################################################################\n",
    "\n",
    "# Morphology\n",
    "length = 2*mm\n",
    "Ri = 150*ohm*cm\n",
    "N = 200\n",
    "\n",
    "# Passive channels\n",
    "EL = -70*mV\n",
    "eqs = '''\n",
    "Im = gL * (EL - v) : amp/meter**2\n",
    "I : amp (point current)\n",
    "'''\n",
    "\n",
    "start_scope()\n",
    "defaultclock.dt = 0.1*ms\n",
    "morpho = Cylinder(diameter=diameter, length=length, n=N)\n",
    "\n",
    "neuron = SpatialNeuron(morphology=morpho, model=eqs, Cm=Cm, Ri=Ri,\n",
    "                       method='exponential_euler')\n",
    "neuron.v = EL\n",
    "M = StateMonitor(neuron, 'v', record=[0, 50])\n",
    "\n",
    "\n",
    "print(\"%s:\" % label)\n",
    "print(\"Cm =\", Cm.in_best_unit(3))\n",
    "print(\"gL =\", gL)\n",
    "\n",
    "la = neuron.space_constant[0]\n",
    "print(\"Length constant = %s\" % la.in_best_unit(2))\n",
    "print(\"Length constant (theory) = %s\" % (sqrt(1/(gL*pi*diameter*Ri/(pi*(diameter/2)**2))).in_best_unit(2)))\n",
    "print(\"Time constant = %s\" % (Cm/gL).in_best_unit(2))\n",
    "\n",
    "# Currrent injection at one end\n",
    "neuron.I[0] = 0.02*nA\n",
    "\n",
    "# Running an plotting\n",
    "report = None\n",
    "run(.5*ms, report=report)\n",
    "run(4.5*ms, report=report)\n",
    "run(45*ms, report=report)\n",
    "\n",
    "ln = ax.plot(M.t/ms, M.v.T[:, 0]/mV, '-',\n",
    "             label=label+' '+str(neuron.morphology.distance[M.record[0]].in_best_unit(2)))\n",
    "ax.plot(M.t/ms, M.v.T[:, 1]/mV, '--', color=ln[0].get_color(),\n",
    "        label=label+' '+str(neuron.morphology.distance[M.record[1]].in_best_unit(2)))\n",
    "\n",
    "\n",
    "ax.legend(title=\"Position along the axon x (mm)\",\n",
    "          loc=\"best\", ncol=2)  # , label=x[M.record])\n",
    "ax.set_xlabel('Time since beginning of current injection (ms)')\n",
    "ax.set_ylabel('Membrane potential $V_m(x, t)$ (mV)')\n",
    "fig.tight_layout()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4daf58a6",
   "metadata": {},
   "source": [
    "# 4. HH Action Potential"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "91b5ff3b",
   "metadata": {},
   "source": [
    "An AP is a rapid and propagating jump in the transmembrane potential. There are many models to describe such a process.\n",
    "The most famous one is the HH model, which is a very detailed purely electrical model.\n",
    "In the first Section it was found that a change in ion specific permeabilities effects the membrane potential. \n",
    "\n",
    "The HH model uses the Goldman eq. and describes the permeabilities with \n",
    "voltage and time dependent expressions.\n",
    "It has more than 20 constant parameters and 3 internal variables (m, n, h).\n",
    "With so many parameters, various AP shapes can be reproduced.\n",
    "However, these properties can not be monitored or controlled so easily, and it is not reaally clear what m, n and h represent in an actual neuron.\n",
    "\n",
    "\n",
    "The following code simuates a HH AP along a long axon, and calculates the propagation velocity.\n",
    "\n",
    "- Run the following code by selecting (click on it) and then pressing SHIFT+ENTER or CTRL+ENTER\n",
    "- whats the AP velocity?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dc632162",
   "metadata": {},
   "source": [
    "The nerve is almost half a millimeter thick and still the AP speed is rather disenchanting (should be around 12 m/s)\n",
    "You have heard of myelin which wraps around axons and increases the AP propagation speed.\n",
    "We can include the insulating effect of myelin by decreasing the leak condictivity $g_L$.\n",
    "(Note, divide $g_L$ by 2 would double the so called Electrotonic length or \"length parameter\")\n",
    "\n",
    "- Try to make the AP double its speed by decresing $g_L$.\n",
    "  What is the relation between length parameter and propagation speed?\n",
    "\n",
    "- Change $C_m$ to reach the desired velocity.\n",
    "\n",
    "- Bonus for fun: Are there other ways to accelerate the AP?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "818bcc48",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-01-16T15:34:43.891120Z",
     "start_time": "2022-01-16T15:34:43.887779Z"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# The following parameter sets are used.\n",
    "HH_parameters = [\n",
    "    {\n",
    "    'Cm': 1 * uF / cm**2,\n",
    "    'Ri': 35.4 * ohm * cm,\n",
    "    'gl': 0.4 * msiemens / cm**2,\n",
    "    'diameter': 2 * 238 * um,\n",
    "    'label': 'Standard'\n",
    "    }, \n",
    "############################################## TODO ##############################################\n",
    "# Add more parameter sets to investigate the effect on the propagation velocity.\n",
    "    {\n",
    "    'Cm': 1 * uF / cm**2,\n",
    "    'Ri': 35.4 * ohm * cm,\n",
    "    'gl': 0.00004 * msiemens / cm**2,\n",
    "    'diameter': 2 * 238 * um,\n",
    "    'label': 'no leak'\n",
    "    },\n",
    "##################################################################################################\n",
    "]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6c497f35",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-01-16T15:34:53.831436Z",
     "start_time": "2022-01-16T15:34:44.847561Z"
    },
    "code_folding": [],
    "hide_input": false,
    "jupyter": {
     "source_hidden": true
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "from scipy import stats\n",
    "\n",
    "fig, ax = plt.subplots(1,1, figsize=(9,5))\n",
    "\n",
    "for HH_parameter in HH_parameters:\n",
    "    \n",
    "    Cm = HH_parameter['Cm']\n",
    "    Ri = HH_parameter['Ri']\n",
    "    gl = HH_parameter['gl']\n",
    "    diameter = HH_parameter['diameter']\n",
    "    label = HH_parameter['label']\n",
    "    \n",
    "    start_scope()\n",
    "    defaultclock.dt = 0.05*ms\n",
    "\n",
    "    morpho = Cylinder(length=10*cm, diameter=diameter, n=500)\n",
    "\n",
    "    El = 10.613*mV\n",
    "    ENa = 115*mV\n",
    "    EK = -12*mV\n",
    "    gNa0 = 120*msiemens/cm**2\n",
    "    gK = 36*msiemens/cm**2\n",
    "    gl = gl\n",
    "\n",
    "    # HH equations\n",
    "    eqs = '''\n",
    "    Im = gl * (El-v) + gNa * m**3 * h * (ENa-v) + gK * n**4 * (EK-v) : amp/meter**2\n",
    "    I : amp (point current) # applied current\n",
    "    dm/dt = alpham * (1-m) - betam * m : 1\n",
    "    dn/dt = alphan * (1-n) - betan * n : 1\n",
    "    dh/dt = alphah * (1-h) - betah * h : 1\n",
    "    alpham = (0.1/mV) * 10.0*mV/exprel((-v+25.0*mV)/(10.0*mV))/ms : Hz\n",
    "    betam = 4 * exp(-v/(18.0*mV))/ms : Hz\n",
    "    alphah = 0.07 * exp(-v/(20.0*mV))/ms : Hz\n",
    "    betah = 1/(exp((-v+30.0*mV) / (10.0*mV)) + 1)/ms : Hz\n",
    "    alphan = (0.01/mV) * 10.0*mV/exprel((-v+10.0*mV)/(10.0*mV))/ms : Hz\n",
    "    betan = 0.125*exp(-v/(80.0*mV))/ms : Hz\n",
    "    gNa : siemens/meter**2\n",
    "    '''\n",
    "\n",
    "    neuron = SpatialNeuron(morphology=morpho, model=eqs, method=\"exponential_euler\",\n",
    "                           refractory=\"m > 0.4\", threshold=\"m > 0.5\",\n",
    "                           Cm=Cm, Ri=Ri)\n",
    "    neuron.v = 0*mV\n",
    "    neuron.h = 1\n",
    "    neuron.m = 0\n",
    "    neuron.n = .5\n",
    "    neuron.I = 0*amp\n",
    "    neuron.gNa = gNa0\n",
    "    M = StateMonitor(neuron, ('v', 'gNa'), record=True)\n",
    "    spikes = SpikeMonitor(neuron)\n",
    "\n",
    "\n",
    "    report=None\n",
    "    print('------------------- Running simulation ---------------------')\n",
    "    #la = neuron.space_constant[0]\n",
    "    #print(\"Init: Length constante: %s\" % la.in_best_unit(2))\n",
    "    #print(\"Init: Time constante:\", (neuron.Cm[0]/gl).in_best_unit(2))\n",
    "    run(20*ms, report=report)\n",
    "    la = neuron.space_constant[0]\n",
    "    print(\"Relaxed: Length constante: %s\" % la.in_best_unit(2))\n",
    "    print(\"Relaxed: Time constante:\", (neuron.Cm[0]/gl).in_best_unit(2))\n",
    "    neuron.I[0] = 3*uA # current injection at one end\n",
    "    #la = neuron.space_constant[0]\n",
    "    #print(\"Post stimulation: Length constante: %s\" % la.in_best_unit(2))\n",
    "    #print(\"Post stimulation: Time constante:\", (neuron.Cm[0]/gl).in_best_unit(2))\n",
    "    run(3*ms, report=report)\n",
    "    neuron.I = 0*amp\n",
    "    run(30*ms, report=report)\n",
    "\n",
    "    # Calculation of velocity\n",
    "    slope, intercept, r_value, p_value, std_err = stats.linregress(spikes.t/second,\n",
    "                                                    neuron.distance[spikes.i]/meter)\n",
    "    print('------------------------  Done  ----------------------------')\n",
    "    print(\"  Velocity = %.2f m/s\" % slope)\n",
    "    \n",
    "    i = morpho.n//3\n",
    "    ln = ax.plot(M.t/ms, M.v[i,:]/mV, \n",
    "         label=label+' '+str(morpho.distance[i]-morpho.distance[0]))\n",
    "    i = 2*morpho.n//3\n",
    "    ax.plot(M.t/ms, M.v[i,:]/mV, '--', color=ln[0].get_color(),\n",
    "         label=label+' '+str(morpho.distance[i]-morpho.distance[0]))\n",
    "    legend(title='Position along the axon')\n",
    "    ylabel('Membrane potential (mV)')\n",
    "    xlabel('Time (ms)')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "139ebca8",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-01-16T15:36:04.866891Z",
     "start_time": "2022-01-16T15:36:04.863947Z"
    }
   },
   "source": [
    "# 5. HH to investigate ion channels\n",
    "\n",
    "John von Neuman once said:\n",
    "\n",
    "    Give me three parameters and I can Fit an Elephant, give me four and i can make him wiggle his trunk.\n",
    "\n",
    "Short describtion of the following cells\n",
    " - HH original\n",
    " - HH One parameter is changed\n",
    " - plot both AP\n",
    " \n",
    " Run these three code-cells and look at the output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7f7e4440",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-01-16T15:58:45.982987Z",
     "start_time": "2022-01-16T15:58:45.354384Z"
    },
    "jupyter": {
     "source_hidden": true
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# HH code with standard parameters\n",
    "\n",
    "HH_parameter = {\n",
    "    'Cm': 1 * uF / cm**2,\n",
    "    'Ri': 35.4 * ohm * cm,\n",
    "    'gl': 0.4 * msiemens / cm**2,\n",
    "    'diameter': 2 * 238 * um,\n",
    "    'label': 'Standard'\n",
    "}\n",
    "\n",
    "Cm = HH_parameter['Cm']\n",
    "Ri = HH_parameter['Ri']\n",
    "gl = HH_parameter['gl']\n",
    "diameter = HH_parameter['diameter']\n",
    "label = HH_parameter['label']\n",
    "\n",
    "start_scope()\n",
    "defaultclock.dt = 0.05 * ms\n",
    "\n",
    "morpho = Cylinder(length=10 * cm, diameter=diameter, n=500)\n",
    "\n",
    "El = 10.613 * mV\n",
    "ENa = 115 * mV\n",
    "EK = -12 * mV\n",
    "gNa0 = 120 * msiemens / cm**2\n",
    "gK = 36 * msiemens / cm**2\n",
    "gl = gl\n",
    "\n",
    "# HH equations\n",
    "eqs = '''\n",
    "Im = gl * (El-v) + gNa * m**3 * h * (ENa-v) + gK * n**4 * (EK-v) : amp/meter**2\n",
    "I : amp (point current) # applied current\n",
    "dm/dt = alpham * (1-m) - betam * m : 1\n",
    "dn/dt = alphan * (1-n) - betan * n : 1\n",
    "dh/dt = alphah * (1-h) - betah * h : 1\n",
    "alpham = (0.1/mV) * 10.0*mV/exprel((-v+25.0*mV)/(10.0*mV))/ms : Hz\n",
    "betam = 4 * exp(-v/(18.0*mV))/ms : Hz\n",
    "alphah = 0.07 * exp(-v/(20.0*mV))/ms : Hz\n",
    "betah = 1/(exp((-v+30.0*mV) / (10.0*mV)) + 1)/ms : Hz\n",
    "alphan = (0.01/mV) * 10.0*mV/exprel((-v+10.0*mV)/(10.0*mV))/ms : Hz\n",
    "betan = 0.125*exp(-v/(80.0*mV))/ms : Hz\n",
    "gNa : siemens/meter**2\n",
    "'''\n",
    "\n",
    "neuron = SpatialNeuron(morphology=morpho,\n",
    "                       model=eqs,\n",
    "                       method=\"exponential_euler\",\n",
    "                       refractory=\"m > 0.4\",\n",
    "                       threshold=\"m > 0.5\",\n",
    "                       Cm=Cm,\n",
    "                       Ri=Ri)\n",
    "neuron.v = 0 * mV\n",
    "neuron.h = 1\n",
    "neuron.m = 0\n",
    "neuron.n = .5\n",
    "neuron.I = 0 * amp\n",
    "neuron.gNa = gNa0\n",
    "M = StateMonitor(neuron, ('v', 'gNa'), record=True)\n",
    "spikes = SpikeMonitor(neuron)\n",
    "\n",
    "la = neuron.space_constant[0]\n",
    "print('------------------- Running simulation ---------------------')\n",
    "print(\"Length constante: %s\" % la.in_best_unit(2))\n",
    "print(\"Time constante:\", (neuron.Cm[0] / gl).in_best_unit(2))\n",
    "print('------------------------  Start ----------------------------')\n",
    "\n",
    "run(20 * ms, report='text')\n",
    "neuron.I[0] = 3 * uA  # current injection at one end\n",
    "run(3 * ms)\n",
    "la = neuron.space_constant[0]\n",
    "print(\"Length constante: %s\" % la.in_best_unit(2))\n",
    "neuron.I = 0 * amp\n",
    "run(30 * ms, report='text')\n",
    "\n",
    "# Calculation of velocity\n",
    "slope, intercept, r_value, p_value, std_err = stats.linregress(\n",
    "    spikes.t / second, neuron.distance[spikes.i] / meter)\n",
    "print('------------------------  Done  ----------------------------')\n",
    "print(\"  Velocity = %.2f m/s\" % slope)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a8c3d0aa",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-01-16T16:20:08.997954Z",
     "start_time": "2022-01-16T16:20:08.152382Z"
    },
    "jupyter": {
     "source_hidden": true
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# HH code with modified parameters\n",
    "\n",
    "HH_parameter = {\n",
    "    'Cm': 1 * uF / cm**2,\n",
    "    'Ri': 35.4 * ohm * cm,\n",
    "    'gl': 0.4 * msiemens / cm**2,\n",
    "    'diameter': 2 * 238 * um,\n",
    "    'label': 'Standard'\n",
    "}\n",
    "\n",
    "Cm = HH_parameter['Cm']\n",
    "Ri = HH_parameter['Ri']\n",
    "gl = HH_parameter['gl']\n",
    "diameter = HH_parameter['diameter']\n",
    "label = HH_parameter['label']\n",
    "\n",
    "start_scope()\n",
    "defaultclock.dt = 0.05 * ms\n",
    "\n",
    "morpho = Cylinder(length=10 * cm, diameter=diameter, n=500)\n",
    "\n",
    "El = 10.613 * mV\n",
    "ENa = 115 * mV\n",
    "EK = -12 * mV\n",
    "gNa0 = 120 * msiemens / cm**2\n",
    "gK = 9 * msiemens / cm**2\n",
    "gl = gl\n",
    "\n",
    "# HH equations\n",
    "eqs = '''\n",
    "Im = gl * (El-v) + gNa * m**3 * h * (ENa-v) + gK * n**4 * (EK-v) : amp/meter**2\n",
    "I : amp (point current) # applied current\n",
    "dm/dt = alpham * (1-m) - betam * m : 1\n",
    "dn/dt = alphan * (1-n) - betan * n : 1\n",
    "dh/dt = alphah * (1-h) - betah * h : 1\n",
    "alpham = (0.1/mV) * 10.0*mV/exprel((-v+25.0*mV)/(10.0*mV))/ms : Hz\n",
    "betam = 4 * exp(-v/(18.0*mV))/ms : Hz\n",
    "alphah = 0.07 * exp(-v/(20.0*mV))/ms : Hz\n",
    "betah = 1/(exp((-v+30.0*mV) / (10.0*mV)) + 1)/ms : Hz\n",
    "alphan = (0.01/mV) * 10.0*mV/exprel((-v+10.0*mV)/(10.0*mV))/ms : Hz\n",
    "betan = 0.125*exp(-v/(80.0*mV))/ms : Hz\n",
    "gNa : siemens/meter**2\n",
    "'''\n",
    "\n",
    "neuron = SpatialNeuron(morphology=morpho,\n",
    "                       model=eqs,\n",
    "                       method=\"exponential_euler\",\n",
    "                       refractory=\"m > 0.4\",\n",
    "                       threshold=\"m > 0.5\",\n",
    "                       Cm=Cm,\n",
    "                       Ri=Ri)\n",
    "neuron.v = 0 * mV\n",
    "neuron.h = 1\n",
    "neuron.m = 0\n",
    "neuron.n = .5\n",
    "neuron.I = 0 * amp\n",
    "neuron.gNa = gNa0\n",
    "M_drugged = StateMonitor(neuron, ('v', 'gNa'), record=True)\n",
    "spikes = SpikeMonitor(neuron)\n",
    "\n",
    "la = neuron.space_constant[0]\n",
    "print('------------------- Running simulation ---------------------')\n",
    "print(\"Length constante: %s\" % la.in_best_unit(2))\n",
    "print(\"Time constante:\", (neuron.Cm[0] / gl).in_best_unit(2))\n",
    "print('------------------------  Start ----------------------------')\n",
    "\n",
    "run(20 * ms, report='text')\n",
    "neuron.I[0] = 3 * uA  # current injection at one end\n",
    "run(3 * ms)\n",
    "la = neuron.space_constant[0]\n",
    "print(\"Length constante: %s\" % la.in_best_unit(2))\n",
    "neuron.I = 0 * amp\n",
    "run(30 * ms, report='text')\n",
    "\n",
    "# Calculation of velocity\n",
    "slope, intercept, r_value, p_value, std_err = stats.linregress(\n",
    "    spikes.t / second, neuron.distance[spikes.i] / meter)\n",
    "print('------------------------  Done  ----------------------------')\n",
    "print(\"  Velocity = %.2f m/s\" % slope)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a06bacbe",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-01-16T16:18:24.170557Z",
     "start_time": "2022-01-16T16:18:24.048314Z"
    },
    "jupyter": {
     "source_hidden": true
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots(1,1)\n",
    "\n",
    "# Normal\n",
    "i = morpho.n//3\n",
    "imax = np.argmax(M.v[i,:])\n",
    "ln = ax.plot((M.t-M.t[imax])/ms, M.v[i,:]/mV, \n",
    "     label='Normal')\n",
    "legend(title='Position along the axon')\n",
    "ylabel('Membrane potential (mV)')\n",
    "xlabel('Time (ms)')\n",
    "\n",
    "\n",
    "# Drug applied\n",
    "i = morpho.n//3\n",
    "\n",
    "imax = np.argmax(M_drugged.v[i,:])\n",
    "ln = ax.plot((M_drugged.t-M_drugged.t[imax])/ms, M_drugged.v[i,:]/mV, \n",
    "     label='Drug applied')\n",
    "legend()\n",
    "ylabel('Membrane potential (mV)')\n",
    "xlabel('Time (ms)')\n",
    "\n",
    "ax.set_xlim(-5, 10)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8c1270b9-4ac7-4817-8899-12d5d606c6ad",
   "metadata": {},
   "source": [
    "# 6. Supplementary material: "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6158bcfc-bdf1-4c3e-b2cd-17c6121772f4",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "## Analytic expression for the velocity\n",
    "The effective $g^\\star$ is around a third of the peak value of $g_{Na}$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "51c75106",
   "metadata": {},
   "outputs": [],
   "source": [
    "Cm = 1 * uF/cm**2\n",
    "diameter = 238*2*um\n",
    "Ri = 36*ohm*cm\n",
    "gstar = 100*siemens/meter**2 \n",
    "\n",
    "v_p = (1/(Cm)) * sqrt(diameter * gstar/(8*Ri))\n",
    "v_p.in_best_unit(1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8c9ab858-7ef1-446e-9234-3f783c74b251",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "## The conductivities and corresponding Goldman equilibrium\n",
    "\n",
    "The following section is just a demonstration how the above provided plots are generated. Understanding the following sections is not part of the Couse."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "78f27362",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-01-15T16:51:50.434373Z",
     "start_time": "2022-01-15T16:51:46.248700Z"
    },
    "hidden": true,
    "hide_input": false,
    "jupyter": {
     "source_hidden": true
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "from scipy import stats\n",
    "\n",
    "start_scope()\n",
    "defaultclock.dt = 0.02*ms\n",
    "\n",
    "morpho = Cylinder(length=10*cm, diameter=2*238*um, n=100)\n",
    "\n",
    "El = 10.613*mV\n",
    "\n",
    "ENa = 115*mV\n",
    "EK = -12*mV\n",
    "\n",
    "gl = 0.4*msiemens/cm**2\n",
    "gNa0 = 120*msiemens/cm**2\n",
    "gK = 36*msiemens/cm**2\n",
    "\n",
    "# HH equations\n",
    "eqs = '''\n",
    "Im = gl * (El-v) + gNa * m**3 * h * (ENa-v) + gK * n**4 * (EK-v) : amp/meter**2\n",
    "I : amp (point current) # applied current\n",
    "dm/dt = alpham * (1-m) - betam * m : 1\n",
    "dn/dt = alphan * (1-n) - betan * n : 1\n",
    "dh/dt = alphah * (1-h) - betah * h : 1\n",
    "alpham = (0.1/mV) * 10.0*mV/exprel((-v+25.0*mV)/(10.0*mV))/ms : Hz\n",
    "betam = 4 * exp(-v/(18.0*mV))/ms : Hz\n",
    "alphah = 0.07 * exp(-v/(20.0*mV))/ms : Hz\n",
    "betah = 1/(exp((-v+30.0*mV) / (10.0*mV)) + 1)/ms : Hz\n",
    "alphan = (0.01/mV) * 10.0*mV/exprel((-v+10.0*mV)/(10.0*mV))/ms : Hz\n",
    "betan = 0.125*exp(-v/(80.0*mV))/ms : Hz\n",
    "gNa : siemens/meter**2\n",
    "gNaTotal = gNa * m**3 *h : siemens/meter**2\n",
    "gKTotal = gK * n**4 : siemens/meter**2\n",
    "'''\n",
    "\n",
    "neuron = SpatialNeuron(morphology=morpho, model=eqs, method=\"exponential_euler\",\n",
    "                       #refractory=\"m > 0.4\", threshold=\"m > 0.5\",\n",
    "                       Cm=1*uF/cm**2, Ri=35.4*ohm*cm)\n",
    "neuron.v = 0*mV\n",
    "neuron.h = 1\n",
    "neuron.m = 0\n",
    "neuron.n = .5\n",
    "neuron.I = 0*amp\n",
    "neuron.gNa = gNa0\n",
    "\n",
    "M = StateMonitor(neuron, ('v', 'gNaTotal', 'gKTotal'), record=[50])\n",
    "\n",
    "la = neuron.space_constant[0]\n",
    "print('------------------- Running simulation ---------------------')\n",
    "print(\"Length constante: %s\" % la.in_best_unit(2))\n",
    "print(\"Time constante:\", (neuron.Cm[0]/gl).in_best_unit(2))\n",
    "print('------------------------  Start ----------------------------')\n",
    "\n",
    "run(20*ms, report='text')\n",
    "neuron.I[0] = 1*uA # current injection at one end\n",
    "run(3*ms)\n",
    "neuron.I = 0*amp\n",
    "run(30*ms, report='text')\n",
    "\n",
    "\n",
    "fig, ax = plt.subplots(1,1,figsize=(9,5))\n",
    "i = 0#50\n",
    "gNatot = M.gNaTotal.T[:, i]\n",
    "ax.plot(M.t/ms, M.gNaTotal.T[:, i]/(siemens/meter**2), label = '$g_{Na}$')\n",
    "ax.plot(M.t/ms, M.gKTotal.T[:, i]/(siemens/meter**2), label = '$g_{K}$')\n",
    "ax.set_ylabel('conductivity [siemens/m$^2$]')\n",
    "ax.set_xlabel('time')\n",
    "ax.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f93e565c",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-01-15T16:52:01.426982Z",
     "start_time": "2022-01-15T16:52:01.421350Z"
    },
    "hidden": true,
    "hide_input": true,
    "jupyter": {
     "source_hidden": true
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "prefactor = 26.7e-3 * volt\n",
    "K_out_HH = K_in_standard *exp(-12*mV/prefactor )\n",
    "#vm_goldmann(g_K=1e99, K_out=K_out_HH)*volt\n",
    "Na_out_HH = Na_in_standard *exp(115*mV/prefactor )\n",
    "#vm_goldmann(g_Na=1e99, Na_out=Na_out_HH)*volt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "56f26a17",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-01-15T16:52:02.682059Z",
     "start_time": "2022-01-15T16:52:02.419802Z"
    },
    "hidden": true,
    "hide_input": true,
    "jupyter": {
     "source_hidden": true
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "fig, axs = plt.subplots(2, 1, figsize=(9, 5), sharex=True)\n",
    "i = 0#50\n",
    "gNatot = M.gNaTotal.T[:, i]\n",
    "axs[0].plot(M.t/ms, M.gNaTotal.T[:, i]/(siemens/meter**2), label = '$g_{Na}$')\n",
    "axs[0].plot(M.t/ms, M.gKTotal.T[:, i]/(siemens/meter**2), label = '$g_{K}$')\n",
    "\n",
    "axs[0].set_ylabel('conductivity [siemens/m$^2$]')\n",
    "axs[0].set_xlabel('time')\n",
    "axs[0].legend()\n",
    "\n",
    "axs[1].plot(M.t/ms, M.v.T[:, i]/mV, label='Membrane potential')\n",
    "axs[1].plot(M.t/ms, vm_goldmann(g_Na=M.gNaTotal.T[:, i],\n",
    "                                g_K=M.gKTotal.T[:, i],\n",
    "                                Na_out=Na_out_HH,\n",
    "                                K_out=K_out_HH,\n",
    "                                )/mV, label = 'Goldman equilibrium (leak-free)')\n",
    "\n",
    "axs[1].set_ylabel('Potential [mV]')\n",
    "axs[1].set_xlabel('time')\n",
    "axs[1].legend()\n",
    "fig.tight_layout()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6a4b238b",
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "hide_input": false,
  "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.8.8"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": false,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {
    "height": "calc(100% - 180px)",
    "left": "10px",
    "top": "150px",
    "width": "384px"
   },
   "toc_section_display": true,
   "toc_window_display": true
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}