from neuron import h, gui
from e import e
s = h.Section()
s.insert('hh')
iname = s.hoc_internal_name()
print(iname)
exec('s2 = h.' + iname)
print('s is s2', s is s2)
print('s is h.cas()', s is h.cas())
print('s == h.cas()', s == h.cas())
h('create soma')
s4 = h.soma
print(s4.hoc_internal_name())
exec('s5 = h.' + s4.hoc_internal_name())
print('s5 is s4', s5 is s4)
print('s5 == s4', s5 == s4)
print(s5.name())
s6 = h.Section(name="s6")
s6.name()
h.topology()
h('''__nrnsec_0x { print secname() }''')
e('s7 = h.__nrnsec_0x')
h('''__nrnsec_0xaaaa { print secname() }''')
e('s7 = h.__nrnsec_0xaaaa')
del(s)
print(s2)
def create_sections(self):
"""Create the sections of the cell."""
self.soma = h.Section(name='soma', cell=self)
self.dend = h.Section(name='dend', cell=self)
from neuron import h, gui
soma = h.Section()
soma.insert('hh')
def pname(msname):
s = h.ref('')
for i in range(-1, 4):
ms = h.MechanismStandard(msname, i)
print('\n', msname, ' vartype=%d' % i) # vartype = 1 -> PARAMETER
for j in range(int(ms.count())):
k = ms.name(s, j)
print('%-5d %-20s size=%d' % (j, s[0], k))
def ptype():
msname = h.ref('')
propList = {}
for i, mechtype in enumerate(['mechs', 'pointps']):
mt = h.MechanismType(
i) # either distributed mechs (0) or point process (1)
propList[mechtype] = {}
for j in range(int(mt.count())):
mt.select(j)
mt.selected(msname)
print('\n\n', msname[0], ' mechanismtype=%d' % j)
pname(msname[0])
ms = h.MechanismStandard(msname[0], 1) # PARAMETER (modifiable)
propList[mechtype][msname[0]] = []
propName = h.ref('')
# This example comes with NeuronVisio.
# Importing the NeuronVisio
from neuronvisio.controls import Controls
controls = Controls()
# Importing hoc interpreter
from neuron import h
# simple model
soma = h.Section(name='soma')
dend1 = h.Section(name='dend1')
dend2 = h.Section(name='dend2')
soma.diam = 10
dend1.diam = 3
dend2.diam = 3
soma.L = 50
dend1.L = 100
dend2.L = 100
dend1.connect(soma)
dend2.connect(soma)
# biophysics
for sec in h.allsec():
sec.Ra = 100
sec.cm = 1
def __init__(self):
neuron_utils.createProject(name='Simple Cell')
self.soma = h.Section(name='soma')
self.dend = h.Section(name='dend')
self.dend.connect(self.soma(1))
# Surface area of cylinder is 2*pi*r*h (sealed ends are implicit).
# Makes a soma of 500 microns squared.
self.soma.L = self.soma.diam = 12.6157
self.dend.L = 200 # microns
self.dend.diam = 1 # microns
for sec in h.allsec():
sec.Ra = 100 # Axial resistance in Ohm * cm
sec.cm = 1 # Membrane capacitance in micro Farads / cm^2
# Insert active Hodgkin-Huxley current in the soma
self.soma.insert('hh')
self.soma.gnabar_hh = 0.12 # Sodium conductance in S/cm2
self.soma.gkbar_hh = 0.036 # Potassium conductance in S/cm2
self.soma.gl_hh = 0.0003 # Leak conductance in S/cm2
self.soma.el_hh = -54.3 # Reversal potential in mV
# Insert passive current in the dendrite
self.dend.insert('pas')
self.dend.g_pas = 0.001 # Passive conductance in S/cm2
self.dend.e_pas = -65 # Leak reversal potential mV
self.dend.nseg = 10
# add synapse (custom channel)
self.syn = h.AlphaSynapse(self.dend(1.0))
self.syn.e = 0 # equilibrium potential in mV
self.syn.onset = 20 # turn on after this time in ms
self.syn.gmax = 0.05 # set conductance in uS
self.syn.tau = 0.1 # set time constant
# self.stim = h.IClamp(self.dend(1.0))
# self.stim.amp = 0.3 # input current in nA
# self.stim.delay = 1 # turn on after this time in ms
# self.stim.dur = 1 # duration of 1 ms
# record soma voltage and time
self.t_vec = h.Vector()
self.t_vec.record(h._ref_t)
neuron_utils.createStateVariable(id='time',
name='time',
units='ms',
python_variable={
"record_variable": self.t_vec,
"segment": None
})
self.v_vec_soma = h.Vector()
self.v_vec_soma.record(self.soma(1.0)._ref_v) # change recoding pos
# TODO How do we extract the units?
neuron_utils.createStateVariable(id='v_vec_soma',
name='v_vec_soma',
units='mV',
python_variable={
"record_variable":
self.v_vec_soma,
"segment": self.soma(1.0)
})
self.v_vec_dend = h.Vector()
self.v_vec_dend.record(self.dend(1.0)._ref_v)
# TODO How do we extract the units?
neuron_utils.createStateVariable(id='v_vec_dend',
name='v_vec_dend',
units='mV',
python_variable={
"record_variable":
self.v_vec_dend,
"segment": self.dend(1.0)
})
# run simulation
h.tstop = 60 # ms
# h.run()
neuron_geometries_utils.extractGeometries()
def testpsection(self):
"""Test neuron.psection(Section)"""
s = h.Section(name='soma')
neuron.psection(s)
from neuron import h, gui
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.colors as colors
import matplotlib.cm as cmx
import matplotlib.animation as animation
from matplotlib.animation import FuncAnimation
dtype = np.float64
# one-compartment cell (soma)
soma = h.Section(name='soma')
soma.diam = 50 # micron
soma.L = 63.66198 # micron, so that area = 10000 micron2
soma.nseg = 1 # adimensional
soma.cm = 1 # uF/cm2
soma.Ra = 70 # ohm-cm
soma.nseg = 1
soma.insert('na15') # insert mechanism
soma.ena = 65
h.celsius = 24 # temperature in celsius
v_init = -120 # holding potential
h.dt = 0.01 # ms - value of the fundamental integration time step, dt, used by fadvance().
# clamping parameters
dur = 500 # clamp duration, ms
step = 3 # voltage clamp increment
st_cl = -120 # clamp start, mV
end_cl = 1 # clamp end, mV
v_cl = -120 # actual voltage clamp, mV
def psection(cls):
"""Test neuron.psection(Section)"""
s = h.Section(name='soma')
neuron.psection(s)
"""
This definition will construct a vector to record all the data taken in the simulation. The potential across each soma will be recorded for each time step.
"""
vec = {}
#Record appropriate number of potentials.
for var in range(0, numNeurons):
vec[str(var + 1)] = h.Vector()
vec[str(var + 1)].record(Soma[var](0.5)._ref_v)
#Record time.
vec['t '] = h.Vector()
vec['t '].record(h._ref_t)
return vec
# Construct initial sections of neurons 1-4.
Soma1 = h.Section()
Soma2 = h.Section()
Soma3 = h.Section()
Soma4 = h.Section()
AD1 = h.Section()
AD2 = h.Section()
AD3 = h.Section()
AD4 = h.Section()
BD1 = h.Section()
BD2 = h.Section()
BD3 = h.Section()
BD4 = h.Section()
Axon1 = h.Section()
Axon2 = h.Section()
Axon3 = h.Section()
Axon4 = h.Section()
from neuron import h
from pylab import *
import timeit
start = timeit.default_timer()
cell = h.Section()
cell.insert('hha2')
stimulus = h.IClamp(0.5)
stimulus.delay = 100
stimulus.dur = 800
stimulus.amp = 7
trec = h.Vector()
vrec = h.Vector()
trec.record(h._ref_t)
vrec.record(cell(0.5)._ref_v)
stimuli_rec = h.Vector()
stimuli_rec.record(stimulus._ref_i)
h.load_file("stdrun.hoc")
h.init()
h.v_init = -65
h.tstop = 1000
before_run = timeit.default_timer()
print('initial time:%f' % (before_run - start))
def testSectionArgOrder(self):
""" First optional arg for Section is name (but name="name" is recommended)"""
soma = h.Section('soma')
assert soma.name() == 'soma'
Equation for synaptic inputs taken from
Izhikevich EM, Edelman GM (2008). "Large-scale model of mammalian thalamocortical systems." PNAS 105(9) 3593-3598.
Cell types available are based on Izhikevich, 2007 book:
1. RS - Layer 5 regular spiking pyramidal cell (fig 8.12 from 2007 book)
2. IB - Layer 5 intrinsically bursting cell (fig 8.19 from 2007 book)
3. CH - Cat primary visual cortex chattering cell (fig8.23 from 2007 book)
4. LTS - Rat barrel cortex Low-threshold spiking interneuron (fig8.25 from 2007 book)
5. FS - Rat visual cortex layer 5 fast-spiking interneuron (fig8.27 from 2007 book)
6. TC - Cat dorsal LGN thalamocortical (TC) cell (fig8.31 from 2007 book)
7. RTN - Rat reticular thalamic nucleus (RTN) cell (fig8.32 from 2007 book)
"""
import collections
from neuron import h
dummy = h.Section()
type2007 = collections.OrderedDict([
# C k vr vt vpeak a b c d celltype
('RS', (1.0, 0.7, -60, -40, 35, 0.03, -2, -50, 100, 1)),
('IB', (1.5, 1.2, -75, -45, 50, 0.01, 5, -56, 130, 2)),
('CH', (0.5, 1.5, -60, -40, 25, 0.03, 1, -40, 150, 3)),
('LTS', (1.0, 1.0, -56, -42, 40, 0.03, 8, -53, 20, 4)),
('FS', (0.2, 1.0, -55, -40, 25, 0.2, -2, -45, -55, 5)),
('TC', (2.0, 1.6, -60, -50, 35, 0.01, 15, -60, 10, 6)),
('TC_burst', (2.0, 1.6, -60, -50, 35, 0.01, 15, -60, 10, 6)),
('RTN', (0.4, 0.25, -65, -45, 0, 0.015, 10, -55, 50, 7)),
('RTN_burst', (0.4, 0.25, -65, -45, 0, 0.015, 10, -55, 50, 7))])
# class of basic Izhikevich neuron based on parameters in type2007
class IzhiCell ():
'''Create an izhikevich cell based on 2007 parameterization using either izhi2007.mod (no hosting section) or izhi2007b.mod (v in created section)
def run_cell(diam,cm,el,gl,gna,gh,gk,tstop,dur,amp,mhalf,hhalf,mk,hk,nhalf,kn,multiply,multiply1,multiply2,seg1,seg2,seg3):
#Load the mechanisms in the current directory
neuron.load_mechanisms(os.path.dirname(os.path.abspath(__file__)))
Passive = [1,-1,-65]
soma = h.Section(name='soma')
soma.L = 100 # um
soma.insert('hh')
v0_vec = h.Vector()
t_vec = h.Vector()
v0_vec.record(soma(0.5)._ref_v)
t_vec.record(h._ref_t)
soma.insert('na1')
soma.insert('k1')
soma.insert('hd')
m_na = h.Vector()
h_hd = h.Vector()
n_k = h.Vector()
tau_m = h.Vector()
tau_h = h.Vector()
tau_n = h.Vector()
m_na.record(soma(0.5)._ref_minf_na1)
h_hd.record(soma(0.5)._ref_linf_hd)
n_k.record(soma(0.5)._ref_ninf_k1)
tau_m.record(soma(0.5)._ref_mtau_na1)
tau_h.record(soma(0.5)._ref_taul_hd)
tau_n.record(soma(0.5)._ref_taun_k1)
soma.diam = diam
soma.cm = cm*1.4884e-4/6.2832e-4
soma.gbar_na1 = gna*1e-3
soma.gbar_k1 = gk*1e-3
soma.gl_hh = gl*1e-6
soma.ghdbar_hd = gh*1e-4
soma.el_hh = el
soma.mhalf_na1 = mhalf
soma.vhalfl_hd = hhalf
soma.mk_na1 = mk
soma.kl_hd = hk
soma.vhalfn_k1 = nhalf
soma.kn_k1 = kn
soma.multiply1_na1 = multiply1
soma.multiply2_na1 = multiply2
soma.multiply_k1 = multiply
soma.seg_value1_k1 = seg1
soma.seg_value2_na1 = seg2
soma.seg_value3_hd = seg3
Source = h.IClamp(soma(0.5))
Source.delay = dur[0]
Source.dur = dur[1]-dur[0]
Source.amp = amp
h.tstop = tstop
h.v_init = el
nc = h.NetCon(soma(0.5)._ref_v,None,sec=soma)
nc.threshold = 0
spvec = h.Vector()
nc.record(spvec)
if Source.amp < 0:
h.run()
print('number of spikes:',len(spvec))
R_in_1 = 1/(soma.gl_hh*1000)
tau_1 = soma.cm*R_in_1
V_rest_1 = v0_vec[int(tstop)-20]
R_in_2 = Passive[1]
tau_2 = Passive[0]
V_rest_2 = Passive[2]
df1 = pd.DataFrame([[tau_1],[V_rest_1],[R_in_1],[tau_2],[V_rest_2],[R_in_2]],
columns=['value '],
index = ['tau_seg ', 'Vrest_seg ', 'Rin_seg ','tau_ori ', 'Vrest_ori ', 'Rin_ori '])
print (df1)
plt.figure(figsize=(10,6))
plt.plot(t_vec, v0_vec,'b')
plt.xlim(0, tstop)
plt.ylabel('mV')
frequency =["all"]
amplitude =["all"]
# FIR Curve
freq1 = []
I1 = []
freq2 = []
I2 = []
if (Source.amp > 0):
for Source.amp in np.arange(amp,amp+1,0.1):
h.run()
freq1.append(len(spvec)*1000/Source.dur)
I1.append(Source.amp)
plt.figure(figsize=(16,14))
plt.subplot(4,1,1)
plt.plot(t_vec, v0_vec,'b')
plt.xlim(0, tstop)
plt.ylabel('mV')
plt.subplot(4,1,2)
plt.plot(amplitude,frequency,'bo')
plt.plot(I1,freq1,'yo')
#plt.legend([soma.flag_k1,1-soma.flag_k1])
plt.xlabel('Injected current (nA)')
plt.ylabel('frequency')
plt.subplot(4,1,3)
plt.plot(v0_vec, m_na,'r.')
plt.plot(v0_vec, h_hd,'b.')
plt.plot(v0_vec, n_k, 'g.')
#plt.xlim(0, tstop)
plt.xlabel('voltage (mV)')
plt.ylabel('Probability')
plt.legend(['minf','hinf','ninf'])
plt.subplot(4,1,4)
plt.plot(v0_vec, tau_m,'r.')
plt.plot(v0_vec, tau_h,'b.')
plt.plot(v0_vec, tau_n, 'g.')
plt.xlabel('voltage (mV)')
plt.ylabel('tau')
plt.legend(['minf','hinf','ninf'])
image = BytesIO()
#plt.show()
plt.savefig(image, format='png')
ret = base64.b64encode(image.getvalue())
return str(ret)
def graph(self):
#Function: graph
#Input: self
#Process: create dendrite branch network
#Output: neuron
self.dendsegs = numpy.array([self.coordinates[:,0], self.coordinates[:,2], self.coordinates[:,3],self.coordinates[:,4],self.coordinates[:,5],self.coordinates[:,6]])
self.seglist = numpy.array(self.coordinates[:,0]-1,dtype=int)
self.segmap = numpy.array(self.coordinates[:,6]-1,dtype=int)
if self.seglist[0] == 1:
self.seglist = numpy.array(self.seglist-1,dtype=int)
self.segmap = numpy.array(self.segmap-1,dtype=int)
#-----------------------------------------------------------------------------------------------------------------------------------------------
self.compartmentdict = {}
segvals = []
Gcompartment = []
#-----------------------------------------------------------------------------------------------------------------------------------------------
for c in range(len(self.seglist)):
#-----------------------------------------------------------------------------------------------------------------------------------------------
if self.segmap[c] < self.seglist[c] - 1:
if len(segvals) == 0:
continue
i = c
self.compartmentdict[i] = [Gcompartment,h.Section(name='compartment',cell=self),segvals]
Gcompartment = []
segvals = []
#-----------------------------------------------------------------------------------------------------------------------------------------------
if c == len(self.seglist) - 1:
if len(segvals) == 0:
break
i = c
self.compartmentdict[i] = [Gcompartment,h.Section(name='compartment',cell=self),segvals]
Gcompartment = []
segvals = []
#-----------------------------------------------------------------------------------------------------------------------------------------------
else:
segvals.append([self.dendsegs[1,c]*1/125.0,self.dendsegs[2,c]*1/125.0,self.dendsegs[3,c]*1/125.0,self.dendsegs[4,c]*1/125.0])
Gcompartment.append(self.seglist[c])
#-----------------------------------------------------------------------------------------------------------------------------------------------
for key in self.compartmentdict.keys():
if len(self.compartmentdict[key][2]) > 0:
s = self.compartmentdict[key][2][0]
e = self.compartmentdict[key][2][-1]
if distance.euclidean(s[0:2],e[0:2]) == 0:
h.pt3dadd(s[0],s[1],s[2],s[3],sec=self.compartmentdict[key][1])
h.pt3dadd(e[0] + 1e-5,e[1] + 1e-5,e[2] + 1e-5,e[3],sec=self.compartmentdict[key][1])
else:
h.pt3dadd(s[0],s[1],s[2],s[3],sec=self.compartmentdict[key][1])
h.pt3dadd(e[0],e[1],e[2],e[3],sec=self.compartmentdict[key][1])
#-----------------------------------------------------------------------------------------------------------------------------------------------
for key in self.compartmentdict.keys():
for part in self.compartmentdict.keys():
if key in self.compartmentdict[part][0]:
self.compartmentdict[key][1].connect(self.compartmentdict[part][1])
#-----------------------------------------------------------------------------------------------------------------------------------------------
for dendID in self.compartmentdict.keys():
n3dID = int(h.n3d(sec=self.compartmentdict[dendID][1]))
for n in range(n3dID):
self.dendgraph[dendID] = numpy.array([float(h.x3d(n,sec=self.compartmentdict[dendID][1])),float(h.y3d(n,sec=self.compartmentdict[dendID][1])),float(h.z3d(n,sec=self.compartmentdict[dendID][1]))])
def create_sections(self):
'''
Creates sections (compartments)
'''
self.branch = h.Section(name='branch', cell=self)
self.stimsec = [h.Section(name='stimsec[%d]' % i) for i in range(self.num)]
elif method in (8, 9):
args = (_pc_dt(tid), _pc_t(tid), pd1_array, pd2_array)
for c in call:
if c[method] is not None:
c[method](*args)
except:
traceback.print_exc()
rval = -1
return rval
_callback = nonvint_block_prototype(nonvint_block)
set_nonvint_block(_callback)
if __name__ == '__main__':
exec(test) # see above string
s = h.Section()
print("fixed step finitialize")
h.finitialize(0)
print("fixed step fadvance")
h.fadvance()
h.load_file('stdgui.hoc')
print("cvode active")
h.cvode_active(1)
print("cvode step finitialize")
h.finitialize(0)
print("cvode fadvance")
h.fadvance()
mtau = 1.0 / (q10 * (alpha + beta))
minf = alpha / (alpha + beta)
# sodium inactivation 'h'
alpha = 0.07 * exp(-(v + 65.0) / 20.0)
beta = 1.0 / (exp(-(v + 35.0) / 10.0) + 1.0)
htau = 1.0 / (q10 * (alpha + beta))
hinf = alpha / (alpha + beta)
# potassium activation 'n'
alpha = 0.01 * vtrap(-(v + 55.0), 10.0)
beta = 0.125 * exp(-(v + 65.0) / 80.0)
ntau = 1.0 / (q10 * (alpha + beta))
ninf = alpha / (alpha + beta)
somaA = h.Section('somaA')
somaA.pt3dclear()
somaA.pt3dadd(-90, 0, 0, 30)
somaA.pt3dadd(-60, 0, 0, 30)
somaA.nseg = 1
somaB = h.Section('somaB')
somaB.pt3dclear()
somaB.pt3dadd(60, 0, 0, 30)
somaB.pt3dadd(90, 0, 0, 30)
somaB.nseg = 1
# mod version
somaB.insert('hh')
# rxd version
from neuron import h, gui
import numpy
# a - red
# b - blue
# c - green
# d - yellow
# e - black
# b(0)->a(1): blue->red
# c(1)->b(1): green->blue
# d(0)->b(1): yellow->blue
# e(0)->a(0): black->red
a, b, c, d, e = [h.Section(name=n) for n in ['a', 'b', 'c', 'd', 'e']]
b.connect(a)
c.connect(b(1), 1) # connect the 1 end of c to the 1 end of b
d.connect(b)
e.connect(a(0)) # connect the 0 end of e to the 0 end of a
for sec in h.allsec():
sec.nseg = 20
sec.L = 100
for seg in sec:
seg.diam = numpy.interp(seg.x, [0, 1], [10, 40])
s = h.Shape()
s.show(False)
s.color(2, sec=a) # a - red
s.color(3, sec=b) # b - blue
s.color(4, sec=c) # c - green
from neuron import h, gui
h.load_file("nrngui.hoc")
#h.nao0_na_ion = 110
#h.cao0_ca_ion = 1.8
soma = h.Section(name="soma")
soma.Ra = 200
soma.L = 40
soma.diam = 50
soma.nseg = 2
soma.insert("pcell")
soma.insert("na")
soma.insert("napump")
soma.insert("gkca")
soma.insert("ca")
soma.insert("cach")
soma.insert("capump")
junction = h.Section(name="soma")
junction.Ra = 200
junction.L = 40
junction.diam = 10
junction.nseg = 2
junction.insert("pcell")
junction.insert("na")
junction.insert("napump")
junction.insert("gkca")
junction.insert("ca")
junction.insert("cach")
junction.insert("capump")
mtau = 1.0 / (q10 * (alpha + beta))
minf = alpha / (alpha + beta)
# sodium inactivation 'h'
alpha = 0.07 * exp(-(v + 65.0) / 20.0)
beta = 1.0 / (exp(-(v + 35.0) / 10.0) + 1.0)
htau = 1.0 / (q10 * (alpha + beta))
hinf = alpha / (alpha + beta)
# potassium activation 'n'
alpha = 0.01 * vtrap(-(v + 55.0), 10.0)
beta = 0.125 * exp(-(v + 65.0) / 80.0)
ntau = 1.0 / (q10 * (alpha + beta))
ninf = alpha / (alpha + beta)
somaA = h.Section("somaA")
somaA.pt3dclear()
somaA.pt3dadd(-90, 0, 0, 30)
somaA.pt3dadd(-60, 0, 0, 30)
somaA.nseg = 1
somaB = h.Section("somaB")
somaB.pt3dclear()
somaB.pt3dadd(60, 0, 0, 30)
somaB.pt3dadd(90, 0, 0, 30)
somaB.nseg = 1
# mod version
somaB.insert("hh")
# rxd version
def test_is_point_process():
section = h.Section()
clamp = h.SEClamp(section(0.5))
assert simulator.is_point_process(clamp)
section.insert('hh')
assert not simulator.is_point_process(section(0.5).hh)
def load(filename,
fileformat=None,
cell=None,
use_axon=True,
xshift=0,
yshift=0,
zshift=0):
"""
Load an SWC from filename and instantiate inside cell. Code kindly provided
by @ramcdougal.
Args:
filename = .swc file containing morphology
cell = Cell() object. (Default: None, creates new object)
filename = the filename of the SWC file
use_axon = include the axon? Default: True (yes)
xshift, yshift, zshift = use to position the cell
Returns:
Cell() object with populated soma, axon, dend, & apic fields
Minimal example:
# pull the morphology for the demo from NeuroMorpho.Org
from PyNeuronToolbox import neuromorphoorg, load
with open('c91662.swc', 'w') as f:
f.write(neuromorphoorg.morphology('c91662'))
cell = load(filename)
"""
if cell is None:
cell = Cell(name=string.join(filename.split('.')[:-1]))
if fileformat is None:
fileformat = filename.split('.')[-1]
name_form = {1: 'soma[%d]', 2: 'axon[%d]', 3: 'dend[%d]', 4: 'apic[%d]'}
# load the data. Use Import3d_SWC_read for swc, Import3d_Neurolucida3 for
# Neurolucida V3, Import3d_MorphML for MorphML (level 1 of NeuroML), or
# Import3d_Eutectic_read for Eutectic.
if fileformat == 'swc':
morph = h.Import3d_SWC_read()
elif fileformat == 'asc':
morph = h.Import3d_Neurolucida3()
else:
raise Exception('file format `%s` not recognized' % (fileformat))
morph.input(filename)
# easiest to instantiate by passing the loaded morphology to the Import3d_GUI
# tool; with a second argument of 0, it won't display the GUI, but it will allow
# use of the GUI's features
i3d = h.Import3d_GUI(morph, 0)
# get a list of the swc section objects
swc_secs = i3d.swc.sections
swc_secs = [swc_secs.object(i) for i in xrange(int(swc_secs.count()))]
# initialize the lists of sections
sec_list = {1: cell.soma, 2: cell.axon, 3: cell.dend, 4: cell.apic}
# name and create the sections
real_secs = {}
for swc_sec in swc_secs:
cell_part = int(swc_sec.type)
# skip everything else if it's an axon and we're not supposed to
# use it... or if is_subsidiary
if (not (use_axon) and cell_part == 2) or swc_sec.is_subsidiary:
continue
# figure out the name of the new section
if cell_part not in name_form:
raise Exception('unsupported point type')
name = name_form[cell_part] % len(sec_list[cell_part])
# create the section
sec = h.Section(name=name)
# connect to parent, if any
if swc_sec.parentsec is not None:
sec.connect(real_secs[swc_sec.parentsec.hname()](swc_sec.parentx))
# define shape
if swc_sec.first == 1:
h.pt3dstyle(1,
swc_sec.raw.getval(0, 0),
swc_sec.raw.getval(1, 0),
swc_sec.raw.getval(2, 0),
sec=sec)
j = swc_sec.first
xx, yy, zz = [swc_sec.raw.getrow(i).c(j) for i in xrange(3)]
dd = swc_sec.d.c(j)
if swc_sec.iscontour_:
# never happens in SWC files, but can happen in other formats supported
# by NEURON's Import3D GUI
raise Exception('Unsupported section style: contour')
if dd.size() == 1:
# single point soma; treat as sphere
x, y, z, d = [dim.x[0] for dim in [xx, yy, zz, dd]]
for xprime in [x - d / 2., x, x + d / 2.]:
h.pt3dadd(xprime + xshift, y + yshift, z + zshift, d, sec=sec)
else:
for x, y, z, d in zip(xx, yy, zz, dd):
h.pt3dadd(x + xshift, y + yshift, z + zshift, d, sec=sec)
# store the section in the appropriate list in the cell and lookup table
sec_list[cell_part].append(sec)
real_secs[swc_sec.hname()] = sec
cell.all = cell.soma + cell.apic + cell.dend + cell.axon
return cell
import sys
import time
import itertools
npar = len(sys.argv)
#if(npar<2):
# print "usage: python wave1d.py <nseg> <nsubseg>"
# sys.exit(0)
#rxd.options.nsubseg =int(sys.argv[2])
rxd.options.subseg_interpolation = 0
rxd.options.subseg_averaging = 0
sec = h.Section()
L = 100
#sec.diam = 1
sec.nseg = 125
#h.pt3dadd(0, 0, 0, 1)
#h.pt3dadd(L, 0, 0, 10)
sec.Ra = 150
Rm = 25370
dend= sec
for myseg in dend: myseg.v = -64
for myseg in dend: myseg.cm = 1.41
dend.insert('pas')
for myseg in dend: myseg.pas.g = 1.0/Rm
for myseg in dend: myseg.pas.e = -64
dend.insert('cal') # insert L-type Ca channel
for myseg in dend: myseg.cal.gcalbar = 1.e-6
def create_synapses(self, syn_set):
set_name = syn_set['name']
syn_entries = syn_set['entries']
synapses = self.synapse_sets[set_name] = []
for entry in syn_entries:
rank_source_section = self.rank_section_name(
entry['source_section'])
rank_dest_section = self.rank_section_name(entry['dest_section'])
source_on_rank = rank_source_section is not None
dest_on_rank = rank_dest_section is not None
if dest_on_rank:
dest_sec = self.section_index[rank_dest_section]
dest_x = self.clamp_section_x(entry['dest_x'])
else:
dest_sec = None
dest_x = 0
if source_on_rank:
source_sec = self.section_index[rank_source_section]
source_x = self.clamp_section_x(entry['source_x'])
else:
source_sec = None
source_x = 0
# At first, assume no spines
neck = None
head = None
# Unless indicated otherwise
if source_on_rank and entry['create_spine']:
prefix = set_name + "_" + entry['prefix'] + "[" + str(
len(synapses)) + "]"
# Create the spine head
head = h.Section(name=prefix + ".head")
# basic passive params
head.insert('pas')
# Add the 3D coords
self.add_spine_pt3d(head, entry['head_start'],
entry['head_diameter'])
self.add_spine_pt3d(head, entry['head_end'],
entry['head_diameter'])
# Create the head (if there is enough room)
if entry['neck_start'] is not None:
neck = h.Section(name=prefix + ".neck")
neck.insert('pas')
self.add_spine_pt3d(neck, entry['neck_start'],
entry['neck_diameter'])
self.add_spine_pt3d(neck, entry['neck_end'],
entry['neck_diameter'])
# Connect the spine together to the source section
neck.connect(source_sec(source_x), 0)
head.connect(neck)
else:
# If there is no neck, connect the head to section directly
head.connect(source_sec(source_x), 0)
# Point process should now be placed on the spine head
source_sec = head
source_x = 0.5
source_gid = self.segment_gid(entry['source_section'],
entry['source_seg_i'],
entry['create_spine'])
netcon, syn = self.create_netcon_syn(
entry['dest_syn'], dest_sec, dest_x, entry['dest_syn_params'],
source_sec, source_x, entry['threshold'], entry['delay'],
entry['weight'], source_on_rank, dest_on_rank, source_gid)
# If reciprocal, create a NetCon+Syn going in the opposite direction
if entry['is_reciprocal']:
dest_gid = self.segment_gid(entry['dest_section'],
entry['dest_seg_i'], False)
netcon_recip, syn_recip = self.create_netcon_syn(
entry['source_syn'], source_sec, source_x,
entry['source_syn_params'], dest_sec, dest_x,
entry['threshold'], entry['delay'], entry['weight'],
dest_on_rank, source_on_rank, dest_gid)
else:
netcon_recip, syn_recip = None, None
# Keep references to the synapse parts
synapses.append((netcon, syn, neck, head, netcon_recip, syn_recip))
'''
PyNeuron tutorial.
Create basic conductance-based model
Set up recording of parameters to save and plot the data
'''
import pickle # for saving/reading data
import neuron
from neuron import h # hoc interpreter
import numpy as np
from pylab import * # for drawing
#h.celsius = 37 # set the temperature
cell = h.Section() # create a section (cable)
cell.insert('hh') # insert a Hodgkin-Huxley channel
vrec = h.Vector() # setup recording Vectors
trec = h.Vector()
vrec.record(
cell(0.5)._ref_v) # record voltage from middle (0.5) of the Section
trec.record(h._ref_t) # record time variable
h.finitialize(-60) # voltage at initialization, in mV
h.dt = 0.025 # 0.025 millisecond timestep
neuron.run(1000) # run simulation for 1000 milliseconds
plot(np.array(trec), np.array(vrec)) # plot the output using matplotlib
xlim((0, h.tstop))
xlabel('Time (ms)')
from neuron import * from nrn import * from itertools import chain from neuron import h Section = h.Section from numpy import * from pylab import * #Let's first try making two neurons... soma = h.Section() h.pt3dadd(0, 0, 0, 3, sec=soma) h.pt3dadd(0, 0, 1, 3, sec=soma) dend1 = h.Section() h.pt3dadd(0, 0, 5, 3, sec=dend1) h.pt3dadd(5, 0, 5, 2, sec=dend1) h.pt3dadd(15, 15, 15, 10, sec=dend1) dend2 = h.Section() h.pt3dadd(0, 0, -5, 3, sec=dend2) h.pt3dadd(-5, 0, -5, 4, sec=dend2) h.pt3dadd(-15, -15, -15, 50, sec=dend2) dend1.connect(soma, 0, 0) dend2.connect(soma, 1, 0) soma1 = h.Section() h.pt3dadd(10, 10, 10, 3, sec=soma1) h.pt3dadd(10, 10, 11, 3, sec=soma1) dend3 = h.Section() h.pt3dadd(10, 10, 15, 3, sec=dend3) h.pt3dadd(15, 10, 15, 2, sec=dend3) h.pt3dadd(5, 5, 5, 1, sec=dend3)
from neuron import h, crxd as rxd
import numpy
import __main__
name = __main__.__file__
if name[-3:] == ".py":
name = name[:-3]
h.load_file("stdrun.hoc")
dend1 = h.Section()
dend1.diam = 2
dend1.nseg = 101
dend1.L = 50
dend2 = h.Section()
dend2.diam = 2
dend2.nseg = 101
dend2.L = 50
dend2.connect(dend1)
diff_constant = 1
h.cvode_active(True)
r = rxd.Region(h.allsec(), dx=0.25)
rxd.set_solve_type([dend1], dimension=3)
ca = rxd.Species(
r,
d=diff_constant,
atolscale=0.1,
initial=lambda node: 1 if (0.8 < node.x and node.segment in dend1) or
def create_cell(self):
"""
3D morphology of CA229simp cell.
The diam and L of each compartment is determined by 3D structure.
Same as hoc 3D morphology: CA229.hoc
"""
self.soma = [h.Section(name='soma[%d]' % i) for i in xrange(4)]
self.apical = [h.Section(name='apical[0]')]
self.basal = [h.Section(name='basal[%d]' % i) for i in xrange(10)]
self.axon = [h.Section(name='axon[0]')]
self.axon[0].L = 200.0
self.axon[0].diam = 1.03
self.axon[0].nseg = 1
self.axon[0].connect(self.soma[2])
self.apical[0].L = 454.5
self.apical[0].diam = 6.00
self.apical[0].nseg = 1
self.apical[0].connect(self.soma[3])
self.basal[9].L = 157.2
self.basal[9].diam = 6.00
self.basal[9].nseg = 1
self.basal[9].connect(self.soma[1])
self.basal[8].nseg = 3
# Set up the 3d morphology and connection of soma
h.pt3dclear(sec=self.soma[0])
h.pt3dstyle(1, -53.42, 3.52, -5.95, 13.43, sec=self.soma[0])
h.pt3dadd(-53.42, 3.52, -5.96, 13.43, sec=self.soma[0])
self.soma[1].connect(self.soma[0])
h.pt3dclear(sec=self.soma[1])
h.pt3dadd(-53.42, 3.52, -5.96, 13.43, sec=self.soma[1])
h.pt3dadd(-53.74, 0.93, -5.96, 15.35, sec=self.soma[1])
h.pt3dadd(-54.06, -1.66, -5.96, 11.51, sec=self.soma[1])
self.soma[3].connect(self.soma[0])
h.pt3dclear(sec=self.soma[3])
h.pt3dadd(-53.42, 3.52, -5.96, 13.43, sec=self.soma[3])
h.pt3dadd(-53.1, 6.12, -5.96, 11.19, sec=self.soma[3])
h.pt3dadd(-52.78, 8.71, -5.96, 9.59, sec=self.soma[3])
h.pt3dadd(-52.78, 11.62, -5.96, 7.36, sec=self.soma[3])
h.pt3dadd(-53.1, 14.22, -5.96, 5.76, sec=self.soma[3])
self.soma[2].connect(self.soma[1])
h.pt3dclear(sec=self.soma[2])
h.pt3dadd(-54.06, -1.66, -5.96, 11.51, sec=self.soma[2])
h.pt3dadd(-54.06, -4.25, -5.96, 7.99, sec=self.soma[2])
# Set up the 3d morphology and connection of basal dendrites
self.basal[0].connect(self.soma[0])
h.pt3dclear(sec=self.basal[0])
h.pt3dadd(-53.42, 3.52, -5.96, 2.5, sec=self.basal[0])
h.pt3dadd(-60.3, 3.99, 0.28, 1.28, sec=self.basal[0])
h.pt3dadd(-64.028, 3.787, 1.455, 1.28, sec=self.basal[0])
h.pt3dadd(-68.616, 2.577, 1.405, 1.28, sec=self.basal[0])
h.pt3dadd(-72.55, 1.133, 1.864, 1.28, sec=self.basal[0])
h.pt3dadd(-77.03, 0.483, 3.784, 1.28, sec=self.basal[0])
self.basal[1].connect(self.basal[0])
h.pt3dclear(sec=self.basal[1])
h.pt3dadd(-77.03, 0.483, 3.784, 1.28, sec=self.basal[1])
h.pt3dadd(-80.68, 2.633, 0.564, 0.96, sec=self.basal[1])
h.pt3dadd(-84.2, 3.613, -0.576, 0.96, sec=self.basal[1])
h.pt3dadd(-88.771, 4.452, -1.634, 0.96, sec=self.basal[1])
h.pt3dadd(-93.902, 6.048, -2.616, 0.96, sec=self.basal[1])
h.pt3dadd(-96.462, 6.688, -4.516, 0.96, sec=self.basal[1])
h.pt3dadd(-100.622, 5.718, -5.996, 0.96, sec=self.basal[1])
h.pt3dadd(-102.852, 5.718, -7.876, 0.96, sec=self.basal[1])
self.basal[2].connect(self.basal[1])
h.pt3dclear(sec=self.basal[2])
h.pt3dadd(-102.852, 5.718, -7.876, 0.96, sec=self.basal[2])
h.pt3dadd(-102.852, 3.128, -17.756, 0.64, sec=self.basal[2])
h.pt3dadd(-101.262, 2.478, -21.296, 0.64, sec=self.basal[2])
h.pt3dadd(-100.622, -1.082, -24.456, 0.64, sec=self.basal[2])
h.pt3dadd(-101.892, -1.732, -27.696, 0.64, sec=self.basal[2])
h.pt3dadd(-103.172, -2.702, -35.536, 0.64, sec=self.basal[2])
h.pt3dadd(-105.092, -3.032, -41.596, 0.64, sec=self.basal[2])
h.pt3dadd(-105.412, -2.052, -46.196, 0.64, sec=self.basal[2])
h.pt3dadd(-107.012, -1.412, -47.816, 0.64, sec=self.basal[2])
h.pt3dadd(-108.932, -1.412, -50.276, 0.64, sec=self.basal[2])
h.pt3dadd(-110.212, 0.538, -52.336, 0.496, sec=self.basal[2])
h.pt3dadd(-110.212, 1.508, -56.156, 0.476, sec=self.basal[2])
self.basal[3].connect(self.basal[1])
h.pt3dclear(sec=self.basal[3])
h.pt3dadd(-102.852, 5.718, -7.876, 0.96, sec=self.basal[3])
h.pt3dadd(-104.452, 5.398, -7.876, 0.96, sec=self.basal[3])
h.pt3dadd(-108.932, 5.718, -9.356, 0.804, sec=self.basal[3])
self.basal[4].connect(self.basal[3])
h.pt3dclear(sec=self.basal[4])
h.pt3dadd(-108.932, 5.718, -9.356, 0.804, sec=self.basal[4])
h.pt3dadd(-113.092, 4.428, -12.676, 0.64, sec=self.basal[4])
h.pt3dadd(-115.332, 3.128, -12.676, 0.782, sec=self.basal[4])
h.pt3dadd(-118.842, 3.128, -14.996, 0.738, sec=self.basal[4])
h.pt3dadd(-121.402, 2.158, -17.416, 0.73, sec=self.basal[4])
h.pt3dadd(-124.282, 1.188, -17.416, 0.64, sec=self.basal[4])
self.basal[5].connect(self.basal[4])
h.pt3dclear(sec=self.basal[5])
h.pt3dadd(-124.282, 1.188, -17.416, 0.64, sec=self.basal[5])
h.pt3dadd(-127.162, 0.858, -20.256, 0.64, sec=self.basal[5])
h.pt3dadd(-129.082, 0.858, -20.256, 0.64, sec=self.basal[5])
h.pt3dadd(-131.632, -1.732, -22.016, 0.64, sec=self.basal[5])
h.pt3dadd(-134.192, -3.352, -24.736, 0.64, sec=self.basal[5])
h.pt3dadd(-138.352, -4.322, -29.736, 0.64, sec=self.basal[5])
h.pt3dadd(-140.592, -5.622, -32.256, 0.64, sec=self.basal[5])
h.pt3dadd(-143.472, -6.912, -32.256, 0.64, sec=self.basal[5])
h.pt3dadd(-146.342, -6.912, -35.356, 0.64, sec=self.basal[5])
h.pt3dadd(-149.222, -7.562, -37.116, 0.64, sec=self.basal[5])
h.pt3dadd(-152.102, -7.562, -37.936, 0.64, sec=self.basal[5])
h.pt3dadd(-154.022, -7.562, -37.916, 0.64, sec=self.basal[5])
h.pt3dadd(-157.222, -8.212, -39.196, 0.64, sec=self.basal[5])
h.pt3dadd(-159.782, -10.152, -39.636, 0.64, sec=self.basal[5])
h.pt3dadd(-162.332, -11.452, -43.116, 0.64, sec=self.basal[5])
h.pt3dadd(-165.852, -13.392, -44.816, 0.516, sec=self.basal[5])
h.pt3dadd(-168.092, -14.042, -47.096, 0.486, sec=self.basal[5])
self.basal[6].connect(self.basal[4])
h.pt3dclear(sec=self.basal[6])
h.pt3dadd(-124.282, 1.188, -17.416, 0.64, sec=self.basal[6])
h.pt3dadd(-126.522, -2.052, -19.176, 0.58, sec=self.basal[6])
h.pt3dadd(-130.042, -4.972, -19.176, 0.588, sec=self.basal[6])
h.pt3dadd(-133.872, -5.942, -17.176, 0.622, sec=self.basal[6])
h.pt3dadd(-137.072, -8.212, -17.176, 0.664, sec=self.basal[6])
h.pt3dadd(-139.312, -9.832, -17.176, 0.656, sec=self.basal[6])
h.pt3dadd(-142.512, -12.422, -17.596, 0.618, sec=self.basal[6])
h.pt3dadd(-146.342, -12.752, -16.076, 0.648, sec=self.basal[6])
h.pt3dadd(-149.862, -13.072, -17.236, 0.514, sec=self.basal[6])
h.pt3dadd(-153.062, -12.752, -18.816, 0.612, sec=self.basal[6])
h.pt3dadd(-155.942, -12.422, -20.536, 0.498, sec=self.basal[6])
h.pt3dadd(-159.142, -11.772, -23.916, 0.404, sec=self.basal[6])
self.basal[7].connect(self.basal[3])
h.pt3dclear(sec=self.basal[7])
h.pt3dadd(-108.932, 5.718, -9.356, 0.804, sec=self.basal[7])
h.pt3dadd(-114.692, 7.338, -3.716, 0.72, sec=self.basal[7])
h.pt3dadd(-119.482, 8.638, 1.824, 0.758, sec=self.basal[7])
h.pt3dadd(-122.362, 9.288, 5.544, 0.658, sec=self.basal[7])
h.pt3dadd(-125.882, 10.578, 7.024, 0.676, sec=self.basal[7])
h.pt3dadd(-131.002, 10.908, 9.624, 0.598, sec=self.basal[7])
h.pt3dadd(-133.552, 13.498, 10.304, 0.652, sec=self.basal[7])
h.pt3dadd(-136.752, 14.788, 11.724, 0.546, sec=self.basal[7])
h.pt3dadd(-138.992, 16.088, 13.144, 0.614, sec=self.basal[7])
h.pt3dadd(-144.112, 18.358, 14.244, 0.476, sec=self.basal[7])
self.basal[8].connect(self.basal[0])
h.pt3dclear(sec=self.basal[8])
h.pt3dadd(-77.03, 0.483, 3.784, 1.28, sec=self.basal[8])
h.pt3dadd(-80.23, -0.487, 1.264, 0.788, sec=self.basal[8])
h.pt3dadd(-82.47, -0.487, 1.084, 0.852, sec=self.basal[8])
h.pt3dadd(-85.35, -2.107, 0.664, 0.75, sec=self.basal[8])
h.pt3dadd(-88.084, -4.512, 0.566, 0.848, sec=self.basal[8])
h.pt3dadd(-90.408, -7.229, 0.826, 0.952, sec=self.basal[8])
h.pt3dadd(-93.59, -9.125, 0.336, 0.918, sec=self.basal[8])
h.pt3dadd(-96.47, -9.445, -0.304, 0.732, sec=self.basal[8])
h.pt3dadd(-98.07, -11.395, -1.384, 0.852, sec=self.basal[8])
h.pt3dadd(-99.35, -13.985, -1.924, 0.806, sec=self.basal[8])
h.pt3dadd(-101.59, -16.895, -2.324, 0.834, sec=self.basal[8])
h.pt3dadd(-104.47, -20.135, -3.244, 0.872, sec=self.basal[8])
h.pt3dadd(-106.502, -23.151, -3.947, 0.784, sec=self.basal[8])
h.pt3dadd(-108.055, -26.209, -4.515, 0.798, sec=self.basal[8])
h.pt3dadd(-110.728, -29.518, -5.631, 0.798, sec=self.basal[8])
h.pt3dadd(-113.278, -32.758, -9.111, 0.756, sec=self.basal[8])
h.pt3dadd(-116.798, -35.348, -10.931, 0.776, sec=self.basal[8])
h.pt3dadd(-119.038, -37.288, -14.551, 0.786, sec=self.basal[8])
h.pt3dadd(-121.278, -39.558, -17.851, 0.732, sec=self.basal[8])
h.pt3dadd(-124.798, -42.148, -20.151, 0.788, sec=self.basal[8])
h.pt3dadd(-127.15, -46.524, -19.989, 0.748, sec=self.basal[8])
h.pt3dadd(-130.234, -50.645, -19.025, 0.712, sec=self.basal[8])
h.pt3dadd(-132.082, -54.729, -18.852, 0.64, sec=self.basal[8])
h.pt3dadd(-134.952, -57.639, -18.852, 0.64, sec=self.basal[8])
h.pt3dadd(-137.192, -60.229, -22.812, 0.64, sec=self.basal[8])
h.pt3dadd(-140.072, -62.499, -24.332, 0.64, sec=self.basal[8])
h.pt3dadd(-143.272, -64.449, -23.972, 0.64, sec=self.basal[8])
h.pt3dadd(-145.192, -66.709, -23.972, 0.64, sec=self.basal[8])
h.pt3dadd(-147.752, -69.309, -26.752, 0.64, sec=self.basal[8])
h.pt3dadd(-149.982, -72.219, -25.852, 0.64, sec=self.basal[8])
h.pt3dadd(-150.302, -77.079, -26.312, 0.64, sec=self.basal[8])
h.pt3dadd(-152.222, -79.999, -27.112, 0.64, sec=self.basal[8])
h.pt3dadd(-153.182, -83.889, -27.772, 0.64, sec=self.basal[8])
h.pt3dadd(-156.062, -87.119, -28.132, 0.64, sec=self.basal[8])
h.pt3dadd(-157.342, -91.009, -28.052, 0.64, sec=self.basal[8])
h.pt3dadd(-158.822, -95.029, -26.292, 0.64, sec=self.basal[8])
h.pt3dadd(-160.732, -99.569, -26.272, 0.64, sec=self.basal[8])
h.pt3dadd(-162.012, -102.479, -25.372, 0.64, sec=self.basal[8])
h.pt3dadd(-164.572, -106.049, -24.672, 0.32, sec=self.basal[8])
h.pt3dadd(-167.132, -110.579, -24.672, 0.32, sec=self.basal[8])
h.pt3dadd(-168.732, -116.409, -26.352, 0.32, sec=self.basal[8])
March 2013 - June 2014
"""
from neuron import h, rxd
from matplotlib import pyplot
import numpy
import __main__
name = __main__.__file__
if name[-3:] == '.py':
name = name[:-3]
h.load_file('stdrun.hoc')
dend = h.Section()
dend.diam = 2
dend.nseg = 101
dend.L = 100
diff_constant = 1
r = rxd.Region(h.allsec())
ca = rxd.Species(r,
d=diff_constant,
initial=lambda node: 1 if 0.4 < node.x < 0.6 else 0)
h.finitialize()
for t in [25, 50, 75, 100, 125]:
h.continuerun(t)
fd = sys.stdout.fileno()
keep = os.dup(fd)
sys.stdout.flush()
os.dup2(null.fileno(), fd)
h(arg)
sys.stdout.flush()
os.dup2(keep, fd)
def hoc_setup():
hoc_execute_quiet('load_file("stdrun.hoc")')
# Make model
hoc_setup()
cable = h.Section(name='cable')
cable.diam = diam
cable.L= length
cable.cm = 100*cm # [µF/cm² = 0.01 F/m²]
cable.Ra = 100*ra # [Ω cm = 0.01 Ω m]
cable.nseg = int(n)
cable.insert('pas')
cable.g_pas = 0.0001/rm # [S/cm² = 10000 S/m²]
cable.e_pas = Erev
stim = h.IClamp(cable(0))
stim.delay = 0
stim.dur = tend
stim.amp = iinj
