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 runsim(self, simtime, stepsize=0.1, pulsearray=None):
"""Run the simulation for `simtime`. Save the data at the
end."""
config.logger.info('running: simtime=%g, stepsize=%g, pulsearray=%s' %
(simtime, stepsize, str(pulsearray)))
self.simtime = simtime
if pulsearray is not None:
self.tweak_stimulus(pulsearray)
for ii in range(self.pulsegen.count):
config.logger.info(
'pulse[%d]: delay=%g, width=%g, level=%g' %
(ii, self.pulsegen.delay[ii], self.pulsegen.width[ii],
self.pulsegen.level[ii]))
config.logger.info('Start reinit')
self.schedule(self.simdt, self.plotdt, self.solver)
moose.reinit()
config.logger.info('Finished reinit')
ts = datetime.now()
mutils.stepRun(simtime,
simtime / 10.0,
verbose=True,
logger=config.logger)
# The sleep is required to get all threads to end
while moose.isRunning():
time.sleep(0.1)
te = datetime.now()
td = te - ts
config.logger.info('Simulation time of %g s at simdt=%g with solver %s: %g s' % \
(simtime, self.simdt, self.solver,
td.seconds + td.microseconds * 1e-6))
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 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 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_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 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 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 runsim(self, simtime, stepsize=0.1, pulsearray=None):
"""Run the simulation for `simtime`. Save the data at the
end."""
config.logger.info('running: simtime=%g, stepsize=%g, pulsearray=%s' % (simtime, stepsize, str(pulsearray)))
self.simtime = simtime
if pulsearray is not None:
self.tweak_stimulus(pulsearray)
for ii in range(self.pulsegen.count):
config.logger.info('pulse[%d]: delay=%g, width=%g, level=%g' % (ii, self.pulsegen.delay[ii], self.pulsegen.width[ii], self.pulsegen.level[ii]))
config.logger.info('Start reinit')
self.schedule(self.simdt, self.plotdt, self.solver)
moose.reinit()
config.logger.info('Finished reinit')
ts = datetime.now()
mutils.stepRun(simtime, simtime/10.0, verbose=True, logger=config.logger)
# The sleep is required to get all threads to end
while moose.isRunning():
time.sleep(0.1)
te = datetime.now()
td = te - ts
config.logger.info('Simulation time of %g s at simdt=%g with solver %s: %g s' % \
(simtime, self.simdt, self.solver,
td.seconds + td.microseconds * 1e-6))
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()
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()
pylab.show()
#
def do_sim(pulsegen, amp):
pulsegen.level[0] = amp
pulsegen.delay[0] = 50e-3
pulsegen.width[0] = 100e-3
moose.reinit()
utils.stepRun(simtime, 10000 * simdt, logger=config.logger)
def do_sim(pulsegen, amp):
pulsegen.level[0] = amp
pulsegen.delay[0] = 50e-3
pulsegen.width[0] = 400e-3
moose.reinit()
utils.stepRun(simtime, 10000*simdt, logger=config.logger)
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
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()
