def test_crossing_single(): """This function creates an ematrix of two PulseGen elements and another ematrix of two Table elements. The two pulsegen elements have same amplitude but opposite phase. Table[0] is connected to PulseGen[1] and Table[1] to Pulsegen[0]. In the plot you should see two square pulses of opposite phase. """ size = 2 pg = moose.PulseGen('pulsegen', size) for ix, ii in enumerate(pg.vec): pulse = moose.element(ii) pulse.delay[0] = 1.0 pulse.width[0] = 2.0 pulse.level[0] = (-1)**ix tab = moose.Table('table', size) moose.connect(tab.vec[0], 'requestOut', pg.vec[1], 'getOutputValue', 'Single') moose.connect(tab.vec[1], 'requestOut', pg.vec[0], 'getOutputValue', 'Single') print 'Neighbors:' for t in tab.vec: print t.path for n in moose.element(t).neighbors['requestOut']: print 'requestOut <-', n.path moose.setClock(0, 0.1) moose.useClock(0, '/##', 'process') moose.start(5) for ii in tab.vec: t = moose.Table(ii).vector print len(t) pylab.plot(t) pylab.show()
def _init_plots(self): ExcInhNetBase._init_plots(self) if CaPlasticity: self.recNCa = 5 # number of synapses for which to record Ca # as range(self.N) is too large self.recNwt = 20 # number of synapses for which to record weights ## make tables to store weights of recN exc synapses self.weightsEq = moose.Table('/plotWeightsEq', self.recNwt) wtidx = 0 for i in range(self.N): for j in range(self.excC): if self.excC * i + j not in self.potSyns: moose.connect( self.weightsEq.vec[wtidx], 'requestOut', self.synsEE.vec[i * self.excC + j].synapse[0], 'getWeight') wtidx += 1 if wtidx >= self.recNwt: break ## break only breaks out of one loop, hence repeated here! if wtidx >= self.recNwt: break self.weightsUp = moose.Table('/plotWeightsUp', self.recNwt) for i in range(self.recNwt): # range(self.N) is too large moose.connect(self.weightsUp.vec[i], 'requestOut', self.synsEE.vec[self.potSyns[i]].synapse[0], 'getWeight') self.CaTables = moose.Table('/plotCa', self.recNCa) for i in range(self.recNCa): # range(self.N) is too large moose.connect(self.CaTables.vec[i], 'requestOut', self.synsEE.vec[i * self.excC], 'getCa')
def spinetabs(model, neuron, comps='all'): if not moose.exists(DATA_NAME): moose.Neutral(DATA_NAME) # creates tables of calcium and vm for spines spcatab = defaultdict(list) spvmtab = defaultdict(list) for typenum, neurtype in enumerate(neuron.keys()): if type(comps) == str and comps in {'*', 'all'}: spineHeads = [moose.wildcardFind(neurtype + '/##/#head#[ISA=CompartmentBase]')] else: spineHeads = [moose.wildcardFind(neurtype + '/' + c + '/#head#[ISA=CompartmentBase]') for c in comps] for spinelist in spineHeads: for spinenum, spine in enumerate(spinelist): compname = spine.parent.name sp_num = spine.name.split(NAME_HEAD)[0] spvmtab[typenum].append(moose.Table(vm_table_path(neurtype, spine=sp_num, comp=compname))) log.debug('{} {} {}', spinenum, spine.path, spvmtab[typenum][-1].path) moose.connect(spvmtab[typenum][-1], 'requestOut', spine, 'getVm') if model.calYN: for child in spine.children: if child.className == "CaConc" or child.className == "ZombieCaConc": spcatab[typenum].append( moose.Table(DATA_NAME + '/%s_%s%s' % (neurtype, sp_num, compname) + child.name)) spcal = moose.element(spine.path + '/' + child.name) moose.connect(spcatab[typenum][-1], 'requestOut', spcal, 'getCa') elif child.className == 'DifShell': spcatab[typenum].append( moose.Table(DATA_NAME + '/%s_%s%s' % (neurtype, sp_num, compname) + child.name)) spcal = moose.element(spine.path + '/' + child.name) moose.connect(spcatab[typenum][-1], 'requestOut', spcal, 'getC') return spcatab, spvmtab
def testNMDAChan(simtime=1.0, simdt=1e-5, plotdt=1e-5): context = moose.PyMooseBase.getContext() container = moose.Neutral('test_NMDA') soma_b = moose.Compartment('B', container) soma_b.Rm = 5.3e9 # GM = 2e-5 S/cm^2 soma_b.Cm = 8.4823001646924426e-12 # CM = 0.9 uF/cm^2 soma_b.Em = -65e-3 soma_b.initVm = -65e-3 soma_b.Ra = 282942.12 # RA = 250 Ohm-cm nmda = moose.NMDAChan('nmda', container) nmda.tau2 = 5e-3 nmda.tau1 = 130e-3 nmda.Gbar = 1e-9 nmda.saturation = 1e10 nmda.connect('channel', soma_b, 'channel') spikegen = moose.SpikeGen('spike', container) spikegen.threshold = 0.5 spikegen.connect('event', nmda, 'synapse') spikegen.refractT = 0.0 nmda.delay[0] = 1e-3 nmda.weight[0] = 1.0 pulsegen = moose.PulseGen('pulse', container) pulsegen.setCount(3) pulsegen.level[0] = 1.0 pulsegen.delay[0] = 10e-3 pulsegen.width[0] = 1e-3 pulsegen.level[1] = 1.0 pulsegen.delay[1] = 2e-3 pulsegen.width[1] = 1e-3 pulsegen.delay[2] = 1e9 pulsegen.connect('outputSrc', spikegen, 'Vm') data = moose.Neutral('data') vmB = moose.Table('Vm_B', data) vmB.stepMode = 3 vmB.connect('inputRequest', soma_b, 'Vm') pulse = moose.Table('pulse', data) pulse.stepMode = 3 pulse.connect('inputRequest', pulsegen, 'output') gNMDA = moose.Table('G', data) gNMDA.stepMode = 3 gNMDA.connect('inputRequest', nmda, 'Gk') context.setClock(0, simdt) context.setClock(1, simdt) context.setClock(2, simdt) context.setClock(3, plotdt) context.reset() context.step(simtime) # gNMDA.dumpFile('gNMDA.dat', False) # vmA.dumpFile('Va.dat', False) # vmB.dumpFile('Vb.dat', False) ts = np.linspace(0, simtime, len(gNMDA)) pylab.plot(ts, pulse) pylab.plot(ts, np.asarray(gNMDA) * 1e9, label='gNMDA') pylab.show() np.savetxt('../data/two_comp_nmda.plot', np.transpose(np.vstack((ts, vmB, gNMDA))))
def setupCurrentStepModel(testId, celltype, pulsearray, dt): """Setup a single cell simulation. simid - integer identifying the model celltype - str cell type pulsearray - an nx3 array with row[i] = (delay[i], width[i], level[i]) of current injection. """ modelContainer = moose.Neutral('/test%d' % (testId)) dataContainer = moose.Neutral('/data%d' % (testId)) cell = TCR('%s/TCR' % (modelContainer.path)) # moose.copy(cells.TCR.prototype, modelContainer.path)# pulsegen = moose.PulseGen('%s/pulse' % (modelContainer.path)) pulsegen.count = len(pulsearray) for ii in range(len(pulsearray)): pulsegen.delay[ii] = pulsearray[ii][0] pulsegen.width[ii] = pulsearray[ii][1] pulsegen.level[ii] = pulsearray[ii][2] moose.connect(pulsegen, 'output', cell.soma, 'injectMsg') somaVm = moose.Table('%s/vm' % (dataContainer.path)) moose.connect(somaVm, 'requestOut', cell.soma, 'getVm') pulseTable = moose.Table('%s/pulse' % (dataContainer.path)) moose.connect(pulseTable, 'requestOut', pulsegen, 'getOutputValue') setupClocks(dt) moose.useClock(0, '%s/##[ISA=Compartment]' % (cell.path), 'init') moose.useClock(1, '%s/##[ISA=Compartment]' % (cell.path), 'process') moose.useClock(7, pulsegen.path, 'process') moose.useClock(8, '%s/##' % (dataContainer.path), 'process') return {'cell': cell, 'stimulus': pulsegen, 'vmTable': somaVm, 'stimTable': pulseTable }
def _init_plots(self): ## make a few tables to store a few Vm-s numVms = 10 self.plots = moose.Table('/plotVms', numVms) ## draw numVms out of N neurons # not using random.sample() here since Brian version isn't #nrnIdxs = random.sample(range(self.N),numVms) nrnIdxs = list(range(self.N)) for i in range(numVms): moose.connect( self.network.vec[nrnIdxs[i]], 'VmOut', \ self.plots.vec[i], 'input') ## make self.N tables to store spikes of all neurons self.spikes = moose.Table('/plotSpikes', self.N) moose.connect( self.network, 'spikeOut', \ self.spikes, 'input', 'OneToOne' ) ## make 2 tables to store spikes of all exc and all inh neurons self.spikesExc = moose.Table('/plotSpikesAllExc') for i in range(self.NmaxExc): moose.connect( self.network.vec[i], 'spikeOut', \ self.spikesExc, 'input' ) self.spikesInh = moose.Table('/plotSpikesAllInh') for i in range(self.NmaxExc, self.N): moose.connect( self.network.vec[i], 'spikeOut', \ self.spikesInh, 'input' )
def setup_experiment(presynaptic, postsynaptic, synchan): """Setup step current stimulation of presynaptic neuron. Also setup recording of pre and postsynaptic Vm, Gk of synchan. """ pulse = moose.PulseGen('/model/pulse') pulse.level[0] = 1e-9 pulse.delay[0] = 0.02 # disable the pulsegen pulse.width[0] = 40e-3 pulse.delay[1] = 1e9 moose.connect(pulse, 'output', presynaptic, 'injectMsg') data = moose.Neutral('/data') vm_a = moose.Table('/data/Vm_pre') moose.connect(vm_a, 'requestOut', presynaptic, 'getVm') vm_b = moose.Table('/data/Vm_post') moose.connect(vm_b, 'requestOut', postsynaptic, 'getVm') gksyn_b = moose.Table('/data/Gk_syn') moose.connect(gksyn_b, 'requestOut', synchan, 'getGk') pulsetable = moose.Table('/data/pulse') pulsetable.connect('requestOut', pulse, 'getOutputValue') return { 'stimulus': pulsetable, 'Vm_pre': vm_a, 'Vm_post': vm_b, 'Gk_syn': gksyn_b }
def single_population(size=2): """Example of a single population where each cell is connected to every other cell. Creates a network of single compartmental cells under /network1 and a pulse generaor """ net = moose.Neutral('network1') pop = create_population(moose.Neutral('/network1'), size) make_synapses(pop['spikegen'], pop['synchan']) pulse = moose.PulseGen('/network1/net1_pulse') pulse.firstLevel = 1e-9 pulse.firstDelay = 0.05 pulse.firstWidth = 0.02 moose.connect(pulse, 'output', pop['compartment'][0], 'injectMsg') data = moose.Neutral('/data') vm = [moose.Table('/data/net1_Vm_%d' % (ii)) for ii in range(size)] for tab, comp in zip(vm, pop['compartment']): moose.connect(tab, 'requestOut', comp, 'getVm') gksyn = [moose.Table('/data/net1_Gk_syn_%d' % (ii)) for ii in range(size)] for tab, synchan in zip(gksyn, pop['synchan']): moose.connect(tab, 'requestOut', synchan, 'getGk') pulsetable = moose.Table('/data/net1_pulse') pulsetable.connect('requestOut', pulse, 'getOutputValue') return { 'vm': vm, 'gksyn': gksyn, 'pulse': pulsetable, }
def current_step_test(simtime, simdt, plotdt): """Create a single compartment and set it up for applying a step current injection. We use a PulseGen object to generate a 40 ms wide 1 nA current pulse that starts 20 ms after start of simulation. """ model = moose.Neutral('/model') comp = create_1comp_neuron('/model/neuron') stim = moose.PulseGen('/model/stimulus') stim.delay[0] = 20e-3 stim.level[0] = 1e-9 stim.width[0] = 40e-3 stim.delay[1] = 1e9 moose.connect(stim, 'output', comp, 'injectMsg') data = moose.Neutral('/data') current_tab = moose.Table('/data/current') moose.connect(current_tab, 'requestOut', stim, 'getOutputValue') vm_tab = moose.Table('/data/Vm') moose.connect(vm_tab, 'requestOut', comp, 'getVm') for i in range(10): moose.setClock(i, simdt) moose.setClock(8, plotdt) moose.reinit() moose.start(simtime) ts = np.linspace(0, simtime, len(vm_tab.vector)) return ts, current_tab.vector, vm_tab.vector,
def test_nml2(nogui=True): global SCRIPT_DIR filename = os.path.join(SCRIPT_DIR, 'test_files/passiveCell.nml') mu.info('Loading: %s' % filename) nml = moose.mooseReadNML2(filename) if not nml: mu.warn("Failed to parse NML2 file") return assert nml, "Expecting NML2 object" msoma = nml.getComp(nml.doc.networks[0].populations[0].id, 0, 0) data = moose.Neutral('/data') pg = nml.getInput('pulseGen1') inj = moose.Table('%s/pulse' % (data.path)) moose.connect(inj, 'requestOut', pg, 'getOutputValue') vm = moose.Table('%s/Vm' % (data.path)) moose.connect(vm, 'requestOut', msoma, 'getVm') simtime = 150e-3 moose.reinit() moose.start(simtime) print("Finished simulation!") yvec = vm.vector injvec = inj.vector * 1e12 m1, u1 = np.mean(yvec), np.std(yvec) m2, u2 = np.mean(injvec), np.std(injvec) assert np.isclose(m1, -0.0456943), m1 assert np.isclose(u1, 0.0121968), u1 assert np.isclose(m2, 26.64890), m2 assert np.isclose(u2, 37.70607574), u2
def setup_recording(data_path, neuron, syninfo_list): """Record Vm from soma and synaptic conductances from synapses in syninfo_list """ neuron_path = neuron.path data_container = moose.Neutral(data_path) soma_vm = moose.Table('%s/Vm_soma' % (data_path)) soma_path = '%s/soma_1' % (neuron_path) print('5555 Soma path', soma_path) soma = moose.element(soma_path) moose.connect(soma_vm, 'requestOut', soma, 'getVm') ampa_data = moose.Neutral('%s/G_AMPA' % (data_path)) nmda_data = moose.Neutral('%s/G_NMDA' % (data_path)) ampa_gk = [] nmda_gk = [] # Record synaptic conductances for syninfo in syninfo_list: compname = syninfo['spike'].parent.name tab = moose.Table('%s/Gk_nmda_%s' % (nmda_data.path, compname)) moose.connect(tab, 'requestOut', syninfo['nmda'], 'getGk') nmda_gk.append(tab) tab = moose.Table('%s/Gk_ampa_%s' % (ampa_data.path, compname)) moose.connect(tab, 'requestOut', syninfo['ampa'], 'getGk') ampa_gk.append(tab) return { 'ampa_gk': ampa_gk, 'nmda_gk': nmda_gk, 'soma_vm': soma_vm, 'data': data_container }
def create_network(size=2): """ Create a network containing two neuronal populations, pop_A and pop_B and connect them up. """ net = moose.Neutral('network') pop_a = create_population(moose.Neutral('/network/pop_A'), size) print(pop_a) pop_b = create_population(moose.Neutral('/network/pop_B'), size) make_synapses(pop_a['spikegen'], pop_b['synhandler']) pulse = moose.PulseGen('pulse') pulse.level[0] = 1e-9 pulse.delay[0] = 0.02 # disable the pulsegen pulse.width[0] = 40e-3 pulse.delay[1] = 1e9 data = moose.Neutral('/data') vm_a = moose.Table('/data/Vm_A', n=size) moose.connect(pulse, 'output', pop_a['compartment'], 'injectMsg', 'OneToAll') moose.connect(vm_a, 'requestOut', pop_a['compartment'], 'getVm', 'OneToOne') vm_b = moose.Table('/data/Vm_B', size) moose.connect(vm_b, 'requestOut', pop_b['compartment'], 'getVm', 'OneToOne') gksyn_b = moose.Table('/data/Gk_syn_b', n=size) moose.connect(gksyn_b, 'requestOut', pop_b['synchan'], 'getGk', 'OneToOne') pulsetable = moose.Table('/data/pulse') pulsetable.connect('requestOut', pulse, 'getOutputValue') return {'A': pop_a, 'B': pop_b, 'Vm_A': vm_a, 'Vm_B': vm_b, 'Gsyn_B': gksyn_b }
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 loadAndRun(solver=True): simtime = 500e-3 model = moose.loadModel('../data/h10.CNG.swc', '/cell') comp = moose.element('/cell/apical_e_177_0') soma = moose.element('/cell/soma') for i in range(10): moose.setClock(i, dt) if solver: solver = moose.HSolve('/cell/solver') solver.target = soma.path solver.dt = dt stim = moose.PulseGen('/cell/stim') stim.delay[0] = 50e-3 stim.delay[1] = 1e9 stim.level[0] = 1e-9 stim.width[0] = 2e-3 moose.connect(stim, 'output', comp, 'injectMsg') tab = moose.Table('/cell/Vm') moose.connect(tab, 'requestOut', comp, 'getVm') tab_soma = moose.Table('/cell/Vm_soma') moose.connect(tab_soma, 'requestOut', soma, 'getVm') moose.reinit() print('[INFO] Running for %s' % simtime) moose.start(simtime ) vec = tab_soma.vector moose.delete( '/cell' ) return vec
def test_synintegration(filename, target_cell, source_type): sim = Simulation('synintegration') cell = SpinyStellate(SpinyStellate.prototype, sim.model.path + '/SpinyStellate') vm_table = cell.comp[cell.presyn].insertRecorder('Vm', 'Vm', sim.data) # Create a common spike gen object sp = moose.SpikeGen('spike', sim.model) sp.threshold = 0.0 sp.edgeTriggered = 1 sptab = moose.Table('spike', sim.data) sptab.stepMode = 3 sptab.connect('inputRequest', sp, 'state') (comp_indices, syntype, gbar, tau1, tau2, Ek, ) = \ get_syninfo(filename, target_cell, source_type) # Set up the synapses for ii in range(len(comp_indices)): print '%d\t%s\t%g\t%g\t%g\t%g' % (comp_indices[ii], syntype[ii], gbar[ii], tau1[ii], tau2[ii], Ek[ii]) comp = cell.comp[comp_indices[ii]] weight = 1.0 if syntype[ii] == 'nmda': chan = moose.NMDAChan('nmda_from_%s' % (source_type), comp) chan.MgConc = 1.5 weight = gbar[ii] else: chan = moose.SynChan('%s_from_%s' % (syntype[ii], source_type), comp) chan.Gbar = gbar[ii] chan.tau1 = tau1[ii] chan.tau2 = tau2[ii] chan.Ek = Ek[ii] comp.connect('channel', chan, 'channel') sp.connect('event', chan, 'synapse') count = chan.numSynapses if source_type == 'TCR': chan.delay[count-1] = 1e-3 # thalamocortical delay else: chan.delay[count-1] = 0.05e-3 # default delay chan.weight[count-1] = weight gktable = moose.Table('%s_%s_%s' % (cell.name, comp.name, chan.name), sim.data) gktable.stepMode = 3 gktable.connect('inputRequest', chan, 'Gk') pulsegen = moose.PulseGen('pulse', sim.model) pulsegen.firstDelay = 3.0 pulsegen.firstLevel = 1.0 pulsegen.firstWidth = 1e-3 pulsegen.trigMode = moose.FREE_RUN pulsegen.connect('outputSrc', sp, 'Vm') ptable = moose.Table('pulse', sim.data) ptable.stepMode = 3 ptable.connect('inputRequest', pulsegen, 'output') sim.schedule(simdt=1e-6, plotdt=1e-6) sim.run(10.0) sim.save_data_h5(filename.replace('network_', 'synintegration_'))
def analogStimTable(): """Example of using a StimulusTable as an analog signal source in a reaction system. It could be used similarly to give other analog inputs to a model, such as a current or voltage clamp signal. This demo creates a StimulusTable and assigns it half a sine wave. Then we assign the start time and period over which to emit the wave. The output of the StimTable is sent to a pool **a**, which participates in a trivial reaction:: table ----> a <===> b The output of **a** and **b** are recorded in a regular table for plotting. """ simtime = 150 simdt = 0.1 model = moose.Neutral('/model') data = moose.Neutral('/data') # This is the stimulus generator stimtable = moose.StimulusTable('/model/stim') a = moose.BufPool( '/model/a' ) b = moose.Pool( '/model/b' ) reac = moose.Reac( '/model/reac' ) reac.Kf = 0.1 reac.Kb = 0.1 moose.connect( stimtable, 'output', a, 'setConcInit' ) moose.connect( reac, 'sub', a, 'reac' ) moose.connect( reac, 'prd', b, 'reac' ) aPlot = moose.Table('/data/aPlot') moose.connect(aPlot, 'requestOut', a, 'getConc') bPlot = moose.Table('/data/bPlot') moose.connect(bPlot, 'requestOut', b, 'getConc') moose.setClock( stimtable.tick, simdt ) moose.setClock( a.tick, simdt ) moose.setClock( aPlot.tick, simdt ) #################################################### # Here we set up the stimulus table. It is half a sine-wave. stim = [ np.sin(0.01 * float(i) ) for i in range( 314 )] stimtable.vector = stim stimtable.stepSize = 0 # This forces use of current time as x value # The table will interpolate its contents over the time start to stop: # At values less than startTime, it emits the first value in table stimtable.startTime = 5 # At values more than stopTime, it emits the last value in table stimtable.stopTime = 60 stimtable.doLoop = 1 # Enable repeat playbacks. stimtable.loopTime = 10 + simtime / 2.0 # Repeat playback over this time moose.reinit() moose.start(simtime) t = [ x * simdt for x in range( len( aPlot.vector ) )] pylab.plot( t, aPlot.vector, label='Stimulus waveform' ) pylab.plot( t, bPlot.vector, label='Reaction product b' ) pylab.legend() pylab.show()
def timetable_demo(): tt_array, sp_array = timetable_nparray() tt_file, sp_file = timetable_file() # Create a synchan inside a compartment to demonstrate how to use # TimeTable to send artificial spike events to a synapse. comp = moose.Compartment('/model/comp') comp.Em = -60e-3 comp.Rm = 1e9 comp.Cm = 1e-12 synchan = moose.SynChan('/model/comp/synchan') synchan.Gbar = 1e-6 synchan.Ek = 0.0 moose.connect(synchan, 'channel', comp, 'channel') synh = moose.SimpleSynHandler('/model/comp/synchan/synh') moose.connect(synh, 'activationOut', synchan, 'activation') synh.synapse.num = 1 moose.connect(tt_file, 'eventOut', moose.element(synh.path + '/synapse'), 'addSpike') # Data recording: record the `state` of the time table filled # using array. data = moose.Neutral('/data') tab_array = moose.Table('/data/tab_array') moose.connect(tab_array, 'requestOut', tt_array, 'getState') # Record the synaptic conductance for the other time table, which # is filled from a text file and sends spike events to a synchan. tab_file = moose.Table('/data/tab_file') moose.connect(tab_file, 'requestOut', synchan, 'getGk') # Scheduling moose.setClock(0, simdt) moose.setClock(1, simdt) moose.useClock(1, '/model/##[ISA=Compartment]', 'init') moose.useClock(1, '/model/##,/data/##', 'process') moose.reinit() moose.start(simtime) # Plotting pylab.subplot(2, 1, 1) pylab.plot(sp_array, np.ones(len(sp_array)), 'rx', label='spike times from numpy array') pylab.plot(np.linspace(0, simtime, len(tab_array.vector)), tab_array.vector, 'b-', label='TimeTable state') pylab.legend() pylab.subplot(2, 1, 2) pylab.plot(sp_file, np.ones(len(sp_file)), 'rx', label='spike times from file') pylab.plot(np.linspace(0, simtime, len(tab_file.vector)), tab_file.vector * 1e6, 'b-', label='Syn Gk (uS)') pylab.legend() pylab.show()
def run(nogui): reader = NML2Reader(verbose=True) filename = 'test_files/passiveCell.nml' print('Loading: %s' % filename) reader.read(filename) msoma = reader.getComp(reader.doc.networks[0].populations[0].id, 0, 0) print(msoma) data = moose.Neutral('/data') pg = reader.getInput('pulseGen1') inj = moose.Table('%s/pulse' % (data.path)) moose.connect(inj, 'requestOut', pg, 'getOutputValue') vm = moose.Table('%s/Vm' % (data.path)) moose.connect(vm, 'requestOut', msoma, 'getVm') simdt = 1e-6 plotdt = 1e-4 simtime = 150e-3 if (1): #moose.showmsg( '/clock' ) for i in range(8): moose.setClock(i, simdt) moose.setClock(8, plotdt) moose.reinit() else: utils.resetSim([model.path, data.path], simdt, plotdt, simmethod='ee') moose.showmsg('/clock') moose.start(simtime) print("Finished simulation!") t = np.linspace(0, simtime, len(vm.vector)) if not nogui: import matplotlib.pyplot as plt plt.subplot(211) plt.plot(t, vm.vector * 1e3, label='Vm (mV)') plt.legend() plt.title('Vm') plt.subplot(212) plt.title('Input') plt.plot(t, inj.vector * 1e9, label='injected (nA)') #plt.plot(t, gK.vector * 1e6, label='K') #plt.plot(t, gNa.vector * 1e6, label='Na') plt.legend() plt.show() plt.close()
def setup_two_cells(): """ Create two cells with leaky integrate and fire compartments. Each cell is a single compartment a1 and b2. a1 is stimulated by a step current injection. The compartment a1 is connected to the compartment b2 through a synaptic channel. """ model = moose.Neutral('/model') data = moose.Neutral('/data') a1 = LIFComp('/model/a1') b2 = LIFComp(moose.copy(a1, '/model', 'b2')) a1.Vthreshold = 10e-3 a1.Vreset = 0 b2.Vthreshold = 10e-3 b2.Vreset = 0 syn = moose.SynChan('%s/syn' % (b2.path)) syn.tau1 = 1e-3 syn.tau2 = 5e-3 syn.Ek = 90e-3 synh = moose.SimpleSynHandler(syn.path + '/synh') moose.connect(synh, 'activationOut', syn, 'activation') synh.synapse.num += 1 # syn.numSynapses = 1 synh.synapse.delay = delayMax moose.connect(b2, 'channel', syn, 'channel') ## Single message works most of the time but occassionally gives a ## core dump # m = moose.connect(a1.spikegen, 'spikeOut', # syn.synapse.vec, 'addSpike') ## With Sparse message and random connectivity I did not get core ## dump. m = moose.connect(a1.spikegen, 'spikeOut', synh.synapse.vec, 'addSpike', 'Sparse') m.setRandomConnectivity(1.0, 1) stim = moose.PulseGen('/model/stim') stim.delay[0] = 100e-3 stim.width[0] = 1e3 stim.level[0] = 11e-9 moose.connect(stim, 'output', a1, 'injectMsg') tables = [] 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) synh.synapse[0].delay = 1e-3 syn.Gbar = 1e-6 return tables
def graphtables(model, neuron,pltcurr,curmsg, plas=[],compartments='all'): print("GRAPH TABLES, of ", neuron.keys(), "plas=",len(plas),"curr=",pltcurr) #tables for Vm and calcium in each compartment vmtab={} catab={key:[] for key in neuron.keys()} currtab={} # Make sure /data exists if not moose.exists(DATA_NAME): moose.Neutral(DATA_NAME) for typenum,neur_type in enumerate(neuron.keys()): if type(compartments)==str and compartments in {'all', '*'}: neur_comps = moose.wildcardFind(neur_type + '/#[TYPE=Compartment]') else: neur_comps=[moose.element(neur_type+'/'+comp) for comp in compartments] vmtab[neur_type] = [moose.Table(vm_table_path(neur_type, comp=ii)) for ii in range(len(neur_comps))] for ii,comp in enumerate(neur_comps): moose.connect(vmtab[neur_type][ii], 'requestOut', comp, 'getVm') if model.calYN: for ii,comp in enumerate(neur_comps): for child in comp.children: if child.className in {"CaConc", "ZombieCaConc"}: catab[neur_type].append(moose.Table(DATA_NAME+'/%s_%d_' % (neur_type,ii)+child.name)) cal = moose.element(comp.path+'/'+child.name) moose.connect(catab[neur_type][-1], 'requestOut', cal, 'getCa') elif child.className == 'DifShell': catab[neur_type].append(moose.Table(DATA_NAME+'/%s_%d_' % (neur_type,ii)+child.name)) cal = moose.element(comp.path+'/'+child.name) moose.connect(catab[neur_type][-1], 'requestOut', cal, 'getC') if pltcurr: currtab[neur_type]={} #CHANNEL CURRENTS (Optional) for channame in model.Channels: tabs = [moose.Table(DATA_NAME+'/chan%s%s_%d' %(channame,neur_type,ii)) for ii in range(len(neur_comps))] currtab[neur_type][channame] = tabs for tab, comp in zip(tabs, neur_comps): path = comp.path+'/'+channame try: chan=moose.element(path) moose.connect(tab, 'requestOut', chan, curmsg) except Exception: log.debug('no channel {}', path) # # synaptic weight and plasticity (Optional) for one synapse per neuron plastab={key:[] for key in neuron.keys()} if len(plas): for num,neur_type in enumerate(plas.keys()): if len(plas[neur_type]): for comp_name in plas[neur_type]: plastab[neur_type].append(add_one_table(DATA_NAME,plas[neur_type],comp_name)) return vmtab,catab,plastab,currtab
def setup_stimulation(comp): stim = moose.PulseGen('/model/stimulus') stim.delay[0], stim.level[0] = 20e-3, 1e-9 #Start injection ar 20ms, with 1nanoAmp. stim.width[0], stim.delay[1] = 40e-3, 1e9 #Duration of current is 40ms. moose.connect(stim, 'output', comp, 'injectMsg') data = moose.Neutral('/data') current_tab = moose.Table('/data/current') moose.connect(current_tab, 'requestOut', stim, 'getOutputValue') vm_tab = moose.Table('/data/Vm') moose.connect(vm_tab, 'requestOut', comp, 'getVm') return (current_tab, vm_tab)
def test_hsolve_calcium(): for tick in range(0, 7): moose.setClock(tick, 10e-6) moose.setClock(8, 0.005) lib = moose.Neutral('/library') model = moose.loadModel(p_file, 'neuron') assert model, model pulse = moose.PulseGen('/neuron/pulse') inject = 100e-10 chan_proto.chan_proto('/library/SK', param_chan.SK) chan_proto.chan_proto('/library/CaL12', param_chan.Cal) pulse.delay[0] = 8. pulse.width[0] = 500e-12 pulse.level[0] = inject pulse.delay[1] = 1e9 for comp in moose.wildcardFind('/neuron/#[TYPE=Compartment]'): new_comp = moose.element(comp) new_comp.initVm = -.08 difs, difb = td.add_difshells_and_buffers(new_comp, difshell_no, difbuf_no) for name in cond: chan = td.addOneChan(name, cond[name], new_comp) if 'Ca' in name: moose.connect(chan, "IkOut", difs[0], "influx") if 'SK' in name: moose.connect(difs[0], 'concentrationOut', chan, 'concen') data = moose.Neutral('/data') vmtab = moose.Table('/data/Vm') shelltab = moose.Table('/data/Ca') caltab = moose.Table('/data/CaL_Gk') sktab = moose.Table('/data/SK_Gk') moose.connect(vmtab, 'requestOut', moose.element('/neuron/soma'), 'getVm') moose.connect(shelltab, 'requestOut', difs[0], 'getC') moose.connect(caltab, 'requestOut', moose.element('/neuron/soma/CaL12'), 'getGk') moose.connect(sktab, 'requestOut', moose.element('/neuron/soma/SK'), 'getGk') hsolve = moose.HSolve('/neuron/hsolve') hsolve.dt = 10e-6 hsolve.target = ('/neuron/soma') t_stop = 10. moose.reinit() moose.start(t_stop) vec1 = sktab.vector vec2 = shelltab.vector assert_stat(vec1, [0.0, 5.102834e-22, 4.79066e-22, 2.08408e-23]) assert_stat(vec2, [5.0e-5, 5.075007e-5, 5.036985e-5, 2.1950117e-7]) assert len(np.where(sktab.vector < 1e-19)[0]) == 2001 assert len(np.where(shelltab.vector > 50e-6)[0]) == 2000
def syn_plastabs(connections, model, plas=[]): synapse_msg = model.param_sim.plot_synapse_message if not moose.exists(DATA_NAME): moose.Neutral(DATA_NAME) # dictionary of tables with synaptic conductance for all synapses that receive input syn_tabs = {ntype: {k: [] for nname in connections[ntype].keys() for k in list(connections[ntype][nname].keys()) if k != 'postsoma_loc'} for ntype in connections.keys()} if model.plasYN: plas_tabs = { ntype: {k: [] for nname in connections[ntype].keys() for k in list(connections[ntype][nname].keys()) if k != 'postsoma_loc'} for ntype in connections.keys()} else: plas_tabs = [] if getattr(model, 'stpYN', False): stp_tabs = { ntype: {k: [] for nname in connections[ntype].keys() for k in list(connections[ntype][nname].keys()) if k != 'postsoma_loc'} for ntype in connections.keys()} else: stp_tabs = [] for neur_type in connections.keys(): for neur_name in connections[neur_type].keys(): for syntype in list(syn_tabs[neur_type].keys()): for precomp in connections[neur_type][neur_name][syntype].keys(): if 'extern' in precomp: for comp in connections[neur_type][neur_name][syntype][precomp].keys(): synchan = moose.element(neur_name + '/' + comp + '/' + syntype) # print ('##### syn_plastabs',synchan.path,'/'+neur_name.split('/')[-1]+'-'+precomp,comp) syn_tabs[neur_type][syntype].append(moose.Table(DATA_NAME + '/%s' % ( neur_name.split('/')[-1] + '-' + precomp + CONNECT_SEPARATOR + comp.replace('/', '-')))) log.debug('{} {} {} {} {}', neur_name, syntype, synchan.path, precomp, syn_tabs[neur_type][syntype][-1]) moose.connect(syn_tabs[neur_type][syntype][-1], 'requestOut', synchan, 'getGk') if getattr(model, 'stpYN', False): create_plas_tabs(synchan, syn_tabs[neur_type][syntype][-1].name, stp_tabs[neur_type][syntype], ['fac', 'dep', 'stp']) if model.plasYN: create_plas_tabs(synchan, syn_tabs[neur_type][syntype][-1].name, plas_tabs[neur_type][syntype], ['plas']) else: synchan = moose.element(neur_name + '/' + precomp.split(CONNECT_SEPARATOR)[-1] + '/' + syntype) # print ('###########',synchan.path,'/'+neur_name.split('/')[-1]+'-'+precomp) syn_tabs[neur_type][syntype].append( moose.Table(DATA_NAME + '/%s' % (neur_name.split('/')[-1] + '-' + precomp))) log.debug('neur={} syn={} {} comp={} tab={}', neur_name, syntype, synchan.path, precomp, syn_tabs[neur_type][syntype][-1], ) moose.connect(syn_tabs[neur_type][syntype][-1], 'requestOut', synchan, synapse_message) if getattr(model, 'stpYN', False): create_stp_tabs(synchan, syn_tabs[neur_type][syntype][-1].name, stp_tabs[neur_type][syntype], ['fac', 'dep', 'stp']) if model.plasYN: create_plas_tabs(synchan, syn_tabs[neur_type][syntype][-1].name, plas_tabs[neur_type][syntype], ['plas']) return syn_tabs, plas_tabs, stp_tabs
def setup_data_recording(neuron, pulse, synapse, spikegen): data = moose.Neutral('/data') vm_table = moose.Table('/data/Vm') moose.connect(vm_table, 'requestOut', neuron, 'getVm') inject_table = moose.Table('/data/Inject') 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]
def make_model(): sinePeriod = 50 maxFiringRate = 10 refractT = 0.05 for i in range(20): moose.setClock(i, dt) ############### Create objects ############### stim = moose.StimulusTable('stim') spike = moose.RandSpike('spike') syn = moose.SimpleSynHandler('syn') fire = moose.IntFire('fire') stats1 = moose.SpikeStats('stats1') stats2 = moose.Stats('stats2') plots = moose.Table('plots') plot1 = moose.Table('plot1') plot2 = moose.Table('plot2') plotf = moose.Table('plotf') ############### Set up parameters ############### stim.vector = [ maxFiringRate * numpy.sin(x * 2 * numpy.pi / sinePeriod) for x in range(sinePeriod) ] stim.startTime = 0 stim.stopTime = sinePeriod stim.loopTime = sinePeriod stim.stepSize = 0 stim.stepPosition = 0 stim.doLoop = 1 spike.refractT = refractT syn.synapse.num = 1 syn.synapse[0].weight = 1 syn.synapse[0].delay = 0 fire.thresh = 100 # Don't want it to spike, just to integrate fire.tau = 1.0 / maxFiringRate stats1.windowLength = int(1 / dt) stats2.windowLength = int(1 / dt) ############### Connect up circuit ############### moose.connect(stim, 'output', spike, 'setRate') moose.connect(spike, 'spikeOut', syn.synapse[0], 'addSpike') moose.connect(spike, 'spikeOut', stats1, 'addSpike') moose.connect(syn, 'activationOut', fire, 'activation') moose.connect(stats2, 'requestOut', fire, 'getVm') moose.connect(plots, 'requestOut', stim, 'getOutputValue') moose.connect(plot1, 'requestOut', stats1, 'getWmean') moose.connect(plot2, 'requestOut', stats2, 'getWmean') moose.connect(plotf, 'requestOut', fire, 'getVm')
def setUp(self): self.testId = uuid.uuid4().int self.container = moose.Neutral('test%d' % (self.testId)) self.model = moose.Neutral('%s/model' % (self.container.path)) self.data = moose.Neutral('%s/data' % (self.container.path)) self.soma = create_compartment('%s/soma' % (self.model.path), **compartment_propeties) self.tables = {} tab = moose.Table('%s/Vm' % (self.data.path)) self.tables['Vm'] = tab moose.connect(tab, 'requestOut', self.soma, 'getVm') for channelname, conductance in channel_density.items(): chanclass = eval(channelname) channel = insert_channel(self.soma, chanclass, conductance, density=True) if issubclass(chanclass, KChannel): channel.Ek = erev['K'] elif issubclass(chanclass, NaChannel): channel.Ek = erev['Na'] elif issubclass(chanclass, CaChannel): channel.Ek = erev['Ca'] elif issubclass(chanclass, AR): channel.Ek = erev['AR'] tab = moose.Table('%s/%s' % (self.data.path, channelname)) moose.connect(tab, 'requestOut', channel, 'getGk') self.tables['Gk_' + channel.name] = tab archan = moose.HHChannel(self.soma.path + '/AR') archan.X = 0.0 ca = insert_ca(self.soma, 2.6e7, 50e-3) tab = moose.Table('%s/Ca' % (self.data.path)) self.tables['Ca'] = tab moose.connect(tab, 'requestOut', ca, 'getCa') self.pulsegen = moose.PulseGen('%s/inject' % (self.model.path)) moose.connect(self.pulsegen, 'output', self.soma, 'injectMsg') tab = moose.Table('%s/injection' % (self.data.path)) moose.connect(tab, 'requestOut', self.pulsegen, 'getOutputValue') self.tables['pulsegen'] = tab self.pulsegen.count = len(stimulus) for ii in range(len(stimulus)): self.pulsegen.delay[ii] = stimulus[ii][0] self.pulsegen.width[ii] = stimulus[ii][1] self.pulsegen.level[ii] = stimulus[ii][2] setup_clocks(simdt, plotdt) assign_clocks(self.model, self.data) moose.reinit() start = datetime.now() moose.start(simtime) end = datetime.now() delta = end - start print 'Simulation of %g s finished in %g s' % ( simtime, delta.seconds + delta.microseconds * 1e-6)
def run(self, key): try: Vm = self.Vm_tables[key] u = self.u_tables[key] except KeyError, e: Vm = moose.Table(self.data_container.path + '/' + key + '_Vm') nrn = self.neurons[key] moose.connect(Vm, 'requestOut', nrn, 'getVm') utable = moose.Table(self.data_container.path + '/' + key + '_u') utable.connect('requestOut', self.neurons[key], 'getU') self.Vm_tables[key] = Vm self.u_tables[key] = utable
def setup_current_step_model(model_container, data_container, celltype, pulsearray): """Setup a single cell simulation. model_container: element to hold the model data_container: element to hold data celltype: str - cell type pulsearray: nx3 array - with row[i] = (delay[i], width[i], level[i]) of current injection. simdt: float - simulation time step plotdt: float - sampling interval for plotting solver: str - numerical method to use, can be `hsolve` or `ee` """ cell_class = eval('cells.%s' % (celltype)) cell = cell_class('%s/%s' % (model_container.path, celltype)) print '111111', cell.path pulsegen = moose.PulseGen('%s/pulse' % (model_container.path)) print '121221211', pulsegen.path pulsegen.count = len(pulsearray) print '7777777', pulsegen.count, pulsegen.id_ for ii in range(len(pulsearray)): print '999999', pulsegen.id_, pulsegen.count print '-', pulsegen.delay[ii] pulsegen.delay[ii] = pulsearray[ii][0] pulsegen.width[ii] = pulsearray[ii][1] pulsegen.level[ii] = pulsearray[ii][2] print '8888888', ii, pulsegen.delay[ii] moose.connect(pulsegen, 'outputOut', cell.soma, 'injectMsg') print '22222' presyn_vm = moose.Table('%s/presynVm' % (data_container.path)) print '33333' soma_vm = moose.Table('%s/somaVm' % (data_container.path)) print '44444' moose.connect(presyn_vm, 'requestData', cell.presynaptic, 'get_Vm') moose.connect(soma_vm, 'requestData', cell.soma, 'get_Vm') pulse_table = moose.Table('%s/injectCurrent' % (data_container.path)) moose.connect(pulse_table, 'requestData', pulsegen, 'get_output') print '55555' return {'cell': cell, 'stimulus': pulsegen, 'presynVm': presyn_vm, 'somaVm': soma_vm, 'injectionCurrent': pulse_table, }
def createDataTables(compname, data_hierarchy, pulsename): # Create a new path using string manipulation to be used in the creation # of a unique data table for each compartment comp_path = compname.path.split('/')[-1] comp_path = comp_path.strip(']') comp_path = comp_path.replace('[', '') # Create the unique membrane potential table and connect this to the compartment Vmtab = moose.Table(data_hierarchy.path + '/' + comp_path + '_Vm') moose.connect(Vmtab, 'requestOut', compname, 'getVm') # Create the unique external current table and connect this to the compartment current_tab = moose.Table(data_hierarchy.path + '/' + comp_path + '_Iex') moose.connect(current_tab, 'requestOut', pulsename, 'getOutputValue') return Vmtab, current_tab
def add_one_table(DATA_NAME, plas_entry, comp_name): if comp_name.find('/') == 0: comp_name = comp_name[1:] plastab = moose.Table(DATA_NAME + '/plas' + comp_name) plasCumtab = moose.Table(DATA_NAME + '/cum' + comp_name) syntab = moose.Table(DATA_NAME + '/syn' + comp_name) print(plas_entry) moose.connect(plastab, 'requestOut', plas_entry['plas'], 'getValue') moose.connect(plasCumtab, 'requestOut', plas_entry['cum'], 'getValue') shname = plas_entry['syn'].path + '/SH' sh = moose.element(shname) moose.connect(syntab, 'requestOut', sh.synapse[0], 'getWeight') return {'plas': plastab, 'cum': plasCumtab, 'syn': syntab}