def test_net_injection(calcium, synapses, spines, single, ghk, plasticity): "Create the neuron and run a very short simulation" # pytest.skip("skipping network tests") if ghk and not hasattr(moose, 'GHK'): pytest.skip("GHK is missing") if spines and not single: pytest.skip("spines are too much with multiple neurons") d1d2.calYN = bool(calcium) d1d2.plasYN = bool(plasticity) d1d2.ghkYN = bool(ghk) d1d2.spineYN = bool(spines) d1d2.synYN = bool(synapses) str_net.single = bool(single) MSNsyn, neurons = cell_proto.neuronclasses(d1d2) population, connection, plas = create_network.create_network( d1d2, str_net, neurons) pg = inject_func.setupinj(d1d2, 0.02, 0.01, population['pop']) pg.firstLevel = 1e-9 data = moose.Neutral('/data') vmtab, catab, plastab, currtab = tables.graphtables( d1d2, neurons, False, 'getGk') moose.reinit() moose.start(0.05) vm1 = vmtab[0][0].vector vm2 = vmtab[1][0].vector # Quick sanity check that the values are not outlandish. # We do not check at the beginning because of the initial fluctuation. assert -0.01 < vm1[250] < 0.05 assert -0.01 < vm2[250] < 0.05 assert -0.01 < vm1[499] < 0.05 assert -0.01 < vm2[499] < 0.05 return vm1, vm2
def test_net_injection(calcium, synapses, spines, single, ghk, plasticity): "Create the neuron and run a very short simulation" #pytest.skip("skipping network tests") if ghk and not hasattr(moose, 'GHK'): pytest.skip("GHK is missing") if spines and not single: pytest.skip("spines are too much with multiple neurons") d1d2.calYN = bool(calcium) d1d2.plasYN = bool(plasticity) d1d2.ghkYN = bool(ghk) d1d2.spineYN = bool(spines) d1d2.synYN = bool(synapses) str_net.single = bool(single) MSNsyn, neurons = cell_proto.neuronclasses(d1d2) population,connection, plas = create_network.create_network(d1d2, str_net, neurons) pg = inject_func.setupinj(d1d2, 0.02, 0.01, population['pop']) pg.firstLevel = 1e-9 data = moose.Neutral('/data') vmtab, catab, plastab, currtab = tables.graphtables(d1d2, neurons, False, 'getGk') moose.reinit() moose.start(0.05) vm1 = vmtab[0][0].vector vm2 = vmtab[1][0].vector # Quick sanity check that the values are not outlandish. # We do not check at the beginning because of the initial fluctuation. assert -0.01 < vm1[250] < 0.05 assert -0.01 < vm2[250] < 0.05 assert -0.01 < vm1[499] < 0.05 assert -0.01 < vm2[499] < 0.05 return vm1, vm2
def setup(param_sim, model): if param_sim.calcium is not None: model.calYN = param_sim.calcium if param_sim.spines is not None: model.spineYN = param_sim.spines condset = getattr(model.Condset, param_sim.neuron_type) if param_sim.Kir_offset is not None: model.Channels.Kir.X.A_vhalf += param_sim.Kir_offset model.Channels.Kir.X.B_vhalf += param_sim.Kir_offset for cond in sorted(param_sim.cond): name, comp, value = cond print('cond:', name, comp, value) setup_conductance(condset, name, comp, value) new_file = morph_morph_file(model, param_sim.neuron_type, param_sim.morph_file, RA=param_sim.RA, RM=param_sim.RM, CM=param_sim.CM, Erest=param_sim.Erest, Eleak=param_sim.Eleak) model.morph_file[param_sim.neuron_type] = new_file.name MSNsyn, neurons = cell_proto.neuronclasses(model) neuron_paths = {ntype:[neuron.path] for ntype, neuron in neurons.items()} pg = inject_func.setupinj(model, param_sim.injection_delay, param_sim.injection_width, neuron_paths) tables.graphtables(model, neurons, param_sim.plot_current, param_sim.plot_current_message) writer = tables.setup_hdf5_output(model, neurons, compartments=['soma'], filename='d1d2_bs.h5') simpaths=['/'+param_sim.neuron_type] clocks.assign_clocks(simpaths, param_sim.simdt, param_sim.plotdt, param_sim.hsolve, model.param_cond.NAME_SOMA) if param_sim.hsolve and model.calYN: calcium.fix_calcium(model.neurontypes(), model) return pg, writer
def test_single_injection(calcium, synapses, spines, ghk, plasticity): "Create the neuron and run a very short simulation" if ghk and not hasattr(moose, 'GHK'): pytest.skip("GHK is missing") d1d2.calYN = bool(calcium) d1d2.plasYN = bool(plasticity) d1d2.ghkYN = bool(ghk) d1d2.spineYN = bool(spines) d1d2.synYN = bool(synapses) MSNsyn, neurons = cell_proto.neuronclasses(d1d2) neuron_paths = {ntype:[neuron.path] for ntype, neuron in neurons.items()} pg = inject_func.setupinj(d1d2, 0.02, 0.01, neuron_paths) pg.firstLevel = 1e-8 data = moose.Neutral('/data') vmtab, catab, plastab, currtab = tables.graphtables(d1d2, neurons, False, 'getGk') moose.reinit() moose.start(0.05) vm1 = vmtab[0][0].vector vm2 = vmtab[1][0].vector # Quick sanity check that the values are not outlandish. # We do not check at the beginning because of the initial fluctuation. exp = (0.174 - 0.025 * bool(spines) - 0.043 * bool(calcium)) assert exp - 0.01 < vm1[250] < exp + 0.02 assert exp - 0.01 < vm2[250] < exp + 0.02 assert -0.01 < vm1[499] < 0.05 assert -0.01 < vm2[499] < 0.05
def test_single_injection(calcium, synapses, spines, ghk, plasticity): "Create the neuron and run a very short simulation" if ghk and not hasattr(moose, 'GHK'): pytest.skip("GHK is missing") d1d2.calYN = bool(calcium) d1d2.plasYN = bool(plasticity) d1d2.ghkYN = bool(ghk) d1d2.spineYN = bool(spines) d1d2.synYN = bool(synapses) MSNsyn, neurons = cell_proto.neuronclasses(d1d2) neuron_paths = {ntype: [neuron.path] for ntype, neuron in neurons.items()} pg = inject_func.setupinj(d1d2, 0.02, 0.01, neuron_paths) pg.firstLevel = 1e-8 data = moose.Neutral('/data') vmtab, catab, plastab, currtab = tables.graphtables( d1d2, neurons, False, 'getGk') moose.reinit() moose.start(0.05) vm1 = vmtab[0][0].vector vm2 = vmtab[1][0].vector # Quick sanity check that the values are not outlandish. # We do not check at the beginning because of the initial fluctuation. exp = (0.174 - 0.025 * bool(spines) - 0.043 * bool(calcium)) assert exp - 0.01 < vm1[250] < exp + 0.02 assert exp - 0.01 < vm2[250] < exp + 0.02 assert -0.01 < vm1[499] < 0.05 assert -0.01 < vm2[499] < 0.05
sim_time.append(st) plas[ntype] = spines param_sim.simtime = max(sim_time) param_sim.injection_current = [0] else: ### Current Injection alone, either use values from Paradigm or from command-line options if not np.any(param_sim.injection_current): param_sim.injection_current = [ ca1.param_stim.Stimulation.Paradigm.A_inject ] param_sim.injection_delay = ca1.param_stim.Stimulation.stim_delay param_sim.injection_width = ca1.param_stim.Stimulation.Paradigm.width_AP all_neurons = {} for ntype in neuron.keys(): all_neurons[ntype] = list([neuron[ntype].path]) pg = inject_func.setupinj(ca1, param_sim.injection_delay, param_sim.injection_width, all_neurons) #If calcium and synapses created, could test plasticity at a single synapse in syncomp #Need to debug this since eliminated param_sim.stimtimes #See what else needs to be changed in plasticity_test. if ca1.plasYN: plas, stimtab = plasticity_test.plasticity_test(ca1, param_sim.syncomp, MSNsyn, param_sim.stimtimes) ###############--------------output elements if param_sim.plot_channels: for chan in ca1.Channels.keys(): libchan = moose.element('/library/' + chan) plot_channel.plot_gate_params(libchan, param_sim.plot_activation, ca1.VMIN, ca1.VMAX, ca1.CAMIN, ca1.CAMAX)
def moose_main(corticalinput): import numpy as np import matplotlib.pyplot as plt # plt.ion() import moose from moose_nerp.prototypes import (create_model_sim, clocks, inject_func, create_network, tables, net_output) from moose_nerp import d1opt as model from moose_nerp import str_net as net # additional, optional parameter overrides specified from with python terminal # model.Condset.D1.NaF[model.param_cond.prox] /= 3 # model.Condset.D1.KaS[model.param_cond.prox] *= 3 net.connect_dict['D1']['ampa']['extern1'].dend_loc.postsyn_fraction = 0.8 net.param_net.tt_Ctx_SPN.filename = corticalinput print('cortical_fraction = {}'.format(net.connect_dict['D1']['ampa']['extern1'].dend_loc.postsyn_fraction)) model.synYN = True model.plasYN = True model.calYN = True model.spineYN = True net.single = True create_model_sim.setupOptions(model) param_sim = model.param_sim param_sim.useStreamer = True param_sim.plotdt = .1e-3 param_sim.stim_loc = model.NAME_SOMA param_sim.stim_paradigm = 'inject' param_sim.injection_current = [0] # [-0.2e-9, 0.26e-9] param_sim.injection_delay = 0.2 param_sim.injection_width = 0.4 param_sim.simtime = 21 net.num_inject = 0 net.confile = 'str_connect_plas_simd1opt_{}_corticalfraction_{}'.format(net.param_net.tt_Ctx_SPN.filename, 0.8) if net.num_inject == 0: param_sim.injection_current = [0] #################################-----------create the model: neurons, and synaptic inputs model = create_model_sim.setupNeurons(model, network=not net.single) all_neur_types = model.neurons # FSIsyn,neuron = cell_proto.neuronclasses(FSI) # all_neur_types.update(neuron) population, connections, plas = create_network.create_network(model, net, all_neur_types) ###### Set up stimulation - could be current injection or plasticity protocol # set num_inject=0 to avoid current injection if net.num_inject < np.inf: inject_pop = inject_func.inject_pop(population['pop'], net.num_inject) else: inject_pop = population['pop'] # Does setupStim work for network? # create_model_sim.setupStim(model) pg = inject_func.setupinj(model, param_sim.injection_delay, param_sim.injection_width, inject_pop) moose.showmsg(pg) ##############--------------output elements if net.single: # fname=model.param_stim.Stimulation.Paradigm.name+'_'+model.param_stim.location.stim_dendrites[0]+'.npz' # simpath used to set-up simulation dt and hsolver simpath = ['/' + neurotype for neurotype in all_neur_types] create_model_sim.setupOutput(model) else: # population of neurons spiketab, vmtab, plastab, catab = net_output.SpikeTables(model, population['pop'], net.plot_netvm, plas, net.plots_per_neur) # simpath used to set-up simulation dt and hsolver simpath = [net.netname] clocks.assign_clocks(simpath, param_sim.simdt, param_sim.plotdt, param_sim.hsolve, model.param_cond.NAME_SOMA) if model.synYN and (param_sim.plot_synapse or net.single): # overwrite plastab above, since it is empty syntab, plastab, stp_tab = tables.syn_plastabs(connections, model) nonstim_plastab = tables.nonstimplastabs(plas) # Streamer to prevent Tables filling up memory on disk # This is a hack, should be better implemented if param_sim.useStreamer == True: allTables = moose.wildcardFind('/##[ISA=Table]') streamer = moose.Streamer('/streamer') streamer.outfile = 'plas_simd1opt_{}_corticalfraction_{}.npy'.format(net.param_net.tt_Ctx_SPN.filename, 0.8) moose.setClock(streamer.tick, 0.1) for t in allTables: if any(s in t.path for s in ['plas', 'VmD1_0', 'extern', 'Shell_0']): streamer.addTable(t) else: t.tick = -2 ################### Actually run the simulation def run_simulation(injection_current, simtime): print(u'◢◤◢◤◢◤◢◤ injection_current = {} ◢◤◢◤◢◤◢◤'.format(injection_current)) pg.firstLevel = injection_current moose.reinit() moose.start(simtime, True) traces, names = [], [] for inj in param_sim.injection_current: run_simulation(injection_current=inj, simtime=param_sim.simtime) weights = [w.value for w in moose.wildcardFind('/##/plas##[TYPE=Function]')] plt.figure() plt.hist(weights, bins=100) plt.title('plas_sim_{}_corticalfraction_{}'.format(net.param_net.tt_Ctx_SPN.filename, cortical_fraction)) plt.savefig('plas_simd1opt_{}_corticalfraction_{}.png'.format(net.param_net.tt_Ctx_SPN.filename, 0.8)) if param_sim.useStreamer == True: import atexit atexit.register(moose.quit) return weights
def moose_main(p): stimfreq, presyn, stpYN, trialnum, prefix, ttGPe, ttstr, ttSTN = p import numpy as np import os import moose from moose_nerp.prototypes import (calcium, create_model_sim, clocks, inject_func, create_network, tables, net_output, util) from moose_nerp import ep as model from moose_nerp import ep_net as net from moose_nerp.graph import net_graph, neuron_graph, spine_graph np.random.seed() #additional, optional parameter overrides specified from with python terminal model.synYN = True model.stpYN = stpYN net.single = True stimtype = 'PSP_' outdir = "ep_net/output/" ############## if stim_freq>0, stim_paradigm adds regular input and synaptic plasticity at single synapse #################### if stimfreq > 0: model.param_sim.stim_paradigm = stimtype + str(stimfreq) + 'Hz' model.param_stim.Stimulation.StimLoc = model.param_stim.location[ presyn] else: model.param_sim.stim_paradigm = 'inject' create_model_sim.setupOptions(model) param_sim = model.param_sim param_sim.injection_current = [0e-12] param_sim.injection_delay = 0.0 param_sim.plot_synapse = False if prefix.startswith('POST-HFS'): net.connect_dict['ep']['ampa']['extern1'].weight = 0.6 #STN - weaker net.connect_dict['ep']['gaba']['extern2'].weight = 0.8 #GPe - weaker net.connect_dict['ep']['gaba']['extern3'].weight = 1.4 #str - stronger if prefix.startswith('POST-NoDa'): net.connect_dict['ep']['ampa'][ 'extern1'].weight = 1.0 #STN - no change net.connect_dict['ep']['gaba']['extern2'].weight = 2.8 #GPe - stronger net.connect_dict['ep']['gaba'][ 'extern3'].weight = 1.0 #str - no change #override time tables here - before creating model, e.g. fname_part = '' if len(ttGPe): net.param_net.tt_GPe.filename = ttGPe print('!!!!!!!!!!!!!! new tt file for GPe:', net.param_net.tt_GPe.filename, 'trial', trialnum) fname_part = fname_part + '_tg_' + os.path.basename(ttGPe) else: print('$$$$$$$$$$$$$$ old tt file for GPe:', net.param_net.tt_GPe.filename, 'trial', trialnum) if len(ttstr): net.param_net.tt_str.filename = ttstr print('!!!!!!!!!!!!!! new tt file for str:', net.param_net.tt_str.filename, 'trial', trialnum) fname_part = fname_part + '_ts_' + os.path.basename(ttstr) else: print('$$$$$$$$$$$$$$ old tt file for str:', net.param_net.tt_str.filename, 'trial', trialnum) if len(ttSTN): net.param_net.tt_STN.filename = ttSTN print('!!!!!!!!!!!!!! new tt file for STN:', net.param_net.tt_STN.filename, 'trial', trialnum) fname_part = fname_part + '_ts_' + os.path.basename(ttSTN) else: print('$$$$$$$$$$$$$$ old tt file for STN:', net.param_net.tt_STN.filename, 'trial', trialnum) #################################-----------create the model: neurons, and synaptic inputs if model.stpYN == False: remember_stpYN = False model.stpYN = True #create network with stp, and then turn it off for extra synapse (if model.stpYN is False) else: remember_stpYN = True fname_stp = str(1 if model.stpYN else 0) + str(1 if remember_stpYN else 0) model = create_model_sim.setupNeurons(model, network=not net.single) print('trialnum', trialnum) population, connections, plas = create_network.create_network( model, net, model.neurons) model.stpYN = remember_stpYN ####### Set up stimulation - could be current injection or plasticity protocol # set num_inject=0 to avoid current injection if net.num_inject < np.inf: model.inject_pop = inject_func.inject_pop(population['pop'], net.num_inject) if net.num_inject == 0: param_sim.injection_current = [0] else: model.inject_pop = population['pop'] ############## Set-up test of synaptic plasticity at single synapse #################### if presyn == 'str': stp_params = net.param_net.str_plas elif presyn == 'GPe': stp_params = net.param_net.GPe_plas else: print('########### unknown synapse type', 'trial', trialnum) param_sim.fname = 'ep' + prefix + stimtype + presyn + '_freq' + str( stimfreq) + '_plas' + fname_stp + fname_part + 't' + str(trialnum) print( '>>>>>>>>>> moose_main, presyn {} stpYN {} stimfreq {} simtime {} trial {} plotcomps {} tt {} {}' .format(presyn, model.stpYN, stimfreq, param_sim.simtime, trialnum, param_sim.plotcomps, ttGPe, ttstr)) create_model_sim.setupStim(model) print('>>>> After setupStim, simtime:', param_sim.simtime, 'trial', trialnum, 'stpYN', model.stpYN) ##############--------------output elements if net.single: create_model_sim.setupOutput(model) else: #population of neurons model.spiketab, model.vmtab, model.plastab, model.catab = net_output.SpikeTables( model, population['pop'], net.plot_netvm, plas, net.plots_per_neur) #simpath used to set-up simulation dt and hsolver simpath = [net.netname] clocks.assign_clocks(simpath, param_sim.simdt, param_sim.plotdt, param_sim.hsolve, model.param_cond.NAME_SOMA) # Fix calculation of B parameter in CaConc if using hsolve if model.param_sim.hsolve and model.calYN: calcium.fix_calcium(util.neurontypes(model.param_cond), model) # if model.synYN and (param_sim.plot_synapse or net.single): #overwrite plastab above, since it is empty model.syntab, model.plastab, model.stp_tab = tables.syn_plastabs( connections, model) # #add short term plasticity to synapse as appropriate param_dict = { 'syn': presyn, 'freq': stimfreq, 'plas': model.stpYN, 'inj': param_sim.injection_current, 'simtime': param_sim.simtime, 'trial': trialnum, 'dt': param_sim.plotdt } if stimfreq > 0: from moose_nerp.prototypes import plasticity_test as plas_test extra_syntab = {ntype: [] for ntype in model.neurons.keys()} extra_plastabset = {ntype: [] for ntype in model.neurons.keys()} for ntype in model.neurons.keys(): for tt_syn_tuple in model.tuples[ntype].values(): if model.stpYN: extra_syntab[ntype], extra_plastabset[ ntype] = plas_test.short_term_plasticity_test( tt_syn_tuple, syn_delay=0, simdt=model.param_sim.simdt, stp_params=stp_params) print('!!!!!!!!!!!!! setting up plasticity, stpYN', model.stpYN) else: extra_syntab[ntype] = plas_test.short_term_plasticity_test( tt_syn_tuple, syn_delay=0) print('!!!!!!!!!!!!! NO plasticity, stpYN', model.stpYN) param_dict[ntype] = { 'syn_tt': [(k, tt[0].vector) for k, tt in model.tuples[ntype].items()] } # #################### Actually run the simulation param_sim.simtime = 5.0 print('$$$$$$$$$$$$$$ paradigm=', model.param_stim.Stimulation.Paradigm.name, ' inj=0? ', np.all([inj == 0 for inj in param_sim.injection_current]), 'simtime:', param_sim.simtime, 'trial', trialnum, 'fname', outdir + param_sim.fname) if model.param_stim.Stimulation.Paradigm.name is not 'inject' and not np.all( [inj == 0 for inj in param_sim.injection_current]): pg = inject_func.setupinj(model, param_sim.injection_delay, model.param_sim.simtime, model.inject_pop) inj = [i for i in param_sim.injection_current if i != 0] pg.firstLevel = param_sim.injection_current[0] create_model_sim.runOneSim(model, simtime=model.param_sim.simtime) else: for inj in model.param_sim.injection_current: create_model_sim.runOneSim(model, simtime=model.param_sim.simtime, injection_current=inj) #net_output.writeOutput(model, param_sim.fname+'vm',model.spiketab,model.vmtab,population) # #Save results: spike time, Vm, parameters, input time tables from moose_nerp import ISI_anal spike_time, isis = ISI_anal.spike_isi_from_vm( model.vmtab, param_sim.simtime, soma=model.param_cond.NAME_SOMA) vmout = { ntype: [tab.vector for tab in tabset] for ntype, tabset in model.vmtab.items() } if np.any([len(st) for tabset in spike_time.values() for st in tabset]): np.savez(outdir + param_sim.fname, spike_time=spike_time, isi=isis, params=param_dict, vm=vmout) else: print('no spikes for', param_sim.fname, 'saving vm and parameters') np.savez(outdir + param_sim.fname, params=param_dict, vm=vmout) if net.single: #save spiketime of all input time tables timtabs = {} for neurtype, neurtype_dict in connections.items(): for neur, neur_dict in neurtype_dict.items(): for syn, syn_dict in neur_dict.items(): timtabs[syn] = {} for pretype, pre_dict in syn_dict.items(): timtabs[syn][pretype] = {} for branch, presyn in pre_dict.items(): for i, possible_tt in enumerate(presyn): if 'TimTab' in possible_tt: timtabs[syn][pretype][ branch + '_syn' + str(i)] = moose.element( possible_tt).vector np.save(outdir + 'tt' + param_sim.fname, timtabs) #create dictionary with the output (vectors) from test plasticity tab_dict = {} if stimfreq > 0: for ntype, tabset in extra_syntab.items(): tab_dict[ntype] = { 'syn': tabset.vector, 'syndt': tabset.dt, 'tt': { ntype + '_' + pt: tab.vector for pt, tab in model.tt[ntype].items() } } if model.stpYN: tab_dict[ntype]['plas'] = { tab.name: tab.vector for tab in extra_plastabset[ntype] } return param_dict, tab_dict, vmout, spike_time, isis
param_dict={'syn':presyn,'freq':stimfreq,'plas':model.stpYN,'inj':param_sim.injection_current,'simtime':param_sim.simtime} for ntype in model.neurons.keys(): for tt_syn_tuple in model.tuples[ntype].values(): if model.stpYN: syntab[ntype],plastabset[ntype]=plas_test.short_term_plasticity_test(tt_syn_tuple,syn_delay=0, simdt=model.param_sim.simdt,stp_params=stp_params) else: syntab[ntype]=plas_test.short_term_plasticity_test(tt_syn_tuple,syn_delay=0) param_dict[ntype]={'syn_tt': [(k,tt[0].vector) for k,tt in model.tuples[ntype].items()]} #additional current injection, e.g. if an offset current is desired if model.param_stim.Stimulation.Paradigm.name is not 'inject' and not np.all([inj==0 for inj in param_sim.injection_current]): print('$$$$$$$$$$$$$$ stim paradigm',model.param_stim.Stimulation.Paradigm.name, 'inject', param_sim.injection_current) neuron_pop = {ntype:[neur.path] for ntype, neur in model.neurons.items()} #set injection width to simulation time pg=inject_func.setupinj(model, param_sim.injection_delay,param_sim.simtime,neuron_pop) pg.firstLevel = param_sim.injection_current[0] ##################### for debugging: shows that some spikes elicit 2x increase in weight fac=moose.element('/ep/p0b1b1b2/gaba/fac0') x0=fac.x[0] x1=fac.x[1] x0tab=moose.Table('x0tab') x1tab=moose.Table('x1tab') moose.connect(x0tab,'requestOut',x0,'getValue') moose.connect(x1tab,'requestOut',x1,'getValue') ttstate=moose.Table('/data/ttstate') tt=list(model.tuples['ep'].values())[0][0] moose.connect(ttstate, 'requestOut', tt, 'getState') param_sim.simtime=0.1 #####################
#################################-----------create the model: neurons, and synaptic inputs model=create_model_sim.setupNeurons(model,network=not net.single) all_neur_types=model.neurons #FSIsyn,neuron = cell_proto.neuronclasses(FSI) #all_neur_types.update(neuron) population,connections,plas=create_network.create_network(model, net, all_neur_types) ###### Set up stimulation - could be current injection or plasticity protocol # set num_inject=0 to avoid current injection if net.num_inject<np.inf : inject_pop=inject_func.inject_pop(population['pop'],net.num_inject) else: inject_pop=population['pop'] #Does setupStim work for network? #create_model_sim.setupStim(model) pg=inject_func.setupinj(model, param_sim.injection_delay,param_sim.injection_width,inject_pop) moose.showmsg(pg) ##############--------------output elements if net.single: #fname=model.param_stim.Stimulation.Paradigm.name+'_'+model.param_stim.location.stim_dendrites[0]+'.npz' #simpath used to set-up simulation dt and hsolver simpath=['/'+neurotype for neurotype in all_neur_types] create_model_sim.setupOutput(model) else: #population of neurons spiketab,vmtab,plastab,catab=net_output.SpikeTables(model, population['pop'], net.plot_netvm, plas, net.plots_per_neur) #simpath used to set-up simulation dt and hsolver simpath=[net.netname] clocks.assign_clocks(simpath, param_sim.simdt, param_sim.plotdt, param_sim.hsolve,model.param_cond.NAME_SOMA) if model.synYN and (param_sim.plot_synapse or net.single): #overwrite plastab above, since it is empty
def setup(param_sim, model): #these next two overrides are not used in optimization as they are not passed in from optimize #they could be used if running basic_simulation directly ''' if param_sim.calcium is not None: model.calYN = param_sim.calcium if param_sim.spines is not None: model.spineYN = param_sim.spines ''' ''' if model.type = nml: this block of code updates neuroml files write a bunch of new code else: #this block of code updates moose_nerp foramt files ''' condset = getattr( model.Condset, param_sim.neuron_type) # Fetch reference for model condutances. chanset = model.Channels # Fetch reference for model channels. for cond in sorted(param_sim.cond): name, comp, value = cond if logger.level == logging.DEBUG: print('cond:', name, comp, value) setup_conductance(condset, name, comp, value) for chan in param_sim.chan: chan_name, opt, gate, value = chan if logger.level == logging.DEBUG: print('chan:', chan_name, opt, gate, value) if opt == 'taumul': scale_voltage_dependents_tau_muliplier(chanset, chan_name, gate, value) elif opt == 'vshift': offset_voltage_dependents_vshift(chanset, chan_name, gate, value) new_file = morph_morph_file(model, param_sim.neuron_type, param_sim.morph_file, RA=param_sim.RA, RM=param_sim.RM, CM=param_sim.CM, Erest=param_sim.Erest, Eleak=param_sim.Eleak) logger.info('morph_file: {}'.format(new_file.name)) model.morph_file[param_sim.neuron_type] = new_file.name #end of code that updates moose_nerp files plotcomps = [model.param_cond.NAME_SOMA] fname = param_sim.neuron_type + '.h5' param_sim.save = 1 #create neuron model and set up output model.param_sim = param_sim setup_CaPool(param_sim, model) #syn,neurons,writer,tables=create_model_sim.create_model_sim(model,fname,param_sim,plotcomps) create_model_sim.setupNeurons(model) #set up current injection neuron_paths = { ntype: [neuron.path] for ntype, neuron in model.neurons.items() } pg = inject_func.setupinj(model, param_sim.injection_delay, param_sim.injection_width, neuron_paths) writer = tables.setup_hdf5_output(model, model.neurons, filename=fname, compartments=plotcomps) tables.graphtables(model, model.neurons, model.param_sim.plot_current, model.param_sim.plot_current_message, model.plas, plotcomps) if logger.level == logging.DEBUG: print_params.print_elem_params(model, param_sim.neuron_type, param_sim) return pg, writer
#################################-----------create the model: neurons, and synaptic inputs model = create_model_sim.setupNeurons(model, network=not net.single) all_neur_types = model.neurons # FSIsyn,neuron = cell_proto.neuronclasses(FSI) # all_neur_types.update(neuron) population, connections, plas = create_network.create_network(model, net, all_neur_types) ###### Set up stimulation - could be current injection or plasticity protocol # set num_inject=0 to avoid current injection if net.num_inject < np.inf: inject_pop = inject_func.inject_pop(population['pop'], net.num_inject) else: inject_pop = population['pop'] # Does setupStim work for network? # create_model_sim.setupStim(model) pg = inject_func.setupinj(model, param_sim.injection_delay, param_sim.injection_width, inject_pop) moose.showmsg(pg) ##############--------------output elements if net.single: # fname=model.param_stim.Stimulation.Paradigm.name+'_'+model.param_stim.location.stim_dendrites[0]+'.npz' # simpath used to set-up simulation dt and hsolver simpath = ['/' + neurotype for neurotype in all_neur_types] create_model_sim.setupOutput(model) else: # population of neurons spiketab, vmtab, plastab, catab = net_output.SpikeTables(model, population['pop'], net.plot_netvm, plas, net.plots_per_neur) # simpath used to set-up simulation dt and hsolver simpath = [net.netname] clocks.assign_clocks(simpath, param_sim.simdt, param_sim.plotdt, param_sim.hsolve, model.param_cond.NAME_SOMA) if model.synYN and (param_sim.plot_synapse or net.single):
def moose_main(p): stimfreq, presyn, stpYN, inj = p import numpy as np from moose_nerp.prototypes import create_model_sim, inject_func from moose_nerp import ep as model model.synYN = True model.stpYN = stpYN outdir = "ep/output/" stimtype = 'PSP_' # choose from AP and PSP model.param_sim.stim_paradigm = stimtype + str(stimfreq) + 'Hz' create_model_sim.setupOptions(model) # Parameter overrides can be specified: param_sim = model.param_sim param_sim.injection_current = [inj] param_sim.injection_delay = 0.0 param_sim.save_txt = True param_sim.plot_synapse = False param_sim.plot_calcium = False # this is only needed if adding short term plasticity to synapse from moose_nerp import ep_net as net if presyn == 'str' and model.stpYN: stp_params = net.param_net.str_plas elif presyn == 'GPe' and model.stpYN: stp_params = net.param_net.GPe_plas else: print('########### unknown synapse type', presyn) param_sim.fname = 'ep' + stimtype + presyn + '_freq' + str( stimfreq) + '_plas' + str(1 if model.stpYN else 0) + '_inj' + str( param_sim.injection_current[0]) print( '>>>>>>>>>> moose_main, stimfreq {} presyn {} stpYN {} plot comps {}'. format(stimfreq, presyn, stpYN, param_sim.plotcomps)) # This function creates the neuron(s) in Moose: create_model_sim.setupNeurons(model) # This function sets up the Output options, e.g. saving, graph tables, etc. create_model_sim.setupOutput(model) # This function sets up the stimulation in Moose, e.g. pulsegen for current # injection or synaptic stimulation: create_model_sim.setupStim(model) # add short term plasticity to synapse as appropriate param_dict = { 'syn': presyn, 'freq': stimfreq, 'plas': model.stpYN, 'inj': param_sim.injection_current, 'simtime': param_sim.simtime, 'dt': param_sim.plotdt } from moose_nerp.prototypes import plasticity_test as plas_test syntab = {ntype: [] for ntype in model.neurons.keys()} plastabset = {ntype: [] for ntype in model.neurons.keys()} param_dict = { 'syn': presyn, 'freq': stimfreq, 'plas': model.stpYN, 'inj': param_sim.injection_current, 'simtime': param_sim.simtime } for ntype in model.neurons.keys(): for tt_syn_tuple in model.tuples[ntype].values(): if model.stpYN: syntab[ntype], plastabset[ ntype] = plas_test.short_term_plasticity_test( tt_syn_tuple, syn_delay=0, simdt=model.param_sim.simdt, stp_params=stp_params) else: syntab[ntype] = plas_test.short_term_plasticity_test( tt_syn_tuple, syn_delay=0) param_dict[ntype] = { 'syn_tt': [(k, tt[0].vector) for k, tt in model.tuples[ntype].items()] } # simulate the model if model.param_stim.Stimulation.Paradigm.name is not 'inject' and not np.all( [ij == 0 for ij in param_sim.injection_current]): print('$$$$$$$$$$$$$$ stim paradigm', model.param_stim.Stimulation.Paradigm.name, 'inject', param_sim.injection_current) neuron_pop = { ntype: [neur.path] for ntype, neur in model.neurons.items() } # set injection width to simulation time pg = inject_func.setupinj(model, param_sim.injection_delay, model.param_sim.simtime, neuron_pop) # for ij in model.param_sim.injection_current: pg.firstLevel = param_sim.injection_current[0] ''' create_model_sim.runOneSim(model, simtime=model.param_sim.simtime) else: ''' create_model_sim.runAll(model, printParams=True) print('<<<<<<<<<<< moose_main, sim {} finished'.format(param_sim.fname)) # Extract spike times and calculate ISI if spikes occur vmtab = { ntype: [tab.vector for tab in tabset] for ntype, tabset in model.vmtab.items() } import numpy as np import ISI_anal # stim_spikes are spikes that occur during stimulation - they prevent correct psp_amp calculation spike_time, isis = ISI_anal.spike_isi_from_vm( model.vmtab, param_sim.simtime, soma=model.param_cond.NAME_SOMA) stim_spikes = ISI_anal.stim_spikes(spike_time, model.tt, soma=model.param_cond.NAME_SOMA) if not np.all( [len(st) for tabset in stim_spikes.values() for st in tabset]): psp_amp, psp_norm = ISI_anal.psp_amp(model.vmtab, model.tt, soma=model.param_cond.NAME_SOMA) np.savez(outdir + param_sim.fname, amp=psp_amp, norm=psp_norm, params=param_dict, vm=vmtab) print('&&&&&&&&&&&&&&&&& Saving PSP amplitude &&&&&&&&&&&&&&&&&&&', param_sim.fname) if np.any([len(st) for tabset in stim_spikes.values() for st in tabset]): np.savez(outdir + param_sim.fname, spike_time=spike_time, isi=isis, params=param_dict, vm=vmtab) print('&&&&&&&&&&&&&&&&& Saving spike times &&&&&&&&&&&&&&&&&&&', param_sim.fname) # # create dictionary with the output (vectors) from tables tab_dict = {} for ntype, tabset in syntab.items(): tab_dict[ntype] = { 'syn': tabset.vector, 'syndt': tabset.dt, 'tt': { ntype + '_' + pt: tab.vector for pt, tab in model.tt[ntype].items() } } # ,'tt_dt':tabset.dt} if model.stpYN: tab_dict[ntype]['plas'] = { tab.name: tab.vector for tab in plastabset[ntype] } return param_dict, tab_dict, vmtab, spike_time, isis
def moose_main(p): stimfreq,presyn,stpYN,trialnum=p import numpy as np import moose from moose_nerp.prototypes import (create_model_sim, clocks, inject_func, create_network, tables, net_output, util) from moose_nerp import ep as model from moose_nerp import ep_net as net from moose_nerp.graph import net_graph, neuron_graph, spine_graph #additional, optional parameter overrides specified from with python terminal model.synYN = True model.stpYN = stpYN net.single=True model.param_sim.stim_paradigm='PSP_'+str(stimfreq)+'Hz' model.param_stim.Stimulation.StimLoc=model.param_stim.location[presyn] create_model_sim.setupOptions(model) param_sim = model.param_sim param_sim.injection_current = [0e-12] param_sim.injection_delay = 0.0 param_sim.plot_synapse=False #################################-----------create the model: neurons, and synaptic inputs model=create_model_sim.setupNeurons(model,network=not net.single) population,connections,plas=create_network.create_network(model, net, model.neurons) ####### Set up stimulation - could be current injection or plasticity protocol # set num_inject=0 to avoid current injection if net.num_inject<np.inf : model.inject_pop=inject_func.inject_pop(population['pop'],net.num_inject) else: model.inject_pop=population['pop'] if net.num_inject==0: param_sim.injection_current=[0] ############## Set-up test of synaptic plasticity at single synapse #################### if presyn=='str': stp_params=net.param_net.str_plas elif presyn=='GPe': stp_params=net.param_net.GPe_plas else: print('########### unknown synapse type') param_sim.fname='epGABA_syn'+presyn+'_freq'+str(stimfreq)+'_plas'+str(1 if model.stpYN else 0)+'_inj'+str(param_sim.injection_current[0])+'t'+str(trialnum) print('>>>>>>>>>> moose_main, presyn {} stpYN {} stimfreq {} trial {}'.format(presyn,model.stpYN,stimfreq,trialnum)) create_model_sim.setupStim(model) if model.param_stim.Stimulation.Paradigm.name is not 'inject' and not np.all([inj==0 for inj in param_sim.injection_current]): pg=inject_func.setupinj(model, param_sim.injection_delay,param_sim.injection_width,model.inject_pop) pg.firstLevel = param_sim.injection_current[0] ##############--------------output elements if net.single: #fname=model.param_stim.Stimulation.Paradigm.name+'_'+model.param_stim.location.stim_dendrites[0]+'.npz' create_model_sim.setupOutput(model) else: #population of neurons spiketab,vmtab,plastab,catab=net_output.SpikeTables(model, population['pop'], net.plot_netvm, plas, net.plots_per_neur) #simpath used to set-up simulation dt and hsolver simpath=[net.netname] clocks.assign_clocks(simpath, param_sim.simdt, param_sim.plotdt, param_sim.hsolve,model.param_cond.NAME_SOMA) # Fix calculation of B parameter in CaConc if using hsolve if model.param_sim.hsolve and model.calYN: calcium.fix_calcium(util.neurontypes(model.param_cond), model) if model.synYN and (param_sim.plot_synapse or net.single): #overwrite plastab above, since it is empty syntab, plastab, stp_tab=tables.syn_plastabs(connections,model) from moose_nerp.prototypes import plasticity_test as plas_test extra_syntab={ntype:[] for ntype in model.neurons.keys()} extra_plastabset={ntype:[] for ntype in model.neurons.keys()} param_dict={'syn':presyn,'freq':stimfreq,'plas':model.stpYN,'inj':param_sim.injection_current,'simtime':param_sim.simtime, 'trial': trialnum} for ntype in model.neurons.keys(): for tt_syn_tuple in model.tuples[ntype].values(): if model.stpYN: extra_syntab[ntype],extra_plastabset[ntype]=plas_test.short_term_plasticity_test(tt_syn_tuple,syn_delay=0, simdt=model.param_sim.simdt,stp_params=stp_params) else: extra_syntab[ntype]=plas_test.short_term_plasticity_test(tt_syn_tuple,syn_delay=0) param_dict[ntype]={'syn_tt': [(k,tt[0].vector) for k,tt in model.tuples[ntype].items()]} # #################### Actually run the simulation if not np.all([inj==0 for inj in param_sim.injection_current]): inj=[i for i in param_sim.injection_current if i !=0] create_model_sim.runOneSim(model, simtime=model.param_sim.simtime, injection_current=inj[0]) else: create_model_sim.runOneSim(model) #net_output.writeOutput(model, param_sim.fname+'vm',spiketab,vmtab,population) # import ISI_anal #stim_spikes are spikes that occur during stimulation - they prevent correct psp_amp calculation spike_time,isis=ISI_anal.spike_isi_from_vm(model.vmtab,param_sim.simtime) stim_spikes=ISI_anal.stim_spikes(spike_time,model.tt) if np.any([len(st) for tabset in spike_time.values() for st in tabset]): np.savez(param_sim.fname,spike_time=spike_time,isi=isis,params=param_dict) else: print('no spikes for',param_sim.fname) #create dictionary with the output (vectors) from tables tab_dict={} for ntype,tabset in extra_syntab.items(): tab_dict[ntype]={'syn':tabset.vector,'syndt':tabset.dt, 'tt': {ntype+'_'+pt:tab.vector for pt,tab in model.tt[ntype].items()}}#,'tt_dt':tabset.dt} if model.stpYN: tab_dict[ntype]['plas']={tab.name:tab.vector for tab in extra_plastabset[ntype]} vmtab={ntype:[tab.vector for tab in tabset] for ntype,tabset in model.vmtab.items()} return param_dict,tab_dict,vmtab,spike_time,isis