def define_biophysics(*arg):
"""Defines the biophysics of the cell, if the first argument is 1 an hh model, if 2 an adapted version of HH
in accordance with Yu et all will be applied with following parameters:
2st argument: cell
3rd argument: Sodium conductance (in S/cm^2)
4th argument: Potassium conductance (in S/cm^2)
5th argument: Leak conductance (in S/cm^2)
6th argument: Membrane Capacitance (in uF/cm^2)
7th argument: Axial resistance (in Ohm*cm)
8th argument: Reversal potential leak (in mV)
9th argument: Reversal potential Sodium (in mV)
10th argument: Reversal potential Potassium (in mV)"""
if arg[0] == 1:
arg[1].insert('hh')
arg[1].gnabar_hh = arg[2]
arg[1].gkbar_hh = arg[3]
arg[1].gl_hh = arg[4]
arg[1].cm = arg[5]
arg[1].Ra = arg[6]
arg[1].el_hh = arg[7]
arg[1].ena = arg[8]
arg[1].ek = arg[9]
if arg[0 == 2]:
arg[1].insert('pas')
arg[1].insert('na')
arg[1].insert('kv')
arg[1].gbar_na = arg[2]
arg[1].gbar_kv = arg[3]
arg[1].g_pas = arg[4]
arg[1].cm = arg[5]
arg[1].Ra = arg[6]
arg[1].e_pas = arg[7]
arg[1].ena = arg[8]
arg[1].ek = arg[9]
h.psection(sec=arg[1])
def debug():
# Debug
# Check section
for sec in h.allsec():
h.psection(sec=sec)
# #Topology
h.topology()
def createAxon(self, nseg=100, diam=2, L=200, Ra=123):
'''
Define axon biological structure.
'''
self.axon = h.Section(name='axon')
self.axon.nseg = nseg
self.axon.Ra = Ra
self.axon.L = L
self.axon.diam = diam
h.psection(sec=self.axon)
def createSoma(self, cm=0.5, diam=500, L=100, Ra=35.4):
'''
Define soma biological structure.
'''
self.soma = h.Section(name='soma')
self.soma.cm = cm
self.soma.diam = diam
self.soma.L = L
self.soma.Ra = Ra
h.psection(sec=self.soma)
def one(mechname):
m = Model(mechname)
if 'ProbAMPANMDA_EMS' in mechname:
m.syn.setRNG(3, 1)
h.psection()
dtsav = h.dt
try:
result = m.run()
except:
print("%s run failed, ignore result" % mechname)
result = None
h.dt = dtsav
return m, result
def main():
tmax = 20e-3
fs = 500e3
sg.set_fs(fs)
sg.set_celsius(37)
# Acoustic stimmulation
anf_ac = sg.ANF_Axon(record_voltages=True)
h.topology()
h.psection(sec=anf_ac.get_sections()[0])
anf_ac.vesicles = [2e-3, 5e-3]
# Electrical stimulation
# set-up ANF
anf_el = sg.ANF_Axon(record_voltages=True)
# anf_el.set_geometry('straight', x0=250e-6, y0=500e-6, z0=0)
anf_el.set_geometry('bent', a=750e-6, b=500e-6, z=0)
# set-up electrode
el = sg.Electrode()
el.z = 0
stim = np.zeros(int(tmax * fs))
stim[int(tmax / 3 * fs):int((tmax / 3 + 1e-3) * fs)] = -0.2e-3 # (A)
el.fs = fs
el.stim = stim
# `connect' ANF and electrode
anf_el.electrodes = [el]
# Run
sg.run(tmax, [anf_ac, anf_el])
# Plot
print(anf_ac.get_spikes(), anf_el.get_spikes())
sg.plot_vectors(anf_ac.get_voltages()[:, 0:6], fs)
sg.plot_vectors(anf_el.get_voltages()[:, 0:6], fs)
sg.plot_geometry([anf_el, el])
plt.show()
def Record_Simulation_Electrical(self, T, dt=0.01):
'''
Run & Recording dynamics
'''
h.dt = dt
h.psection()
self.V = h.Vector() # Membrane potential vector is created here
self.t = h.Vector()
self.m = h.Vector()
self.n = h.Vector()
self.h = h.Vector()
self.s = h.Vector()
self.V.record(self.soma(0.5)._ref_v)
self.Record_Simulation_aux()
self.t.record(h._ref_t)
h.v_init = -60 # Let's set the initial condition of the membrane potential
h.t = 0.0 # Let's reset the initial time of the simulation to 0 ms
h.tstop = float(T)
h.run()
def simulatepar(delay, dur, std, offset, amp, freq, dt, tau, mu, loc, simdur,
init, cel, seed, loop):
init_simulation()
cell = rn.create_cell(False)
h.psection()
counts = h.Vector()
apc = h.APCount(cell.soma[0](0.5))
apc.thresh = -15
apc.record(counts)
stim = attach_noise_sin_clamp(cell, delay, dur, offset, amp, freq, dt, tau,
std, mu, loc, seed)
h.dt = dt
h.tstop = simdur
h.v_init = init
h.celsius = cel
h.run()
filename = './OUTPUT/spiketrain5Hzmfr' + str(freq) + 'freq' + str(
std) + 'std' + str(seed) + 'seed' + str(loop) + 'loop.txt'
writetofile(filename, counts)
return 0
def testCell(run, plot, amplitude = 10.e-3):
from GRANULE_Cell import Grc
delay = 100.
duration = 500.
tstop = 700
granule = Grc(position=np.zeros(3))
electrode = h.IClamp(0.5, sec=granule.soma)
electrode.delay = delay
electrode.dur = duration
electrode.amp = amplitude
h.psection()
h.celsius = 30
print "Temperature of simulation is %f deg C "%h.celsius
# run the simulation
h.load_file("stdrun.hoc")
h.tstop = tstop
h.dt = 0.025
h.steps_per_ms = 40
h.v_init = -60
if run:
h.run()
# convert the membrane potential and time values in numpy arrays
time_points = np.array(granule.time)
vm_points = np.array(granule.vm)
spiking = 0
threshold = 0
spike_times = []
for i in range(len(time_points)):
if not spiking and vm_points[i] >= threshold:
spike_times.append(float(time_points[i]))
spiking = 1
elif spiking and vm_points[i] < threshold:
spiking = 0
spike_times_file = open("spike_times_%sdeg_%snA.dat"%(h.celsius, electrode.amp), 'w')
for st in spike_times:
spike_times_file.write('%f\n'%st)
spike_times_file.close()
print "Saved spike times in file %s"%spike_times_file.name
voltage_file = open("voltage_%sdeg_%snA.dat"%(h.celsius, electrode.amp), 'w')
for i in range(len(time_points)):
voltage_file.write('%s\t%s\n'%(time_points[i], vm_points[i]))
voltage_file.close()
print "Saved voltage in file %s"%voltage_file.name
if plot:
h.run()
from matplotlib import pyplot as plt
fig = plt.figure()
trace_ax = fig.add_subplot(111)
trace_ax.plot(time_points, vm_points)
trace_ax.set_xlabel('Time (ms)')
trace_ax.set_ylabel('mV')
trace_ax.set_title('Membrane potential')
fig.suptitle('Pulse duration: %d ms; pulse amplitude: %d pA; temperature: %d deg C' % (duration, amplitude * 1e3, h.celsius))
plt.show()
return granule
plt.plot(time_lt, rn3_lt)
plt.xlabel("time[ms]")
plt.ylabel("voltage[mV]")
twin = plt.twinx()
twin.plot(time_lt, stim_lt,'y')
twin.set_ylabel("iclamp[nA]")
twin.set_ylim(-100, 100)
TEXT = 'GPea\n'+'LENGTH = '+str(LENGTH)+' AMPLITUDE = '+str(AMPLITUDE)+' FREQUENCY = '+str(FREQUENCY)+'\nL_RATIO = ' + str(L_RATIO) + ' A_RATIO = '+str(A_RATIO)+' POLAR_T = '+str(POLAR_T)
ymin, ymax = plt.ylim()
plt.text(2,ymin+5, TEXT, fontsize = 10)
timestr = strftime("%m%d%H%M%S",localtime())
plt_filename = './graph/output'+timestr+'.png'
print plt_filename
plt.savefig(plt_filename)
plt.show()
h.psection()
"""
nframe = 0
h.cell.translation(30, 0, 0)
"""
"""
def step():
for i in range(nstep_steprun):
advance()
sh.rotate(60,0,0,0,rotationPerStep,0)
Plot()
if 0:
sh.printfile("temp.ps")
from matplotlib import pyplot as plt
import scipy.fftpack as scfft
# Create 3 soma, one for each kind of simulation (1 clean clamp, 2 noisy)
soma = [h.Section(name='soma%d'%(i)) for i in range(3)]
v_vec = []
for s in soma:
# Tune the soma, inserting HH model
s.insert('hh')
# Change diameter, length and axial resistance
s.L = 18.8
s(0.5).diam = 18.8
s.Ra = 123.
# Some output to check the good configuration
h.psection(sec = s)
# Create a vector recording the membrane reversal potential during the simulation
v = h.Vector()
v.record(s(0.5)._ref_v)
v_vec.append(v)
# Get a time vector
t_vec = h.Vector()
t_vec.record(h._ref_t)
# Configure the simulation
res = 1000 # Nb. of current points
min_curr = 0 # Starting stimuli current
max_curr = .4 # Max stim. current
duration = 1000 # Duration of the step
import types
h("objref p")
h("p = new PythonObject()")
try:
import pylab
from pylab import plot, arange, figure
my_pylab_loaded = True
except ImportError:
print "Pylab not imported"
my_pylab_loaded = False
def htype (obj): st=obj.hname(); sv=st.split('['); return sv[0]
def secname (obj): obj.push(); print h.secname() ; h.pop_section()
def psection (obj): obj.push(); print h.psection() ; h.pop_section()
allsecs=None #global list containing all NEURON sections, initialized via mkallsecs
# still need to generate a full allsecs
def mkallsecs ():
""" mkallsecs - make the global allsecs variable, containing
all the NEURON sections.
"""
global allsecs
allsecs=h.SectionList() # no .clear() command
roots=h.SectionList()
roots.allroots()
for s in roots:
s.push()
allsecs.wholetree()
for i in range(sec.n3d()):
x = sec.x3d(i)
y = sec.y3d(i)
c = cos(theta)
s = sin(theta)
xprime = x * c - y * s
yprime = x * s + y * c
h.pt3dchange(i,
xprime,
yprime,
sec.z3d(i),
sec.diam3d(i),
sec=sec)
"""
soma = h.Section(name='soma')
dend = h.Section(name='dend')
h.psection(sec=soma)
dend.connect(soma(1))
h.psection(sec=dend)
h.topology()
# Surface area of cylinder is 2*pi*r*h (sealed ends are implicit).
# Here we make a square cylinder in that the diameter
# is equal to the height, so diam = h. ==> Area = 4*pi*r^2
# We want a soma of 500 microns squared:
# r^2 = 500/(4*pi) ==> r = 6.2078, diam = 12.6157
soma.L = soma.diam = 12.6157 # Makes a soma of 500 microns squared.
dend.L = 200 # microns
morph.show(2) # show as linear schematic
# unsure how to programmatically change the size, but it is very to do in the
# gui, so just do that, and make it "whole scene" option
# translate 90 degrees over each axis
morph.rotate(0, 0, 0, 1.5708, 0, 0) # over x axis
morph.rotate(0, 0, 0, 0, 1.5708, 0) # over y axis
morph.rotate(0, 0, 0, 0, 0, 1.5708) # over z axis
# save current view to file as a post script image
morph.printfile(figure_dir + 'bhalla_morphology_section.ps')
# pull out conductances as function of distance from soma or in different compartments
for sec in h.allsec():
h.psection(sec)
for sec in h.allsec():
if sec == h.soma:
h.psection(sec)
elif sec == h.axon[0]:
h.psection(sec)
elif sec == h.axon[5]:
h.psection(sec)
elif sec == h.prim_dend[4]:
h.psection(sec)
def synapse_group_test(env,
presyn_name,
gid,
cell,
syn_ids,
syn_mech_dict,
group_size,
v_init,
tstart=200.):
syn_attrs = env.synapse_attributes
vv = h.Vector()
vv.append(0, 0, 0, 0, 0, 0)
ranstream = np.random.RandomState(0)
if len(syn_ids) == 0:
return
selected = ranstream.choice(np.arange(0, len(syn_ids)),
size=group_size,
replace=False)
selected_ids = [syn_ids[i] for i in selected]
for syn_name in syn_mech_dict:
nclst = []
print('synapse_group_test: %s %s synapses: %i out of %i' %
(presyn_name, syn_name, len(selected_ids), len(syn_ids)))
ns = h.NetStim()
ns.interval = 1000
ns.number = 1
ns.start = 200
ns.noise = 0
nclst = []
first_syn_id = None
for syn_id in selected_ids:
if syn_attrs.has_netcon(gid, syn_id, syn_name):
syn_index = syn_attrs.syn_name_index_dict[syn_name]
del (syn_attrs.pps_dict[gid][syn_id].netcon[syn_index])
syn = syn_attrs.get_pps(gid, syn_id, syn_name)
this_nc = h.NetCon(ns, syn)
syn_attrs.add_netcon(gid, syn_id, syn_name, this_nc)
synapses.config_syn(syn_name=syn_name,
rules=syn_attrs.syn_param_rules,
mech_names=syn_attrs.syn_mech_names,
nc=this_nc,
**syn_mech_dict[syn_name])
nclst.append(this_nc)
if first_syn_id is None:
first_syn_id = syn_id
print("%s netcon: %s" %
(syn_name,
str([
this_nc.weight[i]
for i in range(int(this_nc.wcnt()))
])))
for sec in list(cell.all):
h.psection(sec=sec)
v_holding_exc = -75
v_holding_inh = -45
if syn_name in ['NMDA', 'SatAMPA', 'AMPA']:
v_holding = v_holding_exc
v = cell.syntest_exc(
tstart, v_holding, v_init,
"MossyCell_%s_%s_synapse_trace_%i.dat" %
(presyn_name, syn_name, group_size))
elif syn_name in [
'SatGABA', 'GABA', 'SatGABA_A', 'GABA_A', 'SatGABA_B', 'GABA_B'
]:
v_holding = v_holding_inh
v = cell.syntest_inh(
tstart, v_holding, v_init,
"MossyCell_%s_%s_synapse_trace_%i.dat" %
(presyn_name, syn_name, group_size))
else:
raise RuntimeError('Unknown synapse mechanism type %s' % syn_name)
vv = vv.add(v)
amp = vv.x[0]
t_10_90 = vv.x[1]
t_20_80 = vv.x[2]
t_all = vv.x[3]
t_50 = vv.x[4]
t_decay = vv.x[5]
f = open(
"MossyCell_%s_%s_synapse_results_%i.dat" %
(presyn_name, syn_name, group_size), 'w')
f.write("%s synapses: \n" % syn_name)
f.write(" Amplitude %f\n" % amp)
f.write(" 10-90 Rise Time %f\n" % t_10_90)
f.write(" 20-80 Rise Time %f\n" % t_20_80)
f.write(" Decay Time Constant %f\n" % t_decay)
f.close()
## Ball and stick model w/ NEURON
## Hasan Khan
## July 28, 2016
import neuron
from neuron import h, gui
import matplotlib
from matplotlib import pyplot
## TOPOLOGY ################################################################
soma = h.Section(name='soma')
dend = h.Section(name='dend')
h.psection(
sec=soma) ## retrieve info using this. Pass in section u want info for
dend.connect(soma(1)) ## connects dendrite to the '1' end of the Soma
h.psection(sec=dend)
h.topology()
## GEOMETRY ################################################################
# Surface area of cylinder is 2*pi*r*h (sealed ends are implicit).
# Here we make a square cylinder in that the diameter
# is equal to the height, so diam = h. ==> Area = 4*pi*r^2
# We want a soma of 500 microns squared:
# r^2 = 500/(4*pi) ==> r = 6.2078, diam = 12.6157
soma.L = soma.diam = 12.6157 # Makes a soma of 500 microns squared.
# -*- coding: utf-8 -*-
"""
Created on Thu Jul 19 14:19:18 2018
@author: janniez
"""
import numpy
from matplotlib import pyplot
from neuron import h, gui
from math import sin, cos, pi
from ballandstick import BallAndStick
cell = BallAndStick()
h.psection(sec=cell.dend)
def attach_current_clamp(cell, delay=5, dur=1, amp=.1, loc=1):
"""Attach a current Clamp to a cell.
:param cell: Cell object to attach the current clamp.
:param delay: Onset of the injected current.
:param dur: Duration of the stimulus.
:param amp: Magnitude of the current.
:param loc: Location on the dendrite where the stimulus is placed.
"""
stim = h.IClamp(cell.dend(loc))
stim.delay = delay
stim.dur = dur
stim.amp = amp
return stim
import sys
sys.path.insert(0, "mitral_cell")
from pprint import pprint
from neuron import h
from mitralcell import MitralCell
h.nrn_load_dll("../nmodl/x86_64/.libs/libnrnmech.so")
if __name__ == "__main__":
cell = MitralCell("1", nodes=5)
for sec in h.allsec():
pprint(h.psection(sec))
print("Exited normally")
sys.exit(1)
def print_report():
for sec in h.allsec():
print h.psection()
print h.topology()
plt.ylim(-150, 150)
twin = plt.twinx()
twin.plot(time_lt, stim_lt, 'y')
twin.set_ylabel("iclamp[nA]")
twin.set_ylim(-150, 150)
TEXT = 'GPea\n' + 'LENGTH = ' + str(LENGTH) + ' AMPLITUDE = ' + str(
AMPLITUDE) + ' FREQUENCY = ' + str(FREQUENCY) + '\nL_RATIO = ' + str(
L_RATIO) + ' A_RATIO = ' + str(A_RATIO) + ' POLAR_T = ' + str(POLAR_T)
ymin, ymax = plt.ylim()
plt.text(2, ymin + 5, TEXT, fontsize=10)
timestr = strftime("%m%d%H%M%S", localtime())
plt_filename = './graph/output' + timestr + '.png'
print plt_filename
#plt.savefig(plt_filename,dpi=None)
print h.psection()
plt.show()
"""
nframe = 0
h.cell.translation(30, 0, 0)
"""
"""
def step():
for i in range(nstep_steprun):
advance()
sh.rotate(60,0,0,0,rotationPerStep,0)
Plot()
if 0:
10.0
>>> h.tstop
40.0
>>> h.run()
0.0
>>> plt.plot(t_vec,v_vec)
[<matplotlib.lines.Line2D object at 0x7f018e586f50>]
>>> ncstim.weight[0]=0.8
>>> plt.plot(t_vec,v_vec)
[<matplotlib.lines.Line2D object at 0x7f018e586c10>]
>>> ncstim.weight[0]=8
>>> h.run()
0.0
>>> plt.plot(t_vec,v_vec)
[<matplotlib.lines.Line2D object at 0x7f018bd1c950>]
>>> h.psection()
soma { nseg=1 L=100 Ra=35.4
/*location 0 attached to cell 0*/
/* First segment only */
insert morphology { diam=500}
insert capacitance { cm=1}
insert pas { g_pas=0.001 e_pas=-70}
insert AlphaSynapse { onset=1000 tau=0.1 gmax=1 e=0}
insert ExpSyn { tau=0.1 e=0}
}
1.0
>>> ncstim.weight[0]=80
>>> h.run()
0.0
>>> plt.plot(t_vec,v_vec)
[<matplotlib.lines.Line2D object at 0x7f018ee77a10>]
h.fcurrent()
h.frecord_init()
h.tstop = tstop
h.v_init = vinit
h.run()
def show_output(v_vec, t_vec):
''' show graphs
Parameters
----------
v_vec: h.Vector()
recorded voltage
t_vec: h.Vector()
recorded time
'''
dend_plot = pyplot.plot(t_vec, v_vec)
pyplot.xlabel('time (ms)')
pyplot.ylabel('mV')
if __name__ == '__main__':
cell = cfiber(250, 0.25, 100, 0, False)
for sec in h.allsec():
h.psection(sec=sec) #show parameters of each section
branch_vec, t_vec = set_recording_vectors(cell.branch)
dend_vec, t_vec = set_recording_vectors(cell.stimsec[59])
dend80_vec, t_vec = set_recording_vectors(cell.stimsec[20])
simulate(cell)
show_output(branch_vec, t_vec)
show_output(dend_vec, t_vec)
show_output(dend80_vec, t_vec)
pyplot.show()
electro_tests = get_neab.substitute_parallel_for_serial(electro_tests)
tests, observation = electro_tests[0]
scores = {}
#import dask.bag as db
kl = list(izh07.type2007.keys())
E = ExternalModel()
E.inject_square_current = inject_square_current
for i in kl:
iz07bw.reparam(type=i)
print(iz07bw.izh.C, iz07bw.izh.k, iz07bw.izh.vr, iz07bw.izh.vt,
iz07bw.izh.vpeak, iz07bw.izh.a, iz07bw.izh.b, iz07bw.izh.c,
iz07bw.izh.d, iz07bw.izh.celltype)
h.tstop = 1250
print(h.psection())
v = []
recd = {'u7bw': [iz07bw.izh._ref_u], 'v7bw': [iz07bw.sec(0.5)._ref_v]}
for x, v in recd.items():
v.append(h.Vector(h.tstop / h.dt + 100))
v[1].record(v[0])
h.run()
dt = h.dt
print(np.shape(v[1]))
vm = AnalogSignal(v[1], units=mV, sampling_period=dt * ms)
E.set_membrane_potential(vm)
for t in tests:
score = t.judge(E)
print(dir(E.inject_square_current))
print(score)
def synapse_group_rate_test(env,
presyn_name,
gid,
cell,
syn_ids,
syn_mech_dict,
group_size,
rate,
tstart=200.):
syn_attrs = env.synapse_attributes
syn_attrs = env.synapse_attributes
ranstream = np.random.RandomState(0)
if len(syn_ids) == 0:
return
selected = ranstream.choice(np.arange(0, len(syn_ids)),
size=group_size,
replace=False)
selected_ids = [syn_ids[i] for i in selected]
for syn_name in syn_mech_dict:
print('synapse_group_rate_test: %s %s synapses: %i out of %i ' %
(presyn_name, syn_name, len(selected_ids), len(syn_ids)))
ns = h.NetStim()
ns.interval = 1000. / rate
ns.number = rate
ns.start = 200
ns.noise = 0
nclst = []
first_syn_id = None
for syn_id in selected_ids:
for syn_name in syn_mech_dict:
if syn_attrs.has_netcon(gid, syn_id, syn_name):
syn_index = syn_attrs.syn_name_index_dict[syn_name]
del (syn_attrs.pps_dict[gid][syn_id].netcon[syn_index])
syn = syn_attrs.get_pps(gid, syn_id, syn_name)
this_nc = h.NetCon(ns, syn)
syn_attrs.add_netcon(gid, syn_id, syn_name, this_nc)
synapses.config_syn(syn_name=syn_name,
rules=syn_attrs.syn_param_rules,
mech_names=syn_attrs.syn_mech_names,
nc=this_nc,
**syn_mech_dict[syn_name])
nclst.append(this_nc)
if first_syn_id is None:
print("%s netcon: %s" %
(syn_name,
str([
this_nc.weight[i]
for i in range(int(this_nc.wcnt()))
])))
if first_syn_id is None:
first_syn_id = syn_id
for sec in list(cell.all):
h.psection(sec=sec)
print('synapse_group_rate_test: %s %s synapses: %i netcons ' %
(presyn_name, syn_name, len(nclst)))
v_init_exc = -75
v_init_inh = 0
if syn_name in ['NMDA', 'SatAMPA', 'AMPA']:
v_init = v_init_exc
elif syn_name in [
'SatGABA', 'GABA', 'SatGABA_A', 'GABA_A', 'SatGABA_B', 'GABA_B'
]:
v_init = v_init_inh
else:
raise RuntimeError('Unknown synapse mechanism type %s' % syn_name)
res = cell.syntest_rate(tstart, rate, v_init)
tlog = res.o(0)
vlog = res.o(1)
f = open(
"MossyCell_%s_%s_synapse_rate_%i.dat" %
(presyn_name, syn_name, group_size), 'w')
for i in range(0, int(tlog.size())):
f.write('%g %g\n' % (tlog.x[i], vlog.x[i]))
f.close()
def connectcells(env, gid_list):
datasetPath = os.path.join(env.datasetPrefix, env.datasetName)
connectivityFilePath = os.path.join(datasetPath, env.modelConfig['Connection Data'])
forestFilePath = os.path.join(datasetPath, env.modelConfig['Cell Data'])
if env.verbose:
if env.pc.id() == 0:
print '*** Connectivity file path is %s' % connectivityFilePath
prj_dict = defaultdict(list)
for (src, dst) in read_projection_names(env.comm, connectivityFilePath):
prj_dict[dst].append(src)
if env.verbose:
if env.pc.id() == 0:
print '*** Reading projections: ', prj_dict.items()
for (postsyn_name, presyn_names) in prj_dict.iteritems():
synapse_config = env.celltypes[postsyn_name]['synapses']
if synapse_config.has_key('spines'):
spines = synapse_config['spines']
else:
spines = False
if synapse_config.has_key('unique'):
unique = synapse_config['unique']
else:
unique = False
if synapse_config.has_key('weights'):
has_weights = synapse_config['weights']
else:
has_weights = False
if synapse_config.has_key('weights namespace'):
weights_namespace = synapse_config['weights namespace']
else:
weights_namespace = 'Weights'
if env.verbose:
if int(env.pc.id()) == 0:
print '*** Reading synapse attributes of population %s' % (postsyn_name)
gid_index_synapses_map = get_cell_attributes_index_map(env.comm, forestFilePath, 'GC', 'Synapse Attributes')
if synapse_config.has_key('weights namespace'):
gid_index_weights_map = get_cell_attributes_index_map(env.comm, forestFilePath, 'GC', weights_namespace)
cell_synapses_dict, cell_weights_dict = {}, {}
for gid in gid_list:
cell_attributes_dict = select_cell_attributes(gid, env.comm, forestFilePath, gid_index_synapses_map,
'GC', 'Synapse Attributes')
cell_synapses_dict[gid] = {k: v for (k, v) in cell_attributes_dict['Synapse Attributes']}
if has_weights:
cell_attributes_dict.update(get_cell_attributes_by_gid(gid, env.comm, forestFilePath,
gid_index_synapses_map, 'GC', weights_namespace))
cell_weights_dict[gid] = {k: v for (k, v) in cell_attributes_dict[weights_namespace]}
if env.verbose:
if env.pc.id() == 0:
print '*** Found synaptic weights for population %s' % (postsyn_name)
else:
has_weights = False
cell_weights_dict[gid] = None
del cell_attributes_dict
for presyn_name in presyn_names:
edge_count = 0
if env.verbose:
if env.pc.id() == 0:
print '*** Connecting %s -> %s' % (presyn_name, postsyn_name)
if env.nodeRanks is None:
(graph, a) = scatter_read_graph(env.comm, connectivityFilePath, io_size=env.IOsize,
projections=[(presyn_name, postsyn_name)],
namespaces=['Synapses', 'Connections'])
else:
(graph, a) = scatter_read_graph(env.comm, connectivityFilePath, io_size=env.IOsize,
node_rank_map=env.nodeRanks,
projections=[(presyn_name, postsyn_name)],
namespaces=['Synapses', 'Connections'])
edge_iter = graph[postsyn_name][presyn_name]
connection_dict = env.connection_generator[postsyn_name][presyn_name].connection_properties
kinetics_dict = env.connection_generator[postsyn_name][presyn_name].synapse_kinetics
syn_id_attr_index = a[postsyn_name][presyn_name]['Synapses']['syn_id']
distance_attr_index = a[postsyn_name][presyn_name]['Connections']['distance']
for (postsyn_gid, edges) in edge_iter:
postsyn_cell = env.pc.gid2cell(postsyn_gid)
cell_syn_dict = cell_synapses_dict[postsyn_gid]
if has_weights:
cell_wgt_dict = cell_weights_dict[postsyn_gid]
syn_wgt_dict = {int(syn_id): float(weight) for (syn_id, weight) in
itertools.izip(np.nditer(cell_wgt_dict['syn_id']),
np.nditer(cell_wgt_dict['weight']))}
else:
syn_wgt_dict = None
presyn_gids = edges[0]
edge_syn_ids = edges[1]['Synapses'][syn_id_attr_index]
edge_dists = edges[1]['Connections'][distance_attr_index]
cell_syn_types = cell_syn_dict['syn_types']
cell_swc_types = cell_syn_dict['swc_types']
cell_syn_locs = cell_syn_dict['syn_locs']
cell_syn_sections = cell_syn_dict['syn_secs']
edge_syn_ps_dict = synapses.mksyns(postsyn_gid,
postsyn_cell,
edge_syn_ids,
cell_syn_types,
cell_swc_types,
cell_syn_locs,
cell_syn_sections,
kinetics_dict, env,
add_synapse=synapses.add_unique_synapse if unique else synapses.add_shared_synapse,
spines=spines)
if env.verbose:
if int(env.pc.id()) == 0:
if edge_count == 0:
for sec in list(postsyn_cell.all):
h.psection(sec=sec)
wgt_count = 0
for (presyn_gid, edge_syn_id, distance) in itertools.izip(presyn_gids, edge_syn_ids, edge_dists):
syn_ps_dict = edge_syn_ps_dict[edge_syn_id]
for (syn_mech, syn_ps) in syn_ps_dict.iteritems():
connection_syn_mech_config = connection_dict[syn_mech]
if has_weights and syn_wgt_dict.has_key(edge_syn_id):
wgt_count += 1
weight = float(syn_wgt_dict[edge_syn_id]) * connection_syn_mech_config['weight']
else:
weight = connection_syn_mech_config['weight']
delay = distance / connection_syn_mech_config['velocity']
if type(weight) is float:
h.nc_appendsyn(env.pc, h.nclist, presyn_gid, postsyn_gid, syn_ps, weight, delay)
else:
h.nc_appendsyn_wgtvector(env.pc, h.nclist, presyn_gid, postsyn_gid, syn_ps, weight, delay)
if env.verbose:
if int(env.pc.id()) == 0:
if edge_count == 0:
print '*** Found %i synaptic weights for gid %i' % (wgt_count, postsyn_gid)
edge_count += len(presyn_gids)
# following this tutorial
# https://neuron.yale.edu/neuron/static/docs/neuronpython/ballandstick1.html
from neuron import h,gui
from matplotlib import pyplot
import numpy
soma = h.Section(name='soma')
dend = h.Section(name='dend')
h.psection(sec=soma)
dend.connect(soma(1))
h.psection(sec=dend)
h.topology()
# Surface area of cylinder is 2*pi*r*h (sealed ends are implicit).
# Here we make a square cylinder in that the diameter
# is equal to the height, so diam = h. ==> Area = 4*pi*r^2
# We want a soma of 500 microns squared:
# r^2 = 500/(4*pi) ==> r = 6.2078, diam = 12.6157
soma.L = soma.diam = 12.6157 # Makes a soma of 500 microns squared.
dend.L = 200 # microns
dend.diam = 1 # microns
print("Surface area of soma = {}".format(soma(0.5).area()))
#shape_window = h.PlotShape()
def mkcells(env):
h('objref templatePaths, templatePathValue')
rank = int(env.pc.id())
nhosts = int(env.pc.nhost())
v_sample_seed = int(env.modelConfig['Random Seeds']['Intracellular Voltage Sample'])
ranstream_v_sample = np.random.RandomState()
ranstream_v_sample.seed(v_sample_seed)
datasetPath = os.path.join(env.datasetPrefix, env.datasetName)
h.templatePaths = h.List()
for path in env.templatePaths:
h.templatePathValue = h.Value(1, path)
h.templatePaths.append(h.templatePathValue)
popNames = env.celltypes.keys()
popNames.sort()
for popName in popNames:
templateName = env.celltypes[popName]['template']
h.find_template(env.pc, h.templatePaths, templateName)
dataFilePath = os.path.join(datasetPath, env.modelConfig['Cell Data'])
if rank == 0:
print 'cell attributes: ', env.cellAttributeInfo
for popName in popNames:
if env.verbose:
if env.pc.id() == 0:
print "*** Creating population %s" % popName
templateName = env.celltypes[popName]['template']
templateClass = eval('h.%s' % templateName)
if env.celltypes[popName].has_key('synapses'):
synapses = env.celltypes[popName]['synapses']
else:
synapses = {}
v_sample_set = set([])
env.v_dict[popName] = {}
for gid in xrange(env.celltypes[popName]['start'],
env.celltypes[popName]['start'] + env.celltypes[popName]['num']):
if ranstream_v_sample.uniform() <= env.vrecordFraction:
v_sample_set.add(gid)
if env.cellAttributeInfo.has_key(popName) and env.cellAttributeInfo[popName].has_key('Trees'):
if env.verbose:
if env.pc.id() == 0:
print "*** Reading trees for population %s" % popName
if env.nodeRanks is None:
(trees, forestSize) = scatter_read_trees(env.comm, dataFilePath, popName, io_size=env.IOsize)
else:
(trees, forestSize) = scatter_read_trees(env.comm, dataFilePath, popName, io_size=env.IOsize,
node_rank_map=env.nodeRanks)
if env.verbose:
if env.pc.id() == 0:
print "*** Done reading trees for population %s" % popName
h.numCells = 0
i = 0
for (gid, tree) in trees:
if env.verbose:
if env.pc.id() == 0:
print "*** Creating gid %i" % gid
verboseflag = 0
model_cell = cells.make_neurotree_cell(templateClass, neurotree_dict=tree, gid=gid, local_id=i,
dataset_path=datasetPath)
if env.verbose:
if (rank == 0) and (i == 0):
for sec in list(model_cell.all):
h.psection(sec=sec)
env.gidlist.append(gid)
env.cells.append(model_cell)
env.pc.set_gid2node(gid, int(env.pc.id()))
## Tell the ParallelContext that this cell is a spike source
## for all other hosts. NetCon is temporary.
nc = model_cell.connect2target(h.nil)
env.pc.cell(gid, nc, 1)
## Record spikes of this cell
env.pc.spike_record(gid, env.t_vec, env.id_vec)
## Record voltages from a subset of cells
if gid in v_sample_set:
v_vec = h.Vector()
soma = list(model_cell.soma)[0]
v_vec.record(soma(0.5)._ref_v)
env.v_dict[popName][gid] = v_vec
i = i + 1
h.numCells = h.numCells + 1
if env.verbose:
if env.pc.id() == 0:
print "*** Created %i cells" % i
elif env.cellAttributeInfo.has_key(popName) and env.cellAttributeInfo[popName].has_key('Coordinates'):
if env.verbose:
if env.pc.id() == 0:
print "*** Reading coordinates for population %s" % popName
if env.nodeRanks is None:
cell_attributes_dict = scatter_read_cell_attributes(env.comm, dataFilePath, popName,
namespaces=['Coordinates'],
io_size=env.IOsize)
else:
cell_attributes_dict = scatter_read_cell_attributes(env.comm, dataFilePath, popName,
namespaces=['Coordinates'],
node_rank_map=env.nodeRanks,
io_size=env.IOsize)
if env.verbose:
if env.pc.id() == 0:
print "*** Done reading coordinates for population %s" % popName
coords = cell_attributes_dict['Coordinates']
h.numCells = 0
i = 0
for (gid, _) in coords:
if env.verbose:
if env.pc.id() == 0:
print "*** Creating gid %i" % gid
verboseflag = 0
model_cell = cells.make_cell(templateClass, gid=gid, local_id=i, dataset_path=datasetPath)
env.gidlist.append(gid)
env.cells.append(model_cell)
env.pc.set_gid2node(gid, int(env.pc.id()))
## Tell the ParallelContext that this cell is a spike source
## for all other hosts. NetCon is temporary.
nc = model_cell.connect2target(h.nil)
env.pc.cell(gid, nc, 1)
## Record spikes of this cell
env.pc.spike_record(gid, env.t_vec, env.id_vec)
i = i + 1
h.numCells = h.numCells + 1
# set up the capacitance
soma.cm = 1
# μF/cm^2
# add conductances from Liu et al. 1998
soma.insert('pas')
soma.insert('na')
soma.insert('kd')
# set maximal conductances
soma(0.5).pas.g = 1 / 10000
soma(0.5).na.gbar = 1000 / 10000
soma(0.5).kd.gbar = 300 / 10000
# check to make sure everything is set up properly
h.psection(sec=soma)
# set up injected current
stim = h.IClamp(soma(0.5))
stim.amp = 0.2 # nA
stim.dur = 30000 # ms
# set up simulation
h.dt = 0.1 # ms
h.tstop = 30000 # ms
tic = time.perf_counter() # s
h.run()
toc = time.perf_counter() # s
# set up vectors to hold outputs
def show_all_sections(self):
for sec in self.sections:
h.psection(sec=sec)
# f = open('./res.txt', 'w')
# for v in list(v_vec):
# f.write(str(v)+"\n")
pyplot.legend()
pyplot.xlabel('time (ms)')
pyplot.ylabel('mA/cm^2')
if __name__ == '__main__':
numofmodel = int(sys.argv[3])
if numofmodel < 1 or numofmodel > 14:
print("ERROR! Please input model number in range 1...14")
else:
cell = cfiber(250, 0.25, 0, 15020, True, numofmodel)
for sec in h.allsec():
h.psection(sec=sec) #show parameters of each section
# branch_vec, t_vec = set_recording_vectors(cell.stimsec[9])
v_vec11, v_vec13, v_vec16, v_vec17, v_vec18, v_vecka, v_veckd, v_vec, v_veckca, t_vec = set_recording_vectors(
cell.branch)
vc = h.VClamp(0.5, sec=cell.stimsec[9])
vc.dur[0] = 10.0
vc.dur[1] = 100.0
vc.dur[2] = 0.0
vc.amp[0] = -55
vc.amp[1] = -40
vc.amp[2] = 0
# branch_vec1, t_vec1 = set_recording_vectors(cell.stimsec[1])
# branch_vec2, t_vec2 = set_recording_vectors(cell.stimsec[4])
print("Number of model - ", cell.numofmodel)
simulate(cell)
from neuron import h, gui
from matplotlib import pyplot as plt
# create soma section
soma = h.Section(name='soma')
dend = h.Section(name='dend')
h.psection(soma)
# create dend section and connect to soma
dend.connect(soma(1))
h.topology()
# set geometry
soma.L = soma.diam = 12.6157 # Makes a soma of 500 microns squared.
dend.L = 200 # microns
dend.diam = 1 # microns
dend.nseg = 11
# Set membrane properties
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
soma.insert('hh')
soma.gnabar_hh = 0.12 # Sodium conductance in S/cm2
soma.gkbar_hh = 0.036 # Potassium conductance in S/cm2
soma.gl_hh = 0.0003 # Leak conductance in S/cm2
soma.el_hh = -54.3 # Reversal potential in mV
from neuron import h, gui
from neuron.units import ms, mV
soma = h.Section(name='soma')
soma.nseg = 1
soma.diam = 18.8
soma.L = 18.8
soma.Ra = 123.0
soma.insert('hh')
h.psection()
# stim
iclamp = h.IClamp(soma(0.5))
iclamp.delay = 100
iclamp.dur = 100
iclamp.amp = 0.1
# record
v = h.Vector().record(soma(0.5)._ref_v) # Membrane potential vector
t = h.Vector().record(h._ref_t) # Time stamp vector
# run
h.load_file('stdrun.hoc')
#h.fcurrent() # Make all assigned variables (currents, conductances, etc) consistent with the values of the states. Useful in combination with finitialize().
h.finitialize(-64.97 * mV)
h.continuerun(300 * ms)
# plot
import matplotlib.pyplot as plt
plt.figure()
plt.plot(t, v)
from neuron import h, gui
soma = h.Section(name='soma')
h.psection() # prints information about the cell
#dir(soma) # shows all attributes of the cell 'soma'
dend = h.Section(name='dend')
h.psection(sec=dend)
h.topology() # shows connection diagram
# Surface area of cylinder is 2*pi*r*h (sealed ends are implicit).
# Here we make a square cylinder in that the diameter
# is equal to the height, so diam = h. ==> Area = 4*pi*r^2
# We want a soma of 500 microns squared:
# r^2 = 500/(4*pi) ==> r = 6.2078, diam = 12.6157
soma.L = soma.diam = 12.6157 # Makes a soma of 500 microns squared.
dend.L = 180 # microns
dend.diam = 1 # microns
dend.nseg = 11 # odd number of segments
soma_area = h.area(0.5, sec=soma)
print("Surface area of soma = {}".format(soma_area, ))
# Iterate over all sections
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
soma.insert('hh')
# Insert passive leak current in dendrite
dend.insert('pas')
