def testVmSeriesPlot(self):
utils.setDefaultDt(elecdt=simdt)
utils.assignDefaultTicks(modelRoot=self.m2.path)
utils.assignTicks({0:'%s/##[ISA=HSolve]' % (self.m1.path),
1: '%s/##[ISA=PulseGen]' % (self.m1.path),
7: '%s/##[ISA=VClamp]' % (self.m1.path)})
moose.reinit()
tick = moose.element('/clock/tick')
for ii in range(10):
field = 'proc%d' % (ii)
print 'Connected to', field
for n in tick.neighbours[field]:
print '\t', n
ts = datetime.now()
moose.start(simtime)
te = datetime.now()
td = te - ts
t1 = np.linspace(0, simtime, len(self.p1['somaVm'].vec))
t2 = np.linspace(0, simtime, len(self.p2['somaVm'].vec))
pylab.plot(t1, self.p1['somaVm'].vec, label='hsolve')
pylab.plot(t2, self.p2['somaVm'].vec, label='euler')
config.logger.info('Finished simulation of %g s with %d process threads in %g s' % (simtime, moose.NUMPTHREADS, td.seconds + 1e-6 * td.microseconds))
hsolve_data_file = os.path.join(config.data_dir, 'hsolve_tcr_%s.csv' % (config.filename_suffix))
eeuler_data_file = os.path.join(config.data_dir, 'ee_tcr_%s.csv' % (config.filename_suffix))
np.savetxt(hsolve_data_file, np.vstack((t1, self.p1['somaVm'].vec)).transpose())
np.savetxt(eeuler_data_file, np.vstack((t2, self.p2['somaVm'].vec)).transpose())
print 'Saved Exp Euler data in %s\nHSolve data in %s' % (hsolve_data_file, eeuler_data_file)
pylab.legend()
pylab.show()
def run_sim_parallel(passive=True, solver='hsolve'):
data_info_list = []
model_info_list = []
for jj, ti in enumerate(intervals):
for ii, st in enumerate(stim_order):
experiment_name = 'expt_%d_%d' % (jj, ii)
dinfo, minfo = setup_experiment(experiment_name, st, tonset, ti, passive=passive, solver=solver)
data_info_list.append(dinfo)
model_info_list.append(minfo)
mutils.setDefaultDt(elecdt=simdt)
mutils.assignDefaultTicks()
moose.reinit()
moose.start(tstop)
print('$$$$$$$$$$$', moose.element('/clock' ).currentTime)
axes_vm = fig.add_subplot(111)
# axes_vm_out = fig.add_subplot(121)
# axes_vm_in = fig.add_subplot(122, sharex=axes_vm_out, sharey=axes_vm_out)
################
# axes_vm = fig.add_subplot(311)
# axes_nmda = fig.add_subplot(312)
# axes_ampa = fig.add_subplot(313)
for jj, ti in enumerate(intervals):
for ii, st in enumerate(stim_order):
dinfo = data_info_list[jj * len(stim_order) + ii]
print('Interval=', ti, 'Stim order=', st)
print('dinfo:', dinfo)
print(dinfo['soma_vm'])
print(dinfo['soma_vm'].vector)
v = dinfo['soma_vm'].vector
t = np.linspace(0, tstop, len(v))
print('num points=', len(t), 't0=', t[0], 't_last=', t[-1], 'v0=', v[0], 'v_last=', v[-1])
def gapjunction_demo():
model = moose.Neutral('model')
data = moose.Neutral('data')
comps = []
comp1 = make_compartment('%s/comp1' % (model.path))
comp2 = make_compartment('%s/comp2' % (model.path))
pulse = moose.PulseGen('%s/pulse' % (model.path))
pulse.level[0] = 1e-9
pulse.delay[0] = 50e-3
pulse.width[0] = 20e-3
pulse.delay[1] = 1e9
moose.connect(pulse, 'output', comp1, 'injectMsg')
gj = moose.GapJunction('%s/gj' % (model.path))
gj.Gk = 1e-6
moose.connect(gj, 'channel1', comp1, 'channel')
moose.connect(gj, 'channel2', comp2, 'channel')
vm1_tab = moose.Table('%s/Vm1' % (data.path))
moose.connect(vm1_tab, 'requestOut', comp1, 'getVm')
vm2_tab = moose.Table('%s/Vm2' % (data.path))
moose.connect(vm2_tab, 'requestOut', comp2, 'getVm')
pulse_tab = moose.Table('%s/inject' % (data.path))
moose.connect(pulse_tab, 'requestOut', pulse, 'getOutputValue')
utils.setDefaultDt(elecdt=simdt, plotdt2=simdt)
utils.assignDefaultTicks()
utils.stepRun(simtime, 10000*simdt)
# print len(vm1_tab.vector), len(vm2_tab.vector), len(pulse_tab.vector)
# moose.showmsg(comp1)
# moose.showmsg(comp2)
# moose.showmsg(pulse)
t = pylab.linspace(0, simtime, len(vm1_tab.vector))
pylab.plot(t, vm1_tab.vector*1000, label='Vm1 (mV)')
pylab.plot(t, vm2_tab.vector*1000, label='Vm2 (mV)')
pylab.plot(t, pulse_tab.vector*1e9, label='inject (nA)')
pylab.legend()
pylab.show()
def main():
"""
This shows the use of SynChan with Izhikevich neuron. This can be
used for creating a network of Izhikevich neurons.
"""
simtime = 200.0
stepsize = 10.0
model_dict = make_model()
vm, inject, gk, spike = setup_data_recording(model_dict['neuron'],
model_dict['pulse'],
model_dict['synapse'],
model_dict['spike_in'])
mutils.setDefaultDt(elecdt=0.01, plotdt2=0.25)
mutils.assignDefaultTicks(solver='ee')
moose.reinit()
mutils.stepRun(simtime, stepsize)
pylab.subplot(411)
pylab.plot(pylab.linspace(0, simtime, len(vm.vector)), vm.vector, label='Vm (mV)')
pylab.legend()
pylab.subplot(412)
pylab.plot(pylab.linspace(0, simtime, len(inject.vector)), inject.vector, label='Inject (uA)')
pylab.legend()
pylab.subplot(413)
pylab.plot(spike.vector, pylab.ones(len(spike.vector)), '|', label='input spike times')
pylab.legend()
pylab.subplot(414)
pylab.plot(pylab.linspace(0, simtime, len(gk.vector)), gk.vector, label='Gk (mS)')
pylab.legend()
pylab.show()
def main():
"""
This shows the use of SynChan with Izhikevich neuron. This can be
used for creating a network of Izhikevich neurons.
"""
simtime = 200.0
stepsize = 10.0
model_dict = make_model()
vm, inject, gk, spike = setup_data_recording(model_dict['neuron'],
model_dict['pulse'],
model_dict['synapse'],
model_dict['spike_in'])
mutils.setDefaultDt(elecdt=0.01, plotdt2=0.25)
mutils.assignDefaultTicks(solver='ee')
moose.reinit()
mutils.stepRun(simtime, stepsize)
pylab.subplot(411)
pylab.plot(pylab.linspace(0, simtime, len(vm.vector)), vm.vector, label='Vm (mV)')
pylab.legend()
pylab.subplot(412)
pylab.plot(pylab.linspace(0, simtime, len(inject.vector)), inject.vector, label='Inject (uA)')
pylab.legend()
pylab.subplot(413)
pylab.plot(spike.vector, pylab.ones(len(spike.vector)), '|', label='input spike times')
pylab.legend()
pylab.subplot(414)
pylab.plot(pylab.linspace(0, simtime, len(gk.vector)), gk.vector, label='Gk (mS)')
pylab.legend()
pylab.show()
def main():
"""
This is an example of how you can create a Leaky Integrate and Fire
compartment using regular compartment and Func to check for thresold
crossing and resetting the Vm.
"""
tables = setup_two_cells()
utils.setDefaultDt(elecdt=simdt, plotdt2=plotdt)
utils.assignDefaultTicks(modelRoot='/model', dataRoot='/data', solver='ee')
moose.reinit()
utils.stepRun(simtime, stepsize)
data = []
for tab in tables:
data.append(tab.vector)
data = np.vstack(data)
# Travis fix for Ubuntu-12.04
try:
np.savetxt('lifcomp.csv',
data.transpose(),
delimiter='\t',
header=' '.join([tab.name for tab in tables]))
except TypeError as e: # old numpy may not have header.
np.savetxt('lifcomp.csv', data.transpose(), delimiter='\t')
def simulateSelected(self):
cellnames = [str(c.text()) for c in self.cellListWidget.selectedItems()]
assert(len(cellnames) == 1)
name = cellnames[0]
params = self.createCell(name)
# print 'Here ......'
# hsolve = moose.HSolve('%s/solver' % (params['cell'].path))
# hsolve.dt = simdt
# hsolve.target = params['cell'].path
mutils.setDefaultDt(elecdt=simdt, plotdt2=plotdt)
mutils.assignDefaultTicks(modelRoot=params['modelRoot'],
dataRoot=params['dataRoot'],
solver='hsolve')
delay = float(str(self.delayText.text())) * 1e-3
width = float(str(self.widthText.text())) * 1e-3
levelMin = float(str(self.ampMinText.text())) * 1e-12
levelMax = float(str(self.ampMaxText.text())) * 1e-12
levelStep = float(str(self.ampStepText.text())) * 1e-12
params['stimulus'].delay[0] = delay
params['stimulus'].width[0] = width
params['stimulus'].level[0] = levelMin
simtime = float(str(self.simtimeEdit.text()))*1e-3
tdlist = []
self.vmAxes.clear()
self.vmAxes.set_title('membrane potential at soma')
self.vmAxes.set_ylabel('mV')
self.vmAxes.get_xaxis().set_visible(False)
self.stimAxes.clear()
self.stimAxes.set_title('current injected at soma')
self.stimAxes.set_ylabel('pA')
self.stimAxes.set_xlabel('ms')
styles = ['-', '--', '-.', ':']
cnt = int((levelMax - levelMin)/levelStep)
ii = 0
while params['stimulus'].level[0] < levelMax:
tstart = datetime.now()
moose.reinit()
moose.start(simtime)
tend = datetime.now()
td = tend - tstart
tdlist.append(td.days * 86400 + td.seconds + td.microseconds * 1e-6)
ts = np.linspace(0, simtime, len(params['somaVm'].vector))
vm = params['somaVm'].vector
stim = params['injectionCurrent'].vector
alpha = 0.1 + 0.9 * params['stimulus'].level[0] / levelMax
color = cmap(ii*1.0/cnt, cnt)
self.vmAxes.plot(ts * 1e3, vm * 1e3, color=color, label='%g pA' % (params['stimulus'].level[0]*1e12), alpha=0.8)
self.stimAxes.plot(ts * 1e3, stim * 1e12, color=color, label='Current (pA)')
self.plotCanvas.draw()
params['stimulus'].level[0] += levelStep
ii += 1
self.gs.tight_layout(self.plotFigure)
self.vmAxes.legend()
self.plotCanvas.draw()
td = np.mean(tdlist)
print 'Simulating %g s took %g s of computer time' % (simtime, td)
def simulateSelected(self):
cellnames = [str(c.text()) for c in self.cellListWidget.selectedItems()]
assert(len(cellnames) == 1)
name = cellnames[0]
params = self.createCell(name)
# hsolve = moose.HSolve('%s/solver' % (params['cell'].path))
# hsolve.dt = simdt
# hsolve.target = params['cell'].path
mutils.setDefaultDt(elecdt=simdt, plotdt2=plotdt)
mutils.assignDefaultTicks(modelRoot=params['modelRoot'],
dataRoot=params['dataRoot'],
solver='hsolve')
delay = float(str(self.delayText.text())) * 1e-3
width = float(str(self.widthText.text())) * 1e-3
levelMin = float(str(self.ampMinText.text())) * 1e-12
levelMax = float(str(self.ampMaxText.text())) * 1e-12
levelStep = float(str(self.ampStepText.text())) * 1e-12
params['stimulus'].delay[0] = delay
params['stimulus'].width[0] = width
params['stimulus'].level[0] = levelMin
simtime = float(str(self.simtimeEdit.text()))*1e-3
tdlist = []
self.vmAxes.clear()
self.vmAxes.set_title('membrane potential at soma')
self.vmAxes.set_ylabel('mV')
self.vmAxes.get_xaxis().set_visible(False)
self.stimAxes.clear()
self.stimAxes.set_title('current injected at soma')
self.stimAxes.set_ylabel('pA')
self.stimAxes.set_xlabel('ms')
styles = ['-', '--', '-.', ':']
cnt = int((levelMax - levelMin)/levelStep)
ii = 0
while params['stimulus'].level[0] < levelMax:
tstart = datetime.now()
moose.reinit()
moose.start(simtime)
tend = datetime.now()
td = tend - tstart
tdlist.append(td.days * 86400 + td.seconds + td.microseconds * 1e-6)
ts = np.linspace(0, simtime, len(params['somaVm'].vector))
vm = params['somaVm'].vector
stim = params['injectionCurrent'].vector
alpha = 0.1 + 0.9 * params['stimulus'].level[0] / levelMax
color = cmap(ii*1.0/cnt, cnt)
self.vmAxes.plot(ts * 1e3, vm * 1e3, color=color, label='%g pA' % (params['stimulus'].level[0]*1e12), alpha=0.8)
self.stimAxes.plot(ts * 1e3, stim * 1e12, color=color, label='Current (pA)')
self.plotCanvas.draw()
params['stimulus'].level[0] += levelStep
ii += 1
self.gs.tight_layout(self.plotFigure)
self.vmAxes.legend()
self.plotCanvas.draw()
td = np.mean(tdlist)
print(('Simulating %g s took %g s of computer time' % (simtime, td)))
def run_sim_parallel(passive=True, solver='hsolve'):
data_info_list = []
model_info_list = []
for jj, ti in enumerate(intervals):
for ii, st in enumerate(stim_order):
experiment_name = 'expt_%d_%d' % (jj, ii)
dinfo, minfo = setup_experiment(experiment_name, st, tonset, ti, passive=passive, solver=solver)
data_info_list.append(dinfo)
model_info_list.append(minfo)
mutils.setDefaultDt(elecdt=simdt)
mutils.assignDefaultTicks()
moose.reinit()
moose.start(tstop)
print '$$$$$$$$$$$', moose.element('/clock' ).currentTime
fig = plt.figure()
axes_vm = fig.add_subplot(111)
# axes_vm_out = fig.add_subplot(121)
# axes_vm_in = fig.add_subplot(122, sharex=axes_vm_out, sharey=axes_vm_out)
################
# axes_vm = fig.add_subplot(311)
# axes_nmda = fig.add_subplot(312)
# axes_ampa = fig.add_subplot(313)
for jj, ti in enumerate(intervals):
for ii, st in enumerate(stim_order):
dinfo = data_info_list[jj * len(stim_order) + ii]
print 'Interval=', ti, 'Stim order=', st
print 'dinfo:', dinfo
print dinfo['soma_vm']
print dinfo['soma_vm'].vector
v = dinfo['soma_vm'].vector
t = np.linspace(0, tstop, len(v))
print 'num points=', len(t), 't0=', t[0], 't_last=', t[-1], 'v0=', v[0], 'v_last=', v[-1]
axes_vm.plot(t, v)
# if ii % 2 == 0:
# axes_vm_in.plot(t,
# v,
# color=color[ii])
# else:
# axes_vm_out.plot(t,
# v,
# color=color[ii])
# for tab in dinfo['nmda_gk']:
# axes_nmda.plot(np.linspace(0, tstop, len(tab.vector)),
# tab.vector, color=color[ii])
# # axes_nmda.legend()
# for tab in dinfo['ampa_gk']:
# axes_ampa.plot(np.linspace(0, tstop, len(tab.vector)),
# tab.vector, label='%s/%s' % (dinfo['data'].name, tab.name), color=color[ii])
# axes_vm.legend([plt.Line2D([0], [0], color=color[ii]) for ii in range(len(stim_order))],
# [str(st) for st in stim_order])
#axes_vm.legend()
#axes_nmda.legend()
#axes_ampa.legend()
plt.show()
def run_sim_parallel(passive=True, solver='hsolve'):
data_info_list = []
model_info_list = []
for jj, ti in enumerate(intervals):
for ii, st in enumerate(stim_order):
experiment_name = 'expt_%d_%d' % (jj, ii)
dinfo, minfo = setup_experiment(experiment_name, st, tonset, ti, passive=passive, solver=solver)
data_info_list.append(dinfo)
model_info_list.append(minfo)
mutils.setDefaultDt(elecdt=simdt)
mutils.assignDefaultTicks()
moose.reinit()
moose.start(tstop)
print('$$$$$$$$$$$', moose.element('/clock' ).currentTime)
fig = plt.figure()
axes_vm = fig.add_subplot(111)
# axes_vm_out = fig.add_subplot(121)
# axes_vm_in = fig.add_subplot(122, sharex=axes_vm_out, sharey=axes_vm_out)
################
# axes_vm = fig.add_subplot(311)
# axes_nmda = fig.add_subplot(312)
# axes_ampa = fig.add_subplot(313)
for jj, ti in enumerate(intervals):
for ii, st in enumerate(stim_order):
dinfo = data_info_list[jj * len(stim_order) + ii]
print('Interval=', ti, 'Stim order=', st)
print('dinfo:', dinfo)
print(dinfo['soma_vm'])
print(dinfo['soma_vm'].vector)
v = dinfo['soma_vm'].vector
t = np.linspace(0, tstop, len(v))
print('num points=', len(t), 't0=', t[0], 't_last=', t[-1], 'v0=', v[0], 'v_last=', v[-1])
axes_vm.plot(t, v)
# if ii % 2 == 0:
# axes_vm_in.plot(t,
# v,
# color=color[ii])
# else:
# axes_vm_out.plot(t,
# v,
# color=color[ii])
# for tab in dinfo['nmda_gk']:
# axes_nmda.plot(np.linspace(0, tstop, len(tab.vector)),
# tab.vector, color=color[ii])
# # axes_nmda.legend()
# for tab in dinfo['ampa_gk']:
# axes_ampa.plot(np.linspace(0, tstop, len(tab.vector)),
# tab.vector, label='%s/%s' % (dinfo['data'].name, tab.name), color=color[ii])
# axes_vm.legend([plt.Line2D([0], [0], color=color[ii]) for ii in range(len(stim_order))],
# [str(st) for st in stim_order])
#axes_vm.legend()
#axes_nmda.legend()
#axes_ampa.legend()
plt.show()
def schedule(self, simdt, plotdt, solver):
config.logger.info('Scheduling: simdt=%g, plotdt=%g, solver=%s' % (simdt, plotdt, solver))
self.simdt = simdt
self.plotdt = plotdt
self.solver = solver
if self.solver == 'hsolve':
self.hsolve = moose.HSolve('%s/solver' % (self.cell.path))
self.hsolve.dt = simdt
self.hsolve.target = self.cell.path
mutils.setDefaultDt(elecdt=simdt, plotdt2=plotdt)
mutils.assignDefaultTicks(modelRoot=self.model_container.path,
dataRoot=self.data_container.path,
solver=self.solver)
def schedule(self, simdt, plotdt, solver):
config.logger.info('Scheduling: simdt=%g, plotdt=%g, solver=%s' % (simdt, plotdt, solver))
self.simdt = simdt
self.plotdt = plotdt
self.solver = solver
if self.solver == 'hsolve':
self.hsolve = moose.HSolve('%s/solver' % (self.cell.path))
self.hsolve.dt = simdt
self.hsolve.target = self.cell.path
mutils.setDefaultDt(elecdt=simdt, plotdt2=plotdt)
mutils.assignDefaultTicks(modelRoot=self.model_container.path,
dataRoot=self.data_container.path,
solver=self.solver)
def run_model():
model = moose.Neutral('/model')
data = moose.Neutral('/data')
cell = TuftedIB('/model/TuftedIB')
stim = alpha_stimulus('/model/stim', 1.0e-9, 15e-3, 20e-3, simtime, simdt)
stim.startTime = 1e9
p1 = cell.path + '/' + d1
p2 = cell.path + '/' + d2
comp_d1 = moose.element(p1) if moose.exists(p1) else moose.Compartment(p1)
comp_d2 = moose.element(p2) if moose.exists(p2) else moose.Compartment(p2)
s = '%s/%s' % (cell.path, 'comp_1')
comp_soma = moose.element(s) if moose.exists(s) else moose.Compartment(s)
comp_soma.inject = -0.2e-9
moose.connect(stim, 'output', comp_d1, 'injectMsg')
tab_d1 = moose.Table('%s/d1_Vm' % (data.path))
tab_d2 = moose.Table('%s/d2_Vm' % (data.path))
tab_soma = moose.Table('%s/soma_Vm' % (data.path))
tab_stim = moose.Table('%s/stim' % (data.path))
moose.connect(tab_d1, 'requestOut', comp_d1, 'getVm')
moose.connect(tab_d2, 'requestOut', comp_d2, 'getVm')
moose.connect(tab_soma, 'requestOut', comp_soma, 'getVm')
moose.connect(stim, 'output', tab_stim, 'input')
solver = moose.HSolve('%s/solver' % (cell.path))
solver.dt = simdt
solver.target = cell.path
utils.setDefaultDt(elecdt=simdt, plotdt2=plotdt)
utils.assignDefaultTicks()
moose.reinit()
utils.stepRun(simtime, 1e5 * simdt, logger=config.logger)
pylab.subplot(211)
pylab.plot(np.linspace(0, simtime, len(tab_d1.vector)),
tab_d1.vector * 1e3,
label='D1 Vm (mV)')
pylab.plot(np.linspace(0, simtime, len(tab_d2.vector)),
tab_d2.vector * 1e3,
label='D2 Vm (mV)')
pylab.plot(np.linspace(0, simtime, len(tab_soma.vector)),
tab_soma.vector * 1e3,
label='SOMA Vm (mV)')
pylab.legend()
pylab.subplot(212)
pylab.plot(np.linspace(0, simtime, len(tab_stim.vector)),
tab_stim.vector * 1e9,
label='Stimulus (nA)')
pylab.legend()
pylab.savefig('fig_a4c.png')
pylab.show()
def run_current_pulse(amps,
delay=100e-3,
dur=100e-3,
trail=100e-3,
outfile='f_i_curves_data.h5'):
models = []
model = moose.Neutral('/model')
data = moose.Neutral('/data')
ddict = defaultdict(list)
for ii, amp in enumerate(amps):
mc = moose.Neutral('{}/mc_{}'.format(model.path, ii))
models.append(mc)
stim = moose.PulseGen('{}/stim_{}'.format(mc.path, ii))
stim.delay[0] = delay
stim.width[0] = dur
stim.level[0] = amp
stim.delay[
1] = 1e9 # make delay so large that it does not activate again
for celltype in [SpinyStellate, DeepBasket, DeepLTS]:
cell = celltype('{}/{}_{}'.format(mc.path, celltype.__name__, ii))
solver = moose.HSolve('{}/solver'.format(cell.path))
solver.dt = simdt
solver.target = cell.path
stim.connect('output', cell.soma, 'injectMsg')
tab = moose.Table('/data/Vm_{}'.format(cell.name))
ddict[ii].append(tab)
tab.connect('requestOut', cell.soma, 'getVm')
mutils.setDefaultDt(elecdt=simdt, plotdt2=plotdt)
mutils.assignDefaultTicks(modelRoot='/model',
dataRoot='/data',
solver='hsolve')
moose.reinit()
print('Finished scheduling')
moose.start(delay + dur + trail)
print('Finished simulation')
# Save data
fd = h5.File(outfile, 'w')
for ii, tabs in ddict.items():
for tab in tabs:
print('Table', tab.name)
node = fd.create_dataset(tab.name, data=tab.vector)
node.attrs['current'] = amps[ii]
node.attrs['delay'] = delay
node.attrs['width'] = dur
fd.close()
print('Finished saving data in file', outfile)
def main():
"""
This is an example of how you can create a Leaky Integrate and Fire
compartment using regular compartment and Func to check for thresold
crossing and resetting the Vm.
"""
tables = setup_two_cells()
utils.setDefaultDt(elecdt=simdt, plotdt2=plotdt)
utils.assignDefaultTicks(modelRoot='/model', dataRoot='/data', solver='ee')
moose.reinit()
utils.stepRun(simtime, stepsize)
for ii, tab in enumerate(tables):
subplot(len(tables), 1, ii + 1)
t = np.linspace(0, simtime, len(tab.vector)) * 1e3
plot(t, tab.vector * 1e3, label=tab.name)
legend()
show()
def main():
"""
This is an example of how you can create a Leaky Integrate and Fire
compartment using regular compartment and Func to check for thresold
crossing and resetting the Vm.
"""
tables = setup_two_cells()
utils.setDefaultDt(elecdt=simdt, plotdt2=plotdt)
utils.assignDefaultTicks(modelRoot='/model', dataRoot='/data', solver='ee')
moose.reinit()
utils.stepRun(simtime, stepsize)
for ii, tab in enumerate(tables):
subplot(len(tables), 1, ii+1)
t = np.linspace(0, simtime, len(tab.vector))*1e3
plot(t, tab.vector*1e3, label=tab.name)
legend()
show()
def setup_model(root='/', hsolve=True):
moose.ce(root)
model = moose.Neutral('model')
data = moose.Neutral('data')
cell = DeepBasket('%s/deepbasket' % (model.path))
soma = moose.Compartment('%s/comp_1' % (cell.path))
if hsolve:
solver = moose.HSolve('%s/solve' % (cell.path))
solver.dt = simdt
solver.target = cell.path
pulse = moose.PulseGen('%s/stimulus' % (model.path))
moose.connect(pulse, 'output', soma, 'injectMsg')
tab_vm = moose.Table('%s/spinystellate_soma_Vm' % (data.path))
moose.connect(tab_vm, 'requestOut', soma, 'getVm')
tab_stim = moose.Table('%s/spinystellate_soma_inject' % (data.path))
moose.connect(tab_stim, 'requestOut', pulse, 'getOutputValue')
utils.setDefaultDt(elecdt=simdt, plotdt2=plotdt)
utils.assignDefaultTicks(model, data)
return {'stimulus': pulse, 'tab_vm': tab_vm, 'tab_stim': tab_stim}
def setup_model(root="/", hsolve=True):
moose.ce(root)
model = moose.Neutral("model")
data = moose.Neutral("data")
cell = DeepBasket("%s/deepbasket" % (model.path))
soma = moose.Compartment("%s/comp_1" % (cell.path))
if hsolve:
solver = moose.HSolve("%s/solve" % (cell.path))
solver.dt = simdt
solver.target = cell.path
pulse = moose.PulseGen("%s/stimulus" % (model.path))
moose.connect(pulse, "output", soma, "injectMsg")
tab_vm = moose.Table("%s/spinystellate_soma_Vm" % (data.path))
moose.connect(tab_vm, "requestOut", soma, "getVm")
tab_stim = moose.Table("%s/spinystellate_soma_inject" % (data.path))
moose.connect(tab_stim, "requestOut", pulse, "getOutputValue")
utils.setDefaultDt(elecdt=simdt, plotdt2=plotdt)
utils.assignDefaultTicks(model, data)
return {"stimulus": pulse, "tab_vm": tab_vm, "tab_stim": tab_stim}
def simulateSelected(self):
cellnames = [str(c.text()) for c in self.cellListWidget.selectedItems()]
assert(len(cellnames) == 1)
name = cellnames[0]
params = self.createCell(name)
print 'Here ......'
hsolve = moose.HSolve('%s/solver' % (params['cell'].path))
hsolve.dt = simdt
hsolve.target = params['cell'].path
mutils.setDefaultDt(elecdt=simdt, plotdt2=plotdt)
mutils.assignDefaultTicks(modelRoot=params['modelRoot'],
dataRoot=params['dataRoot'],
solver='hsolve')
delay = float(str(self.delayText.text()))
width = float(str(self.widthText.text()))
level = float(str(self.ampText.text()))
params['stimulus'].delay[0] = delay * 1e-3
params['stimulus'].width[0] = width * 1e-3
params['stimulus'].level[0] = level * 1e-12
moose.reinit()
simtime = float(str(self.simtimeEdit.text()))*1e-3
ts = datetime.now()
moose.start(simtime)
te = datetime.now()
td = te - ts
print 'Simulating %g s took %g s of computer time' % (simtime, td.days * 86400 + td.seconds + td.microseconds * 1e-6)
ts = np.linspace(0, simtime, len(params['somaVm'].vec))
vm = params['somaVm'].vec
stim = params['injectionCurrent'].vec
self.vmAxes.clear()
self.vmAxes.set_title('membrane potential at soma')
self.vmAxes.set_ylabel('mV')
self.vmAxes.plot(ts * 1e3, vm * 1e3, 'b-', label='Vm (mV)')
self.vmAxes.get_xaxis().set_visible(False)
self.stimAxes.clear()
self.stimAxes.set_title('current injected at soma')
self.stimAxes.set_ylabel('pA')
self.stimAxes.set_xlabel('ms')
self.stimAxes.plot(ts * 1e3, stim * 1e12, 'r-', label='Current (pA)')
self.gs.tight_layout(self.plotFigure)
# self.plotFigure.tight_layout()
self.plotCanvas.draw()
def setup_model(root='/', hsolve=True):
moose.ce(root)
model = moose.Neutral('model')
data = moose.Neutral('data')
cell = SpinyStellate('%s/spinystellate' % (model.path))
soma = moose.Compartment('%s/comp_1' % (cell.path))
if hsolve:
solver = moose.HSolve('%s/solve' % (cell.path))
solver.dt = simdt
solver.target = cell.path
pulse = moose.PulseGen('%s/stimulus' % (model.path))
moose.connect(pulse, 'output', soma, 'injectMsg')
tab_vm = moose.Table('%s/spinystellate_soma_Vm' % (data.path))
moose.connect(tab_vm, 'requestOut', soma, 'getVm')
tab_stim = moose.Table('%s/spinystellate_soma_inject' % (data.path))
moose.connect(tab_stim, 'requestOut', pulse, 'getOutputValue')
utils.setDefaultDt(elecdt=simdt, plotdt2=plotdt)
utils.assignDefaultTicks(model, data)
return {'stimulus': pulse,
'tab_vm': tab_vm,
'tab_stim': tab_stim}
def run_current_pulse(amps, delay=100e-3, dur=100e-3, trail=100e-3, outfile='f_i_curves_data.h5'):
models = []
model = moose.Neutral('/model')
data = moose.Neutral('/data')
ddict = defaultdict(list)
for ii, amp in enumerate(amps):
mc = moose.Neutral('{}/mc_{}'.format(model.path, ii))
models.append(mc)
stim = moose.PulseGen('{}/stim_{}'.format(mc.path, ii))
stim.delay[0] = delay
stim.width[0] = dur
stim.level[0] = amp
stim.delay[1] = 1e9 # make delay so large that it does not activate again
for celltype in [SpinyStellate, DeepBasket, DeepLTS]:
cell = celltype('{}/{}_{}'.format(mc.path, celltype.__name__, ii))
solver = moose.element('{}/solver'.format(cell.path))
solver.dt = simdt
solver.target = cell.path
stim.connect('output', cell.soma, 'injectMsg')
tab = moose.Table('/data/Vm_{}'.format(cell.name))
ddict[ii].append(tab)
tab.connect('requestOut', cell.soma, 'getVm')
mutils.setDefaultDt(elecdt=simdt, plotdt2=plotdt)
mutils.assignDefaultTicks(modelRoot='/model', dataRoot='/data', solver='hsolve')
moose.reinit()
print('Finished scheduling')
moose.start(delay + dur + trail)
print('Finished simulation')
# Save data
fd = h5.File(outfile, 'w')
for ii, tabs in list(ddict.items()):
for tab in tabs:
print(('Table', tab.name))
node = fd.create_dataset(tab.name, data=tab.vector)
node.attrs['current'] = amps[ii]
node.attrs['delay'] = delay
node.attrs['width'] = dur
fd.close()
print(('Finished saving data in file', outfile))
def main():
"""
This is an example of how you can create a Leaky Integrate and Fire
compartment using regular compartment and Func to check for thresold
crossing and resetting the Vm.
"""
tables = setup_two_cells()
utils.setDefaultDt(elecdt=simdt, plotdt2=plotdt)
utils.assignDefaultTicks(modelRoot='/model', dataRoot='/data', solver='ee')
moose.reinit()
utils.stepRun(simtime, stepsize)
data = []
for tab in tables:
data.append(tab.vector)
data = np.vstack(data)
# Travis fix for Ubuntu-12.04
try:
np.savetxt('lifcomp.csv', data.transpose(), delimiter='\t', header=' '.join([tab.name for tab in tables]))
except TypeError as e: # old numpy may not have header.
np.savetxt('lifcomp.csv', data.transpose(), delimiter='\t' )
def run_sim_parallel(passive=True, solver='hsolve'):
data_info_list = []
model_info_list = []
for jj, ti in enumerate(intervals):
for ii, st in enumerate(stim_order):
experiment_name = 'expt_%d_%d' % (jj, ii)
dinfo, minfo = setup_experiment(experiment_name,
st,
tonset,
ti,
passive=passive,
solver=solver)
data_info_list.append(dinfo)
model_info_list.append(minfo)
mutils.setDefaultDt(elecdt=simdt)
mutils.assignDefaultTicks()
moose.reinit()
moose.start(tstop)
print('$$$$$$$$$$$', moose.element('/clock').currentTime)
axes_vm = fig.add_subplot(111)
# axes_vm_out = fig.add_subplot(121)
# axes_vm_in = fig.add_subplot(122, sharex=axes_vm_out, sharey=axes_vm_out)
################
# axes_vm = fig.add_subplot(311)
# axes_nmda = fig.add_subplot(312)
# axes_ampa = fig.add_subplot(313)
for jj, ti in enumerate(intervals):
for ii, st in enumerate(stim_order):
dinfo = data_info_list[jj * len(stim_order) + ii]
print('Interval=', ti, 'Stim order=', st)
print('dinfo:', dinfo)
print(dinfo['soma_vm'])
print(dinfo['soma_vm'].vector)
v = dinfo['soma_vm'].vector
t = np.linspace(0, tstop, len(v))
print('num points=', len(t), 't0=', t[0], 't_last=', t[-1], 'v0=',
v[0], 'v_last=', v[-1])
def run_model():
model = moose.Neutral('/model')
data = moose.Neutral('/data')
cell = TuftedIB('/model/TuftedIB')
stim = alpha_stimulus('/model/stim', 1.0e-9, 15e-3, 20e-3, simtime, simdt)
stim.startTime = 1e9
comp_d1 = moose.element('%s/%s' % (cell.path, d1))
comp_d2 = moose.element('%s/%s' % (cell.path, d2))
comp_soma = moose.element('%s/%s' % (cell.path, 'comp_1'))
comp_soma.inject = -0.2e-9
moose.connect(stim, 'output', comp_d1, 'injectMsg')
tab_d1 = moose.Table('%s/d1_Vm' % (data.path))
tab_d2 = moose.Table('%s/d2_Vm' % (data.path))
tab_soma = moose.Table('%s/soma_Vm' % (data.path))
tab_stim = moose.Table('%s/stim' % (data.path))
moose.connect(tab_d1, 'requestData', comp_d1, 'get_Vm')
moose.connect(tab_d2, 'requestData', comp_d2, 'get_Vm')
moose.connect(tab_soma, 'requestData', comp_soma, 'get_Vm')
moose.connect(stim, 'output', tab_stim, 'input')
solver = moose.HSolve('%s/solver' % (cell.path))
solver.dt = simdt
solver.target = cell.path
utils.setDefaultDt(elecdt=simdt,plotdt2=plotdt)
utils.assignDefaultTicks()
moose.reinit()
utils.stepRun(simtime, 1e5*simdt, logger=config.logger)
pylab.subplot(211)
pylab.plot(np.linspace(0, simtime, len(tab_d1.vec)), tab_d1.vec * 1e3, label='D1 Vm (mV)')
pylab.plot(np.linspace(0, simtime, len(tab_d2.vec)), tab_d2.vec * 1e3, label='D2 Vm (mV)')
pylab.plot(np.linspace(0, simtime, len(tab_soma.vec)), tab_soma.vec * 1e3, label='SOMA Vm (mV)')
pylab.legend()
pylab.subplot(212)
pylab.plot(np.linspace(0, simtime, len(tab_stim.vec)), tab_stim.vec * 1e9, label='Stimulus (nA)')
pylab.legend()
pylab.savefig('fig_a4c.png')
pylab.show()
moose.connect(inject_table, 'requestOut', pulse, 'getOutputValue')
gk_table = moose.Table('/data/Gk')
moose.connect(gk_table, 'requestOut', synapse, 'getGk')
spike_in_table = moose.Table('/data/spike_in')
moose.connect(spikegen, 'spikeOut', spike_in_table, 'spike')
return [vm_table, inject_table, gk_table, spike_in_table]
if __name__ == '__main__':
simtime = 200.0
stepsize = 10.0
model_dict = make_model()
vm, inject, gk, spike = setup_data_recording(model_dict['neuron'],
model_dict['pulse'],
model_dict['synapse'],
model_dict['spike_in'])
mutils.setDefaultDt(elecdt=0.01, plotdt2=0.25)
mutils.assignDefaultTicks(solver='ee')
moose.reinit()
mutils.stepRun(simtime, stepsize)
pylab.subplot(411)
pylab.plot(pylab.linspace(0, simtime, len(vm.vector)), vm.vector, label='Vm (mV)')
pylab.legend()
pylab.subplot(412)
pylab.plot(pylab.linspace(0, simtime, len(inject.vector)), inject.vector, label='Inject (uA)')
pylab.legend()
pylab.subplot(413)
pylab.plot(spike.vector, pylab.ones(len(spike.vector)), '|', label='input spike times')
pylab.legend()
pylab.subplot(414)
pylab.plot(pylab.linspace(0, simtime, len(gk.vector)), gk.vector, label='Gk (mS)')
pylab.legend()
def test_mgblock():
model = moose.Neutral('/model')
data = moose.Neutral('/data')
soma = moose.Compartment('/model/soma')
soma.Em = -60e-3
soma.Rm = 1e7
soma.Cm = 1e-9
###################################################
# This is where we create the synapse with MgBlock
#--------------------------------------------------
nmda = moose.SynChan('/model/soma/nmda')
nmda.Gbar = 1e-9
mgblock = moose.MgBlock('/model/soma/mgblock')
mgblock.CMg = 2.0
mgblock.KMg_A = 1/0.33
mgblock.KMg_B = 1/60.0
# MgBlock sits between original channel nmda and the
# compartment. The origChannel receives the channel message from
# the nmda SynChan.
moose.connect(nmda, 'channelOut', mgblock, 'origChannel')
moose.connect(mgblock, 'channel', soma, 'channel')
# This is for comparing with MgBlock
nmda_noMg = moose.element(moose.copy(nmda, soma, 'nmda_noMg'))
moose.connect(moose.element(nmda_noMg), 'channel', soma, 'channel')
#########################################
# The rest is for experiment setup
spikegen = moose.SpikeGen('/model/spike')
pulse = moose.PulseGen('/model/input')
pulse.delay[0] = 10e-3
pulse.level[0] = 1.0
pulse.width[0] = 50e-3
moose.connect(pulse, 'output', spikegen, 'Vm')
nmda.synapse.num = 1
syn = moose.element(nmda.synapse.path)
moose.connect(spikegen, 'spikeOut', syn, 'addSpike')
nmda_noMg.synapse.num = 1
moose.connect(spikegen, 'spikeOut', moose.element(nmda_noMg.synapse.path), 'addSpike')
Gnmda = moose.Table('/data/Gnmda')
moose.connect(Gnmda, 'requestOut', mgblock, 'getGk')
Gnmda_noMg = moose.Table('/data/Gnmda_noMg')
moose.connect(Gnmda_noMg, 'requestOut', nmda_noMg, 'getGk')
Vm = moose.Table('/data/Vm')
moose.connect(Vm, 'requestOut', soma, 'getVm')
utils.setDefaultDt(elecdt=simdt, plotdt2=plotdt)
utils.assignDefaultTicks(modelRoot='/model', dataRoot='/data')
moose.reinit()
utils.stepRun(simtime, simtime/10)
for ii in range(10):
for n in moose.element('/clock/tick').neighbors['proc%d' % (ii)]:
print ii, n.path
t = pylab.linspace(0, simtime*1e3, len(Vm.vector))
pylab.plot(t, Vm.vector*1e3, label='Vm (mV)')
pylab.plot(t, Gnmda.vector * 1e9, label='Gnmda (nS)')
pylab.plot(t, Gnmda_noMg.vector * 1e9, label='Gnmda no Mg (nS)')
pylab.legend()
data = pylab.vstack((t, Gnmda.vector, Gnmda_noMg.vector)).transpose()
pylab.savetxt('mgblock.dat', data)
pylab.show()
gk_table = moose.Table('/data/Gk')
moose.connect(gk_table, 'requestOut', synapse, 'getGk')
spike_in_table = moose.Table('/data/spike_in')
moose.connect(spikegen, 'spikeOut', spike_in_table, 'spike')
return [vm_table, inject_table, gk_table, spike_in_table]
if __name__ == '__main__':
simtime = 200.0
stepsize = 10.0
model_dict = make_model()
vm, inject, gk, spike = setup_data_recording(model_dict['neuron'],
model_dict['pulse'],
model_dict['synapse'],
model_dict['spike_in'])
mutils.setDefaultDt(elecdt=0.01, plotdt2=0.25)
mutils.assignDefaultTicks(solver='ee')
moose.reinit()
mutils.stepRun(simtime, stepsize)
pylab.subplot(411)
pylab.plot(pylab.linspace(0, simtime, len(vm.vector)),
vm.vector,
label='Vm (mV)')
pylab.legend()
pylab.subplot(412)
pylab.plot(pylab.linspace(0, simtime, len(inject.vector)),
inject.vector,
label='Inject (uA)')
pylab.legend()
pylab.subplot(413)
pylab.plot(spike.vector,
data = moose.Neutral('/data')
for c in moose.wildcardFind('/##[ISA=Compartment]'):
tab = moose.Table('%s/%s_Vm' % (data.path, c.name))
moose.connect(tab, 'requestOut', c, 'getVm')
tables.append(tab)
syntab = moose.Table('%s/%s' % (data.path, 'Gk'))
moose.connect(syntab, 'requestOut', syn, 'getGk')
tables.append(syntab)
syn.synapse[0].delay = 1e-3
syn.Gbar = 1e-6
return tables
if __name__ == '__main__':
tables = setup_two_cells()
utils.setDefaultDt(elecdt=simdt, plotdt2=plotdt)
utils.assignDefaultTicks(modelRoot='/model', dataRoot='/data', solver='ee')
moose.reinit()
utils.stepRun(simtime, stepsize)
data = []
for tab in tables:
data.append(tab.vector)
data = np.concatenate(data)
np.savetxt('lifcomp.csv', data.transpose(), delimiter='\t', header=' '.join([tab.name for tab in tables]))
# subplot(len(tables), 1, ii+1)
# t = np.linspace(0, simtime, len(tab.vector))*1e3
# plot(t, tab.vector*1e3, label=tab.name)
# legend()
# show()
#
# lifcomp.py ends here
data = moose.Neutral('/data')
for c in moose.wildcardFind('/##[ISA=Compartment]'):
tab = moose.Table('%s/%s' % (data.path, c.name))
moose.connect(tab, 'requestOut', c, 'getVm')
tables.append(tab)
# t1 = moose.Table('%s/%s' % (data.path, c.name))
# moose.connect(t1, 'requestOut', moose.element('%s/dynamics' % (c.path)), 'getX')
# tables.append(t1)
syntab = moose.Table('%s/%s' % (data.path, 'Gk'))
moose.connect(syntab, 'requestOut', syn, 'getGk')
tables.append(syntab)
synh.synapse[0].delay = 1e-3
syn.Gbar = 1e-6
return tables
if __name__ == '__main__':
tables = setup_two_cells()
utils.setDefaultDt(elecdt=simdt, plotdt2=plotdt)
utils.assignDefaultTicks(modelRoot='/model', dataRoot='/data', solver='ee')
moose.reinit()
utils.stepRun(simtime, stepsize)
for ii, tab in enumerate(tables):
subplot(len(tables), 1, ii+1)
t = np.linspace(0, simtime, len(tab.vector))*1e3
plot(t, tab.vector*1e3, label=tab.name)
legend()
show()
#
# multicomp_lif.py ends here
