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 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()