Hyperexcitability from Nav1.2 channel loss in neocortical pyramidal cells (Spratt et al 2021)

 Download zip file   Auto-launch 
Help downloading and running models
Accession:267067
Based on the Layer 5 thick-tufted pyramidal cell from the Blue Brain Project, we modify the distribution of the sodium channel Nav1.2 to recapitulate an increase in excitability observed in ex vivo slice experiments.
Reference:
1 . Spratt PWE, Alexander RPD, Ben-Shalom R, Sahagun A, Kyoung H, Keeshen CM, Sanders SJ, Bender KJ (2021) Paradoxical hyperexcitability from NaV1.2 sodium channel loss in neocortical pyramidal cells Cell Rep. 36(5):109483 [PubMed]
Citations  Citation Browser
Model Information (Click on a link to find other models with that property)
Model Type: Neuron or other electrically excitable cell;
Brain Region(s)/Organism: Prefrontal cortex (PFC);
Cell Type(s): Neocortex layer 5 pyramidal cell;
Channel(s): I h; I M; I Potassium; I Sodium; I L high threshold; I T low threshold;
Gap Junctions:
Receptor(s):
Gene(s): Nav1.2 SCN2A;
Transmitter(s):
Simulation Environment: NEURON; Python;
Model Concept(s):
Implementer(s): Ben-Shalom, Roy [rbenshalom at ucdavis.edu]; Kyoung, Henry [hkyoung at berkeley.edu];
Search NeuronDB for information about:  I L high threshold; I T low threshold; I M; I h; I Sodium; I Potassium;
{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**NOTE:**\n",
    "\n",
    "Copied from KJB folder/SCN2AKO_BK_SK - FINAL UPDATE 110520.ipynb"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# SCN2A BBP L5TTPC Hybrid model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-07-04T22:21:38.475949Z",
     "start_time": "2020-07-04T22:21:37.283336Z"
    }
   },
   "outputs": [],
   "source": [
    "import matplotlib as mpl\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "from scipy import stats\n",
    "\n",
    "plt.rcParams['axes.spines.right'] = False\n",
    "plt.rcParams['axes.spines.top'] = False\n",
    "plt.rcParams['font.sans-serif'] = \"Arial\"\n",
    "plt.rcParams['font.family'] = \"sans-serif\"\n",
    "plt.rcParams['pdf.fonttype'] = 42\n",
    "plt.rcParams['ps.fonttype'] = 42\n",
    "\n",
    "tick_major = 6\n",
    "tick_minor = 4\n",
    "plt.rcParams[\"xtick.major.size\"] = tick_major\n",
    "plt.rcParams[\"xtick.minor.size\"] = tick_minor\n",
    "plt.rcParams[\"ytick.major.size\"] = tick_major\n",
    "plt.rcParams[\"ytick.minor.size\"] = tick_minor\n",
    "\n",
    "font_small = 12\n",
    "font_medium = 13\n",
    "font_large = 14\n",
    "plt.rc('font', size=font_small)          # controls default text sizes\n",
    "plt.rc('axes', titlesize=font_medium)    # fontsize of the axes title\n",
    "plt.rc('axes', labelsize=font_medium)    # fontsize of the x and y labels\n",
    "plt.rc('xtick', labelsize=font_small)    # fontsize of the tick labels\n",
    "plt.rc('ytick', labelsize=font_small)    # fontsize of the tick labels\n",
    "plt.rc('legend', fontsize=font_small)    # legend fontsize\n",
    "plt.rc('figure', titlesize=font_large)   # fontsize of the figure title\n",
    "\n",
    "import matplotlib.colors as clr"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Initializing the Model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Loading the model\n",
    "This is a L5 pyramidal neuron from the blue brain project"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-07-04T22:26:36.352517Z",
     "start_time": "2020-07-04T22:26:35.108532Z"
    },
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\t1 \n",
      "\t1 \n",
      "Setting temperature to 34.000000 C\n",
      "Setting simulation time step to 0.100000 ms\n",
      "\t1 \n",
      "\t1 \n",
      "\t1 \n",
      "\t1 \n",
      "\t1 \n",
      "\t1 \n",
      "\t1 \n",
      "\t1 \n",
      "\t1 \n",
      "\t1 \n",
      "axon updated\n",
      "5 \n",
      "\t1 \n",
      "\t1 \n",
      "\t1 \n",
      "**********************\n",
      "cADpyr232_L5_TTPC1_0fb1ca4724[0].soma[0]\n",
      "1 \n",
      "\t1 \n",
      "axon updated\n",
      "5 \n",
      "axon updated\n",
      "5 \n",
      "\t1 \n",
      "\t1 \n",
      "cADpyr232_L5_TTPC1_0fb1ca4724[0].soma[0]\n"
     ]
    }
   ],
   "source": [
    "from neuron import h\n",
    "import numpy as np\n",
    "h.load_file(\"runModel.hoc\")\n",
    "soma_ref = h.root.sec\n",
    "print(soma_ref)\n",
    "soma = h.secname(sec=soma_ref)\n",
    "sl = h.SectionList()\n",
    "sl.wholetree(sec=soma_ref)\n",
    "\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Model Controls"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-07-04T22:26:27.376014Z",
     "start_time": "2020-07-04T22:26:27.359586Z"
    },
    "code_folding": [
     0,
     55,
     67,
     77,
     91
    ]
   },
   "outputs": [],
   "source": [
    "from scipy.optimize import curve_fit\n",
    "def model_func(x, a, k, b):\n",
    "    return a * np.exp(-k*x) + b\n",
    "def init_stim(sweep_len = 5000, stim_start = 1000, stim_dur = 2000, amp = -0.1, dt = 0.1):\n",
    "    # updates the stimulation params used by the model\n",
    "    # time values are in ms\n",
    "    # amp values are in nA\n",
    "    \n",
    "    h(\"st.del = \" + str(stim_start))\n",
    "    h(\"st.dur = \" + str(stim_dur))\n",
    "    h(\"st.amp = \" + str(amp))\n",
    "    h.tstop = sweep_len\n",
    "    h.dt = dt\n",
    "    \n",
    "\n",
    "def init_settings(nav12=1,\n",
    "                  nav16=1,\n",
    "                  dend_nav12=1, \n",
    "                  soma_nav12=1, \n",
    "                  ais_nav12=1, \n",
    "                  dend_nav16=1, \n",
    "                  soma_nav16=1,\n",
    "                  ais_nav16=1, \n",
    "                  axon_Kp=1,\n",
    "                  axon_Kt =1,\n",
    "                  axon_K=1,\n",
    "                  soma_K=1,\n",
    "                  dend_K=1,\n",
    "                  gpas_all=1,\n",
    "                  hcn=1):\n",
    "    \n",
    "    # create default model parameters to avoid loading the model\n",
    "    \n",
    "    h.dend_na12 = 0.026145/2 \n",
    "    h.dend_na16 = h.dend_na12 \n",
    "    h.dend_k = 0.004226 * soma_K\n",
    "\n",
    "\n",
    "    h.soma_na12 = 0.983955/10 \n",
    "    h.soma_na16 = h.soma_na12 \n",
    "    h.soma_K = 0.303472 * soma_K\n",
    "\n",
    "    h.ais_na16 = 4 \n",
    "    h.ais_na12 = 4 \n",
    "    h.ais_ca = 0.000990\n",
    "    h.ais_KCa = 0.007104\n",
    "\n",
    "    h.node_na = 2\n",
    "\n",
    "    h.axon_KP = 0.973538 * axon_Kp\n",
    "    h.axon_KT = 0.089259 * axon_Kt\n",
    "    h.axon_K = 1.021945 * axon_K\n",
    "\n",
    "    h.cell.axon[0].gCa_LVAstbar_Ca_LVAst = 0.001376286159287454\n",
    "    \n",
    "    #h.soma_na12 = h.soma_na12/2\n",
    "    h.naked_axon_na = h.soma_na16/5\n",
    "    h.navshift = -10\n",
    "    h.myelin_na = h.naked_axon_na\n",
    "    h.myelin_K = 0.303472\n",
    "    h.myelin_scale = 10\n",
    "    h.gpas_all = 3e-5 * gpas_all\n",
    "    h.cm_all = 1\n",
    "    \n",
    "    \n",
    "    h.dend_na12 = h.dend_na12 * nav12 * dend_nav12\n",
    "    h.soma_na12 = h.soma_na12 * nav12 * soma_nav12\n",
    "    h.ais_na12 = h.ais_na12 * nav12 * ais_nav12\n",
    "    \n",
    "    h.dend_na16 = h.dend_na16 * nav16 * dend_nav16\n",
    "    h.soma_na16 = h.soma_na16 * nav16 * soma_nav16\n",
    "    h.ais_na16 = h.ais_na16 * nav16 * ais_nav16\n",
    "    \n",
    "    h.hcn = hcn\n",
    "    \n",
    "    h.working()\n",
    "\n",
    "    \n",
    "def block_everything():\n",
    "    h.dend_na12 =0.026145/2\n",
    "    h.dend_na16 =h.dend_na12\n",
    "    h.dend_k = 0.004226\n",
    "\n",
    "    h.soma_na12 = 0.983955/10\n",
    "    h.soma_na16 = h.soma_na12\n",
    "    h.soma_K = 0.303472\n",
    "\n",
    "    h.ais_na16=4\n",
    "    h.ais_na12=4\n",
    "#     h.ais_ca = 0.000990\n",
    "#     h.ais_KCa = 0.007104\n",
    "\n",
    "#     h.node_na = 2\n",
    "\n",
    "    h.axon_KP =0.973538\n",
    "    h.axon_KT = 0.089259\n",
    "    h.axon_K = 1.021945\n",
    "    working()\n",
    "    h.gpas_all = 5e-6\n",
    "    h(\"epas_all = -88\")\n",
    "    h.cm_all = 0.2\n",
    "    h.working()\n",
    "    for curr_sec in sl:\n",
    "        curr_sec.ena = 60\n",
    "        curr_sec.e_pas = h.epas_all\n",
    "        curr_sec.Ra = 100\n",
    "        curr_sec.cm=h.cm_all\n",
    "\n",
    "def new_init():\n",
    "    h.dend_na12 =0.026145/2\n",
    "    h.dend_na16 =0.026145/2\n",
    "    h.dend_k = 0.004226\n",
    "\n",
    "    h.soma_na12 = 0.983955/10\n",
    "    h.soma_na16 = 0.983955/10\n",
    "    h.soma_K = 0.303472\n",
    "\n",
    "    h.ais_na16=4\n",
    "    h.ais_na12=4\n",
    "#     h.ais_ca = 0.000990\n",
    "#     h.ais_KCa = 0.007104\n",
    "\n",
    "#     h.node_na = 2\n",
    "\n",
    "    h.axon_KP =0.973538\n",
    "    h.axon_KT = 0.089259\n",
    "    h.axon_K = 1.021945\n",
    "    \n",
    "    h('dend_Im = 0.000143')\n",
    "    h('dend_ih = 5e-5')\n",
    "    h.gpas_all = 5e-6\n",
    "    h(\"epas_all = -88\")\n",
    "    h.cm_all = 0.2\n",
    "    h.working()\n",
    "    \n",
    "    for curr_sec in sl:\n",
    "        curr_sec.ena = 60\n",
    "        curr_sec.e_pas = h.epas_all\n",
    "        curr_sec.Ra = 100\n",
    "        curr_sec.cm=h.cm_all\n",
    "    for curr_sec in h.cell.apical:\n",
    "        #curr_sec.ehcn_Ih = -30\n",
    "        curr_sec.gIhbar_Ih = h.dend_ih\n",
    "        curr_sec.gSKv3_1bar_SKv3_1 = h.dend_k \n",
    "        curr_sec.gImbar_Im = h.dend_Im\n",
    "    for curr_sec in h.cell.basal:\n",
    "        #curr_sec.ehcn_Ih = -30\n",
    "        curr_sec.gIhbar_Ih = h.dend_ih\n",
    "        curr_sec.gSKv3_1bar_SKv3_1 = h.dend_k \n",
    "        curr_sec.gImbar_Im = h.dend_Im\n",
    "    #for curr_sec in h.somatic:\n",
    "    h.working()\n",
    "\n",
    "    \n",
    "def scale_na_k(scale):\n",
    "    new_init()\n",
    "    h.dend_na12 =h.dend_na12*scale\n",
    "    h.dend_na16 =h.dend_na16*scale\n",
    "    h.dend_k = h.dend_k*scale\n",
    "\n",
    "    h.soma_na12 = h.soma_na12*scale\n",
    "    h.soma_na16 = h.soma_na16*scale\n",
    "    h.soma_K = h.soma_K*scale\n",
    "\n",
    "    h.ais_na16=h.ais_na16*scale\n",
    "    h.ais_na12=h.ais_na12*scale\n",
    "#     h.ais_ca = 0.000990\n",
    "#     h.ais_KCa = 0.007104\n",
    "\n",
    "#     h.node_na = 2\n",
    "\n",
    "    h.axon_KP =h.axon_KP*scale\n",
    "    h.axon_KT = h.axon_KT*scale\n",
    "    h.axon_K = h.axon_K*scale\n",
    "    \n",
    "    h.dend_Im = h.dend_Im*scale\n",
    "    h.working()\n",
    "    \n",
    "    for curr_sec in h.cell.apical:\n",
    "        #curr_sec.ehcn_Ih = -30\n",
    "        curr_sec.gIhbar_Ih = h.dend_ih\n",
    "        curr_sec.gSKv3_1bar_SKv3_1 = h.dend_k \n",
    "        curr_sec.gImbar_Im = h.dend_Im\n",
    "    for curr_sec in h.cell.basal:\n",
    "        #curr_sec.ehcn_Ih = -30\n",
    "        curr_sec.gIhbar_Ih = h.dend_ih\n",
    "        curr_sec.gSKv3_1bar_SKv3_1 = h.dend_k \n",
    "        curr_sec.gImbar_Im = h.dend_Im\n",
    "    #for curr_sec in h.somatic:\n",
    "    \n",
    "        \n",
    "        \n",
    "def just_ih_ks():\n",
    "    h.dend_na12 =0\n",
    "    h.dend_na16 =0\n",
    "    h.dend_k = 0.004226\n",
    "\n",
    "    h.soma_na12 = 0\n",
    "    h.soma_na16 = 0\n",
    "    h.soma_K = 0.303472\n",
    "\n",
    "    h.ais_na16=0\n",
    "    h.ais_na12=0\n",
    "#     h.ais_ca = 0.000990\n",
    "#     h.ais_KCa = 0.007104\n",
    "\n",
    "#     h.node_na = 2\n",
    "\n",
    "    \n",
    "    h.axon_KP =0.973538\n",
    "    h.axon_KT = 0.089259\n",
    "    h.axon_K = 1.021945\n",
    "    h('dend_Im = 0.000143')\n",
    "    h('dend_ih = 5e-5')\n",
    "    h.gpas_all = 5e-6\n",
    "    h(\"epas_all = -88\")\n",
    "    h.cm_all = 0.2\n",
    "   \n",
    "    \n",
    "    for curr_sec in sl:\n",
    "        curr_sec.ena = 60\n",
    "        curr_sec.e_pas = h.epas_all\n",
    "        curr_sec.Ra = 100\n",
    "        curr_sec.cm=h.cm_all\n",
    "    for curr_sec in h.cell.apical:\n",
    "        curr_sec.gIhbar_Ih = h.dend_ih\n",
    "        curr_sec.gSKv3_1bar_SKv3_1 = h.dend_k \n",
    "        curr_sec.gImbar_Im = h.dend_Im\n",
    "    for curr_sec in h.cell.basal:\n",
    "        curr_sec.gIhbar_Ih = h.dend_ih\n",
    "        curr_sec.gSKv3_1bar_SKv3_1 = h.dend_k \n",
    "        curr_sec.gImbar_Im = h.dend_Im\n",
    "        \n",
    "        \n",
    "        \n",
    "   \n",
    "    h.working()\n",
    "def update_params2():\n",
    "    h.cm_all = 0.2\n",
    "    for curr_sec in sl:\n",
    "        curr_sec.cm=h.cm_all\n",
    "        \n",
    "def run_model(start_Vm = -72):\n",
    "\n",
    "    h.finitialize(start_Vm)\n",
    "    timesteps = int(h.tstop/h.dt)\n",
    "    \n",
    "    Vm = np.zeros(timesteps)\n",
    "    I = {}\n",
    "    I['Na'] = np.zeros(timesteps)\n",
    "    I['Ca'] = np.zeros(timesteps)\n",
    "    I['K'] = np.zeros(timesteps)\n",
    "    t = np.zeros(timesteps)\n",
    "    \n",
    "    for i in range(timesteps):\n",
    "        Vm[i] = h.cell.soma[0].v\n",
    "        I['Na'][i] = h.cell.soma[0](0.5).ina\n",
    "        I['Ca'][i] = h.cell.soma[0](0.5).ica\n",
    "        I['K'][i] = h.cell.soma[0](0.5).ik\n",
    "        t[i] = i*h.dt / 1000\n",
    "        h.fadvance()\n",
    "        \n",
    "    return Vm, I, t\n",
    "\n",
    "def plot_Soma_I_Na(start_Vm = -72):\n",
    "    h.finitialize(start_Vm)\n",
    "    timesteps = int(h.tstop/h.dt)\n",
    "    \n",
    "\n",
    "    current = np.zeros(timesteps)\n",
    "    time = np.zeros(timesteps)\n",
    "    for i in range(timesteps):\n",
    "        curr_I = h.cell.soma[0](0.5).ina\n",
    "        time[i] = i*h.dt / 1000\n",
    "        current[i] = curr_I\n",
    "        h.fadvance()\n",
    "    return current, time\n",
    "def ko12():\n",
    "    for curr_sec in sl:\n",
    "        curr_sec.gbar_na12 = 0\n",
    "        \n",
    "def add_ttx():\n",
    "    \n",
    "    h.ais_na16= 0\n",
    "    h.ais_na12= 0\n",
    "    h.dend_na12 = 0\n",
    "    h.dend_na16 = 0\n",
    "    h.soma_na12 = 0\n",
    "    h.soma_na16 = 0\n",
    "    h.node_na = 0\n",
    "    h.naked_axon_na = 0\n",
    "    h.working()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## KJB tune here!!!!!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "#M Current Kinetics\n",
    "#mAlpha = a_pre_exp/(1+exp((-v+a_vshift)/a_exp_div)) \n",
    "#mBeta =  b_pre_exp*exp((-v+ b_vshift)/b_exp_div)\n",
    "#mInf = mAlpha/(mAlpha + mBeta)\n",
    "#mTau = 1/(mAlpha + mBeta)\n",
    "Im_a_pre_exp = 0.02 \n",
    "Im_a_vshift = -20\n",
    "Im_a_exp_div = 0.2\n",
    "Im_b_pre_exp = 0.01    #0.01 \n",
    "Im_b_vshift = -50      #-45\n",
    "Im_b_exp_div = 0.05556*10       #0.005556\n",
    "\n",
    "\n",
    "#BK Kinetics:\n",
    "#PROCEDURE rates( v (mV) ) {\n",
    "\t#v = v + 5 (mV)\n",
    "\t#minf = 1 / ( 1+exp(-(v+cvm)/ckm) )\n",
    "\t#taum = (1e3) * ( ctm + 1 (s) / ( exp(-(v+cvtm1)/cktm1) + exp(-(v+cvtm2)/cktm2) ) ) / qt\n",
    "\t\n",
    "\t#zinf = 1 /(1 + zhalf/cai)\n",
    "    #  tauz = ctauz/qt\n",
    "\n",
    "\t#hinf = ch + (1-ch) / ( 1+exp(-(v+cvh)/ckh) )\n",
    "\t#tauh = (1e3) * ( cth + 1 (s) / ( exp(-(v+cvth1)/ckth1) + exp(-(v+cvth2)/ckth2) ) ) / qt\n",
    "#}\n",
    "cvm = 28.9 #(mV)28.9\n",
    "ckm = 6.2 #(mV)6.2\n",
    "\n",
    "ctm = 0.00150  #(s)0.000505\n",
    "cvtm1 = 86.4 #(mV)86.4\n",
    "cktm1 = -10.1 #(mV)-10.1\n",
    "cvtm2 = -33.3#(mV)-33.3\n",
    "cktm2 = 10 #(mV)10\n",
    "\n",
    "ctauz = 1 #(ms)1\n",
    "\n",
    "ch = 0.085#0.085\n",
    "cvh = 32 #(mV)32\n",
    "ckh = -5.8 #(mV)-5.8\n",
    "cth = 0.0019 #(s)0.0019\n",
    "cvth1 = 48.5 #(mV)48.5\n",
    "ckth1 = -5.2 #(mV)-5.2\n",
    "cvth2 = -54.2 #(mV)-54.2\n",
    "ckth2 = 12.9 #(mV)12.9"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 186,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "axon updated\n",
      "0.616 \n",
      "0.08406999999999999\n"
     ]
    }
   ],
   "source": [
    "#h.dend_na12 =0.0026145\n",
    "#h.dend_na16 =0.0026145\n",
    "\n",
    "h.dend_na12 = 0.0196791*0.8*0.3\n",
    "h.dend_na16 = 0.0196791*0.8*0.3\n",
    "h.soma_na12 = 0.0196791*1.9\n",
    "h.soma_na16 = 0.0196791*1.9\n",
    "h.ais_na16=0.8*0.7*1.1\n",
    "h.ais_na12=0.8*0.7*1.1\n",
    "\n",
    "h.dend_k = 0.0008452/26*0         #Kv3.1\n",
    "h.soma_K = 0.0606944/50*0         #kv3.1\n",
    "h.axon_K = 0.104389/26*0          #kv3.1\n",
    "\n",
    "h.dend_KT = 0.0178518*0.1\n",
    "h.soma_KT = 0.0178518*1\n",
    "h.axon_KT = 0.0178518*40*0.5  #0.0178518*40*.5\n",
    "\n",
    "KT_mtau = 1   #activation\n",
    "KT_htau = 0.5    #inactivation  0.7  before \n",
    "\n",
    "\n",
    "#OLD KCa (SK,BK combined)\n",
    "h.soma_KCa = 0 #0.008407*0.05\n",
    "h.dend_KCa = 0 # 0.008407*0.3\n",
    "h.ais_KCa = 0 #0.0014208*0       \n",
    "\n",
    "soma_SK = 0.008407*10\n",
    "dend_SK = 0.008407*10\n",
    "ais_SK = 0.0014208*0\n",
    "\n",
    "soma_BK = 0.008407*30000000*1.5\n",
    "dend_BK = 0.008407*30000000*1.5\n",
    "ais_BK = 0.0014208*0\n",
    "\n",
    "h.dend_Im =0.0000286*150*1  # all 3 started at 0.5 in FINAL 102720 KJB\n",
    "h.soma_Im =0.0000286*750*1\n",
    "h.axon_Im =0.0000286*1500*1\n",
    "#---super phat\n",
    "#Right now KiM is only at the dendrites \n",
    "\n",
    "\n",
    "\n",
    "h.axon_KP =0.1947076*0.5     #-------phat\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "#h.soma_KCa = 0.0016814*0      #BK\n",
    "#h.axon_KP =0.1947076\n",
    "#h.axon_KT = 0.0178518*0.1\n",
    "\n",
    "#------------------------------\n",
    "\n",
    "\n",
    "h.dend_CaT = 0.0000666*35000*1.1\n",
    "h.soma_CaT = 0.0000666*350*1\n",
    "h.soma_Ca = 0.0001988*1 #HVA\n",
    "\n",
    "h.ais_ca = 0.000198*0.1 #HVA\n",
    "\n",
    "h.dend_ih = 5e-5*1\n",
    "h.soma_ih = 0.000080*1\n",
    "\n",
    "h.node_na = 0.4\n",
    "\n",
    "h.gpas_all = 5e-6*20    # started at 5e-6 in FINAL\n",
    "epas_all = -88\n",
    "h.cm_all = 0.2\n",
    "\n",
    "h.working()\n",
    "\n",
    "\n",
    "\n",
    "for curr_sec in sl:\n",
    "    #print(curr_sec)\n",
    "    curr_sec.ena = 60\n",
    "    curr_sec.e_pas = h.epas_all\n",
    "    curr_sec.Ra = 100\n",
    "    curr_sec.cm=h.cm_all\n",
    "    curr_sec.htau_fact_K_Tst = KT_htau\n",
    "    curr_sec.mtau_fact_K_Tst = KT_mtau\n",
    "    curr_sec.a_pre_exp_Im = Im_a_pre_exp\n",
    "    curr_sec.a_vshift_Im = Im_a_vshift\n",
    "    curr_sec.a_exp_div_Im = Im_a_exp_div\n",
    "    curr_sec.b_pre_exp_Im = Im_b_pre_exp\n",
    "    curr_sec.b_vshift_Im = Im_b_vshift\n",
    "    curr_sec.b_exp_div_Im = Im_b_exp_div\n",
    "    #UPDATING BK\n",
    "    \n",
    "    curr_sec.cvm_bk = cvm \n",
    "    curr_sec.ckm_bk = ckm \n",
    "\n",
    "    curr_sec.ctm_bk = ctm \n",
    "    curr_sec.cvtm1_bk = cvtm1  \n",
    "    curr_sec.cktm1_bk = cktm1  \n",
    "    curr_sec.cvtm2_bk = cvtm2  \n",
    "    curr_sec.cktm2_bk = cktm2 \n",
    "    curr_sec.ctauz_bk = ctauz \n",
    "    curr_sec.ch_bk = ch  \n",
    "    curr_sec.cvh_bk = cvh  \n",
    "    curr_sec.ckh_bk = ckh \n",
    "    curr_sec.cth_bk = cth\n",
    "    curr_sec.cvth1_bk = cvth1 \n",
    "    curr_sec.ckth1_bk = ckth1 \n",
    "    curr_sec.cvth2_bk = cvth2\n",
    "    curr_sec.ckth2_bk = ckth2\n",
    "    \n",
    "    \n",
    "    \n",
    "    \n",
    "    \n",
    "for curr_sec in h.cell.apical:\n",
    "    #curr_sec.ehcn_Ih = -30\n",
    "    curr_sec.gIhbar_Ih = h.dend_ih\n",
    "    curr_sec.gSKv3_1bar_SKv3_1 = h.dend_k \n",
    "    curr_sec.gImbar_Im = h.dend_Im\n",
    "    curr_sec.gbar_sk = dend_SK\n",
    "    curr_sec.gbar_bk = dend_BK\n",
    "for curr_sec in h.cell.basal:\n",
    "    #curr_sec.ehcn_Ih = -30\n",
    "    curr_sec.gIhbar_Ih = h.dend_ih\n",
    "    curr_sec.gSKv3_1bar_SKv3_1 = h.dend_k \n",
    "    curr_sec.gImbar_Im = h.dend_Im\n",
    "    curr_sec.gbar_sk = dend_SK\n",
    "    curr_sec.gbar_bk = dend_BK\n",
    "for curr_sec in h.cell.somatic:\n",
    "    curr_sec.gImbar_Im = h.soma_Im\n",
    "    curr_sec.gbar_sk = soma_SK\n",
    "    curr_sec.gbar_bk = soma_BK\n",
    "for curr_sec in h.cell.axonal:\n",
    "    curr_sec.gImbar_Im = h.axon_Im\n",
    "    curr_sec.gbar_sk = ais_SK\n",
    "    curr_sec.gbar_bk = ais_BK\n",
    "#for curr_sec in h.somatic:\n",
    "print(soma_SK)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 187,
   "metadata": {},
   "outputs": [],
   "source": [
    "#na inactivation issues\n",
    "for curr_sec in sl:\n",
    "    h.Rg_na12 = 0.1 #ms\n",
    "    h.ar2_na12 = 0.75 #0 inactivation, 1 no inactivation\n",
    "    h.Rg_na16 = 0.1 #ms\n",
    "    h.ar2_na16 = 0.4 #0 inactivation, 1 no inactivation  0.25\n",
    "    h.thi2_na12 = -45 #mV\n",
    "    h.thi2_na16 = -45 #mV"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 188,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cADpyr232_L5_TTPC1_0fb1ca4724[0].soma[0] gbar_bk - 378315.0\n"
     ]
    }
   ],
   "source": [
    "#for curr_sec in h.cell.axonal:\n",
    "#    print(f'{h.secname()} na12 - {curr_sec.gbar_na12} na16 - {curr_sec.gbar_na16}')\n",
    "#    for seg in curr_sec:\n",
    "#        print(f'{seg.x} na12 - {seg.gbar_na12}')\n",
    "    #print(curr_sec.gbar_na16)\n",
    "    #print(curr_sec.gNap_Et2_Nap_Et2)\n",
    "    #print(curr_sec.gbar_na16)\n",
    "for curr_sec in h.cell.somatic:\n",
    "    print(f'{h.secname()} gbar_bk - {curr_sec.gbar_bk}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Running the model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 189,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-07-04T22:26:39.970753Z",
     "start_time": "2020-07-04T22:26:39.948537Z"
    }
   },
   "outputs": [],
   "source": [
    "\n",
    "sweep_len = 500\n",
    "stim_dur = 300\n",
    "amp = 0.15\n",
    "dt = 0.01\n",
    "init_stim(sweep_len = sweep_len, stim_start = 100,stim_dur = stim_dur, amp = amp, dt = dt)\n",
    "\n",
    "# Run model\n",
    "Vm, I, t = run_model()\n",
    "dvdt = np.gradient(Vm)/h.dt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 190,
   "metadata": {},
   "outputs": [],
   "source": [
    "timesteps = int(h.tstop/h.dt)\n",
    "times = np.cumsum(np.ones([1,timesteps])*h.dt)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Plot Output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 191,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-07-04T22:24:06.868750Z",
     "start_time": "2020-07-04T22:24:06.485694Z"
    },
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, [ax1, ax2] = plt.subplots(nrows=1, ncols=2, figsize=(10,4), sharex=False, sharey=False)\n",
    "fig_title = 'Model Run Example'\n",
    "fig.suptitle(fig_title) \n",
    "\n",
    "title_txt = '{amp}nA for {stim_dur}ms'.format(amp = amp, stim_dur = stim_dur)\n",
    "ax1.set_title(title_txt) \n",
    "ax1.set_xlabel('Time (sec)')\n",
    "ax1.set_ylabel('Vm (mV)')\n",
    "\n",
    "ax2.set_title('Phase plane')\n",
    "ax2.set_xlabel('Vm (mV)')\n",
    "ax2.set_ylabel('dVdt (V/s)')\n",
    "\n",
    "ax1.plot(t, Vm, color = 'k')\n",
    "ax2.plot(Vm, dvdt, color = 'k')\n",
    "\n",
    "plt.rcParams['axes.spines.right'] = False\n",
    "plt.rcParams['axes.spines.top'] = False\n",
    "\n",
    "tick_major = 6\n",
    "tick_minor = 4\n",
    "plt.rcParams[\"xtick.major.size\"] = tick_major\n",
    "plt.rcParams[\"xtick.minor.size\"] = tick_minor\n",
    "plt.rcParams[\"ytick.major.size\"] = tick_major\n",
    "plt.rcParams[\"ytick.minor.size\"] = tick_minorfont_small = 12\n",
    "font_medium = 13\n",
    "font_large = 14\n",
    "plt.rc('font', size=font_small)          # controls default text sizes\n",
    "plt.rc('axes', titlesize=font_medium)    # fontsize of the axes title\n",
    "plt.rc('axes', labelsize=font_medium)    # fontsize of the x and y labels\n",
    "plt.rc('xtick', labelsize=font_small)    # fontsize of the tick labels\n",
    "plt.rc('ytick', labelsize=font_small)    # fontsize of the tick labels\n",
    "plt.rc('legend', fontsize=font_small)    # legend fontsize\n",
    "plt.rc('figure', titlesize=font_large)   # fontsize of the figure title\n",
    "\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "## 12 KO"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 181,
   "metadata": {},
   "outputs": [],
   "source": [
    "ko12()\n",
    "\n",
    "\n",
    "\n",
    "# Run model\n",
    "Vm, I, t = run_model()\n",
    "dvdt = np.gradient(Vm)/h.dt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Display currents"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 533,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "def record_all_currents(sections,is_to_plot):\n",
    "    all_is = {}\n",
    "    for curr_sec in sections:\n",
    "        all_is[curr_sec] = np.zeros([len(is_to_plot[curr_sec])+1,timesteps])\n",
    "    volts = np.zeros([timesteps,1])\n",
    "    h.finitialize(-80)\n",
    "    for i in range(timesteps):\n",
    "        for curr_sec in sections:\n",
    "            curr_is = is_to_plot[curr_sec]\n",
    "            curr_rec = all_is[curr_sec]\n",
    "            for j in range(len(curr_is)):\n",
    "                #print(f'j is {j} i is {i} curr_rec shape is {np.shape(curr_rec)}')\n",
    "                #if (h.cell.soma[0].v<-10 and h.cell.soma[0].v>-50 ):\n",
    "                h(f'val = cell.{curr_sec}[0].{curr_is[j]}(0.28)')\n",
    "                #else:\n",
    "                #    h.val = 0\n",
    "                #tmp_str = f'soma_ref.{is_to_plot[j]}'\n",
    "                #tmp_val = eval(tmp_str)\n",
    "                curr_rec[j,i] = h.val\n",
    "                #if (h.cell.soma[0].v<-10 and h.cell.soma[0].v>-50 ):\n",
    "                h(f'val = cell.{curr_sec}[0].v(0.28)')\n",
    "                #else:\n",
    "                #    h.val = 0\n",
    "            curr_rec[j+1,i] = h.val\n",
    "            h.fadvance()\n",
    "    return all_is\n",
    "            \n",
    "def display_all_currents(sections,is_to_plot,all_is,xlim):       \n",
    "    for curr_sec in sections:           \n",
    "        curr_is = is_to_plot[curr_sec]\n",
    "        curr_rec = all_is[curr_sec]\n",
    "        fig,axs = plt.subplots(len(curr_is)+1,1,figsize=[10,30])\n",
    "        for j in range(len(curr_is)):\n",
    "            curr_ax = axs[j]\n",
    "            curr_ax.plot(times,curr_rec[j,:])\n",
    "            curr_ax.set_title(f'{curr_sec} {curr_is[j]}')\n",
    "            curr_ax.set_xlim(xlim)\n",
    "        curr_ax = axs[j+1]\n",
    "        curr_ax.plot(times,curr_rec[j+1,:])\n",
    "        curr_ax.set_title('volts')\n",
    "        curr_ax.set_xlim(xlim)\n",
    "def display_all_currents_overlaid(sections,is_to_plot,all_is,xlim): \n",
    "    fig,axs = plt.subplots(len(sections),1,figsize=[10,30])\n",
    "    for i,curr_sec in enumerate(sections):\n",
    "        curr_ax = axs[i]\n",
    "        curr_is = is_to_plot[curr_sec]\n",
    "        curr_rec = all_is[curr_sec]\n",
    "        for j in range(len(curr_is)):\n",
    "            curr_ax.plot(times,curr_rec[j,:],label=curr_is[j])\n",
    "        curr_ax.set_xlim(xlim)\n",
    "        curr_ax.legend(loc='best')\n",
    "        curr_ax.set_title(curr_sec)\n",
    "        #curr_ax.plot(times,curr_rec[j+1,:],label='volts')\n",
    "    #print(volts[2499])\n",
    "    #print(np.min(volts))\n",
    "    #axs[0,0].set_ylim([-80,50])\n",
    "    #axs[1,0].plot(volts)\n",
    "    #axs[1,0].set_ylim([-90,-60])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 534,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "sections = ['soma','axon','apic']\n",
    "is_to_plot = {}\n",
    "\n",
    "#is_to_plot[\"soma\"] = ['i_cap','i_pas','ica','ik','ik_K_Tst','ik_SK_E2','ik_SKv3_1','ina','ihcn_Ih']\n",
    "is_to_plot[\"soma\"] = ['ik_K_Tst','ik_sk','ik_bk','ik_Im','ik','ina_na12','ina_na16','ina']\n",
    "#is_to_plot[\"axon\"] = ['i_cap','i_pas','ica','ik','ik_K_Tst','ik_SK_E2','ik_SKv3_1','ik_K_Pst','ina']\n",
    "is_to_plot[\"axon\"] = ['ik_K_Tst','ik_sk','ik_bk','ik_K_Pst','ik_Im','ik','ina_na12','ina_na16','ina']\n",
    "\n",
    "is_to_plot[\"apic\"] = ['ik_K_Tst','ik_sk','ik_bk','ik_Im','ik','ina_na12','ina_na16','ina']\n",
    "#sections = ['soma','axon','apic','dend']\n",
    "\n",
    "\n",
    "all_is = record_all_currents(sections,is_to_plot)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 538,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x2160 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "display_all_currents_overlaid(sections,is_to_plot,all_is,[37,41]) # last argument is x axis limits"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "## Display reversals and membrane properties"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "axon updated\n",
      "4 \n",
      "axon updated\n",
      "4 \n",
      "axon updated\n",
      "0.8 \n",
      "soma properties are:\n",
      "e_pas = -88.0\n",
      "eca = 131.02906385838395\n",
      "ek = -85.0\n",
      "ena = 60.0\n",
      "cm = 0.2\n",
      "Ra = 100.0\n",
      "axon properties are:\n",
      "e_pas = -88.0\n",
      "eca = 131.02842876045239\n",
      "ek = -85.0\n",
      "ena = 60.0\n",
      "cm = 0.2\n",
      "Ra = 100.0\n",
      "apic properties are:\n",
      "e_pas = -88.0\n",
      "eca = 131.04640556452472\n",
      "ek = -85.0\n",
      "ena = 60.0\n",
      "cm = 0.2\n",
      "Ra = 100.0\n",
      "dend properties are:\n",
      "e_pas = -88.0\n",
      "eca = 131.04672032498624\n",
      "ek = -77.0\n",
      "ena = 60.0\n",
      "cm = 0.2\n",
      "Ra = 100.0\n"
     ]
    }
   ],
   "source": [
    "#block_everything()\n",
    "#just_ih_ks()\n",
    "scale_na_k(0.2)\n",
    "reversals = ['e_pas','eca','ek','ena','cm']\n",
    "sections = ['soma','axon','apic','dend']\n",
    "for curr_sec in sections:\n",
    "    print(f'{curr_sec} properties are:')\n",
    "    for curr_rev in reversals:\n",
    "        h(f'val = cell.{curr_sec}[0].{curr_rev}(0.5)')\n",
    "        print(f'{curr_rev} = {h.val}')\n",
    "    h(f'val = cell.soma[0].Ra')\n",
    "    print(f'Ra = {h.val}')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Display reversals and membrane properties"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#just_ih_ks()\n",
    "new_init()\n",
    "#init_stim(sweep_len = 5000, stim_start = 1000, stim_dur = 2000, amp = -0.1, dt = 0.5)\n",
    "init_stim(sweep_len = 1000, stim_start = 200, stim_dur = 100, amp = 0.4, dt = 0.1)\n",
    "timesteps = int(h.tstop/h.dt)\n",
    "times = np.cumsum(np.ones(timesteps)*h.dt)\n",
    "\n",
    "del_ind = int(h.st.delay/h.dt)-1\n",
    "stim_end_ind = int((h.st.delay+h.st.dur)/h.dt)-1\n",
    "h.finitialize(-80)\n",
    "volts = np.zeros(timesteps)\n",
    "fig,ax = plt.subplots(1,1,figsize=[10,10])\n",
    "for i in range(len(times)):\n",
    "    volts[i] = soma_ref.v\n",
    "    h.fadvance()\n",
    "ax.plot(times,volts)\n",
    "ax.set_title('volts')\n",
    "dv = volts[stim_end_ind] - volts[del_ind]\n",
    "rin = (dv*1e-3)/(h.st.amp*1e-9)\n",
    "print(f'rin is {rin/1e6} Mohms')\n",
    "np.savetxt('times.txt',times,delimiter='\\n')\n",
    "np.savetxt('volts.txt',volts,delimiter='\\n')\n",
    "y_tofit = volts[del_ind+50:stim_end_ind-500]\n",
    "t_tofit = times[del_ind+50:stim_end_ind-500]\n",
    "t0 = t_tofit[0]\n",
    "t_tofit = t_tofit-t0\n",
    "#p0 = (-131,41.55,386.1) # starting search koefs\n",
    "#opt, pcov = curve_fit(model_func, t_tofit, y_tofit, p0)\n",
    "#a, k, b = opt\n",
    "#print(f'a={a},k={k},b={b}')\n",
    "#t_tofit = t_tofit+t0\n",
    "#ax.plot(t_tofit,y_tofit,'green')\n",
    "#fitted = model_func(t_tofit,a,k,b)\n",
    "#ax.plot(t_tofit,fitted,'r')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## displaying all currents"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "\n",
    "is_to_plot = {}\n",
    "all_is = {}\n",
    "is_to_plot[\"soma\"] = ['i_cap','i_pas','ica','ik','ina','ihcn_Ih']\n",
    "is_to_plot[\"axon\"] = ['i_cap','i_pas','ica','ik','ina']\n",
    "all_is[\"soma\"]= np.zeros([len(is_to_plot[\"soma\"])+1,timesteps])\n",
    "all_is[\"axon\"]= np.zeros([len(is_to_plot[\"axon\"])+1,timesteps])\n",
    "volts = np.zeros([timesteps,1])\n",
    "#sections = ['soma','axon','apic','dend']\n",
    "sections = ['soma','axon']\n",
    "\n",
    "#all_gs = []\n",
    "\n",
    "\n",
    "h.finitialize(-80)\n",
    "for i in range(timesteps):\n",
    "    for curr_sec in sections:\n",
    "        curr_is = is_to_plot[curr_sec]\n",
    "        curr_rec = all_is[curr_sec]\n",
    "        for j in range(len(curr_is)):\n",
    "            #print(f'j is {j} i is {i} curr_rec shape is {np.shape(curr_rec)}')\n",
    "            h(f'val = cell.{curr_sec}[0].{curr_is[j]}(0.5)')\n",
    "            #tmp_str = f'soma_ref.{is_to_plot[j]}'\n",
    "            #tmp_val = eval(tmp_str)\n",
    "            curr_rec[j,i] = h.val\n",
    "        h(f'val = cell.{curr_sec}[0].v(0.5)')\n",
    "        curr_rec[j+1,i] = h.val\n",
    "        h.fadvance()\n",
    "            \n",
    "            \n",
    "for curr_sec in sections:           \n",
    "    curr_is = is_to_plot[curr_sec]\n",
    "    curr_rec = all_is[curr_sec]\n",
    "    fig,axs = plt.subplots(len(curr_is)+1,1,figsize=[10,30])\n",
    "    for j in range(len(curr_is)):\n",
    "        curr_ax = axs[j]\n",
    "        curr_ax.plot(times,curr_rec[j,:])\n",
    "        curr_ax.set_title(f'{curr_sec} {curr_is[j]}')\n",
    "    curr_ax = axs[j+1]\n",
    "    curr_ax.plot(times,curr_rec[j+1,:])\n",
    "    curr_ax.set_title('volts')\n",
    "    volts = curr_rec[j+1,:]\n",
    "    #print(volts[2499])\n",
    "    #print(np.min(volts))\n",
    "    #axs[0,0].set_ylim([-80,50])\n",
    "    #axs[1,0].plot(volts)\n",
    "    #axs[1,0].set_ylim([-90,-60])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-07-04T22:24:20.441965Z",
     "start_time": "2020-07-04T22:24:20.116683Z"
    }
   },
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots(nrows=1, ncols=1, figsize=(8,4), sharex=False, sharey=False)\n",
    "fig_title = 'Ionic Currents at Soma'\n",
    "fig.suptitle(fig_title) \n",
    "\n",
    "ax.set_xlabel(\"Time (sec)\")\n",
    "ax.set_ylabel(\"Somatic Current (nA)\")\n",
    "\n",
    "ax.plot(t, I['Na'], label = 'Na', color = 'lightgreen')\n",
    "ax.plot(t, I['Ca'], label = 'Ca', color = 'red')\n",
    "ax.plot(t, I['K'], label = 'K', color = 'skyblue')\n",
    "\n",
    "ax.legend()\n",
    "# plt.savefig(\"{}.pdf\".format(fig_title), transparent=True)\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Model Tuning\n",
    "\n",
    "In general there are a few issues with this model\n",
    "- It doesn't burst \n",
    "- The AHP is very steep\n",
    "- The repolarization is very fast\n",
    "- loss of Scn2a dramatically affects AP height (twice as much as real data)\n",
    "- Repolarization is a little fast\n",
    "\n",
    "This suggests to me that K channels are a little too strong in this model\n",
    "\n",
    "Here are the K conductances:\n",
    "- h.dend_k = 0.004226\n",
    "- h.soma_K = 0.303472 # fast Kv\n",
    "- h.ais_KCa = 0.007104 # calcium activated K channel?\n",
    "- h.axon_KP =0.973538 # slow Kv\n",
    "- h.axon_KT = 0.089259 \n",
    "- h.axon_K = 1.021945 # fast Kv"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Adding T-type channels "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-26T00:38:29.827692Z",
     "start_time": "2020-06-26T00:38:27.645647Z"
    }
   },
   "outputs": [],
   "source": [
    "sweep_len = 400\n",
    "stim_dur = 300\n",
    "stim_start = 1\n",
    "amp = 0.3\n",
    "dt = 0.05\n",
    "init_stim(sweep_len=sweep_len, \n",
    "          stim_start=stim_start,\n",
    "          stim_dur=stim_dur,\n",
    "          amp=amp,\n",
    "          dt=dt)\n",
    "\n",
    "\n",
    "\n",
    "fig, [ax1, ax2] = plt.subplots(nrows=1, ncols=2, figsize=(10,4), sharex=False, sharey=False)\n",
    "fig_title = 'Baseline Model'\n",
    "fig.suptitle(fig_title) \n",
    "\n",
    "ax1.set_xlabel('Time (sec)')\n",
    "ax1.set_ylabel('Vm (mV)')\n",
    "\n",
    "ax2.set_xlabel('Vm (mV)')\n",
    "ax2.set_ylabel('dVdt (V/s)')\n",
    "\n",
    "channel_percent = np.arange(15,30,3)\n",
    "channel_percent = [20]\n",
    "cmap = clr.LinearSegmentedColormap.from_list('scn2a', \n",
    "                                             [(0,    'k'),\n",
    "                                              (1,    'red')], N=256)\n",
    "\n",
    "ax1.set_prop_cycle('color',cmap(np.linspace(0,1,len(channel_percent))))\n",
    "ax2.set_prop_cycle('color',cmap(np.linspace(0,1,len(channel_percent))))\n",
    "\n",
    "AP_peak = []\n",
    "for i, p in enumerate(channel_percent):\n",
    "    init_settings()\n",
    "#     h.soma_LVA = h.soma_LVA * 18\n",
    "    h.AIS_LVA = h.AIS_LVA * 18\n",
    "    h.axon_KP = h.axon_KP * .7\n",
    "    h.soma_KCa = 0\n",
    "    h.ais_KCa = 0\n",
    "#     add_ttx()\n",
    "    h.working()\n",
    "    \n",
    "    Vm, I, t = run_model()\n",
    "    dvdt = np.gradient(Vm)/h.dt\n",
    "    ax1.plot(t, Vm, linewidth = 1, label = '{}%'.format(int(p*100)))\n",
    "    ax2.plot(Vm, dvdt, linewidth = 1)\n",
    "    AP_peak.append(np.max(Vm))\n",
    "    \n",
    "ax1.legend(frameon=False)\n",
    "# plt.savefig(\"\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Changing  K channels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-26T18:07:37.853828Z",
     "start_time": "2020-06-26T18:07:35.009335Z"
    }
   },
   "outputs": [],
   "source": [
    "sweep_len = 1000\n",
    "\n",
    "stim_dur = 95\n",
    "stim_start = 5\n",
    "amp = 0\n",
    "dt = 0.1\n",
    "init_stim(sweep_len=sweep_len, \n",
    "          stim_start=stim_start,\n",
    "          stim_dur=stim_dur,\n",
    "          amp=amp,\n",
    "          dt=dt)\n",
    "\n",
    "fig, [ax1, ax2, ax3] = plt.subplots(nrows=1, ncols=3, figsize=(15,4), sharex=False, sharey=False)\n",
    "fig_title = 'Baseline Model'\n",
    "fig.suptitle(fig_title) \n",
    "\n",
    "ax1.set_xlabel('Time (sec)')\n",
    "ax1.set_ylabel('Vm (mV)')\n",
    "\n",
    "ax2.set_xlabel('Vm (mV)')\n",
    "ax2.set_ylabel('dVdt (V/s)')\n",
    "\n",
    "channel_percent = np.arange(1,-0.1,-.1)\n",
    "channel_percent = [0]\n",
    "cmap = clr.LinearSegmentedColormap.from_list('scn2a', \n",
    "                                             [(0,    'k'),\n",
    "                                              (1,    'red')], N=256)\n",
    "\n",
    "ax1.set_prop_cycle('color',cmap(np.linspace(0,1,len(channel_percent))))\n",
    "ax2.set_prop_cycle('color',cmap(np.linspace(0,1,len(channel_percent))))\n",
    "ax3.set_prop_cycle('color',cmap(np.linspace(0,1,len(channel_percent))))\n",
    "\n",
    "\n",
    "AP_peak = []\n",
    "for i, p in enumerate(channel_percent):\n",
    "    init_settings()\n",
    "#     h.ais_na12=h.ais_na12*p\n",
    "#     h.soma_na12 = h.soma_na12*p \n",
    "#     h.dend_na12 = h.dend_na12*p\n",
    "\n",
    "    h.dend_k = h.dend_k * p \n",
    "    \n",
    "    h.soma_K = h.soma_K * p\n",
    "    h.soma_KCa = h.soma_KCa * p\n",
    "    \n",
    "    h.ais_KCa = h.ais_KCa * p\n",
    "    h.axon_KP = h.axon_KP * p\n",
    "    h.axon_KT = h.axon_KT * p\n",
    "    h.axon_K = h.axon_K * p\n",
    "    h.gpas_all = 0\n",
    "    h.gpas_axon = 0\n",
    "    add_ttx()\n",
    "    h.working()\n",
    "\n",
    "    Vm, I, t = run_model()\n",
    "    dvdt = np.gradient(Vm)/h.dt\n",
    "    ax1.plot(t, Vm, linewidth = 1, label = '{}%'.format(int(p*100)))\n",
    "    ax2.plot(Vm, dvdt, linewidth = 1)\n",
    "    \n",
    "    Vm = Vm+55\n",
    "#     ax3.plot(t, Vm/np.max(Vm), linewidth = 1)\n",
    "#     ax3.plot(t, dvdt / np.max(np.abs(dvdt)) , linewidth = 1, color = 'darkgrey')\n",
    "    ax3.plot(t, I['K'] , linewidth = 1)    \n",
    "#     ax3.plot(t, I['K'] / np.max(np.abs(I['K'])) , linewidth = 1)\n",
    "#     ax3.plot(t, np.abs(I['Na']) / np.max(np.abs(I['Na'])), linewidth = 1, color = 'b')\n",
    "    AP_peak.append(np.max(Vm))\n",
    "    \n",
    "ax1.legend(frameon=False)\n",
    "ax1.set_title('k current')\n",
    "\n",
    "# ax1.set_xlim(0.024, 0.03)\n",
    "# ax3.set_xlim(0.024, 0.03)\n",
    "# plt.savefig(\"\n",
    "\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# AIS NaV Composition on AP Waveform"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Removing All NaV1.2 in baseline model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-07-04T22:23:10.792411Z",
     "start_time": "2020-07-04T22:22:58.865408Z"
    },
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "sweep_len = 50\n",
    "stim_dur = 25\n",
    "stim_start = 25\n",
    "amp = 0.5\n",
    "dt = 0.01\n",
    "init_stim(sweep_len=sweep_len, \n",
    "          stim_start=stim_start,\n",
    "          stim_dur=stim_dur,\n",
    "          amp=amp,\n",
    "          dt=dt)\n",
    "\n",
    "fig, [ax1, ax2] = plt.subplots(nrows=1, ncols=2, figsize=(10,4), sharex=False, sharey=False)\n",
    "fig_title = 'Baseline Model'\n",
    "fig.suptitle(fig_title) \n",
    "\n",
    "ax1.set_xlabel('Time (sec)')\n",
    "ax1.set_ylabel('Vm (mV)')\n",
    "\n",
    "ax2.set_xlabel('Vm (mV)')\n",
    "ax2.set_ylabel('dVdt (V/s)')\n",
    "\n",
    "nav12_percent = np.arange(1,-0.1,-.1)\n",
    "cmap = clr.LinearSegmentedColormap.from_list('scn2a', \n",
    "                                             [(0,    'k'),\n",
    "                                              (0.5, 'skyblue'),\n",
    "                                              (1,    'red')], N=256)\n",
    "\n",
    "ax1.set_prop_cycle('color',cmap(np.linspace(0,1,len(nav12_percent))))\n",
    "ax2.set_prop_cycle('color',cmap(np.linspace(0,1,len(nav12_percent))))\n",
    "\n",
    "\n",
    "AP_peak = []\n",
    "for i, p in enumerate(nav12_percent):\n",
    "    init_settings()\n",
    "    h.ais_na12=h.ais_na12*p\n",
    "    h.soma_na12 = h.soma_na12*p \n",
    "    h.dend_na12 = h.dend_na12*p\n",
    "    h.working()\n",
    "\n",
    "    Vm, I, t = run_model()\n",
    "    dvdt = np.gradient(Vm)/h.dt\n",
    "    ax1.plot(t + i*.005, Vm, linewidth = 1, label = '{}%'.format(int(p*100)))\n",
    "    ax2.plot(Vm, dvdt, linewidth = 1)\n",
    "    AP_peak.append(np.max(Vm))\n",
    "    \n",
    "ax1.legend(frameon=False, title='NaV1.2')\n",
    "plt.savefig('model_phase_plane.pdf')\n",
    "\n",
    "plt.show()\n",
    "\n",
    "fig, ax = plt.subplots(nrows=1, ncols=1, figsize=(4,4), sharex=False, sharey=False)\n",
    "\n",
    "ax.set_ylabel('AP peak (mV)')\n",
    "ax.set_xlabel('Percent NaV1.2')\n",
    "\n",
    "ax.plot(nav12_percent * 100, AP_peak, color = 'k', linewidth = 1)\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Removing AIS NaV1.2 in baseline model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-09T22:55:18.563224Z",
     "start_time": "2020-06-09T22:55:05.013279Z"
    }
   },
   "outputs": [],
   "source": [
    "fig, [ax1, ax2] = plt.subplots(nrows=1, ncols=2, figsize=(10,4), sharex=False, sharey=False)\n",
    "fig_title = 'Baseline Model'\n",
    "fig.suptitle(fig_title) \n",
    "\n",
    "nav12_percent = np.arange(1,-0.1,-.1)\n",
    "cmap = plt.cm.binary_r\n",
    "\n",
    "ax1.set_prop_cycle('color',cmap(np.linspace(0,.5,len(nav16_percent))))\n",
    "ax2.set_prop_cycle('color',cmap(np.linspace(0,.5,len(nav16_percent))))\n",
    "\n",
    "for i, p in enumerate(nav12_percent):\n",
    "    init_settings()\n",
    "    h.ais_na12=h.ais_na12*p\n",
    "    h.working()\n",
    "\n",
    "    phase_plane_plot(ax1, ax2, label = '{}%'.format(int(p*100)))\n",
    "    \n",
    "ax1.legend(frameon=False, title='NaV1.2')\n",
    "# plt.savefig(\"{}.pdf\".format(fig_title), transparent=True)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-09T20:39:50.410218Z",
     "start_time": "2020-06-09T20:39:50.407570Z"
    }
   },
   "source": [
    "### Removing somatodendritic NaV1.2 in baseline model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-09T22:55:36.495246Z",
     "start_time": "2020-06-09T22:55:22.993672Z"
    }
   },
   "outputs": [],
   "source": [
    "fig, [ax1, ax2] = plt.subplots(nrows=1, ncols=2, figsize=(10,4), sharex=False, sharey=False)\n",
    "fig_title = 'Baseline Model'\n",
    "fig.suptitle(fig_title) \n",
    "\n",
    "nav12_percent = np.arange(1,-0.1,-.1)\n",
    "cmap = plt.cm.binary_r\n",
    "\n",
    "ax1.set_prop_cycle('color',cmap(np.linspace(0,.5,len(nav16_percent))))\n",
    "ax2.set_prop_cycle('color',cmap(np.linspace(0,.5,len(nav16_percent))))\n",
    "\n",
    "for i, p in enumerate(nav12_percent):\n",
    "    init_settings()\n",
    "    h.soma_na12 = h.soma_na12*p \n",
    "    h.dend_na12 = h.dend_na12*p\n",
    "    h.working()\n",
    "\n",
    "    phase_plane_plot(ax1, ax2, label = '{}%'.format(int(p*100)))\n",
    "    \n",
    "ax1.legend(frameon=False, title='NaV1.2')\n",
    "# plt.savefig(\"{}.pdf\".format(fig_title), transparent=True)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Removing somatic NaV1.2 in baseline model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-09T20:42:41.165853Z",
     "start_time": "2020-06-09T20:42:27.360928Z"
    }
   },
   "outputs": [],
   "source": [
    "fig, [ax1, ax2] = plt.subplots(nrows=1, ncols=2, figsize=(10,4), sharex=False, sharey=False)\n",
    "fig_title = 'Baseline Model'\n",
    "fig.suptitle(fig_title) \n",
    "\n",
    "nav12_percent = np.arange(1,-0.1,-.1)\n",
    "cmap = plt.cm.binary_r\n",
    "\n",
    "ax1.set_prop_cycle('color',cmap(np.linspace(0,.5,len(nav16_percent))))\n",
    "ax2.set_prop_cycle('color',cmap(np.linspace(0,.5,len(nav16_percent))))\n",
    "\n",
    "for i, p in enumerate(nav12_percent):\n",
    "    init_settings()\n",
    "    h.soma_na12 = h.soma_na12*p \n",
    "    h.working()\n",
    "\n",
    "    phase_plane_plot(ax1, ax2, label = '{}%'.format(int(p*100)))\n",
    "    \n",
    "ax1.legend(frameon=False, title='NaV1.2')\n",
    "# plt.savefig(\"{}.pdf\".format(fig_title), transparent=True)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Removing dendritic NaV1.2 in baseline model\n",
    "\n",
    "Only subtle changes to the second part of the repolarization phase, likely due to less recruitment of calcium activated K channels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-09T20:36:27.978306Z",
     "start_time": "2020-06-09T20:36:14.767485Z"
    }
   },
   "outputs": [],
   "source": [
    "fig, [ax1, ax2] = plt.subplots(nrows=1, ncols=2, figsize=(10,4), sharex=False, sharey=False)\n",
    "fig_title = 'Baseline Model'\n",
    "fig.suptitle(fig_title) \n",
    "\n",
    "nav12_percent = np.arange(1,-0.1,-.1)\n",
    "cmap = plt.cm.binary_r\n",
    "\n",
    "ax1.set_prop_cycle('color',cmap(np.linspace(0,.5,len(nav16_percent))))\n",
    "ax2.set_prop_cycle('color',cmap(np.linspace(0,.5,len(nav16_percent))))\n",
    "\n",
    "for i, p in enumerate(nav12_percent):\n",
    "    init_settings()\n",
    "    h.dend_na12=h.dend_na12*p\n",
    "    h.working()\n",
    "\n",
    "    phase_plane_plot(ax1, ax2, label = '{}%'.format(int(p*100)))\n",
    "    \n",
    "ax1.legend(frameon=False, title='NaV1.2')\n",
    "# plt.savefig(\"{}.pdf\".format(fig_title), transparent=True)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Model with modified somatic NaV1.2 and NaV1.6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-09T20:28:54.020562Z",
     "start_time": "2020-06-09T20:28:40.875914Z"
    }
   },
   "outputs": [],
   "source": [
    "fig, [ax1, ax2] = plt.subplots(nrows=1, ncols=2, figsize=(10,4), sharex=False, sharey=False)\n",
    "fig_title = '1.5x somatic NaV1.2, 0.7x somatic '\n",
    "fig.suptitle(fig_title) \n",
    "\n",
    "nav12_percent = np.arange(1,-0.1,-.1)\n",
    "cmap = plt.cm.binary_r\n",
    "\n",
    "ax1.set_prop_cycle('color',cmap(np.linspace(0,.5,len(nav16_percent))))\n",
    "ax2.set_prop_cycle('color',cmap(np.linspace(0,.5,len(nav16_percent))))\n",
    "\n",
    "for i, p in enumerate(nav12_percent):\n",
    "    init_settings()\n",
    "    h.soma_na12 = h.soma_na12*1.5\n",
    "    h.soma_na16 = h.soma_na16*.7\n",
    "    \n",
    "    h.ais_na12=h.ais_na12*p\n",
    "    h.soma_na12 = h.soma_na12*p \n",
    "    h.dend_na12 = h.dend_na12*p\n",
    "    h.working()\n",
    "\n",
    "    phase_plane_plot(ax1, ax2, label = '{}%'.format(int(p*100)))\n",
    "    \n",
    "ax1.legend(frameon=False, title='NaV1.2')\n",
    "# plt.savefig(\"{}.pdf\".format(fig_title), transparent=True)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Compensation by NaV1.6 in the AIS"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Increasing NaV1.6 in the AIS"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-09T22:24:10.271739Z",
     "start_time": "2020-06-09T22:23:58.628309Z"
    }
   },
   "outputs": [],
   "source": [
    "fig, [ax1, ax2] = plt.subplots(nrows=1, ncols=2, figsize=(10,4), sharex=False, sharey=False)\n",
    "fig_title = 'Base Model with increasing NaV1.6 '\n",
    "fig.suptitle(fig_title) \n",
    "\n",
    "nav16_percent = np.arange(1, 3, .2)\n",
    "cmap = plt.cm.binary_r\n",
    "\n",
    "ax1.set_prop_cycle('color',cmap(np.linspace(0,.5,len(nav16_percent))))\n",
    "ax2.set_prop_cycle('color',cmap(np.linspace(0,.5,len(nav16_percent))))\n",
    "\n",
    "for i, p in enumerate(nav16_percent):\n",
    "    init_settings()    \n",
    "    h.ais_na16=h.ais_na16*p\n",
    "    h.working()\n",
    "\n",
    "    phase_plane_plot(ax1, ax2, label = '{}%'.format(int(p*100)))\n",
    "    \n",
    "ax1.legend(frameon=False, title='NaV1.6')\n",
    "# plt.savefig(\"{}.pdf\".format(fig_title), transparent=True)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-09T22:25:48.541322Z",
     "start_time": "2020-06-09T22:25:36.813648Z"
    }
   },
   "outputs": [],
   "source": [
    "fig, [ax1, ax2] = plt.subplots(nrows=1, ncols=2, figsize=(10,4), sharex=False, sharey=False)\n",
    "fig_title = 'Base Model with increasing NaV1.6 '\n",
    "fig.suptitle(fig_title) \n",
    "\n",
    "nav16_percent = np.arange(1, 3, .2)\n",
    "cmap = plt.cm.binary_r\n",
    "\n",
    "ax1.set_prop_cycle('color',cmap(np.linspace(0,.5,len(nav16_percent))))\n",
    "ax2.set_prop_cycle('color',cmap(np.linspace(0,.5,len(nav16_percent))))\n",
    "\n",
    "for i, p in enumerate(nav16_percent):\n",
    "    init_settings()    \n",
    "    h.ais_na16=h.ais_na16*p\n",
    "    h.ais_na12= 0\n",
    "    h.dend_na12 = 0\n",
    "    h.soma_na12 = 0    \n",
    "    h.working()\n",
    "\n",
    "    phase_plane_plot(ax1, ax2, label = '{}%'.format(int(p*100)))\n",
    "    \n",
    "ax1.legend(frameon=False, title='NaV1.6')\n",
    "# plt.savefig(\"{}.pdf\".format(fig_title), transparent=True)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Functions to enable NaV1.2 replacement at the AIS by NaV1.2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-09T22:44:12.915176Z",
     "start_time": "2020-06-09T22:44:12.125076Z"
    },
    "code_folding": [
     0,
     18
    ],
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "def replace_AIS_nav12_with_nav16(scale _NaV12 = 1):\n",
    "    NaV12 = []\n",
    "    NaV16 = []\n",
    "    for i in range(nseg):\n",
    "        x = i/ h.cell.axon[0].nseg\n",
    "        NaV12.append(h.cell.axon[0](x).gbar_na12 + h.cell.axon[0](x).gbar_na12mut)\n",
    "        NaV16.append(h.cell.axon[0](x).gbar_na16)\n",
    "    h.ais_na12= 0\n",
    "    h.dend_na12 = 0\n",
    "    h.soma_na12 = 0    \n",
    "    h.working()\n",
    "    \n",
    "    NaV12 = NaV12 * scale_NaV12\n",
    "    for i in range(nseg):\n",
    "        x = i/ h.cell.axon[0].nseg\n",
    "        h.cell.axon[0](x).gbar_na16 = NaV12[i] + NaV16[i]\n",
    "        \n",
    "\n",
    "def plot_AIS_NaV_distribution(ax):\n",
    "    NaV12 = []\n",
    "    NaV16 = []\n",
    "    distance = []\n",
    "    nseg = h.cell.axon[0].nseg\n",
    "\n",
    "    for i in range(nseg):\n",
    "        x = i/nseg\n",
    "        distance.append(x)\n",
    "        NaV12.append(h.cell.axon[0](x).gbar_na12 + h.cell.axon[0](x).gbar_na12mut)\n",
    "        NaV16.append(h.cell.axon[0](x).gbar_na16)\n",
    "\n",
    "    NaV12 = np.asarray(NaV12)\n",
    "    NaV16 = np.asarray(NaV16)   \n",
    " \n",
    "    ax.set_xlabel(\"Distance\")\n",
    "    ax.set_ylabel(\"Channel density\")\n",
    "    \n",
    "    ax.plot(distance, NaV12, label = 'NaV12')\n",
    "    ax.plot(distance, NaV16, label = 'NaV16')\n",
    "    ax.plot(distance, NaV12 + NaV16, label = 'NaV12 + NaV16')\n",
    "\n",
    "    ax.legend(frameon = False)\n",
    "    \n",
    "    return ax \n",
    "\n",
    "# baseline model\n",
    "init_settings()\n",
    "\n",
    "fig, ax = plt.subplots(nrows=1, ncols=1, figsize=(8,4), sharex=False, sharey=False)\n",
    "ax.set_title('Baseline model AIS NaV distribution')\n",
    "ax = plot_AIS_NaV_distribution(ax)\n",
    "plt.show()\n",
    "\n",
    "# Hom model \n",
    "init_settings()\n",
    "h.ais_na12= 0\n",
    "h.dend_na12 = 0\n",
    "h.soma_na12 = 0    \n",
    "h.working()\n",
    "\n",
    "fig, ax = plt.subplots(nrows=1, ncols=1, figsize=(8,4), sharex=False, sharey=False)\n",
    "ax.set_title('Hom model AIS NaV distribution')\n",
    "ax = plot_AIS_NaV_distribution(ax)\n",
    "plt.show()\n",
    "\n",
    "# Hom model with NaV1.6 replacement\n",
    "init_settings()\n",
    "replace_AIS_nav12_with_nav16()\n",
    "\n",
    "fig, ax = plt.subplots(nrows=1, ncols=1, figsize=(8,4), sharex=False, sharey=False)\n",
    "ax.set_title('Hom model with NaV1.6 replacement AIS NaV distribution')\n",
    "ax = plot_AIS_NaV_distribution(ax)\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Running the replacement model\n",
    "This seems to create too large of an AIS hump, and there is no change of threshold "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-09T22:58:10.090373Z",
     "start_time": "2020-06-09T22:58:05.119761Z"
    }
   },
   "outputs": [],
   "source": [
    "sweep_len = 50\n",
    "stim_dur = 25\n",
    "stim_start = 25\n",
    "amp = 0.5\n",
    "dt = 0.01\n",
    "init_stim(sweep_len=sweep_len, \n",
    "          stim_start=stim_start,\n",
    "          stim_dur=stim_dur,\n",
    "          amp=amp,\n",
    "          dt=dt)\n",
    "\n",
    "fig, [ax1, ax2] = plt.subplots(nrows=1, ncols=2, figsize=(10,4), sharex=False, sharey=False)\n",
    "fig_title = 'Replacement Model'\n",
    "fig.suptitle(fig_title) \n",
    "\n",
    "nav12_percent = np.arange(1,-0.1,-.1)\n",
    "cmap = plt.cm.binary_r\n",
    "\n",
    "init_settings()\n",
    "phase_plane_plot(ax1, ax2, label = 'WT')\n",
    "\n",
    "init_settings()\n",
    "h.ais_na12= 0\n",
    "h.dend_na12 = 0\n",
    "h.soma_na12 = 0    \n",
    "h.working()\n",
    "phase_plane_plot(ax1, ax2, label = 'Hom without replacement')\n",
    "\n",
    "init_settings()\n",
    "replace_AIS_nav12_with_nav16()\n",
    "phase_plane_plot(ax1, ax2, label = 'Hom with replacement')\n",
    "\n",
    "init_settings()\n",
    "h.ais_na12= 0\n",
    "h.dend_na12 = 0\n",
    "h.soma_na12 = 0    \n",
    "h.working()\n",
    "scale_NaV16_proxmimal_AIS()\n",
    "phase_plane_plot(ax1, ax2, label = 'Hom with even NaV1.6')\n",
    "\n",
    "ax1.legend(frameon=False, title='NaV1.2')\n",
    "# plt.savefig(\"{}.pdf\".format(fig_title), transparent=True)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-09T22:45:32.861333Z",
     "start_time": "2020-06-09T22:45:29.898986Z"
    }
   },
   "outputs": [],
   "source": [
    "def scale_NaV16_proxmimal_AIS():\n",
    "    \n",
    "    for i in range(2, 4):\n",
    "        x = i/h.cell.axon[0].nseg\n",
    "        h.cell.axon[0](x).gbar_na16 = 4\n",
    "\n",
    "init_settings()\n",
    "h.ais_na12= 0\n",
    "h.dend_na12 = 0\n",
    "h.soma_na12 = 0    \n",
    "h.working()\n",
    "scale_NaV16_proxmimal_AIS()\n",
    "fig, ax = plt.subplots(nrows=1, ncols=1, figsize=(8,4), sharex=False, sharey=False)\n",
    "ax.set_title('Hom model + Proximal NaV1.6 AIS NaV distribution')\n",
    "ax = plot_AIS_NaV_distribution(ax)\n",
    "plt.show()\n",
    "\n",
    "\n",
    "sweep_len = 50\n",
    "stim_dur = 25\n",
    "stim_start = 25\n",
    "amp = 0.5\n",
    "dt = 0.01\n",
    "init_stim(sweep_len=sweep_len, \n",
    "          stim_start=stim_start,\n",
    "          stim_dur=stim_dur,\n",
    "          amp=amp,\n",
    "          dt=dt)\n",
    "\n",
    "fig, [ax1, ax2] = plt.subplots(nrows=1, ncols=2, figsize=(10,4), sharex=False, sharey=False)\n",
    "fig_title = 'Replacement Model'\n",
    "fig.suptitle(fig_title) \n",
    "\n",
    "ax1.set_xlabel('Time (sec)')\n",
    "ax1.set_ylabel('Vm (mV)')\n",
    "\n",
    "ax2.set_xlabel('Vm (mV)')\n",
    "ax2.set_ylabel('dVdt (V/s)')\n",
    "\n",
    "\n",
    "init_settings()\n",
    "\n",
    "# scale_NaV16_proxmimal_AIS()\n",
    "Vm, I, t = run_model()\n",
    "dvdt = np.gradient(Vm)/h.dt\n",
    "\n",
    "ax1.plot(t + 2*.005, Vm, linewidth = 1, label = 'WT')\n",
    "ax2.plot(Vm, dvdt, linewidth = 1)\n",
    "\n",
    "init_settings()\n",
    "h.ais_na12= 0\n",
    "h.dend_na12 = 0\n",
    "h.soma_na12 = 0    \n",
    "h.working()\n",
    "scale_NaV16_proxmimal_AIS()\n",
    "Vm, I, t = run_model()\n",
    "dvdt = np.gradient(Vm)/h.dt\n",
    "\n",
    "ax1.plot(t + 2*.005, Vm, linewidth = 1, label = 'Hom with even NaV1.6')\n",
    "ax2.plot(Vm, dvdt, linewidth = 1)\n",
    "\n",
    "\n",
    "ax1.legend(frameon=False, title='NaV1.2')\n",
    "# plt.savefig(\"{}.pdf\".format(fig_title), transparent=True)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# FI Curves"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-07-04T22:12:48.681712Z",
     "start_time": "2020-07-04T22:12:48.491635Z"
    },
    "code_folding": []
   },
   "outputs": [],
   "source": [
    "from scipy.signal import find_peaks\n",
    "\n",
    "def FI_curve(stims, stim_start = 50, stim_dur = 300, sweep_len = 350, dt = 0.1):\n",
    "             \n",
    "    f = []\n",
    "    i = []\n",
    "    for amp in stims:\n",
    "        i.append(amp)\n",
    "        init_stim(stim_start=stim_start, stim_dur=stim_dur, sweep_len=sweep_len, dt=dt, amp=amp)\n",
    "        Vm, I, t = run_model()\n",
    "        peaks = find_peaks(Vm)[0]\n",
    "        \n",
    "        num_spikes = 0\n",
    "        for peak in peaks:\n",
    "            if Vm[peak] > -40:\n",
    "                num_spikes = num_spikes + 1\n",
    "        f.append(num_spikes)\n",
    "    \n",
    "    return f, i\n",
    "\n",
    "def FI_curve_plot(stims, ax, label='', stim_start = 50, stim_dur = 300, sweep_len = 350, dt = 0.1):\n",
    "    f, i = FI_curve(stims=stims, stim_start=stim_start, stim_dur=stim_dur, sweep_len=sweep_len, dt=dt)\n",
    "    \n",
    "    ax.set_ylabel('Spikes per Epoch ({}ms)'.format(stim_dur))\n",
    "    ax.set_xlabel('Injected Current (nA)')\n",
    "    ax.plot(i, f, linewidth = 1, label=label) \n",
    "\n",
    "    \n",
    "def FI_curve_spikes(stims, ax, title='', color='k', stim_start = 25, stim_dur = 300, sweep_len = 450, dt = 0.1):\n",
    "    \n",
    "    for i, amp in enumerate(stims):\n",
    "        init_stim(stim_start=stim_start, stim_dur=stim_dur, sweep_len=sweep_len, dt=dt, amp=amp)\n",
    "        Vm, I, t = run_model()\n",
    "        \n",
    "        ax.plot(t, Vm + 110*i, linewidth=1, color=color)\n",
    "        ax.set_xlim(.035,.325)\n",
    "    ax.plot([.035, .035], [0, 20], color = 'k')\n",
    "    ax.plot([.035, .085], [0, 0], color = 'k')\n",
    "    ax.set_title(title)\n",
    "    ax.set_axis_off()\n",
    "    \n",
    "stims = np.arange(0, .6, .1)\n",
    "init_settings()\n",
    "\n",
    "# fig, ax = plt.subplots(nrows=1, ncols=1, figsize=(8,4), sharex=False, sharey=False)\n",
    "# FI_curve_plot(stims, ax)\n",
    "# plt.show()\n",
    "\n",
    "# fig, ax = plt.subplots(nrows=1, ncols=1, figsize=(8, 16), sharex=False, sharey=False)\n",
    "# FI_curve_spikes(stims, ax, title='WT')\n",
    "# plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## FI Curves with baseline model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-07-04T22:13:05.070368Z",
     "start_time": "2020-07-04T22:12:50.579477Z"
    }
   },
   "outputs": [],
   "source": [
    "stims = np.arange(0, .6, .1)\n",
    "\n",
    "fig, ax = plt.subplots(nrows=1, ncols=1, figsize=(8,4), sharex=False, sharey=False)\n",
    "ax.set_prop_cycle('color',['k', 'skyblue', 'red'])\n",
    "\n",
    "init_settings()\n",
    "FI_curve_plot(stims, ax=ax, label='WT')\n",
    "\n",
    "init_settings()\n",
    "h.ais_na12 = h.ais_na12/2\n",
    "h.soma_na12 = h.soma_na12/2\n",
    "h.dend_na12 = h.dend_na12/2\n",
    "h.working()\n",
    "FI_curve_plot(stims, ax=ax, label='Het')\n",
    "\n",
    "init_settings()\n",
    "h.ais_na12 = h.ais_na12*0\n",
    "h.soma_na12 = h.soma_na12*0\n",
    "h.dend_na12 = h.dend_na12*0\n",
    "h.working()\n",
    "FI_curve_plot(stims, ax=ax, label='Hom')\n",
    "\n",
    "ax.legend(frameon = False)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-07-04T20:53:47.960854Z",
     "start_time": "2020-07-04T20:53:30.068710Z"
    }
   },
   "outputs": [],
   "source": [
    "fig, [ax1, ax2, ax3] = plt.subplots(nrows=1, ncols=3, figsize=(24, 16), sharex=False, sharey=False)\n",
    "\n",
    "stims = np.arange(0.15, .6, .1)\n",
    "\n",
    "init_settings()\n",
    "FI_curve_spikes(stims, ax1, color='k', title='100% NaV1.2')\n",
    "\n",
    "init_settings()\n",
    "h.ais_na12 = h.ais_na12/2\n",
    "h.soma_na12 = h.soma_na12/2\n",
    "h.dend_na12 = h.dend_na12/2\n",
    "h.working()\n",
    "FI_curve_spikes(stims, ax2, color='skyblue', title='50% NaV1.2')\n",
    "\n",
    "init_settings()\n",
    "h.ais_na12 = h.ais_na12*0\n",
    "h.soma_na12 = h.soma_na12*0\n",
    "h.dend_na12 = h.dend_na12*0\n",
    "h.working()\n",
    "FI_curve_spikes(stims, ax3, color='red', title='0% NaV1.2')\n",
    "\n",
    "plt.savefig('model_FI_spiking.pdf')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-07-04T21:03:59.250314Z",
     "start_time": "2020-07-04T20:54:25.883520Z"
    }
   },
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots(nrows=1, ncols=1, figsize=(8,4), sharex=False, sharey=False)\n",
    "fig_title = 'FI curve'\n",
    "fig.suptitle(fig_title) \n",
    "\n",
    "nav12_percent = np.arange(1,-0.1,-.1)\n",
    "\n",
    "stims = np.arange(0, .6001, .01)\n",
    "cmap = clr.LinearSegmentedColormap.from_list('scn2a', \n",
    "                                             [(0,    'k'),\n",
    "                                              (0.5, 'skyblue'),\n",
    "                                              (1,    'red')], N=256)\n",
    "\n",
    "ax.set_prop_cycle('color',cmap(np.linspace(0,1,len(nav12_percent))))\n",
    "nav12_percent = np.arange(1,-0.1,-.1)\n",
    "for p in nav12_percent:\n",
    "    init_settings()\n",
    "    h.ais_na12 = h.ais_na12 * p\n",
    "    h.soma_na12 = h.soma_na12 * p\n",
    "    h.dend_na12 = h.dend_na12 * p\n",
    "    h.working()\n",
    "    FI_curve_plot(stims, ax=ax, label='{}%'.format(int(p * 100)))\n",
    "\n",
    "ax.legend(frameon=False)\n",
    "plt.savefig('model_FI_curve.pdf')\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-10T05:20:43.895611Z",
     "start_time": "2020-06-10T05:18:17.294139Z"
    }
   },
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots(nrows=1, ncols=1, figsize=(8,4), sharex=False, sharey=False)\n",
    "fig_title = 'FI curve'\n",
    "fig.suptitle(fig_title) \n",
    "\n",
    "stims = np.arange(0, .6, .1)\n",
    "cmap = plt.cm.binary_r\n",
    "ax.set_prop_cycle('color',cmap(np.linspace(0,.5,len(nav16_percent) + 1)))\n",
    "nav16_percent = np.arange(1,2,.1)\n",
    "for p in nav16_percent:\n",
    "    init_settings()\n",
    "    h.ais_na16 = h.ais_na16 * p\n",
    "    h.ais_na12 = 0\n",
    "    h.soma_na12 = 0\n",
    "    h.dend_na12 = 0\n",
    "    h.working()\n",
    "    FI_curve_plot(stims, ax=ax, label='{}%'.format(int(p * 100)))\n",
    "\n",
    "ax.legend(frameon=False)\n",
    "# plt.savefig(\"{}.pdf\".format(fig_title), transparent=True)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-10T17:19:06.019468Z",
     "start_time": "2020-06-10T17:16:23.802197Z"
    }
   },
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots(nrows=1, ncols=1, figsize=(8,4), sharex=False, sharey=False)\n",
    "fig_title = 'FI curve'\n",
    "fig.suptitle(fig_title) \n",
    "\n",
    "stims = np.arange(0, .6, .1)\n",
    "cmap = plt.cm.spectral\n",
    "ax.set_prop_cycle('color',cmap(np.linspace(0,1,len(nav16_percent) + 1)))\n",
    "nav16_percent = np.arange(1,-0.1,-.1)\n",
    "for p in nav16_percent:\n",
    "    init_settings()\n",
    "    h.ais_na16 = h.ais_na16 * p\n",
    "    h.soma_na16 = h.soma_na16 * p\n",
    "    h.dend_na16 = h.dend_na16 * p\n",
    "    h.working()\n",
    "    FI_curve_plot(stims, ax=ax, label='{}%'.format(int(p * 100)))\n",
    "\n",
    "ax.legend(frameon=False)\n",
    "# plt.savefig(\"{}.pdf\".format(fig_title), transparent=True)\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Interspike AHP"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-07-04T22:09:27.778872Z",
     "start_time": "2020-07-04T22:09:20.493685Z"
    },
    "code_folding": [
     18,
     19,
     25,
     48,
     49,
     82
    ],
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "sweep_len = 100\n",
    "stim_dur = 50\n",
    "stim_start = 25\n",
    "amp = 0.6\n",
    "dt = 0.1\n",
    "init_stim(sweep_len=sweep_len, \n",
    "          stim_start=stim_start,\n",
    "          stim_dur=stim_dur,\n",
    "          amp=amp,\n",
    "          dt=dt)\n",
    "\n",
    "### Model with decreasing NaV1.2\n",
    "fig, ax = plt.subplots(nrows=1, ncols=1, figsize=(4,3), sharex=False, sharey=False)\n",
    "ax.set_title('Model Reducing NaV1.2')\n",
    "ax.set_ylabel('Vm (mV)')\n",
    "ax.set_ylabel('Time (sec)')\n",
    "\n",
    "nav12_percent = np.arange(1,-0.1,-.1)\n",
    "cmap = clr.LinearSegmentedColormap.from_list('scn2a', \n",
    "                                             [(0,    'k'),\n",
    "                                              (0.5, 'skyblue'),\n",
    "                                              (1,    'red')], N=256)\n",
    "\n",
    "ax.set_prop_cycle('color',cmap(np.linspace(0,1,len(nav12_percent))))\n",
    "\n",
    "for i, p in enumerate(nav12_percent):\n",
    "    init_settings()\n",
    "    h.ais_na12=h.ais_na12*p\n",
    "    h.soma_na12 = h.soma_na12*p \n",
    "    h.dend_na12 = h.dend_na12*p\n",
    "    h.working()\n",
    "    \n",
    "    Vm, I, t = run_model()\n",
    "    ax.plot(t, Vm, linewidth=1, label = '{}'.format(int(p*100)))\n",
    "    \n",
    "ax.legend(frameon=False, title='NaV1.2 (%)')\n",
    "ax.set_xlim(.035,.073)\n",
    "ax.set_ylim(-75,40)\n",
    "\n",
    "plt.savefig('model_AHP.pdf')\n",
    "plt.show()\n",
    "\n",
    "### Hom Model with increasing KP\n",
    "fig, ax = plt.subplots(nrows=1, ncols=1, figsize=(4,3), sharex=False, sharey=False)\n",
    "ax.set_title('Hom model with increasing KP')\n",
    "ax.set_ylabel('Vm (mV)')\n",
    "ax.set_ylabel('Time (sec)')\n",
    "\n",
    "k_percent = np.arange(1,2.6,.25)\n",
    "cmap = clr.LinearSegmentedColormap.from_list('scn2a', \n",
    "                                             [(0,    'red'),\n",
    "                                              (1,    'k')], N=256)\n",
    "\n",
    "ax.set_prop_cycle('color',cmap(np.linspace(0,1,len(k_percent))))\n",
    "\n",
    "for i, p in enumerate(k_percent):\n",
    "    init_settings()\n",
    "    h.ais_na12= 0\n",
    "    h.soma_na12 = 0\n",
    "    h.dend_na12 = 0\n",
    "    h.axon_KP = h.axon_KP * p\n",
    "    h.working()\n",
    "    Vm, I, t = run_model()\n",
    "    ax.plot(t, Vm, linewidth=1, label = '{}'.format(int(p*100)))\n",
    "    \n",
    "ax.legend(frameon=False, title='KP (%)')\n",
    "ax.set_xlim(.035,.073)\n",
    "ax.set_ylim(-75,40)\n",
    "plt.savefig('model_AHP_Hom_increasing_KP.pdf')\n",
    "plt.show()\n",
    "\n",
    "### WT model with decreasing KP\n",
    "fig, ax = plt.subplots(nrows=1, ncols=1, figsize=(4,3), sharex=False, sharey=False)\n",
    "\n",
    "ax.set_title('WT model reducing KP')\n",
    "k_percent = np.arange(1,0.3,-.1)\n",
    "cmap = clr.LinearSegmentedColormap.from_list('scn2a', \n",
    "                                             [(0,    'K'),\n",
    "                                              (1,    'blue')], N=256)\n",
    "\n",
    "ax.set_prop_cycle('color',cmap(np.linspace(0,1,len(k_percent))))\n",
    "\n",
    "for i, p in enumerate(k_percent):\n",
    "    init_settings()\n",
    "    h.axon_KP = h.axon_KP * p\n",
    "    h.working()\n",
    "    \n",
    "    Vm, I, t = run_model()\n",
    "    ax.plot(t, Vm, linewidth=1, label = '{}'.format(int(p*100)))\n",
    "    \n",
    "ax.legend(frameon=False, title='KP (%)')\n",
    "ax.set_xlim(.035,.073)\n",
    "ax.set_ylim(-75,40)\n",
    "plt.savefig('model_AHP_WT_decreasing_KP.pdf')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-07-04T21:34:56.912072Z",
     "start_time": "2020-07-04T21:12:35.719748Z"
    }
   },
   "outputs": [],
   "source": [
    "stims = np.arange(0, .6001, .01)\n",
    "\n",
    "\n",
    "fig, ax = plt.subplots(nrows=1, ncols=1, figsize=(4,2), sharex=False, sharey=False)\n",
    "fig_title = 'FI curve WT to Hom'\n",
    "fig.suptitle(fig_title) \n",
    "\n",
    "cmap = clr.LinearSegmentedColormap.from_list('scn2a', \n",
    "                                             [(0,    'k'),\n",
    "                                              (0.5, 'skyblue'),\n",
    "                                              (1,    'red')], N=256)\n",
    "\n",
    "ax.set_prop_cycle('color',cmap(np.linspace(0,1,len(nav12_percent))))\n",
    "nav12_percent = np.arange(1,-0.1,-.1)\n",
    "for p in nav12_percent:\n",
    "    init_settings()\n",
    "    h.ais_na12 = h.ais_na12 * p\n",
    "    h.soma_na12 = h.soma_na12 * p\n",
    "    h.dend_na12 = h.dend_na12 * p\n",
    "    h.working()\n",
    "    FI_curve_plot(stims, ax=ax, label='{}%'.format(int(p * 100)))\n",
    "\n",
    "ax.legend(frameon=False)\n",
    "plt.savefig('model_FI_curve.pdf')\n",
    "plt.show()\n",
    "\n",
    "\n",
    "\n",
    "fig, ax = plt.subplots(nrows=1, ncols=1, figsize=(4,2), sharex=False, sharey=False)\n",
    "fig_title = 'FI curve Hom with increasing KP'\n",
    "fig.suptitle(fig_title) \n",
    "\n",
    "k_percent = np.arange(1,2.6,.25)\n",
    "cmap = clr.LinearSegmentedColormap.from_list('scn2a', \n",
    "                                             [(0,    'red'),\n",
    "                                              (1,    'k')], N=256)\n",
    "\n",
    "ax.set_prop_cycle('color',cmap(np.linspace(0,1,len(k_percent))))\n",
    "for p in k_percent:\n",
    "    init_settings()\n",
    "    h.ais_na12 = h.ais_na12 * 0\n",
    "    h.soma_na12 = h.soma_na12 * 0\n",
    "    h.dend_na12 = h.dend_na12 * 0\n",
    "    h.axon_KP = h.axon_KP * p\n",
    "    h.working()\n",
    "    \n",
    "    FI_curve_plot(stims, ax=ax, label='{}%'.format(int(p * 100)))\n",
    "\n",
    "ax.legend(frameon=False)\n",
    "plt.savefig('model_FI_curve_Hom_increasing_KP.pdf')\n",
    "plt.show()\n",
    "\n",
    "\n",
    "\n",
    "fig, ax = plt.subplots(nrows=1, ncols=1, figsize=(4,2), sharex=False, sharey=False)\n",
    "fig_title = 'FI curve – WT with decrease KP'\n",
    "fig.suptitle(fig_title) \n",
    "\n",
    "k_percent = np.arange(1,0.3,-.1)\n",
    "cmap = clr.LinearSegmentedColormap.from_list('scn2a', \n",
    "                                             [(0,    'K'),\n",
    "                                              (1,    'blue')], N=256)\n",
    "ax.set_prop_cycle('color',cmap(np.linspace(0,1,len(k_percent))))\n",
    "\n",
    "for p in k_percent:\n",
    "    init_settings()\n",
    "    h.axon_KP = h.axon_KP * p\n",
    "    h.working()\n",
    "    \n",
    "    FI_curve_plot(stims, ax=ax, label='{}%'.format(int(p * 100)))\n",
    "\n",
    "ax.legend(frameon=False)\n",
    "plt.savefig('model_FI_curve_WT_decreasing_KP.pdf')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Currents"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-10T18:00:24.978717Z",
     "start_time": "2020-06-10T18:00:11.667281Z"
    }
   },
   "outputs": [],
   "source": [
    "def Na_k_current_plots(ax1, ax2, label):\n",
    "    ax1.set_title('I_Na')\n",
    "    ax1.set_xlabel('Time (sec)')\n",
    "    ax1.set_ylabel('I_Na (nA)')\n",
    "    \n",
    "    ax2.set_title('I_k')\n",
    "    ax2.set_xlabel('Time (sec)')\n",
    "    ax2.set_ylabel('I_k (nA)')\n",
    "    \n",
    "    ax3.set_title('Na/K ratio')\n",
    "    ax3.set_ylabel('Na/K ratio')\n",
    "    ax3.set_xlabel('Percent NaV1.2')\n",
    "    ax3.set_xlim(105, -5)\n",
    "    \n",
    "    Vm, I, t = run_model()\n",
    "    \n",
    "    ax1.plot(t + i*.005, I['Na'], linewidth = 1, label = label)\n",
    "    ax2.plot(t + i*.005, I['K'], linewidth = 1, label = label)\n",
    "    \n",
    "    ratio = np.max(np.abs(I['Na']))/np.max(np.abs(I['K']))\n",
    "    ax3.scatter(int(p * 100), ratio)\n",
    "\n",
    "\n",
    "sweep_len = 50\n",
    "stim_dur = 25\n",
    "stim_start = 25\n",
    "amp = 0.5\n",
    "dt = 0.01\n",
    "init_stim(sweep_len=sweep_len, \n",
    "          stim_start=stim_start,\n",
    "          stim_dur=stim_dur,\n",
    "          amp=amp,\n",
    "          dt=dt)\n",
    "\n",
    "fig, [ax1, ax2, ax3] = plt.subplots(nrows=1, ncols=3, figsize=(15,4), sharex=False, sharey=False)\n",
    "fig_title = 'Baseline Model'\n",
    "fig.suptitle(fig_title) \n",
    "\n",
    "nav12_percent = np.arange(1,-0.1,-.1)\n",
    "cmap = clr.LinearSegmentedColormap.from_list('scn2a', \n",
    "                                             [(0,    'k'),\n",
    "                                              (0.5, 'skyblue'),\n",
    "                                              (1,    'red')], N=256)\n",
    "\n",
    "ax1.set_prop_cycle('color',cmap(np.linspace(0,1,len(nav12_percent))))\n",
    "ax2.set_prop_cycle('color',cmap(np.linspace(0,1,len(nav12_percent))))\n",
    "ax3.set_prop_cycle('color',cmap(np.linspace(0,1,len(nav12_percent))))\n",
    "\n",
    "for i, p in enumerate(nav12_percent):\n",
    "    init_settings()\n",
    "    h.ais_na12=h.ais_na12*p\n",
    "    h.soma_na12 = h.soma_na12*p \n",
    "    h.dend_na12 = h.dend_na12*p\n",
    "    h.working()\n",
    "\n",
    "    Na_k_current_plots(ax1, ax2, label = '{}'.format(int(p*100)))\n",
    "    \n",
    "ax1.legend(frameon=False, title='NaV1.2 (%)')\n",
    "# plt.savefig(\"{}.pdf\".format(fig_title), transparent=True)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Old stuff"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "init_stim(dur = 300, len = 400, amp = .2, dt = .02, delay = 50)\n",
    "\n",
    "\n",
    "fig = plt.figure(figsize = (10, 5))\n",
    "ax1 = fig.add_subplot(121)\n",
    "ax1.set_xlabel('Time (sec)')\n",
    "ax1.set_ylabel('Vm (mV)')\n",
    "ax2 = fig.add_subplot(122)\n",
    "ax2.set_xlabel('Vm (mV)')\n",
    "ax2.set_ylabel('dVdt (V/s)')\n",
    "\n",
    "init_settings()\n",
    "h.soma_na12 = h.soma_na12*1.3\n",
    "h.soma_na16 = h.soma_na16*.85\n",
    "h.working()\n",
    "\n",
    "volts, time = run_model()\n",
    "dvdt = np.gradient(volts)/h.dt\n",
    "ax1.plot(time,volts, color = 'black')\n",
    "ax2.plot(volts,dvdt, color = 'black')\n",
    "\n",
    "init_settings()\n",
    "h.ais_na12 = h.ais_na12/2\n",
    "h.soma_na12 = h.soma_na12/2\n",
    "# h.ais_na16 = h.ais_na16 * 1.3\n",
    "h.working()\n",
    "\n",
    "volts, time = run_model()\n",
    "dvdt = np.gradient(volts)/h.dt\n",
    "ax1.plot(time,volts, color = 'skyblue')\n",
    "ax2.plot(volts,dvdt, color = 'skyblue')\n",
    "\n",
    "init_settings()\n",
    "h.ais_na12 = 0\n",
    "h.soma_na12 = 0\n",
    "h.soma_na12 = 0\n",
    "# h.ais_na16 = h.ais_na16 * 1.5\n",
    "h.working()\n",
    "\n",
    "volts, time = run_model()\n",
    "volts, time = run_model()\n",
    "dvdt = np.gradient(volts)/h.dt\n",
    "ax1.plot(time,volts, color = 'red')\n",
    "ax2.plot(volts,dvdt, color = 'red')\n",
    "\n",
    "# ax2.set_xlim(-55, -45)\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "\n",
    "stims = np.arange(0, 1, .1)\n",
    "\n",
    "fig = plt.figure()\n",
    "ax = plt.gca()\n",
    "ax.set_ylabel('Spikes per epoch (300 ms)')\n",
    "ax.set_xlabel('Current injection (nA)')\n",
    "\n",
    "init_settings()\n",
    "h.soma_na12 = h.soma_na12*1.3\n",
    "h.soma_na16 = h.soma_na16*.85\n",
    "\n",
    "h.working()\n",
    "f, i = FI_curve(stims)\n",
    "ax.plot(i, f, color = 'k', label = 'WT')\n",
    "\n",
    "h.ais_na12 = h.ais_na12/2\n",
    "h.soma_na12 = h.soma_na12/2\n",
    "h.working()\n",
    "f, i = FI_curve(stims)\n",
    "ax.plot(i, f, color = 'skyblue', label = '50% NaV1.2')\n",
    "\n",
    "h.ais_na12 = 0\n",
    "h.soma_na12 = 0\n",
    "h.soma_na12 = 0\n",
    "# h.ais_na16 = h.ais_na16 * 1.5\n",
    "h.working()\n",
    "f, i = FI_curve(stims)\n",
    "ax.plot(i, f, color = 'red', label = 'No NaV1.2')\n",
    "\n",
    "\n",
    "h.ais_na12 = 0\n",
    "h.soma_na12 = 0\n",
    "h.soma_na12 = 0\n",
    "h.ais_na16 = h.ais_na16 * 1.5\n",
    "h.working()\n",
    "f, i = FI_curve(stims)\n",
    "ax.plot(i, f, color = 'firebrick', label = 'No NaV1.2 + 1.5x NaV1.6')\n",
    "\n",
    "ax.legend(frameon=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig = plt.figure()\n",
    "ax = plt.gca()\n",
    "\n",
    "init_settings()\n",
    "h.soma_na12 = h.soma_na12*1.3\n",
    "h.soma_na16 = h.soma_na16*.85\n",
    "h.ais_na12 = 0\n",
    "h.soma_na12 = 0\n",
    "h.soma_na12 = 0\n",
    "h.ais_na16 = h.ais_na16 * 1.5\n",
    "\n",
    "stims = np.arange(0, 1, .2)\n",
    "for i, stim in enumerate(stims):\n",
    "    init_stim(dur = 300, len = 450, amp = stim, dt = 0.1)\n",
    "    volts, time = run_model()\n",
    "    \n",
    "    ax.plot(time, volts + i*80, color = 'k')\n",
    "    \n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig = plt.figure()\n",
    "ax = plt.gca()\n",
    "ax.set_ylabel('Spikes per epoch (300 ms)')\n",
    "ax.set_xlabel('Current injection (nA)')\n",
    "\n",
    "ax.set_title('Hom AIS NaV1.6 compensation comparison')\n",
    "init_settings()\n",
    "h.soma_na12 = h.soma_na12*1.3\n",
    "h.soma_na16 = h.soma_na16*.85\n",
    "\n",
    "h.ais_na12 = 0\n",
    "h.soma_na12 = 0\n",
    "h.soma_na12 = 0\n",
    "# h.ais_na16 = h.ais_na16 * 1.5\n",
    "h.working()\n",
    "f, i = FI_curve(stims)\n",
    "ax.plot(i, f, color = 'k', label = 'Hom')\n",
    "\n",
    "h.ais_na16 = h.ais_na16 * 1.5\n",
    "h.working()\n",
    "f, i = FI_curve(stims)\n",
    "ax.plot(i, f, color = 'red', label = 'Hom + 1.5x AIS NaV1.6')\n",
    "\n",
    "ax.legend(frameon=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-10T17:57:57.434424Z",
     "start_time": "2020-06-10T17:57:57.235143Z"
    }
   },
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "gradient = np.linspace(0, 1, 256)\n",
    "gradient = np.vstack((gradient, gradient))\n",
    "plt.imshow(gradient, aspect='auto', cmap=cmap)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "asdf\n",
    "ç\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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.8.5"
  },
  "notify_time": "10",
  "toc": {
   "base_numbering": "0",
   "nav_menu": {},
   "number_sections": true,
   "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": "280px"
   },
   "toc_section_display": true,
   "toc_window_display": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}