# -*- coding: utf-8 -*-
"""
Created on April 03 14:27:26 2020
Depressing_Spinal_Motoneuron_Cell_Classes.py
This file contains the Spinal_Motoneuron class describing a five-compartment
motoneuron structure (single soma and four dendritic compartments) each
containing hodgkin-huxley type ionic mechanisms. Each dendritic compartment
receives a synaptic input due to correlated and independent synaptic currents.
Implemented by: John Fleming, john.fleming@ucdconnect.ie,
Sageanne Senneff, sageanne.senneff@ucdconnect.ie
Edits: 06-11-19 : John Fleming - Converted Sageanne's implementation of the motoneuron NEURON model into correct format for PyNN
04-06-20 : John Fleming - Updated the motoneuron class to have synapse mechanisms for correlated and independent synaptic inputs on the dendrites
"""
from neuron import h
from nrnutils import Mechanism, Section
from pyNN.neuron import NativeCellType
from pyNN.parameters import Sequence
import numpy as np
# Import global variables for generating the seeds for the dendritic noise
import Global_Variables as GV
# Load ranstream hoc template for generating random streams
h.load_file("ranstream.hoc")
try:
reduce
except NameError:
from functools import reduce
def _new_property(obj_hierarchy, attr_name):
"""
Returns a new property, mapping attr_name to obj_hierarchy.attr_name.
For example, suppose that an object of class A has an attribute b which
itself has an attribute c which itself has an attribute d. Then placing
e = _new_property('b.c', 'd')
in the class definition of A makes A.e an alias for A.b.c.d
"""
def set(self, value):
obj = reduce(getattr, [self] + obj_hierarchy.split('.'))
setattr(obj, attr_name, value)
def get(self):
obj = reduce(getattr, [self] + obj_hierarchy.split('.'))
return getattr(obj, attr_name)
return property(fset=set, fget=get)
class Spinal_Motoneuron_Synaptic_Bombardment_Point_Process(object):
def __init__(self, **parameters):
# Create Soma Compartments
self.soma = Section(diam = parameters['soma_diam'], L = parameters['soma_L'], Ra = parameters['soma_Ra'], cm = parameters['soma_cm'],
mechanisms = (Mechanism('na3rp', gbar = parameters['soma_na3rp_gbar'], sh = parameters['soma_na3rp_sh'], ar = parameters['soma_na3rp_ar'], qinf = parameters['soma_na3rp_qinf'], thinf = parameters['soma_na3rp_thinf']),
Mechanism('naps', gbar = parameters['soma_naps_gbar'], sh = parameters['soma_naps_sh'], ar = parameters['soma_naps_ar'], vslope = parameters['soma_naps_vslope'], asvh = parameters['soma_naps_asvh'], bsvh = parameters['soma_naps_bsvh']),
Mechanism('kdrRL', gMax = parameters['soma_kdrRL_gMax'], tmin = parameters['soma_kdrRL_tmin'], taumax = parameters['soma_kdrRL_taumax'], mVh = parameters['soma_kdrRL_mVh']),
Mechanism('mAHP', gcamax = parameters['soma_mAHP_gcamax'], gkcamax = parameters['soma_mAHP_gkcamax'], taur = parameters['soma_mAHP_taur'], mtauca = parameters['soma_mAHP_mtauca'], mvhalfca = parameters['soma_mAHP_mvhalfca'])))
# Insert passive mechanism in soma
self.soma.insert('pas')
for seg in self.soma:
seg.pas.g = parameters['soma_pas_g']
seg.pas.e = parameters['soma_pas_e']
# Insert h mechanism in soma
self.soma.insert('gh')
for seg in self.soma:
seg.gh.ghbar = parameters['soma_gh_ghbar']
seg.gh.half = parameters['soma_gh_half']
seg.gh.htau = parameters['soma_gh_htau']
# Set threshold netcons on the neuron
self.soma.v_thresh = parameters['v_thres']
# Add bias current to MU soma - current amplitude is in terms of original model paper, nA
self.soma_bias = h.IClamp(0.5, sec=self.soma)
self.soma_bias.delay = 0
self.soma_bias.dur = 1e12
self.soma_bias.amp = parameters['soma_bias_current_amp']
# Create Dendritic Compartments
self.d1 = Section(diam = parameters['dendrite_diam'], L = parameters['dendrite_L'], Ra = parameters['dendrite_Ra'], cm = parameters['dendrite_cm'],
mechanisms = (Mechanism('pas', g = parameters['dendrite_pas_g'], e = parameters['dendrite_pas_e']),
Mechanism('gh', ghbar = parameters['dendrite_gh_ghbar'], half = parameters['dendrite_gh_half'], htau = parameters['dendrite_gh_htau'])))
self.d2 = Section(diam = parameters['dendrite_diam'], L = parameters['dendrite_L'], Ra = parameters['dendrite_Ra'], cm = parameters['dendrite_cm'],
mechanisms = (Mechanism('pas', g = parameters['dendrite_pas_g'], e = parameters['dendrite_pas_e']),
Mechanism('gh', ghbar = parameters['dendrite_gh_ghbar'], half = parameters['dendrite_gh_half'], htau = parameters['dendrite_gh_htau'])))
self.d3 = Section(diam = parameters['dendrite_diam'], L = parameters['dendrite_L'], Ra = parameters['dendrite_Ra'], cm = parameters['dendrite_cm'],
mechanisms = (Mechanism('pas', g = parameters['dendrite_pas_g'], e = parameters['dendrite_pas_e']),
Mechanism('gh', ghbar = parameters['dendrite_gh_ghbar'], half = parameters['dendrite_gh_half'], htau = parameters['dendrite_gh_htau'])))
self.d4 = Section(diam = parameters['dendrite_diam'], L = parameters['dendrite_L'], Ra = parameters['dendrite_Ra'], cm = parameters['dendrite_cm'],
mechanisms = (Mechanism('pas', g = parameters['dendrite_pas_g'], e = parameters['dendrite_pas_e']),
Mechanism('gh', ghbar = parameters['dendrite_gh_ghbar'], half = parameters['dendrite_gh_half'], htau = parameters['dendrite_gh_htau'])))
# Connect the dendritic compartments to their respective parts of the motoneuron soma
# Note connect only takes one parameter
self.d1.connect(self.soma(1))
self.d2.connect(self.soma(1))
self.d3.connect(self.soma(0))
self.d4.connect(self.soma(0))
# Insert the persistent inward currents on the dendrites & set their values
# Dendrite 1:
self.d1.insert('L_Ca_inact')
for seg in self.d1:
seg.L_Ca_inact.gcabar = parameters['dendrite_1_L_Ca_inact_gcabar']
seg.L_Ca_inact.theta_m = parameters['dendrite_L_Ca_inact_theta_m']
seg.L_Ca_inact.tau_m = parameters['dendrite_L_Ca_inact_tau_m']
seg.L_Ca_inact.theta_h = parameters['dendrite_L_Ca_inact_theta_h']
seg.L_Ca_inact.tau_h = parameters['dendrite_L_Ca_inact_tau_h']
seg.L_Ca_inact.kappa_h = parameters['dendrite_L_Ca_inact_kappa_h']
# Dendrite 2:
self.d2.insert('L_Ca_inact')
for seg in self.d2:
seg.L_Ca_inact.gcabar = parameters['dendrite_2_L_Ca_inact_gcabar']
seg.L_Ca_inact.theta_m = parameters['dendrite_L_Ca_inact_theta_m']
seg.L_Ca_inact.tau_m = parameters['dendrite_L_Ca_inact_tau_m']
seg.L_Ca_inact.theta_h = parameters['dendrite_L_Ca_inact_theta_h']
seg.L_Ca_inact.tau_h = parameters['dendrite_L_Ca_inact_tau_h']
seg.L_Ca_inact.kappa_h = parameters['dendrite_L_Ca_inact_kappa_h']
# Dendrite 3:
self.d3.insert('L_Ca_inact')
for seg in self.d3:
seg.L_Ca_inact.gcabar = parameters['dendrite_3_L_Ca_inact_gcabar']
seg.L_Ca_inact.theta_m = parameters['dendrite_L_Ca_inact_theta_m']
seg.L_Ca_inact.tau_m = parameters['dendrite_L_Ca_inact_tau_m']
seg.L_Ca_inact.theta_h = parameters['dendrite_L_Ca_inact_theta_h']
seg.L_Ca_inact.tau_h = parameters['dendrite_L_Ca_inact_tau_h']
seg.L_Ca_inact.kappa_h = parameters['dendrite_L_Ca_inact_kappa_h']
# Dendrite 4:
self.d4.insert('L_Ca_inact')
for seg in self.d4:
seg.L_Ca_inact.gcabar = parameters['dendrite_4_L_Ca_inact_gcabar']
seg.L_Ca_inact.theta_m = parameters['dendrite_L_Ca_inact_theta_m']
seg.L_Ca_inact.tau_m = parameters['dendrite_L_Ca_inact_tau_m']
seg.L_Ca_inact.theta_h = parameters['dendrite_L_Ca_inact_theta_h']
seg.L_Ca_inact.tau_h = parameters['dendrite_L_Ca_inact_tau_h']
seg.L_Ca_inact.kappa_h = parameters['dendrite_L_Ca_inact_kappa_h']
# Add iclamps for playing in dendritic bias currents
# Dendrite 1:
self.d1_bias_current = h.IClamp(0.5, sec=self.d1) # IClamp used to play bias current into the dendrite
self.d1_bias_current.delay = 0
self.d1_bias_current.dur = 1e12
self.d1_bias_current.amp = parameters['dendrite_bias_current_amp'] # Updated in main script to play a ramped bias current through this IClamp
# Dendrite 2:
self.d2_bias_current = h.IClamp(0.5, sec=self.d2) # IClamp used to play bias current into the dendrite
self.d2_bias_current.delay = 0
self.d2_bias_current.dur = 1e12
self.d2_bias_current.amp = parameters['dendrite_bias_current_amp'] # Updated in main script to play a ramped bias current through this IClamp
# Dendrite 3:
self.d3_bias_current = h.IClamp(0.5, sec=self.d3) # IClamp used to play bias current into the dendrite
self.d3_bias_current.delay = 0
self.d3_bias_current.dur = 1e12
self.d3_bias_current.amp = parameters['dendrite_bias_current_amp'] # Updated in main script to play a ramped bias current through this IClamp
# Dendrite 4:
self.d4_bias_current = h.IClamp(0.5, sec=self.d4) # IClamp used to play bias current into the dendrite
self.d4_bias_current.delay = 0
self.d4_bias_current.dur = 1e12
self.d4_bias_current.amp = parameters['dendrite_bias_current_amp'] # Updated in main script to play a ramped bias current through this IClamp
# Append the gaussian IClamps to global list so they can be updated in the main script
GV.MU_dendritic_bias_current_iclamps.append([self.d1_bias_current, self.d2_bias_current, self.d3_bias_current, self.d4_bias_current])
# Add Double Exponential Synapses to soma and each dendritic compartment for correlated inputs from cortex
# Correlated Inputs - Excitatory Synapse:
# Soma:
self.soma_correlated_exc = h.ExpSyn(0.5, sec=self.soma)
self.soma_correlated_exc.e = parameters['correlated_e_rev_exc'] # Excitatory reversal potential
self.soma_correlated_exc.tau = parameters['correlated_tau'] # Excitatory decay time
# Dendrite 1:
self.d1_correlated_exc = h.ExpSyn(0.5, sec=self.d1)
self.d1_correlated_exc.e = parameters['correlated_e_rev_exc'] # Excitatory reversal potential
self.d1_correlated_exc.tau = parameters['correlated_tau'] # Excitatory decay time
# Dendrite 2:
self.d2_correlated_exc = h.ExpSyn(0.5, sec=self.d2)
self.d2_correlated_exc.e = parameters['correlated_e_rev_exc'] # Excitatory reversal potential
self.d2_correlated_exc.tau = parameters['correlated_tau'] # Excitatory decay time
# Dendrite 3:
self.d3_correlated_exc = h.ExpSyn(0.5, sec=self.d3)
self.d3_correlated_exc.e = parameters['correlated_e_rev_exc'] # Excitatory reversal potential
self.d3_correlated_exc.tau = parameters['correlated_tau'] # Excitatory decay time
# Dendrite 4:
self.d4_correlated_exc = h.ExpSyn(0.5, sec=self.d4)
self.d4_correlated_exc.e = parameters['correlated_e_rev_exc'] # Excitatory reversal potential
self.d4_correlated_exc.tau = parameters['correlated_tau'] # Excitatory decay time
# Independent Inputs - Excitatory Synapse:
# Dendrite 1:
self.d1_independent_exc = h.Exp2Syn(0.5, sec=self.d1)
self.d1_independent_exc.e = parameters['independent_e_rev_exc'] # Excitatory reversal potential
self.d1_independent_exc.tau1 = parameters['independent_tau1'] # Excitatory rise time
self.d1_independent_exc.tau2 = parameters['independent_tau2'] # Excitatory decay time
# Dendrite 2:
self.d2_independent_exc = h.Exp2Syn(0.5, sec=self.d2)
self.d2_independent_exc.e = parameters['independent_e_rev_exc'] # Excitatory reversal potential
self.d2_independent_exc.tau1 = parameters['independent_tau1'] # Excitatory rise time
self.d2_independent_exc.tau2 = parameters['independent_tau2'] # Excitatory decay time
# Dendrite 3:
self.d3_independent_exc = h.Exp2Syn(0.5, sec=self.d3)
self.d3_independent_exc.e = parameters['independent_e_rev_exc'] # Excitatory reversal potential
self.d3_independent_exc.tau1 = parameters['independent_tau1'] # Excitatory rise time
self.d3_independent_exc.tau2 = parameters['independent_tau2'] # Excitatory decay time
# Dendrite 4:
self.d4_independent_exc = h.Exp2Syn(0.5, sec=self.d4)
self.d4_independent_exc.e = parameters['independent_e_rev_exc'] # Excitatory reversal potential
self.d4_independent_exc.tau1 = parameters['independent_tau1'] # Excitatory rise time
self.d4_independent_exc.tau2 = parameters['independent_tau2'] # Excitatory decay time
# Synaptic Bombardment Noise Inputs to Dendrites:
# Dendrite 1:
self.d1_Synaptic_Bombardment = h.Gfluct(0.5, sec=self.d1)
self.d1_Synaptic_Bombardment.ge0 = parameters['dendrite_Gfluct_ge0']
self.d1_Synaptic_Bombardment.gi0 = parameters['dendrite_Gfluct_gi0']
self.d1_Synaptic_Bombardment.stde = parameters['dendrite_Gfluct_stde']
self.d1_Synaptic_Bombardment.stdi = parameters['dendrite_Gfluct_stdi']
self.d1_Synaptic_Bombardment.tau_e = parameters['dendrite_Gfluct_tau_e']
self.d1_Synaptic_Bombardment.tau_i = parameters['dendrite_Gfluct_tau_i']
self.d1_Synaptic_Bombardment.E_e = parameters['dendrite_Gfluct_E_e']
self.d1_Synaptic_Bombardment.E_i = parameters['dendrite_Gfluct_E_i']
# Set new seed for the process
d1_r = h.Random() # Make random number for seed
d1_r.Random123(GV.stream_index, 0, 0)
#self.d1_Synaptic_Bombardment.new_seed = d1_r
# Dendrite 2:
self.d2_Synaptic_Bombardment = h.Gfluct(0.5, sec=self.d2)
self.d2_Synaptic_Bombardment.ge0 = parameters['dendrite_Gfluct_ge0']
self.d2_Synaptic_Bombardment.gi0 = parameters['dendrite_Gfluct_gi0']
self.d2_Synaptic_Bombardment.stde = parameters['dendrite_Gfluct_stde']
self.d2_Synaptic_Bombardment.stdi = parameters['dendrite_Gfluct_stdi']
self.d2_Synaptic_Bombardment.tau_e = parameters['dendrite_Gfluct_tau_e']
self.d2_Synaptic_Bombardment.tau_i = parameters['dendrite_Gfluct_tau_i']
self.d2_Synaptic_Bombardment.E_e = parameters['dendrite_Gfluct_E_e']
self.d2_Synaptic_Bombardment.E_i = parameters['dendrite_Gfluct_E_i']
# Set new seed for the process
d2_r = h.Random() # Make random number for seed
d2_r.Random123(GV.stream_index, 1, 0)
#self.d2_Synaptic_Bombardment.new_seed = d2_r
# Dendrite 3:
self.d3_Synaptic_Bombardment = h.Gfluct(0.5, sec=self.d3)
self.d3_Synaptic_Bombardment.ge0 = parameters['dendrite_Gfluct_ge0']
self.d3_Synaptic_Bombardment.gi0 = parameters['dendrite_Gfluct_gi0']
self.d3_Synaptic_Bombardment.stde = parameters['dendrite_Gfluct_stde']
self.d3_Synaptic_Bombardment.stdi = parameters['dendrite_Gfluct_stdi']
self.d3_Synaptic_Bombardment.tau_e = parameters['dendrite_Gfluct_tau_e']
self.d3_Synaptic_Bombardment.tau_i = parameters['dendrite_Gfluct_tau_i']
self.d3_Synaptic_Bombardment.E_e = parameters['dendrite_Gfluct_E_e']
self.d3_Synaptic_Bombardment.E_i = parameters['dendrite_Gfluct_E_i']
# Set new seed for the process
d3_r = h.Random() # Make random number for seed
d3_r.Random123(GV.stream_index, 2, 0)
#self.d3_Synaptic_Bombardment.new_seed = d3_r
# Dendrite 4:
self.d4_Synaptic_Bombardment = h.Gfluct(0.5, sec=self.d4)
self.d4_Synaptic_Bombardment.ge0 = parameters['dendrite_Gfluct_ge0']
self.d4_Synaptic_Bombardment.gi0 = parameters['dendrite_Gfluct_gi0']
self.d4_Synaptic_Bombardment.stde = parameters['dendrite_Gfluct_stde']
self.d4_Synaptic_Bombardment.stdi = parameters['dendrite_Gfluct_stdi']
self.d4_Synaptic_Bombardment.tau_e = parameters['dendrite_Gfluct_tau_e']
self.d4_Synaptic_Bombardment.tau_i = parameters['dendrite_Gfluct_tau_i']
self.d4_Synaptic_Bombardment.E_e = parameters['dendrite_Gfluct_E_e']
self.d4_Synaptic_Bombardment.E_i = parameters['dendrite_Gfluct_E_i']
# Append the noisy conductances to global list so they can be updated in the main script
GV.MU_dendritic_noisy_conductances.append([self.d1_Synaptic_Bombardment, self.d2_Synaptic_Bombardment, self.d3_Synaptic_Bombardment, self.d4_Synaptic_Bombardment])
# Set new seed for the process
d4_r = h.Random() # Make random number for seed
d4_r.Random123(GV.stream_index, 3, 0)
#self.d4_Synaptic_Bombardment.new_seed = d4_r
# Update the stream index for generating other random number seeds
GV.stream_index = GV.stream_index + 1
# needed for PyNN
self.source_section = self.soma
self.source = self.soma(0.5)._ref_v
self.rec = h.NetCon(self.source, None, sec=self.source_section) # Needed to clear the simulator
self.spike_times = h.Vector(0)
self.traces = {}
self.recording_time = False
self.parameter_names = ('soma_diam', 'soma_L', 'soma_Ra', 'soma_cm', 'soma_ek', 'v_thres',
'dendrite_diam', 'dendrite_L', 'dendrite_Ra', 'dendrite_cm',
'soma_na3rp_gbar', 'soma_na3rp_sh', 'soma_na3rp_ar', 'soma_na3rp_qinf', 'soma_na3rp_thinf',
'soma_naps_gbar', 'soma_naps_sh', 'soma_naps_ar', 'soma_naps_vslope', 'soma_naps_asvh', 'soma_naps_bsvh',
'soma_kdrRL_gMax', 'soma_kdrRL_tmin', 'soma_kdrRL_taumax', 'soma_kdrRL_mVh',
'soma_mAHP_gcamax', 'soma_mAHP_gkcamax', 'soma_mAHP_taur', 'soma_mAHP_mtauca', 'soma_mAHP_mvhalfca',
'soma_gh_ghbar', 'soma_gh_half', 'soma_gh_htau',
'soma_pas_g', 'soma_pas_e',
'dendrite_pas_g', 'dendrite_pas_e',
'dendrite_1_L_Ca_inact_gcabar', 'dendrite_2_L_Ca_inact_gcabar', 'dendrite_3_L_Ca_inact_gcabar', 'dendrite_4_L_Ca_inact_gcabar', 'dendrite_L_Ca_inact_theta_m', 'dendrite_L_Ca_inact_tau_m', 'dendrite_L_Ca_inact_theta_h', 'dendrite_L_Ca_inact_tau_h', 'dendrite_L_Ca_inact_kappa_h',
'dendrite_gh_ghbar', 'dendrite_gh_half', 'dendrite_gh_htau',
'correlated_e_rev_exc', 'correlated_tau',
'independent_e_rev_exc', 'independent_tau1', 'independent_tau2',
'soma_bias_current_amp', 'dendrite_bias_current_amp',
'dendrite_Gfluct_ge0', 'dendrite_Gfluct_gi0', 'dendrite_Gfluct_stde', 'dendrite_Gfluct_stdi', 'dendrite_Gfluct_tau_e', 'dendrite_Gfluct_tau_i', 'dendrite_Gfluct_E_e', 'dendrite_Gfluct_E_i'
)
self.traces = {}
self.recording_time = False
def memb_init(self):
for seg in self.soma: # Initialize all compartment membrane voltages
seg.v = self.v_init
for seg in self.d1:
seg.v = self.v_init
for seg in self.d2:
seg.v = self.v_init
for seg in self.d3:
seg.v = self.v_init
for seg in self.d4:
seg.v = self.v_init
def get_threshold(self): # Initialize the soma membrane threshold for netcons
return self.soma.v_thresh
# Need to make getters and setters for changing motoneuron parameters
# Soma -
# diam Setters & Getters:
def _set_soma_diam(self, value):
self.soma.diam = value
def _get_soma_diam(self):
return self.soma.diam
soma_diam = property(fget=_get_soma_diam, fset=_set_soma_diam)
# L Setters & Getters:
def _set_soma_L(self, value):
self.soma.L = value
def _get_soma_L(self):
return self.soma.L
soma_L = property(fget=_get_soma_L, fset=_set_soma_L)
# cm Setters & Getters:
def _set_soma_cm(self, value):
self.soma.cm = value
def _get_soma_cm(self):
return self.soma.cm
soma_cm = property(fget=_get_soma_cm, fset=_set_soma_cm)
# Ra Setters & Getters:
def _set_soma_Ra(self, value):
self.soma.Ra = value
def _get_soma_Ra(self):
return self.soma.Ra
soma_Ra = property(fget=_get_soma_Ra, fset=_set_soma_Ra)
# na3rp Setters & Getters:
def _set_soma_na3rp_gbar(self, value):
for seg in self.soma:
seg.na3rp.gbar = value
def _get_soma_na3rp_gbar(self):
# Return only the first dendrite parameter, since other dendrites use same value
return self.soma(0.5).na3rp.gbar
soma_na3rp_gbar = property(fget=_get_soma_na3rp_gbar, fset=_set_soma_na3rp_gbar)
def _set_soma_na3rp_sh(self, value):
for seg in self.soma:
seg.na3rp.sh = value
def _get_soma_na3rp_sh(self):
# Return only the first dendrite parameter, since other dendrites use same value
return self.soma(0.5).na3rp.sh
soma_na3rp_sh = property(fget=_get_soma_na3rp_sh, fset=_set_soma_na3rp_sh)
def _set_soma_na3rp_ar(self, value):
for seg in self.soma:
seg.na3rp.ar = value
def _get_soma_na3rp_ar(self):
# Return only the first dendrite parameter, since other dendrites use same value
return self.soma(0.5).na3rp.ar
soma_na3rp_ar = property(fget=_get_soma_na3rp_ar, fset=_set_soma_na3rp_ar)
def _set_soma_na3rp_qinf(self, value):
for seg in self.soma:
seg.na3rp.qinf = value
def _get_soma_na3rp_qinf(self):
# Return only the first dendrite parameter, since other dendrites use same value
return self.soma(0.5).na3rp.qinf
soma_na3rp_qinf = property(fget=_get_soma_na3rp_qinf, fset=_set_soma_na3rp_qinf)
def _set_soma_na3rp_thinf(self, value):
for seg in self.soma:
seg.na3rp.thinf = value
def _get_soma_na3rp_thinf(self):
# Return only the middle soma parameter
return self.soma(0.5).na3rp.thinf
soma_na3rp_thinf = property(fget=_get_soma_na3rp_thinf, fset=_set_soma_na3rp_thinf)
# naps Setters & Getters:
def _set_soma_naps_gbar(self, value):
for seg in self.soma:
seg.naps.gbar = value
def _get_soma_naps_gbar(self):
# Return only the middle soma parameter
return self.soma(0.5).naps.gbar
soma_naps_gbar = property(fget=_get_soma_naps_gbar, fset=_set_soma_naps_gbar)
def _set_soma_naps_sh(self, value):
for seg in self.soma:
seg.naps.sh = value
def _get_soma_naps_sh(self):
# Return only the middle soma parameter
return self.soma(0.5).naps.sh
soma_naps_sh = property(fget=_get_soma_naps_sh, fset=_set_soma_naps_sh)
def _set_soma_naps_ar(self, value):
for seg in self.soma:
seg.naps.ar = value
def _get_soma_naps_ar(self):
# Return only the middle soma parameter
return self.soma(0.5).naps.ar
soma_naps_ar = property(fget=_get_soma_naps_ar, fset=_set_soma_naps_ar)
def _set_soma_naps_vslope(self, value):
for seg in self.soma:
seg.naps.vslope = value
def _get_soma_naps_vslope(self):
# Return only the middle soma parameter
return self.soma(0.5).naps.vslope
soma_naps_vslope = property(fget=_get_soma_naps_vslope, fset=_set_soma_naps_vslope)
def _set_soma_naps_asvh(self, value):
for seg in self.soma:
seg.naps.asvh = value
def _get_soma_naps_asvh(self):
# Return only the middle soma parameter
return self.soma(0.5).naps.asvh
soma_naps_asvh = property(fget=_get_soma_naps_asvh, fset=_set_soma_naps_asvh)
def _set_soma_naps_bsvh(self, value):
for seg in self.soma:
seg.naps.bsvh = value
def _get_soma_naps_bsvh(self):
# Return only the middle soma parameter
return self.soma(0.5).naps.bsvh
soma_naps_bsvh = property(fget=_get_soma_naps_bsvh, fset=_set_soma_naps_bsvh)
# kdrRL Setters & Getters:
def _set_soma_kdrRL_gMax(self, value):
for seg in self.soma:
seg.kdrRL.gMax = value
def _get_soma_kdrRL_gMax(self):
# Return only the middle soma parameter
return self.soma(0.5).kdrRL.gMax
soma_kdrRL_gMax = property(fget=_get_soma_kdrRL_gMax, fset=_set_soma_kdrRL_gMax)
def _set_soma_kdrRL_tmin(self, value):
for seg in self.soma:
seg.kdrRL.tmin = value
def _get_soma_kdrRL_tmin(self):
# Return only the middle soma parameter
return self.soma(0.5).kdrRL.tmin
soma_kdrRL_tmin = property(fget=_get_soma_kdrRL_tmin, fset=_set_soma_kdrRL_tmin)
def _set_soma_kdrRL_taumax(self, value):
for seg in self.soma:
seg.kdrRL.taumax = value
def _get_soma_kdrRL_taumax(self):
# Return only the middle soma parameter
return self.soma(0.5).kdrRL.taumax
soma_kdrRL_taumax = property(fget=_get_soma_kdrRL_taumax, fset=_set_soma_kdrRL_taumax)
def _set_soma_kdrRL_mVh(self, value):
for seg in self.soma:
seg.kdrRL.mVh = value
def _get_soma_kdrRL_mVh(self):
# Return only the middle soma parameter
return self.soma(0.5).kdrRL.mVh
soma_kdrRL_mVh = property(fget=_get_soma_kdrRL_mVh, fset=_set_soma_kdrRL_mVh)
# mAHP Setters & Getters:
def _set_soma_mAHP_gcamax(self, value):
for seg in self.soma:
seg.mAHP.gcamax = value
def _get_soma_mAHP_gcamax(self):
# Return only the middle soma parameter
return self.soma(0.5).mAHP.gcamax
soma_mAHP_gcamax = property(fget=_get_soma_mAHP_gcamax, fset=_set_soma_mAHP_gcamax)
def _set_soma_mAHP_gkcamax(self, value):
for seg in self.soma:
seg.mAHP.gkcamax = value
def _get_soma_mAHP_gkcamax(self):
# Return only the middle soma parameter
return self.soma(0.5).mAHP.gkcamax
soma_mAHP_gkcamax = property(fget=_get_soma_mAHP_gkcamax, fset=_set_soma_mAHP_gkcamax)
def _set_soma_mAHP_taur(self, value):
for seg in self.soma:
seg.mAHP.taur = value
def _get_soma_mAHP_taur(self):
# Return only the middle soma parameter
return self.soma(0.5).mAHP.taur
soma_mAHP_taur = property(fget=_get_soma_mAHP_taur, fset=_set_soma_mAHP_taur)
def _set_soma_mAHP_mtauca(self, value):
for seg in self.soma:
seg.mAHP.mtauca = value
def _get_soma_mAHP_mtauca(self):
# Return only the middle soma parameter
return self.soma(0.5).mAHP.mtauca
soma_mAHP_mtauca = property(fget=_get_soma_mAHP_mtauca, fset=_set_soma_mAHP_mtauca)
def _set_soma_mAHP_mvhalfca(self, value):
for seg in self.soma:
seg.mAHP.mvhalfca = value
def _get_soma_mAHP_mvhalfca(self):
# Return only the middle soma parameter
return self.soma(0.5).mAHP.mvhalfca
soma_mAHP_mvhalfca = property(fget=_get_soma_mAHP_mvhalfca, fset=_set_soma_mAHP_mvhalfca)
# gh Setters & Getters:
def _set_soma_gh_ghbar(self, value):
for seg in self.soma:
seg.gh.ghbar = value
def _get_soma_gh_ghbar(self):
# Return only the middle soma parameter
return self.soma(0.5).gh.ghbar
soma_gh_ghbar = property(fget=_get_soma_gh_ghbar, fset=_set_soma_gh_ghbar)
def _set_soma_gh_half(self, value):
for seg in self.soma:
seg.gh.half = value
def _get_soma_gh_half(self):
# Return only the middle soma parameter
return self.soma(0.5).gh.half
soma_gh_half = property(fget=_get_soma_gh_half, fset=_set_soma_gh_half)
def _set_soma_gh_htau(self, value):
for seg in self.soma:
seg.gh.htau = value
def _get_soma_gh_htau(self):
# Return only the middle soma parameter
return self.soma(0.5).gh.htau
soma_gh_htau = property(fget=_get_soma_gh_htau, fset=_set_soma_gh_htau)
# pas Setters & Getters:
def _set_soma_pas_g(self, value):
for seg in self.soma:
seg.pas.g = value
def _get_soma_pas_g(self):
# Return only the middle soma parameter
return self.soma(0.5).pas.g
soma_pas_g = property(fget=_get_soma_pas_g, fset=_set_soma_pas_g)
def _set_soma_pas_e(self, value):
for seg in self.soma:
seg.pas.e = value
def _get_soma_pas_e(self):
# Return only the middle soma parameter
return self.soma(0.5).pas.e
soma_pas_e = property(fget=_get_soma_pas_e, fset=_set_soma_pas_e)
# Dendrites -
# diam Setters & Getters:
def _set_dendrite_diam(self, value):
self.d1.diam = value
self.d2.diam = value
self.d3.diam = value
self.d4.diam = value
def _get_dendrite_diam(self):
return self.d1.diam
dendrite_diam = property(fget=_get_dendrite_diam, fset=_set_dendrite_diam)
# L Setters & Getters:
def _set_dendrite_L(self, value):
self.d1.L = value
self.d2.L = value
self.d3.L = value
self.d4.L = value
def _get_dendrite_L(self):
return self.d1.L
dendrite_L = property(fget=_get_dendrite_L, fset=_set_dendrite_L)
# cm Setters & Getters:
def _set_dendrite_cm(self, value):
self.d1.cm = value
self.d2.cm = value
self.d3.cm = value
self.d4.cm = value
def _get_dendrite_cm(self):
return self.d1.cm
dendrite_cm = property(fget=_get_dendrite_cm, fset=_set_dendrite_cm)
# Ra Setters & Getters:
def _set_dendrite_Ra(self, value):
self.d1.Ra = value
self.d2.Ra = value
self.d3.Ra = value
self.d4.Ra = value
def _get_dendrite_Ra(self):
return self.d1.Ra
dendrite_Ra = property(fget=_get_dendrite_Ra, fset=_set_dendrite_Ra)
# pas mechanism - g value:
def _set_dendrite_pas_g(self, value):
# Set each dendrite on the motoneuron to have the same parameter value
for seg in self.d1:
seg.pas.g = value
for seg in self.d2:
seg.pas.g = value
for seg in self.d3:
seg.pas.g = value
for seg in self.d4:
seg.pas.g = value
def _get_dendrite_pas_g(self):
# Return only the first dendrite parameter, since other dendrites use same value
return self.d1(0.5).pas.g
dendrite_pas_g = property(fget=_get_dendrite_pas_g, fset=_set_dendrite_pas_g)
# pas mechanism - e value:
def _set_dendrite_pas_e(self, value):
# Set each dendrite on the motoneuron to have the same parameter value
for seg in self.d1:
seg.pas.e = value
for seg in self.d2:
seg.pas.e = value
for seg in self.d3:
seg.pas.e = value
for seg in self.d4:
seg.pas.e = value
def _get_dendrite_pas_e(self):
# Return only the first dendrite parameter, since other dendrites use same value
return self.d1(0.5).pas.e
dendrite_pas_e = property(fget=_get_dendrite_pas_e, fset=_set_dendrite_pas_e)
# PIC conductance values are different on each dendrite compartment, so there are 4 getters and setters corresponding to each conductance
# L_Ca_inact mechanism - gcabar value for dendrite 1:
def _set_dendrite_1_L_Ca_inact_gcabar(self, value):
for seg in self.d1:
seg.L_Ca_inact.gcabar = value
def _get_dendrite_1_L_Ca_inact_gcabar(self):
return self.d1(0.5).L_Ca_inact.gcabar
dendrite_1_L_Ca_inact_gcabar = property(fget=_get_dendrite_1_L_Ca_inact_gcabar, fset=_set_dendrite_1_L_Ca_inact_gcabar)
# L_Ca_inact mechanism - gcabar value for dendrite 2:
def _set_dendrite_2_L_Ca_inact_gcabar(self, value):
for seg in self.d2:
seg.L_Ca_inact.gcabar = value
def _get_dendrite_2_L_Ca_inact_gcabar(self):
return self.d2(0.5).L_Ca_inact.gcabar
dendrite_2_L_Ca_inact_gcabar = property(fget=_get_dendrite_2_L_Ca_inact_gcabar, fset=_set_dendrite_2_L_Ca_inact_gcabar)
# L_Ca_inact mechanism - gcabar value for dendrite 3:
def _set_dendrite_3_L_Ca_inact_gcabar(self, value):
for seg in self.d3:
seg.L_Ca_inact.gcabar = value
def _get_dendrite_3_L_Ca_inact_gcabar(self):
return self.d3(0.5).L_Ca_inact.gcabar
dendrite_3_L_Ca_inact_gcabar = property(fget=_get_dendrite_3_L_Ca_inact_gcabar, fset=_set_dendrite_3_L_Ca_inact_gcabar)
# L_Ca_inact mechanism - gcabar value for dendrite 4:
def _set_dendrite_4_L_Ca_inact_gcabar(self, value):
for seg in self.d4:
seg.L_Ca_inact.gcabar = value
def _get_dendrite_4_L_Ca_inact_gcabar(self):
return self.d4(0.5).L_Ca_inact.gcabar
dendrite_4_L_Ca_inact_gcabar = property(fget=_get_dendrite_4_L_Ca_inact_gcabar, fset=_set_dendrite_4_L_Ca_inact_gcabar)
# L_Ca_inact mechanism - theta_m value:
def _set_dendrite_L_Ca_inact_theta_m(self, value):
# Set each dendrite on the motoneuron to have the same parameter value
for seg in self.d1:
seg.L_Ca_inact.theta_m = value
for seg in self.d2:
seg.L_Ca_inact.theta_m = value
for seg in self.d3:
seg.L_Ca_inact.theta_m = value
for seg in self.d4:
seg.L_Ca_inact.theta_m = value
def _get_dendrite_L_Ca_inact_theta_m(self):
# Return only the first dendrite parameter, since other dendrites use same value
return self.d1(0.5).L_Ca_inact.theta_m
dendrite_L_Ca_inact_theta_m = property(fget=_get_dendrite_L_Ca_inact_theta_m, fset=_set_dendrite_L_Ca_inact_theta_m)
# L_Ca_inact mechanism - tau_m value:
def _set_dendrite_L_Ca_inact_tau_m(self, value):
# Set each dendrite on the motoneuron to have the same parameter value
for seg in self.d1:
seg.L_Ca_inact.tau_m = value
for seg in self.d2:
seg.L_Ca_inact.tau_m = value
for seg in self.d3:
seg.L_Ca_inact.tau_m = value
for seg in self.d4:
seg.L_Ca_inact.tau_m = value
def _get_dendrite_L_Ca_inact_tau_m(self):
# Return only the first dendrite parameter, since other dendrites use same value
return self.d1(0.5).L_Ca_inact.tau_m
dendrite_L_Ca_inact_tau_m = property(fget=_get_dendrite_L_Ca_inact_tau_m, fset=_set_dendrite_L_Ca_inact_tau_m)
# L_Ca_inact mechanism - theta_h value:
def _set_dendrite_L_Ca_inact_theta_h(self, value):
# Set each dendrite on the motoneuron to have the same parameter value
for seg in self.d1:
seg.L_Ca_inact.theta_h = value
for seg in self.d2:
seg.L_Ca_inact.theta_h = value
for seg in self.d3:
seg.L_Ca_inact.theta_h = value
for seg in self.d4:
seg.L_Ca_inact.theta_h = value
def _get_dendrite_L_Ca_inact_theta_h(self):
# Return only the first dendrite parameter, since other dendrites use same value
return self.d1(0.5).L_Ca_inact.theta_h
dendrite_L_Ca_inact_theta_h = property(fget=_get_dendrite_L_Ca_inact_theta_h, fset=_set_dendrite_L_Ca_inact_theta_h)
# L_Ca_inact mechanism - tau_h value:
def _set_dendrite_L_Ca_inact_tau_h(self, value):
# Set each dendrite on the motoneuron to have the same parameter value
for seg in self.d1:
seg.L_Ca_inact.tau_h = value
for seg in self.d2:
seg.L_Ca_inact.tau_h = value
for seg in self.d3:
seg.L_Ca_inact.tau_h = value
for seg in self.d4:
seg.L_Ca_inact.tau_h = value
def _get_dendrite_L_Ca_inact_tau_h(self):
# Return only the first dendrite parameter, since other dendrites use same value
return self.d1(0.5).L_Ca_inact.tau_h
dendrite_L_Ca_inact_tau_h = property(fget=_get_dendrite_L_Ca_inact_tau_h, fset=_set_dendrite_L_Ca_inact_tau_h)
# L_Ca_inact mechanism - kappa_h value:
def _set_dendrite_L_Ca_inact_kappa_h(self, value):
# Set each dendrite on the motoneuron to have the same parameter value
for seg in self.d1:
seg.L_Ca_inact.kappa_h = value
for seg in self.d2:
seg.L_Ca_inact.kappa_h = value
for seg in self.d3:
seg.L_Ca_inact.kappa_h = value
for seg in self.d4:
seg.L_Ca_inact.kappa_h = value
def _get_dendrite_L_Ca_inact_kappa_h(self):
# Return only the first dendrite parameter, since other dendrites use same value
return self.d1(0.5).L_Ca_inact.kappa_h
dendrite_L_Ca_inact_kappa_h = property(fget=_get_dendrite_L_Ca_inact_kappa_h, fset=_set_dendrite_L_Ca_inact_kappa_h)
# gh mechanism - ghbar value:
def _set_dendrite_gh_ghbar(self, value):
# Set each dendrite on the motoneuron to have the same parameter value
for seg in self.d1:
seg.gh.ghbar = value
for seg in self.d2:
seg.gh.ghbar = value
for seg in self.d3:
seg.gh.ghbar = value
for seg in self.d4:
seg.gh.ghbar = value
def _get_dendrite_gh_ghbar(self):
# Return only the first dendrite parameter, since other dendrites use same value
return self.d1(0.5).gh.ghbar
dendrite_gh_ghbar = property(fget=_get_dendrite_gh_ghbar, fset=_set_dendrite_gh_ghbar)
# gh mechanism - half value:
def _set_dendrite_gh_half(self, value):
# Set each dendrite on the motoneuron to have the same parameter value
for seg in self.d1:
seg.gh.half = value
for seg in self.d2:
seg.gh.half = value
for seg in self.d3:
seg.gh.half = value
for seg in self.d4:
seg.gh.half = value
def _get_dendrite_gh_half(self):
# Return only the first dendrite parameter, since other dendrites use same value
return self.d1(0.5).gh.half
dendrite_gh_half = property(fget=_get_dendrite_gh_half, fset=_set_dendrite_gh_half)
# gh mechanism - htau value:
def _set_dendrite_gh_htau(self, value):
# Set each dendrite on the motoneuron to have the same parameter value
for seg in self.d1:
seg.gh.htau = value
for seg in self.d2:
seg.gh.htau = value
for seg in self.d3:
seg.gh.htau = value
for seg in self.d4:
seg.gh.htau = value
def _get_dendrite_gh_htau(self):
# Return only the first dendrite parameter, since other dendrites use same value
return self.d1(0.5).gh.htau
dendrite_gh_htau = property(fget=_get_dendrite_gh_htau, fset=_set_dendrite_gh_htau)
# Getters and Setters for dendritic synapses
# Correlated Inputs - Excitatory Inputs:
def _get_correlated_e_rev_exc(self): # Reversal Potential
return self.d1_correlated_exc.e
def _set_correlated_e_rev_exc(self, value):
self.soma_correlated_exc.e = value
self.d1_correlated_exc.e = value
self.d2_correlated_exc.e = value
self.d3_correlated_exc.e = value
self.d4_correlated_exc.e = value
correlated_e_rev_exc = property(fget=_get_correlated_e_rev_exc, fset=_set_correlated_e_rev_exc)
def _get_correlated_tau(self): # Decay time (ms)
return self.d1_correlated_exc.tau
def _set_correlated_tau(self, value):
self.soma_correlated_exc.tau = value
self.d1_correlated_exc.tau = value
self.d2_correlated_exc.tau = value
self.d3_correlated_exc.tau = value
self.d4_correlated_exc.tau = value
correlated_tau = property(fget=_get_correlated_tau, fset=_set_correlated_tau)
# Independent Inputs - Excitatory Inputs:
def _get_independent_e_rev_exc(self): # Reversal Potential
return self.d1_independent_exc.e
def _set_independent_e_rev_exc(self, value):
self.d1_independent_exc.e = value
self.d2_independent_exc.e = value
self.d3_independent_exc.e = value
self.d4_independent_exc.e = value
independent_e_rev_exc = property(fget=_get_independent_e_rev_exc, fset=_set_independent_e_rev_exc)
def _get_independent_tau1(self): # Rise time (ms)
return self.d1_independent_exc.tau1
def _set_independent_tau1(self, value):
# Excitatory Independent Inputs
self.d1_independent_exc.tau1 = value
self.d2_independent_exc.tau1 = value
self.d3_independent_exc.tau1 = value
self.d4_independent_exc.tau1 = value
independent_tau1 = property(fget=_get_independent_tau1, fset=_set_independent_tau1)
def _get_independent_tau2(self): # Decay time (ms)
return self.d1_independent_exc.tau2
def _set_independent_tau2(self, value):
# Excitatory Independent Inputs
self.d1_independent_exc.tau2 = value
self.d2_independent_exc.tau2 = value
self.d3_independent_exc.tau2 = value
self.d4_independent_exc.tau2 = value
independent_tau2 = property(fget=_get_independent_tau2, fset=_set_independent_tau2)
def _get_soma_bias_current_amp(self): # Getters/Setters for the soma bias current (nA)
return self.soma_bias.amp
def _set_soma_bias_current_amp(self, value):
self.soma_stim.bias = value
soma_bias_current_amp = property(fget=_get_soma_bias_current_amp, fset=_set_soma_bias_current_amp)
def _get_dendrite_bias_current_amp(self): # Getters/Setters for the dendrite bias current (nA)
return self.d1_bias_current.amp
def _set_dendrite_bias_current_amp(self, value):
self.d1_bias_current.amp = value
self.d2_bias_current.amp = value
self.d3_bias_current.amp = value
self.d4_bias_current.amp = value
dendrite_bias_current_amp = property(fget=_get_dendrite_bias_current_amp, fset=_set_dendrite_bias_current_amp)
# Getters and Setters for dendritic stochastic conductance - simulates synaptic bombardment from other structures
# Gfluct mechanism - ge0 value:
def _set_dendrite_Gfluct_g_e0(self, value):
# Set each dendrite on the motoneuron to have the same parameter value
self.d1_Synaptic_Bombardment.ge0 = value
self.d2_Synaptic_Bombardment.ge0 = value
self.d3_Synaptic_Bombardment.ge0 = value
self.d4_Synaptic_Bombardment.ge0 = value
def _get_dendrite_Gfluct_g_e0(self):
# Return only the first dendrite parameter, since other dendrites use same value
return self.d1_Synaptic_Bombardment.ge0
dendrite_Gfluct_ge0 = property(fget=_get_dendrite_Gfluct_g_e0, fset=_set_dendrite_Gfluct_g_e0)
# Gfluct mechanism - gi0 value:
def _set_dendrite_Gfluct_g_i0(self, value):
# Set each dendrite on the motoneuron to have the same parameter value
self.d1_Synaptic_Bombardment.gi0 = value
self.d2_Synaptic_Bombardment.gi0 = value
self.d3_Synaptic_Bombardment.gi0 = value
self.d4_Synaptic_Bombardment.gi0 = value
def _get_dendrite_Gfluct_g_i0(self):
# Return only the first dendrite parameter, since other dendrites use same value
return self.d1_Synaptic_Bombardment.gi0
dendrite_Gfluct_gi0 = property(fget=_get_dendrite_Gfluct_g_i0, fset=_set_dendrite_Gfluct_g_i0)
# Gfluct mechanism - stde value:
def _set_dendrite_Gfluct_std_e(self, value):
# Set each dendrite on the motoneuron to have the same parameter value
self.d1_Synaptic_Bombardment.stde = value
self.d2_Synaptic_Bombardment.stde = value
self.d3_Synaptic_Bombardment.stde = value
self.d4_Synaptic_Bombardment.stde = value
def _get_dendrite_Gfluct_std_e(self):
# Return only the first dendrite parameter, since other dendrites use same value
return self.d1_Synaptic_Bombardment.stde
dendrite_Gfluct_stde = property(fget=_get_dendrite_Gfluct_std_e, fset=_set_dendrite_Gfluct_std_e)
# Gfluct mechanism - stdi value:
def _set_dendrite_Gfluct_std_i(self, value):
# Set each dendrite on the motoneuron to have the same parameter value
self.d1_Synaptic_Bombardment.stdi = value
self.d2_Synaptic_Bombardment.stdi = value
self.d3_Synaptic_Bombardment.stdi = value
self.d4_Synaptic_Bombardment.stdi = value
def _get_dendrite_Gfluct_std_i(self):
# Return only the first dendrite parameter, since other dendrites use same value
return self.d1_Synaptic_Bombardment.stdi
dendrite_Gfluct_stdi = property(fget=_get_dendrite_Gfluct_std_i, fset=_set_dendrite_Gfluct_std_i)
# Gfluct mechanism - tau_e value:
def _set_dendrite_Gfluct_tau_e(self, value):
# Set each dendrite on the motoneuron to have the same parameter value
self.d1_Synaptic_Bombardment.tau_e = value
self.d2_Synaptic_Bombardment.tau_e = value
self.d3_Synaptic_Bombardment.tau_e = value
self.d4_Synaptic_Bombardment.tau_e = value
def _get_dendrite_Gfluct_tau_e(self):
# Return only the first dendrite parameter, since other dendrites use same value
return self.d1_Synaptic_Bombardment.tau_e
dendrite_Gfluct_tau_e = property(fget=_get_dendrite_Gfluct_tau_e, fset=_set_dendrite_Gfluct_tau_e)
# Gfluct mechanism - tau_i value:
def _set_dendrite_Gfluct_tau_i(self, value):
# Set each dendrite on the motoneuron to have the same parameter value
self.d1_Synaptic_Bombardment.tau_i = value
self.d2_Synaptic_Bombardment.tau_i = value
self.d3_Synaptic_Bombardment.tau_i = value
self.d4_Synaptic_Bombardment.tau_i = value
def _get_dendrite_Gfluct_tau_i(self):
# Return only the first dendrite parameter, since other dendrites use same value
return self.d1_Synaptic_Bombardment.tau_i
dendrite_Gfluct_tau_i = property(fget=_get_dendrite_Gfluct_tau_i, fset=_set_dendrite_Gfluct_tau_i)
# Gfluct mechanism - E_e value:
def _set_dendrite_Gfluct_E_e(self, value):
# Set each dendrite on the motoneuron to have the same parameter value
self.d1_Synaptic_Bombardment.E_e = value
self.d2_Synaptic_Bombardment.E_e = value
self.d3_Synaptic_Bombardment.E_e = value
self.d4_Synaptic_Bombardment.E_e = value
def _get_dendrite_Gfluct_E_e(self):
# Return only the first dendrite parameter, since other dendrites use same value
return self.d1_Synaptic_Bombardment.E_e
dendrite_Gfluct_E_e = property(fget=_get_dendrite_Gfluct_E_e, fset=_set_dendrite_Gfluct_E_e)
# Gfluct mechanism - E_i value:
def _set_dendrite_Gfluct_E_i(self, value):
# Set each dendrite on the motoneuron to have the same parameter value
self.d1_Synaptic_Bombardment.E_i = value
self.d2_Synaptic_Bombardment.E_i = value
self.d3_Synaptic_Bombardment.E_i = value
self.d4_Synaptic_Bombardment.E_i = value
def _get_dendrite_Gfluct_E_i(self):
# Return only the first dendrite parameter, since other dendrites use same value
return self.d1_Synaptic_Bombardment.E_i
dendrite_Gfluct_E_i = property(fget=_get_dendrite_Gfluct_E_i, fset=_set_dendrite_Gfluct_E_i)
class Spinal_Motoneuron_Synaptic_Bombardment_Point_Process_Type(NativeCellType):
# Default parameters for the neurons:
default_parameters = {'soma_diam': 22.0, 'soma_L': 2952.0, 'soma_Ra': 0.001, 'soma_cm': 1.35546, 'soma_ek': -80.0, 'v_thres' : -20,
'dendrite_diam': 8.73071, 'dendrite_L': 1794.13, 'dendrite_Ra': 51.038, 'dendrite_cm': 0.867781}
# Soma default parameters:
# na3rp:
default_parameters['soma_na3rp_gbar'] = 0.01
default_parameters['soma_na3rp_sh'] = 1.0
default_parameters['soma_na3rp_ar'] = 1.0
default_parameters['soma_na3rp_qinf'] = 8.0
default_parameters['soma_na3rp_thinf'] = -50.0
# naps:
default_parameters['soma_naps_gbar'] = 2.6e-5
default_parameters['soma_naps_sh'] = 5.0
default_parameters['soma_naps_ar'] = 1.0
default_parameters['soma_naps_vslope'] = 5.0
default_parameters['soma_naps_asvh'] = -90.0
default_parameters['soma_naps_bsvh'] = -22.0
# kdrRL:
default_parameters['soma_kdrRL_gMax'] = 0.015
default_parameters['soma_kdrRL_tmin'] = 0.8
default_parameters['soma_kdrRL_taumax'] = 20.0
default_parameters['soma_kdrRL_mVh'] = -21.0
# mAHP:
default_parameters['soma_mAHP_gcamax'] = 6.4e-06
default_parameters['soma_mAHP_gkcamax'] = 0.00045
default_parameters['soma_mAHP_taur'] = 90.0
default_parameters['soma_mAHP_mtauca'] = 2.0
default_parameters['soma_mAHP_mvhalfca'] = -20.0
# gh:
default_parameters['soma_gh_ghbar'] = 3e-5
default_parameters['soma_gh_half'] = -77.0
default_parameters['soma_gh_htau'] = 30.0
# pas:
default_parameters['soma_pas_g'] = 8.11e-05
default_parameters['soma_pas_e'] = -71.0
# Dendrite default parameters:
# pas:
default_parameters['dendrite_pas_g'] = 7.93e-05
default_parameters['dendrite_pas_e'] = -71.0
# L_Ca_inact:
default_parameters['dendrite_1_L_Ca_inact_gcabar'] = 5.2e-6
default_parameters['dendrite_2_L_Ca_inact_gcabar'] = 4.25e-6
default_parameters['dendrite_3_L_Ca_inact_gcabar'] = 6.62e-6
default_parameters['dendrite_4_L_Ca_inact_gcabar'] = 8.03e-6
default_parameters['dendrite_L_Ca_inact_theta_m'] = -42.0
default_parameters['dendrite_L_Ca_inact_tau_m'] = 40.0
default_parameters['dendrite_L_Ca_inact_theta_h'] = 10.0
default_parameters['dendrite_L_Ca_inact_tau_h'] = 2500.0
default_parameters['dendrite_L_Ca_inact_kappa_h'] = 5.0
# gh:
default_parameters['dendrite_gh_ghbar'] = 3e-5
default_parameters['dendrite_gh_half'] = -77.0
default_parameters['dendrite_gh_htau'] = 30.0
# Dendritic synaptic parameters -
# Correlated Input Parameters:
default_parameters['correlated_e_rev_exc'] = 0.0
default_parameters['correlated_tau'] = 25.0
# Independent Input Parameters:
default_parameters['independent_e_rev_exc'] = 0.0
default_parameters['independent_tau1'] = 4.0
default_parameters['independent_tau2'] = 20.0
# Bias Current Values
default_parameters['soma_bias_current_amp'] = 0.0
default_parameters['dendrite_bias_current_amp'] = 0.0
# Stochastic conductance parameters to simulate inputs from other structures
default_parameters['dendrite_Gfluct_ge0'] = 0.15 # mean value of excitatory conductance - representing input from other neural structures
default_parameters['dendrite_Gfluct_stde'] = 0.25 # standard deviation of excitatory conductance - representing input from other neural structures
default_parameters['dendrite_Gfluct_gi0'] = 0.3 # mean value of inhibitory conductance - representing input from other neural structures
default_parameters['dendrite_Gfluct_stdi'] = 0.25 # standard deviation of inhibitory conductance - representing input from other neural structures
default_parameters['dendrite_Gfluct_tau_e'] = 2.728 # Excitatory Current Time constant - In Powers et al. 2012 Paper value is 2.728 ms to simulate uncorrelated/independent inputs
default_parameters['dendrite_Gfluct_tau_i'] = 10.49 # Inhibitory Current Time constant - In Powers et al. 2012 Paper value is 10.49 ms to simulate uncorrelated/independent inputs
default_parameters['dendrite_Gfluct_E_e'] = 0.0
default_parameters['dendrite_Gfluct_E_i'] = -75.0
default_initial_values = {'v': -65.0} # Can record soma voltage and synaptic currents on each dendrite
recordable = ['soma(0.5).v', 'd1(0.5).v', 'd2(0.5).v', 'd3(0.5).v', 'd4(0.5).v', 'soma_correlated_exc.i', 'd1_correlated_exc.i', 'd2_correlated_exc.i', 'd3_correlated_exc.i', 'd4_correlated_exc.i', 'd1_independent_exc.i', 'd2_independent_exc.i', 'd3_independent_exc.i', 'd4_independent_exc.i', 'd1_Synaptic_Bombardment.i', 'd2_Synaptic_Bombardment.i', 'd3_Synaptic_Bombardment.i', 'd4_Synaptic_Bombardment.i', 'd1_Synaptic_Bombardment.g_e', 'd2_Synaptic_Bombardment.g_e', 'd3_Synaptic_Bombardment.g_e', 'd4_Synaptic_Bombardment.g_e', 'd1_Synaptic_Bombardment.g_i', 'd2_Synaptic_Bombardment.g_i', 'd3_Synaptic_Bombardment.g_i', 'd4_Synaptic_Bombardment.g_i']
units = {'soma(0.5).v' : 'mV', 'd1(0.5).v' : 'mV', 'd2(0.5).v' : 'mV', 'd3(0.5).v' : 'mV', 'd4(0.5).v' : 'mV', 'soma_correlated_exc.i' : 'nA', 'd1_correlated_exc.i' : 'nA', 'd2_correlated_exc.i' : 'nA', 'd3_correlated_exc.i' : 'nA', 'd4_correlated_exc.i' : 'nA', 'd1_independent_exc.i' : 'nA', 'd2_independent_exc.i' : 'nA', 'd3_independent_exc.i' : 'nA', 'd4_independent_exc.i' : 'nA', 'd1_Synaptic_Bombardment.i' : 'nA', 'd2_Synaptic_Bombardment.i' : 'nA', 'd3_Synaptic_Bombardment.i' : 'nA', 'd4_Synaptic_Bombardment.i' : 'nA', 'd1_Synaptic_Bombardment.g_e' : 'uS', 'd2_Synaptic_Bombardment.g_e' : 'uS', 'd3_Synaptic_Bombardment.g_e' : 'uS', 'd4_Synaptic_Bombardment.g_e' : 'uS', 'd1_Synaptic_Bombardment.g_i' : 'uS', 'd2_Synaptic_Bombardment.g_i' : 'uS', 'd3_Synaptic_Bombardment.g_i' : 'uS', 'd4_Synaptic_Bombardment.g_i' : 'uS'}
receptor_types = ['soma_correlated_exc', 'd1_correlated_exc', 'd2_correlated_exc', 'd3_correlated_exc', 'd4_correlated_exc', 'd1_independent_exc', 'd2_independent_exc', 'd3_independent_exc', 'd4_independent_exc']
model = Spinal_Motoneuron_Synaptic_Bombardment_Point_Process
class Spinal_Interneuron(object):
def __init__(self, **parameters):
# Create single compartment Destexhe Interneuron cell section, i.e. soma section
self.soma = Section(L=parameters['L'], diam=parameters['diam'], nseg=parameters['nseg'], Ra=parameters['Ra'], cm=parameters['cm'],
mechanisms=())
#mechanisms=(Mechanism('hh')))
#mechanisms=(Mechanism('interneuron_i_leak'), Mechanism('interneuron_i_na'), Mechanism('interneuron_i_k')))
# Insert the basic HH mechanisms to the soma
self.soma.insert('hh')
# Set the default mechanism parameters
for seg in self.soma:
seg.hh.gnabar = 120e-3
seg.hh.gkbar = 100e-3
seg.hh.gl = 0.51e-3
seg.hh.el = -64
# Add bias current to neuron model - current amplitude is in terms of original model paper, nA
self.soma_bias_current = h.IClamp(0.5, sec=self.soma)
self.soma_bias_current.delay = 0
self.soma_bias_current.dur = 1e12
self.soma_bias_current.amp = parameters['bias_current_amp'] # nA
# Append the gaussian IClamps to global list so they can be updated in the main script
GV.Spinal_Interneuron_bias_current_iclamps.append(self.soma_bias_current)
# Add excitatory synapse to the cell, i.e. add to the soma section
self.synapse_exc = h.ExpSyn(0.5, sec=self.soma)
self.synapse_exc.e = parameters['e_rev']
self.synapse_exc.tau = parameters['tau']
# needed for PyNN
self.source_section = self.soma
self.source = self.soma(0.5)._ref_v
self.rec = h.NetCon(self.source, None, sec=self.source_section) # Needed to clear the simulator
self.spike_times = h.Vector(0)
self.parameter_names = ('L', 'diam', 'nseg', 'Ra', 'cm', 'bias_current_amp', 'e_rev', 'tau')
self.traces = {}
self.recording_time = False
L = _new_property('soma', 'L')
diam = _new_property('soma', 'diam')
nseg = _new_property('soma', 'nseg')
Ra = _new_property('soma', 'Ra')
cm = _new_property('soma', 'cm')
bias_current_amp = _new_property('soma_bias_current', 'amp')
def area(self):
"""Membrane area in µm²"""
return pi * self.soma.L * self.soma.diam
def memb_init(self):
for seg in self.soma:
seg.v = self.v_init
class Spinal_Interneuron_Type(NativeCellType):
default_parameters = {'L': 100, 'diam': 500, 'nseg': 1, 'Ra': 150, 'cm': 1, 'bias_current_amp': 0, 'e_rev': -10, 'tau': 5}
default_initial_values = {'v': -68.0}
recordable = ['soma(0.5).v', 'synapse_exc.i']
units = {'soma(0.5).v' : 'mV', 'synapse_exc.i' : 'nA'}
receptor_types = ['synapse_exc']
model = Spinal_Interneuron
# Function to generate a skewed parameter values for a single parameter value
def generate_skewed_parameter_values(Pop_size, lower_parameter_bound, upper_parameter_bound, nonlin_ind):
# Set Up Nonlinear Interpolation Function - skew
nonlin_ind = motoneuron_pool_parameter_bounds['nonlin_ind']
fraction = np.zeros(Pop_size)
for cell_index in range(Pop_size):
fraction[cell_index] = float(cell_index)/(Pop_size - 1)
if nonlin_ind >= 0:
skew = fraction**(1 + nonlin_ind)
else:
skew = 1 - (1-fraction)**(1 - nonlin_ind)
# Calculate the skewed parameter
parameter_values = lower_parameter_bound + (upper_parameter_bound - lower_parameter_bound)*skew
# return the skewed parameter values
return parameter_values
# Function to generate the distribution of parameter values across the motoneurons in the pool
def generate_motoneuron_population_parameters(Pop_size, motoneuron_pool_parameter_bounds):
# Create dictionary for holding the parameters
motoneuron_parameters = {}
# Set Up Nonlinear Interpolation Function - skew
nonlin_ind = motoneuron_pool_parameter_bounds['nonlin_ind']
fraction = np.zeros(Pop_size)
for cell_index in range(Pop_size):
fraction[cell_index] = float(cell_index)/(Pop_size - 1)
if nonlin_ind >= 0:
skew = fraction**(1 + nonlin_ind)
else:
skew = 1 - (1-fraction)**(1 - nonlin_ind)
# Get the motoneuron sections to update parameters for
motoneuron_sections = list(motoneuron_pool_parameter_bounds.keys())
# Increment over the sections
for i in np.arange(1,len(motoneuron_sections)): # Skip the first skew parameter
section_parameters = list(motoneuron_pool_parameter_bounds[motoneuron_sections[i]].keys())
# Increment over the parameters in the section
for j in np.arange(0,len(section_parameters)):
section_subparameters = list(motoneuron_pool_parameter_bounds[motoneuron_sections[i]][section_parameters[j]].keys())
# Checking/setting cell geometry parameters
if section_subparameters == ['lower', 'upper']:
parameter_key = motoneuron_sections[i]+"_"+section_parameters[j]
lower_parameter_bound = motoneuron_pool_parameter_bounds[motoneuron_sections[i]][section_parameters[j]]['lower']
upper_parameter_bound = motoneuron_pool_parameter_bounds[motoneuron_sections[i]][section_parameters[j]]['upper']
# Calculate the skewed parameters
parameter_values = lower_parameter_bound + (upper_parameter_bound - lower_parameter_bound)*skew
# Add the parameter values to the parameter dictionary
motoneuron_parameters[parameter_key] = parameter_values
else:
for k in np.arange(0,len(section_subparameters)):
mechanism_parameters = list(motoneuron_pool_parameter_bounds[motoneuron_sections[i]][section_parameters[j]][section_subparameters[k]].keys())
parameter_key = motoneuron_sections[i]+"_"+section_parameters[j]+"_"+section_subparameters[k]
lower_parameter_bound = motoneuron_pool_parameter_bounds[motoneuron_sections[i]][section_parameters[j]][section_subparameters[k]]['lower']
upper_parameter_bound = motoneuron_pool_parameter_bounds[motoneuron_sections[i]][section_parameters[j]][section_subparameters[k]]['upper']
# Calculate the skewed parameters
parameter_values = lower_parameter_bound + (upper_parameter_bound - lower_parameter_bound)*skew
# Add the parameter values to the parameter dictionary
motoneuron_parameters[parameter_key] = parameter_values
# Return the updated motoneuron population
return motoneuron_parameters
# Motoneuron parameter bounds for the pool
motoneuron_pool_parameter_bounds = {
"nonlin_ind" : 0.8,
"soma" : {
"diam" : {"lower" : 22, "upper" : 30},
"L" : {"lower" : 2952, "upper" : 3665},
"cm" : {"lower" : 1.35546, "upper" : 1.87853},
"pas" : {
"g" : {"lower" : 8.11e-05, "upper" : 3.77e-04},
"e" : {"lower" : -71, "upper" : -72}
},
"na3rp" : {
"gbar" : {"lower" : 0.01, "upper" : 0.022},
"sh" : {"lower" : 1.0, "upper" : 1.0},
"ar" : {"lower" : 1.0, "upper" : 1.0},
"qinf" : {"lower" : 8.0, "upper" : 8.0},
"thinf" : {"lower" : -50.0, "upper" : -50.0}
},
"naps" : {
"gbar" : {"lower" : 2.60e-05, "upper" : 2.00e-05},
"sh" : {"lower" : 5.0, "upper" : 5.0},
"ar" : {"lower" : 1.0, "upper" : 1.0},
"vslope" : {"lower" : 5.0, "upper" : 5.0},
"asvh" : {"lower" : -90.0, "upper" : -90.0},
"bsvh" : {"lower" : -22.0, "upper" : -22.0}
},
"kdrRL" : {
"gMax" : {"lower" : 0.015, "upper" : 0.02},
"mVh" : {"lower" : -21, "upper" : -21},
"tmin" : {"lower" : 0.8, "upper" : 0.8},
"taumax" : {"lower" : 20.0, "upper" : 20.0}
},
"mAHP" : {
"gcamax" : {"lower" : 6.40e-06, "upper" : 1.05e-05},
"gkcamax" : {"lower" : 0.00045, "upper" : 0.0006},
"taur" : {"lower" : 90, "upper" : 40},
"mvhalfca" : {"lower" : -20, "upper" : -20},
"mtauca" : {"lower" : 2, "upper" : 2}
},
"gh" : {
"ghbar" : {"lower" : 3.00e-05, "upper" : 2.30e-04},
"htau" : {"lower" : 30, "upper" : 30}
},
},
"dendrite" : {
"diam" : {"lower" : 8.73071, "upper" : 11.9055},
"L" : {"lower" : 1794.13, "upper" : 2226.91},
"Ra" : {"lower" : 51.038, "upper" : 40.755},
"cm" : {"lower" : 0.867781, "upper" : 0.880407},
"pas" : {
"g" : {"lower" : 7.93e-05, "upper" : 1.75e-04},
"e" : {"lower" : -71, "upper" : -72}
},
"gh" : {
"ghbar" : {"lower" : 3.00e-05, "upper" : 2.30e-04},
"htau" : {"lower" : 30, "upper" : 30}
},
"L_Ca_inact" : {
"theta_m" : {"lower" : -42, "upper" : -32},
"tau_m" : {"lower" : 40, "upper" : 40},
"theta_h" : {"lower" : 10, "upper" : -10},
"tau_h" : {"lower" : 2500, "upper" : 2500},
"kappa_h" : {"lower" : 5, "upper" : 5}
}
},
"dendrite_1" : {
"L_Ca_inact" : {
"gcabar" : {"lower" : 5.20e-06, "upper" : 5.44e-06}
}
},
"dendrite_2" : {
"L_Ca_inact" : {
"gcabar" : {"lower" : 4.25e-06, "upper" : 6.24e-06}
}
},
"dendrite_3" : {
"L_Ca_inact" : {
"gcabar" : {"lower" : 6.62e-06, "upper" : 7.04e-06}
}
},
"dendrite_4" : {
"L_Ca_inact" : {
"gcabar" : {"lower" : 8.03e-06, "upper" : 8.24e-06}
}
}
}