def handleLocation(self, id, population_id, component, x, y, z): self.printLocationInformation(id, population_id, component, x, y, z) inst = neuroml.Instance(id=id) inst.location = neuroml.Location(x=x, y=y, z=z) self.populations[population_id].instances.append(inst) self.populations[population_id].type = 'populationList'
def add_single_cell_population(net, pop_id, cell_id, x=0, y=0, z=0, color=None): """ Add a population with id `pop_id` containing a single instance of cell `cell_id`. Optionally specify (`x`,`y`,`z`) and the population `color`. """ pop = neuroml.Population(id=pop_id, component=cell_id, type="populationList", size=1) if color is not None: pop.properties.append(Property("color", color)) net.populations.append(pop) inst = neuroml.Instance(id=0) pop.instances.append(inst) inst.location = neuroml.Location(x=x, y=y, z=z) return pop
def handle_location(self, id, population_id, component, x, y, z): ##print('Loc: %s %s (%s,%s,%s)'%(id, population_id, x, y, z)) self.print_location_information(id, population_id, component, x, y, z) if x is not None and y is not None and z is not None: inst = neuroml.Instance(id=id) inst.location = neuroml.Location(x=x,y=y,z=z) self.populations[population_id].instances.append(inst) self.populations[population_id].type = 'populationList' else: self.log.warning('Ignoring location: %s %s (%s,%s,%s)'%(id, population_id, x, y, z))
def parse_dataset(self, d): print("Parsing dataset/array: " + str(d)) if self.current_population and d.name == 'locations': self.current_population.size = d.shape[0] print(" There are %i cells in: %s" % (self.current_population.size, self.current_population.id)) for i in range(0, d.shape[0]): row = d[i, :] instance = neuroml.Instance(i) instance.location = neuroml.Location(row[0], row[1], row[2]) self.current_population.instances.append(instance)
def __init__(self, size, cellclass, cellparams=None, structure=None, initial_values={}, label=None): super(Population, self).__init__(size, cellclass, cellparams, structure,initial_values, label) logger.debug("Created NeuroML Population: %s of size %i" % (self.label, self.size)) for cell in self.all_cells: index = self.id_to_index(cell) inst = neuroml.Instance(id=index) self.pop.instances.append(inst) x = self.positions[0][index] y = self.positions[1][index] z = self.positions[2][index] logger.debug("Creating cell at (%s, %s, %s)"%(x,y,z)) inst.location = neuroml.Location(x=x,y=y,z=z)
def __getitem__(self, index): if len(self.array[index]) == 4: id = self.array[index][self._get_index_or_add('id', 0)] #print(' Getting instance %s in %s (%s)'%(index,self,id)) assert (id == index) else: id = index instance = neuroml.Instance(id=id) instance.location = neuroml.Location( self.array[index][self._get_index_or_add('x', 1)], self.array[index][self._get_index_or_add('y', 2)], self.array[index][self._get_index_or_add('z', 3)]) return instance
def process_celldir(inputs): """Process cell directory""" count, cell_dir, nml2_cell_dir, total_count = inputs local_nml2_cell_dir = os.path.join("..", nml2_cell_dir) print( '\n\n************************************************************\n\n' 'Parsing %s (cell %i/%i)\n' % (cell_dir, count, total_count)) if os.path.isdir(cell_dir): old_cwd = os.getcwd() os.chdir(cell_dir) else: old_cwd = os.getcwd() os.chdir('../' + cell_dir) if make_zips: nml2_cell_dir = '%s/%s' % (zips_dir, cell_dir) if not os.path.isdir(nml2_cell_dir): os.mkdir(nml2_cell_dir) print("Generating into %s" % nml2_cell_dir) bbp_ref = None template_file = open('template.hoc', 'r') for line in template_file: if line.startswith('begintemplate '): bbp_ref = line.split(' ')[1].strip() print( ' > Assuming cell in directory %s is in a template named %s' % (cell_dir, bbp_ref)) load_cell_file = 'loadcell.hoc' variables = {} variables['cell'] = bbp_ref variables['groups_info_file'] = groups_info_file template = """ /////////////////////////////////////////////////////////////////////////////// // // NOTE: This file is not part of the original BBP cell model distribution // It has been generated by ../ParseAll.py to facilitate loading of the cell // into NEURON for exporting the model morphology to NeuroML2 // ////////////////////////////////////////////////////////////////////////////// load_file("stdrun.hoc") objref cvode cvode = new CVode() cvode.active(1) //======================== settings =================================== v_init = -80 hyp_amp = -0.062866 step_amp = 0.3112968 tstop = 3000 //=================== creating cell object =========================== load_file("import3d.hoc") objref cell // Using 1 to force loading of the file, in case file with same name was loaded // before... load_file(1, "constants.hoc") load_file(1, "morphology.hoc") load_file(1, "biophysics.hoc") print "Loaded morphology and biophysics..." load_file(1, "synapses/synapses.hoc") load_file(1, "template.hoc") print "Loaded template..." load_file(1, "createsimulation.hoc") create_cell(0) print "Created new cell using loadcell.hoc: {{ cell }}" define_shape() wopen("{{ groups_info_file }}") fprint("//Saving information on groups in this cell...\\n") fprint("- somatic\\n") forsec {{ cell }}[0].somatic { fprint("%s\\n",secname()) } fprint("- basal\\n") forsec {{ cell }}[0].basal { fprint("%s\\n",secname()) } fprint("- axonal\\n") forsec {{ cell }}[0].axonal { fprint("%s\\n",secname()) } fprint("- apical\\n") forsec {{ cell }}[0].apical { fprint("%s\\n",secname()) } wopen() """ t = Template(template) contents = t.render(variables) load_cell = open(load_cell_file, 'w') load_cell.write(contents) load_cell.close() print(' > Written %s' % load_cell_file) if os.path.isfile(load_cell_file): cell_info = parse_cell_info_file(cell_dir) nml_file_name = "%s.net.nml" % bbp_ref nml_net_loc = "%s/%s" % (local_nml2_cell_dir, nml_file_name) nml_cell_file = "%s_0_0.cell.nml" % bbp_ref nml_cell_loc = "%s/%s" % (local_nml2_cell_dir, nml_cell_file) print(' > Loading %s and exporting to %s' % (load_cell_file, nml_net_loc)) export_to_neuroml2(load_cell_file, nml_net_loc, separateCellFiles=True, includeBiophysicalProperties=False) print(' > Exported to: %s and %s using %s' % (nml_net_loc, nml_cell_loc, load_cell_file)) nml_doc = pynml.read_neuroml2_file(nml_cell_loc) cell = nml_doc.cells[0] print(' > Adding groups from: %s' % groups_info_file) groups = {} current_group = None for line in open(groups_info_file): if not line.startswith('//'): if line.startswith('- '): current_group = line[2:-1] print(' > Adding group: [%s]' % current_group) groups[current_group] = [] else: section = line.split('.')[1].strip() segment_group = section.replace('[', '_').replace(']', '') groups[current_group].append(segment_group) for g in groups.keys(): new_seg_group = neuroml.SegmentGroup(id=g) cell.morphology.segment_groups.append(new_seg_group) for sg in groups[g]: new_seg_group.includes.append(neuroml.Include(sg)) if g in ['basal', 'apical']: new_seg_group.inhomogeneous_parameters.append( neuroml.InhomogeneousParameter( id="PathLengthOver_" + g, variable="p", metric="Path Length from root", proximal=neuroml.ProximalDetails( translation_start="0"))) ignore_chans = [ 'Ih', 'Ca_HVA', 'Ca_LVAst', 'Ca', "SKv3_1", "SK_E2", "CaDynamics_E2", "Nap_Et2", "Im", "K_Tst", "NaTa_t", "K_Pst", "NaTs2_t" ] # ignore_chans=['StochKv','StochKv_deterministic'] ignore_chans = [] bp, incl_chans = get_biophysical_properties( cell_info['e-type'], ignore_chans=ignore_chans, templates_json="../templates.json") cell.biophysical_properties = bp print("Set biophysical properties") notes = '' notes += \ "\n\nExport of a cell model obtained from the BBP Neocortical" \ "Microcircuit Collaboration Portal into NeuroML2" \ "\n\n******************************************************\n*" \ " This export to NeuroML2 has not yet been fully validated!!" \ "\n* Use with caution!!\n***********************************" \ "*******************\n\n" if len(ignore_chans) > 0: notes += "Ignored channels = %s\n\n" % ignore_chans notes += "For more information on this cell model see: " \ "https://bbp.epfl.ch/nmc-portal/microcircuit#/metype/%s/" \ "details\n\n" % cell_info['me-type'] cell.notes = notes for channel in incl_chans: nml_doc.includes.append(neuroml.IncludeType(href="%s" % channel)) if make_zips: print("Copying %s to zip folder" % channel) shutil.copyfile('../../NeuroML2/%s' % channel, '%s/%s' % (local_nml2_cell_dir, channel)) pynml.write_neuroml2_file(nml_doc, nml_cell_loc) stim_ref = 'stepcurrent3' stim_ref_hyp = '%s_hyp' % stim_ref stim_sim_duration = 3000 stim_hyp_amp, stim_amp = get_stimulus_amplitudes(bbp_ref) stim_del = '700ms' stim_dur = '2000ms' new_net_loc = "%s/%s.%s.net.nml" % (local_nml2_cell_dir, bbp_ref, stim_ref) new_net_doc = pynml.read_neuroml2_file(nml_net_loc) new_net_doc.notes = notes stim_hyp = neuroml.PulseGenerator(id=stim_ref_hyp, delay="0ms", duration="%sms" % stim_sim_duration, amplitude=stim_hyp_amp) new_net_doc.pulse_generators.append(stim_hyp) stim = neuroml.PulseGenerator(id=stim_ref, delay=stim_del, duration=stim_dur, amplitude=stim_amp) new_net_doc.pulse_generators.append(stim) new_net = new_net_doc.networks[0] pop_id = new_net.populations[0].id pop_comp = new_net.populations[0].component input_list = neuroml.InputList(id="%s_input" % stim_ref_hyp, component=stim_ref_hyp, populations=pop_id) syn_input = neuroml.Input(id=0, target="../%s/0/%s" % (pop_id, pop_comp), destination="synapses") input_list.input.append(syn_input) new_net.input_lists.append(input_list) input_list = neuroml.InputList(id="%s_input" % stim_ref, component=stim_ref, populations=pop_id) syn_input = neuroml.Input(id=0, target="../%s/0/%s" % (pop_id, pop_comp), destination="synapses") input_list.input.append(syn_input) new_net.input_lists.append(input_list) pynml.write_neuroml2_file(new_net_doc, new_net_loc) generate_lems_file_for_neuroml(cell_dir, new_net_loc, "network", stim_sim_duration, 0.025, "LEMS_%s.xml" % cell_dir, local_nml2_cell_dir, copy_neuroml=False, seed=1234) pynml.nml2_to_svg(nml_net_loc) clear_neuron() pop = neuroml.Population(id="Pop_%s" % bbp_ref, component=bbp_ref + '_0_0', type="populationList") inst = neuroml.Instance(id="0") pop.instances.append(inst) width = 6 X = count % width Z = (count - X) / width inst.location = neuroml.Location(x=300 * X, y=0, z=300 * Z) count += 1 if make_zips: zip_file = "%s/%s.zip" % (zips_dir, cell_dir) print("Creating zip file: %s" % zip_file) with zipfile.ZipFile(zip_file, 'w') as myzip: for next_file in os.listdir(local_nml2_cell_dir): next_file = '%s/%s' % (local_nml2_cell_dir, next_file) arcname = next_file[len(zips_dir):] print("Adding : %s as %s" % (next_file, arcname)) myzip.write(next_file, arcname) os.chdir(old_cwd) return nml_cell_file, pop
file_name = '../examples/test_files/MediumNet.net.nml' nml_doc = read_neuroml2_file(file_name, include_includes=True) print(nml_doc.summary()) net0 = nml_doc.networks[0] nc = NetworkContainer(id="testnet") pc0 = PopulationContainer(id="pre", component="iffy", size=4) nc.populations.append(pc0) pc = PopulationContainer(id="fake", component="izzy") nc.populations.append(pc) instance = neuroml.Instance(0) instance.location = neuroml.Location(100, 100, 33.333) pc.instances.append(instance) instance = neuroml.Instance(1) instance.location = neuroml.Location(200, 200, 66.66) pc.instances.append(instance) prc = ProjectionContainer(id="proj", presynaptic_population=pc0.id, postsynaptic_population=pc.id, synapse="ampa") conn = neuroml.Connection(id=0, pre_cell_id="../%s/%i/%s"%(pc0.id,0,pc0.component), \ pre_segment_id=2, \ pre_fraction_along=0.1, post_cell_id="../%s/%i/%s"%(pc.id,2,pc.id))
def generate_Vm_vs_time_plot(NML2_file, cell_id, # inj_amp_nA = 80, # delay_ms = 20, # inj_dur_ms = 0.5, sim_dur_ms = 1000, dt = 0.05, temperature = "35", spike_threshold_mV=0., plot_voltage_traces=False, show_plot_already=True, simulator="jNeuroML_NEURON", include_included=True): # simulation parameters nogui = '-nogui' in sys.argv # Used to supress GUI in tests for Travis-CI ref = "iMC1_cell_1_origin" print_comment_v("Generating Vm(mV) vs Time(ms) plot for cell %s in %s using %s"% # (Inj %snA / %sms dur after %sms delay)"% (cell_id, NML2_file, simulator))#, inj_amp_nA, inj_dur_ms, delay_ms)) sim_id = 'Vm_%s'%ref duration = sim_dur_ms ls = LEMSSimulation(sim_id, sim_dur_ms, dt) ls.include_neuroml2_file(NML2_file, include_included=include_included) ls.assign_simulation_target('network') nml_doc = nml.NeuroMLDocument(id=cell_id) nml_doc.includes.append(nml.IncludeType(href=NML2_file)) net = nml.Network(id="network", type='networkWithTemperature', temperature='%sdegC'%temperature) nml_doc.networks.append(net) #input_id = ("input_%s"%str(inj_amp_nA).replace('.','_')) #pg = nml.PulseGenerator(id=input_id, # delay="%sms"%delay_ms, # duration='%sms'%inj_dur_ms, # amplitude='%spA'%inj_amp_nA) #nml_doc.pulse_generators.append(pg) pop_id = 'single_cell' pop = nml.Population(id=pop_id, component='iMC1_cell_1_origin', size=1, type="populationList") inst = nml.Instance(id=0) pop.instances.append(inst) inst.location = nml.Location(x=0, y=0, z=0) net.populations.append(pop) # Add these to cells #input_list = nml.InputList(id='il_%s'%input_id, # component=pg.id, # populations=pop_id) #input = nml.Input(id='0', target='../hhpop/0/hhcell', # destination="synapses") #input_list.input.append(input) #net.input_lists.append(input_list) sim_file_name = '%s.sim.nml'%sim_id pynml.write_neuroml2_file(nml_doc, sim_file_name) ls.include_neuroml2_file(sim_file_name) disp0 = 'Voltage_display' ls.create_display(disp0,"Voltages", "-90", "50") ls.add_line_to_display(disp0, "V", "hhpop/0/hhcell/v", scale='1mV') of0 = 'Volts_file' ls.create_output_file(of0, "%s.v.dat"%sim_id) ls.add_column_to_output_file(of0, "V", "hhpop/0/hhcell/v") lems_file_name = ls.save_to_file() if simulator == "jNeuroML": results = pynml.run_lems_with_jneuroml(lems_file_name, nogui=True, load_saved_data=True, plot=plot_voltage_traces, show_plot_already=False) elif simulator == "jNeuroML_NEURON": results = pynml.run_lems_with_jneuroml_neuron(lems_file_name, nogui=True, load_saved_data=True, plot=plot_voltage_traces, show_plot_already=False) if show_plot_already: from matplotlib import pyplot as plt plt.show() #plt.plot("t","V") #plt.title("Vm(mV) vs Time(ms) plot for cell %s in %s using %s (Inj %snA / %sms dur after %sms delay)"% # (cell_id, nml2_file, simulator, inj_amp_nA, inj_dur_ms, delay_ms)) #plt.xlabel('Time (ms)') #plt.ylabel('Vmemb (mV)') #plt.legend(['Test'], loc='upper right') return of0
def generate_network_for_sweeps(cell_type, dataset_id, cell_file_name, cell_id, target_dir, data_dir="../../data"): target_sweep_numbers = DH.DATASET_TARGET_SWEEPS[dataset_id] net_id = "network_%s_%s"%(dataset_id, cell_type) net = neuroml.Network(id=net_id, type="networkWithTemperature", temperature=DH.SIMULATION_TEMPERATURE) net_doc = neuroml.NeuroMLDocument(id=net.id) net_doc.networks.append(net) net_doc.includes.append(neuroml.IncludeType(cell_file_name)) number_cells = len(target_sweep_numbers) pop = neuroml.Population(id="Pop0", component=cell_id, size=number_cells, type="populationList") net.populations.append(pop) for i in range(number_cells): location = neuroml.Location(x=100*i,y=0,z=0) pop.instances.append(neuroml.Instance(id=i,location=location)) print target_sweep_numbers f = "%s/%s_analysis.json"%(data_dir,dataset_id) with open(f, "r") as json_file: data = json.load(json_file) id = data['data_set_id'] sweeps = data['sweeps'] print("Looking at data analysis in %s (dataset: %s)"%(f,id)) index = 0 for s in target_sweep_numbers: current = float(sweeps['%i'%s]["sweep_metadata"]["aibs_stimulus_amplitude_pa"]) print("Sweep %s (%s pA)"%(s, current)) stim_amp = "%s pA"%current input_id = ("input_%i"%s) pg = neuroml.PulseGenerator(id=input_id, delay="270ms", duration="1000ms", amplitude=stim_amp) net_doc.pulse_generators.append(pg) input_list = neuroml.InputList(id=input_id, component=pg.id, populations=pop.id) input = neuroml.Input(id='0', target="../%s/%i/%s"%(pop.id, index, cell_id), destination="synapses") index+=1 input_list.input.append(input) net.input_lists.append(input_list) net_file_name = '%s/%s.net.nml'%(target_dir,net_id) print("Saving generated network to: %s"%net_file_name) pynml.write_neuroml2_file(net_doc, net_file_name) return net_file_name
def generate_Vm_vs_time_plot(nml2_file, cell_id, inj_amp_nA=80, delay_ms=20, inj_dur_ms=60, sim_dur_ms=100, dt=0.05, plot_voltage_traces=False, show_plot_already=True, simulator="jNeuroML", include_included=True): ref = "Test" print_comment_v( "Generating Vm(mV) vs Time(ms) plot for cell %s in %s using %s (Inj %snA / %sms dur after %sms delay)" % (cell_id, nml2_file, simulator, inj_amp_nA, inj_dur_ms, delay_ms)) sim_id = 'Vm_%s' % ref duration = sim_dur_ms ls = LEMSSimulation(sim_id, sim_dur_ms, dt) ls.include_neuroml2_file(nml2_file, include_included=include_included) ls.assign_simulation_target('network') nml_doc = nml.NeuroMLDocument(id=cell_id) nml_doc.includes.append(nml.IncludeType(href=nml2_file)) net = nml.Network(id="network") nml_doc.networks.append(net) input_id = ("input_%s" % str(inj_amp_nA).replace('.', '_')) pg = nml.PulseGenerator(id=input_id, delay="%sms" % delay_ms, duration='%sms' % inj_dur_ms, amplitude='%spA' % inj_amp_nA) nml_doc.pulse_generators.append(pg) pop_id = 'hhpop' pop = nml.Population(id=pop_id, component='hhcell', size=1, type="populationList") inst = nml.Instance(id=0) pop.instances.append(inst) inst.location = nml.Location(x=0, y=0, z=0) net.populations.append(pop) # Add these to cells input_list = nml.InputList(id='il_%s' % input_id, component=pg.id, populations=pop_id) input = nml.Input(id='0', target='../hhpop/0/hhcell', destination="synapses") input_list.input.append(input) net.input_lists.append(input_list) sim_file_name = '%s.sim.nml' % sim_id pynml.write_neuroml2_file(nml_doc, sim_file_name) ls.include_neuroml2_file(sim_file_name) disp0 = 'Voltage_display' ls.create_display(disp0, "Voltages", "-90", "50") ls.add_line_to_display(disp0, "V", "hhpop/0/hhcell/v", scale='1mV') of0 = 'Volts_file' ls.create_output_file(of0, "%s.v.dat" % sim_id) ls.add_column_to_output_file(of0, "V", "hhpop/0/hhcell/v") lems_file_name = ls.save_to_file() if simulator == "jNeuroML": results = pynml.run_lems_with_jneuroml(lems_file_name, nogui=True, load_saved_data=True, plot=plot_voltage_traces, show_plot_already=False) elif simulator == "jNeuroML_NEURON": results = pynml.run_lems_with_jneuroml_neuron(lems_file_name, nogui=True, load_saved_data=True, plot=plot_voltage_traces, show_plot_already=False) if show_plot_already: from matplotlib import pyplot as plt plt.show() return of0
def create_GoC_network( duration, dt, seed, N_goc=0, run=False, prob_type='Boltzmann', GJw_type='Vervaeke2010' ): goc_filename = 'GoC.cell.nml' goc_file = pynml.read_neuroml2_file( goc_filename ) goc_type = goc_file.cells[0] GJ_filename = 'GapJuncCML.nml' GJ_file = pynml.read_neuroml2_file( GJ_filename ) GJ_type = GJ_file.gap_junctions[0] MFSyn_filename = 'MF_GoC_Syn.nml' mfsyn_file = pynml.read_neuroml2_file( MFSyn_filename ) MFSyn_type = mfsyn_file.exp_three_synapses[0] MF20Syn_filename = 'MF_GoC_SynMult.nml' mf20syn_file = pynml.read_neuroml2_file( MF20Syn_filename ) MF20Syn_type = mf20syn_file.exp_three_synapses[0] # Distribute cells in 3D if N_goc>0: GoC_pos = nu.GoC_locate(N_goc) else: GoC_pos = nu.GoC_density_locate() N_goc = GoC_pos.shape[0] # get GJ connectivity GJ_pairs, GJWt = nu.GJ_conn( GoC_pos, prob_type, GJw_type ) tmp1, tmp2 = valnet.gapJuncAnalysis( GJ_pairs, GJWt ) print("Number of gap junctions per cell: ", tmp1) print("Net GJ conductance per cell:", tmp2) # Create pop List goc_pop = nml.Population( id=goc_type.id+"Pop", component = goc_type.id, type="populationList", size=N_goc ) # Create NML document for network specification net = nml.Network( id="gocNetwork", type="networkWithTemperature" , temperature="23 degC" ) net_doc = nml.NeuroMLDocument( id=net.id ) net_doc.networks.append( net ) net_doc.includes.append( goc_type ) net.populations.append( goc_pop ) #Add locations for GoC instances in the population: for goc in range(N_goc): inst = nml.Instance( id=goc ) goc_pop.instances.append( inst ) inst.location = nml.Location( x=GoC_pos[goc,0], y=GoC_pos[goc,1], z=GoC_pos[goc,2] ) # Define input spiketrains input_type = 'spikeGenerator'#'spikeGeneratorPoisson' lems_inst_doc = lems.Model() mf_inputs = lems.Component( "MF_Input", input_type) mf_inputs.set_parameter("period", "2000 ms" ) #mf_inputs.set_parameter("averageRate", "50 Hz") lems_inst_doc.add( mf_inputs ) #synapse_type = 'alphaCurrentSynapse' #alpha_syn = lems.Component( "AlphaSyn", synapse_type) #alpha_syn.set_parameter("tau", "30 ms" ) #alpha_syn.set_parameter("ibase", "200 pA") #lems_inst_doc.add( alpha_syn ) # Define MF input population N_mf = 15 #MF_pop = nml.Population(id=mf_inputs.id+"_pop", component=mf_inputs.id, type="populationList", size=N_mf) #net.populations.append( MF_pop ) mf_type2 = 'spikeGeneratorPoisson' #mf_poisson = lems.Component( "MF_Poisson", mf_type2) #mf_poisson.set_parameter("averageRate", "5 Hz") #lems_inst_doc.add( mf_poisson ) # adding in neuroml document instead of mf_poisson mf_poisson = nml.SpikeGeneratorPoisson( id = "MF_Poisson", average_rate="5 Hz" ) net_doc.spike_generator_poissons.append( mf_poisson ) net_doc.includes.append( goc_type ) MF_Poisson_pop = nml.Population(id=mf_poisson.id+"_pop", component=mf_poisson.id, type="populationList", size=N_mf) net.populations.append( MF_Poisson_pop ) MF_pos = nu.GoC_locate( N_mf ) for mf in range( N_mf ): inst = nml.Instance(id=mf) MF_Poisson_pop.instances.append( inst ) inst.location = nml.Location( x=MF_pos[mf,0], y=MF_pos[mf,1], z=MF_pos[mf,2] ) # Setup Mf->GoC synapses #MFprojection = nml.Projection(id="MFtoGoC", presynaptic_population=MF_pop.id, postsynaptic_population=goc_pop.id, synapse=alpha_syn.id) #net.projections.append(MFprojection) MF2projection = nml.Projection(id="MF2toGoC", presynaptic_population=MF_Poisson_pop.id, postsynaptic_population=goc_pop.id, synapse=MFSyn_type.id)#alpha_syn.id net.projections.append(MF2projection) #Get list of MF->GoC synapse mf_synlist = nu.randdist_MF_syn( N_mf, N_goc, pConn=0.3) nMFSyn = mf_synlist.shape[1] for syn in range( nMFSyn ): mf, goc = mf_synlist[:, syn] conn2 = nml.Connection(id=syn, pre_cell_id='../{}/{}/{}'.format(MF_Poisson_pop.id, mf, mf_poisson.id), post_cell_id='../{}/{}/{}'.format(goc_pop.id, goc, goc_type.id), post_segment_id='0', post_fraction_along="0.5") MF2projection.connections.append(conn2) # Burst of MF input (as explicit input) mf_bursttype = 'transientPoissonFiringSynapse' mf_burst = lems.Component( "MF_Burst", mf_bursttype) mf_burst.set_parameter( "averageRate", "100 Hz" ) mf_burst.set_parameter( "delay", "2000 ms" ) mf_burst.set_parameter( "duration", "500 ms" ) mf_burst.set_parameter( "synapse", MF20Syn_type.id ) mf_burst.set_parameter( "spikeTarget", './{}'.format(MF20Syn_type.id) ) lems_inst_doc.add( mf_burst ) # Add few burst inputs n_bursts = 4 gocPerm = np.random.permutation( N_goc ) ctr = 0 for gg in range(4): goc = gocPerm[gg] for jj in range( n_bursts ): inst = nml.ExplicitInput( id=ctr, target='../{}/{}/{}'.format(goc_pop.id, goc, goc_type.id), input=mf_burst.id, synapse=MF20Syn_type.id, spikeTarget='./{}'.format(MF20Syn_type.id)) net.explicit_inputs.append( inst ) ctr += 1 ''' one-to-one pairing of MF and GoC -> no shared inputs for goc in range(N_mf): #inst = nml.Instance(id=goc) #MF_pop.instances.append( inst ) #inst.location = nml.Location( x=GoC_pos[goc,0], y=GoC_pos[goc,1], z=GoC_pos[goc,2]+100 ) #conn = nml.Connection(id=goc, pre_cell_id='../{}/{}/{}'.format(MF_pop.id, goc, mf_inputs.id), post_cell_id='../{}/{}/{}'.format(goc_pop.id, goc, goc_type.id), post_segment_id='0', post_fraction_along="0.5") #MFprojection.connections.append(conn) goc2 = N_goc-goc-1 inst2 = nml.Instance(id=goc) MF_Poisson_pop.instances.append( inst2 ) inst2.location = nml.Location( x=GoC_pos[goc2,0], y=GoC_pos[goc2,1], z=GoC_pos[goc2,2]+100 ) conn2 = nml.Connection(id=goc, pre_cell_id='../{}/{}/{}'.format(MF_Poisson_pop.id, goc, mf_poisson.id), post_cell_id='../{}/{}/{}'.format(goc_pop.id, goc2, goc_type.id), post_segment_id='0', post_fraction_along="0.5") MF2projection.connections.append(conn2) ''' # Add electrical synapses GoCCoupling = nml.ElectricalProjection( id="gocGJ", presynaptic_population=goc_pop.id, postsynaptic_population=goc_pop.id ) #print(GJ_pairs) gj = nml.GapJunction( id="GJ_0", conductance="426pS" ) net_doc.gap_junctions.append(gj) nGJ = GJ_pairs.shape[0] for jj in range( nGJ ): #gj.append( lems.Component( "GJ_%d"%jj, 'gapJunction') ) #gj[jj].set_parameter( "conductance", "%fnS"%(GJWt[jj]) ) #gj = nml.GapJunction(id="GJ_%d"%jj, conductance="%fnS"%(GJWt[jj])) #net_doc.gap_junctions.append(gj) #lems_inst_doc.add( gj[jj] ) #print("%fnS"%(GJWt[jj]*0.426)) conn = nml.ElectricalConnectionInstanceW( id=jj, pre_cell='../{}/{}/{}'.format(goc_pop.id, GJ_pairs[jj,0], goc_type.id), pre_segment='1', pre_fraction_along='0.5', post_cell='../{}/{}/{}'.format(goc_pop.id, GJ_pairs[jj,1], goc_type.id), post_segment='1', post_fraction_along='0.5', synapse=gj.id, weight=GJWt[jj] )#synapse="GapJuncCML" synapse=gj.id , conductance="100E-9mS" # ------------ need to create GJ component GoCCoupling.electrical_connection_instance_ws.append( conn ) net.electrical_projections.append( GoCCoupling ) net_filename = 'gocNetwork.nml' pynml.write_neuroml2_file( net_doc, net_filename ) lems_filename = 'instances.xml' pynml.write_lems_file( lems_inst_doc, lems_filename, validate=False ) simid = 'sim_gocnet'+goc_type.id ls = LEMSSimulation( simid, duration=duration, dt=dt, simulation_seed=seed ) ls.assign_simulation_target( net.id ) #ls.include_lems_file( 'Synapses.xml', include_included=False) #ls.include_lems_file( 'Inputs.xml', include_included=False) ls.include_neuroml2_file( net_filename) ls.include_neuroml2_file( goc_filename) ls.include_neuroml2_file( GJ_filename) ls.include_neuroml2_file( MFSyn_filename) ls.include_neuroml2_file( MF20Syn_filename) ls.include_lems_file( lems_filename, include_included=False) # Specify outputs eof0 = 'Events_file' ls.create_event_output_file(eof0, "%s.v.spikes"%simid,format='ID_TIME') for jj in range( goc_pop.size): ls.add_selection_to_event_output_file( eof0, jj, '{}/{}/{}'.format( goc_pop.id, jj, goc_type.id), 'spike' ) of0 = 'Volts_file' ls.create_output_file(of0, "%s.v.dat"%simid) for jj in range( goc_pop.size ): ls.add_column_to_output_file(of0, jj, '{}/{}/{}/v'.format( goc_pop.id, jj, goc_type.id)) #Create Lems file to run lems_simfile = ls.save_to_file() #res = pynml.run_lems_with_jneuroml( lems_simfile, max_memory="1G",nogui=True, plot=False) #res = pynml.run_lems_with_jneuroml_neuron( lems_simfile, max_memory="2G", only_generate_scripts = True, compile_mods = False, nogui=True, plot=False) res = pynml.run_lems_with_jneuroml_neuron( lems_simfile, max_memory="2G", compile_mods = False,nogui=True, plot=False) #res=True return res
def distance_dependent_positions(cell_position_array,cell_array,distance_criterion_dict,popIndex,seed_number,golgi_pop_object,dim_dict_max_values,\ dim_dict_offsets={'x_dim_offset':0,'y_dim_offset':0,'z_dim_offset':0},popSize=None,dim_dict_mappings=None,cell_count=None): random.seed(seed_number) if distance_criterion_dict['criterion'] == 'no_overlap': cell_diameter_array = distance_criterion_dict['cellDiameters'] cell_diameter = cell_diameter_array[cell_array[popIndex]['popID']] if distance_criterion_dict['criterion'] == 'minimal_distance': minimal_distance = distance_criterion_dict['minimal_distance'] if popSize == None: popSize = cell_array[popIndex]['size'] use_cell_count = False if cell_count != None: use_cell_count = True for cell in range(0, popSize): if use_cell_count: Golgi_cell = neuroml.Instance(id="%d" % cell_count) cell_count += 1 else: Golgi_cell = neuroml.Instance(id="%d" % cell) golgi_pop_object.instances.append(Golgi_cell) cell_position = np.zeros([1, 3]) if popIndex == 0 and cell == 0: X = random.random() Y = random.random() Z = random.random() Xcoordinate = dim_dict_offsets[ 'x_dim_offset'] + dim_dict_max_values['x_dim'] * X Ycoordinate = dim_dict_offsets[ 'y_dim_offset'] + dim_dict_max_values['y_dim'] * Y Zcoordinate = dim_dict_offsets[ 'z_dim_offset'] + dim_dict_max_values['z_dim'] * Z if dim_dict_mappings != None: cell_position[0, dim_dict_mappings['dim1']] = Xcoordinate cell_position[0, dim_dict_mappings['dim2']] = Ycoordinate cell_position[0, dim_dict_mappings['dim3']] = Zcoordinate else: cell_position[0, 0] = Xcoordinate cell_position[0, 1] = Ycoordinate cell_position[0, 2] = Zcoordinate cell_position_array[cell_array[popIndex]['popID']] = np.vstack( (cell_position_array[cell_array[popIndex]['popID']], cell_position)) Golgi_cell.location = neuroml.Location(x=cell_position[0, 0], y=cell_position[0, 1], z=cell_position[0, 2]) print cell_position[0, 0], cell_position[0, 1], cell_position[0, 2] else: x = 0 try_cell_position = np.zeros([1, 3]) while x == 0: overlap_counter = 0 X = random.random() Y = random.random() Z = random.random() Xcoordinate = dim_dict_offsets[ 'x_dim_offset'] + dim_dict_max_values['x_dim'] * X Ycoordinate = dim_dict_offsets[ 'y_dim_offset'] + dim_dict_max_values['y_dim'] * Y Zcoordinate = dim_dict_offsets[ 'z_dim_offset'] + dim_dict_max_values['z_dim'] * Z if dim_dict_mappings != None: try_cell_position[0, dim_dict_mappings['dim1']] = Xcoordinate try_cell_position[0, dim_dict_mappings['dim2']] = Ycoordinate try_cell_position[0, dim_dict_mappings['dim3']] = Zcoordinate else: try_cell_position[0, 0] = Xcoordinate try_cell_position[0, 1] = Ycoordinate try_cell_position[0, 2] = Zcoordinate Xtry = try_cell_position[0, 0] Ytry = try_cell_position[0, 1] Ztry = try_cell_position[0, 2] for cell_pop_x in range(0, len(cell_array)): pop_cell_positions = cell_position_array[ cell_array[cell_pop_x]['popID']] for cell_x in range(0, len(pop_cell_positions)): if pop_cell_positions[cell_x, 0] + pop_cell_positions[ cell_x, 1] + pop_cell_positions[cell_x, 2] > 0: if distance_criterion_dict[ 'criterion'] == 'no_overlap': if distance( [Xtry, Ytry, Ztry], pop_cell_positions[cell_x] ) < (cell_diameter_array[cell_array[popIndex] ['popID']] + cell_diameter_array[cell_array[cell_pop_x] ['popID']]) / 2: overlap_counter += 1 else: if distance_criterion_dict[ 'criterion'] == 'minimal_distance': if distance([Xtry, Ytry, Ztry], pop_cell_positions[cell_x] ) < minimal_distance: overlap_counter += 1 if overlap_counter == 0: cell_position[0, 0] = Xtry cell_position[0, 1] = Ytry cell_position[0, 2] = Ztry cell_position_array[ cell_array[popIndex]['popID']] = np.vstack(( cell_position_array[cell_array[popIndex]['popID']], cell_position)) Golgi_cell.location = neuroml.Location(x=cell_position[0, 0], y=cell_position[0, 1], z=cell_position[0, 2]) print cell_position[0, 0], cell_position[0, 1], cell_position[0, 2] x = 1 if use_cell_count: return cell_position_array, golgi_pop_object, cell_count else: return cell_position_array, golgi_pop_object
def density_model(location_parameters, cell_position_array, cellType, seed_number, popIndex=None, cell_array=None, cell_diameter_array=None): random.seed(seed_number) densityFilePath = location_parameters['densityFilePath'] X_array, Y_array, density_values = load_density_data(densityFilePath) dim_X_array = np.shape(X_array) print dim_X_array dim_Y_array = np.shape(Y_array) print dim_Y_array print np.shape(density_values) ## assume meshgrid if dim_X_array == dim_Y_array: ## assume that data is not normalized and distribute cells on a specific region on a density sheet X_max = np.nanmax(X_array) Y_max = np.nanmax(Y_array) X_vector = X_array[0] Y_vector = Y_array[0:, 0] print np.nanmax(X_vector) print np.nanmax(Y_vector) print X_vector print Y_vector print len(X_vector) print len(Y_vector) print np.nanmax(density_values) print np.nanmin(density_values) left_x_index = None right_x_index = None low_y_index = None high_y_index = None left_x_found = False right_x_found = False low_y_found = False high_y_found = False for X_value in range(0, len(X_vector)): if left_x_found == False: if X_vector[X_value] > location_parameters[ 'dim1CoordinateVector'][0]: left_x_index = X_value left_x_found = True print("found left x boundary %d" % left_x_index) if right_x_found == False: if X_vector[X_value] > location_parameters[ 'dim1CoordinateVector'][1]: right_x_index = X_value - 1 right_x_found = True print("found right x boundary %d" % right_x_index) for Y_value in range(0, len(Y_vector)): if low_y_found == False: if Y_vector[Y_value] > location_parameters[ 'dim2CoordinateVector'][0]: low_y_index = Y_value low_y_found = True print("found low y boundary %d" % low_y_index) if high_y_found == False: if Y_vector[Y_value] > location_parameters[ 'dim2CoordinateVector'][1]: high_y_index = Y_value - 1 high_y_found = True print("found high y boundary %d" % high_y_index) if left_x_found and right_x_found and low_y_found and high_y_found: X_index_array = range(left_x_index, right_x_index + 1) Y_index_array = range(low_y_index, high_y_index + 1) print X_index_array print Y_index_array a = "Region was found" ##### assume that the discrete density sheet is in mmm3. thus convert dim3 to mm: dim3Boundary = float(location_parameters['dim3Boundary']) / 1000 base_area = float( location_parameters['canonicalVolumeBaseAreainMicrons']) / ( 10**6) canonical_volume = base_area * dim3Boundary base_area_microns = float( location_parameters['canonicalVolumeBaseAreainMicrons']) dim3Boundary_microns = float(location_parameters['dim3Boundary']) dim_dict = {'x': 0, 'y': 1, 'z': 2} pop_position_array = np.zeros([0, 3]) total_no_of_cells = 0 cell_no_per_voxel_array = np.zeros( [len(Y_index_array), len(X_index_array)]) for Y_index in range(0, len(Y_index_array)): for X_index in range(0, len(X_index_array)): density_value = density_values[Y_index_array[Y_index], X_index_array[X_index]] if int(round(density_value * canonical_volume)) >= 1: no_of_cells_per_density_point = int( round(density_value * canonical_volume)) else: if int( round(density_value * canonical_volume, 1) ) == 0.1 and density_value * canonical_volume < 0.1: voxel_probability = density_value * canonical_volume * 10 else: voxel_probability = density_value * canonical_volume if voxel_probability > random.random(): no_of_cells_per_density_point = 1 else: no_of_cells_per_density_point = 0 cell_no_per_voxel_array[ Y_index, X_index] = no_of_cells_per_density_point total_no_of_cells = total_no_of_cells + no_of_cells_per_density_point golgi_pop_object = neuroml.Population( id=location_parameters['popID'], size=total_no_of_cells, type="populationList", component=cellType) cell_counter = 0 for Y_index in range(0, len(Y_index_array)): for X_index in range(0, len(X_index_array)): X_square_centre = X_array[Y_index_array[Y_index], X_index_array[X_index]] Y_square_centre = Y_array[Y_index_array[Y_index], X_index_array[X_index]] no_of_cells_per_density_point = int( round(cell_no_per_voxel_array[Y_index, X_index])) X_left_corner = X_square_centre - ( math.sqrt(base_area_microns) / 2) Y_left_corner = Y_square_centre - ( math.sqrt(base_area_microns) / 2) if no_of_cells_per_density_point != 0: if location_parameters[ 'distanceModel'] == "random_minimal_distance": minimal_distance = location_parameters[ 'minimal_distance'] dim_dict_max_values = {} dim_dict_max_values['x_dim'] = math.sqrt( base_area_microns) dim_dict_max_values['y_dim'] = math.sqrt( base_area_microns) dim_dict_max_values['z_dim'] = dim3Boundary_microns dim_dict_offsets = { 'x_dim_offset': X_left_corner, 'y_dim_offset': Y_left_corner, 'z_dim_offset': 0 } dim_dict_mappings = {} dim_dict_mappings['dim1'] = dim_dict[ location_parameters['planeDimensions']['dim1']] dim_dict_mappings['dim2'] = dim_dict[ location_parameters['planeDimensions']['dim2']] dim_dict_mappings['dim3'] = dim_dict[ location_parameters['dim3']] distance_dict = {} distance_dict['criterion'] = 'minimal_distance' distance_dict[ 'minimal_distance'] = minimal_distance cell_position_array,golgi_pop_object,cell_counter=distance_dependent_positions(cell_position_array,cell_array,distance_dict,popIndex,\ seed_number,golgi_pop_object,dim_dict_max_values,dim_dict_offsets,no_of_cells_per_density_point,dim_dict_mappings,cell_counter) if location_parameters[ 'distanceModel'] == "random_no_overlap": dim_dict_max_values = {} dim_dict_max_values['x_dim'] = math.sqrt( base_area_microns) dim_dict_max_values['y_dim'] = math.sqrt( base_area_microns) dim_dict_max_values['z_dim'] = dim3Boundary_microns dim_dict_offsets = { 'x_dim_offset': X_left_corner, 'y_dim_offset': Y_left_corner, 'z_dim_offset': 0 } dim_dict_mappings = {} dim_dict_mappings['dim1'] = dim_dict[ location_parameters['planeDimensions']['dim1']] dim_dict_mappings['dim2'] = dim_dict[ location_parameters['planeDimensions']['dim2']] dim_dict_mappings['dim3'] = dim_dict[ location_parameters['dim3']] distance_dict = {} distance_dict['criterion'] = 'no_overlap' distance_dict[ 'cellDiameters'] = cell_diameter_array cell_position_array,golgi_pop_object,cell_counter=distance_dependent_positions(cell_position_array,cell_array,distance_dict,popIndex,\ seed_number,golgi_pop_object,dim_dict_max_values,dim_dict_offsets,no_of_cells_per_density_point,dim_dict_mappings,cell_counter) if location_parameters['distanceModel'] == "random": for cell in range(0, no_of_cells_per_density_point): Golgi_cell = neuroml.Instance(id="%d" % (cell_counter)) cell_counter += 1 X = random.random() Y = random.random() Z = random.random() cell_position = np.zeros([1, 3]) cell_position[0, dim_dict[ location_parameters['planeDimensions'] ['dim1']]] = X_left_corner + math.sqrt( base_area_microns) * X cell_position[0, dim_dict[ location_parameters['planeDimensions'] ['dim2']]] = Y_left_corner + math.sqrt( base_area_microns) * Y cell_position[0, dim_dict[location_parameters[ 'dim3']]] = dim3Boundary_microns * Z cell_position_array[ location_parameters['popID']] = np.vstack( (cell_position_array[ location_parameters['popID']], cell_position)) Golgi_cell.location = neuroml.Location( x=cell_position[0, 0], y=cell_position[0, 1], z=cell_position[0, 2]) golgi_pop_object.instances.append(Golgi_cell) print cell_position[cell, 0], cell_position[ cell, 1], cell_position[cell, 2] ### override any specified value of population Size return cell_position_array, total_no_of_cells, golgi_pop_object
def generate_grc_layer_network( p_mf_ON, duration, dt, minimumISI, # ms ONRate, # Hz OFFRate, # Hz run=False): # Load connectivity matrix file = open('GCLconnectivity.pkl') p = pkl.load(file) conn_mat = p['conn_mat'] N_mf, N_grc = conn_mat.shape assert (np.all(conn_mat.sum( axis=0) == 4)), 'Connectivity matrix is incorrect.' # Load GrC and MF rosette positions grc_pos = p['grc_pos'] glom_pos = p['glom_pos'] # Choose which mossy fibers are on, which are off N_mf_ON = int(N_mf * p_mf_ON) mf_indices_ON = random.sample(range(N_mf), N_mf_ON) mf_indices_ON.sort() N_mf_OFF = N_mf - N_mf_ON mf_indices_OFF = [x for x in range(N_mf) if x not in mf_indices_ON] mf_indices_OFF.sort() # load NeuroML components, LEMS components and LEMS componentTypes from external files ##spikeGeneratorRefPoisson is now a standard nml type... ##spike_generator_doc = pynml.read_lems_file(spike_generator_file_name) iaF_GrC = nml.IafRefCell(id="iaF_GrC", refract="2ms", C="3.22pF", thresh="-40mV", reset="-63mV", leak_conductance="1.498nS", leak_reversal="-79.67mV") ampa_syn_filename = "RothmanMFToGrCAMPA.xml" nmda_syn_filename = "RothmanMFToGrCNMDA.xml" rothmanMFToGrCAMPA_doc = pynml.read_lems_file(ampa_syn_filename) rothmanMFToGrCNMDA_doc = pynml.read_lems_file(nmda_syn_filename) # define some components from the componentTypes we just loaded ##spike_generator_ref_poisson_type = spike_generator_doc.component_types['spikeGeneratorRefPoisson'] lems_instances_doc = lems.Model() spike_generator_ref_poisson_type_name = 'spikeGeneratorRefPoisson' spike_generator_on = lems.Component("mossySpikerON", spike_generator_ref_poisson_type_name) spike_generator_on.set_parameter("minimumISI", "%s ms" % minimumISI) spike_generator_on.set_parameter("averageRate", "%s Hz" % ONRate) lems_instances_doc.add(spike_generator_on) spike_generator_off = lems.Component( "mossySpikerOFF", spike_generator_ref_poisson_type_name) spike_generator_off.set_parameter("minimumISI", "%s ms" % minimumISI) spike_generator_off.set_parameter("averageRate", "%s Hz" % OFFRate) lems_instances_doc.add(spike_generator_off) rothmanMFToGrCAMPA = rothmanMFToGrCAMPA_doc.components[ 'RothmanMFToGrCAMPA'].id rothmanMFToGrCNMDA = rothmanMFToGrCNMDA_doc.components[ 'RothmanMFToGrCNMDA'].id # create populations GrCPop = nml.Population(id=iaF_GrC.id + "Pop", component=iaF_GrC.id, type="populationList", size=N_grc) GrCPop.properties.append(nml.Property(tag='color', value='0 0 0.8')) GrCPop.properties.append(nml.Property(tag='radius', value=2)) mossySpikersPopON = nml.Population(id=spike_generator_on.id + "Pop", component=spike_generator_on.id, type="populationList", size=N_mf_ON) mossySpikersPopON.properties.append( nml.Property(tag='color', value='0.8 0 0')) mossySpikersPopON.properties.append(nml.Property(tag='radius', value=2)) mossySpikersPopOFF = nml.Population(id=spike_generator_off.id + "Pop", component=spike_generator_off.id, size=N_mf_OFF) mossySpikersPopOFF.properties.append( nml.Property(tag='color', value='0 0.8 0')) mossySpikersPopOFF.properties.append(nml.Property(tag='radius', value=2)) # create network and add populations net = nml.Network(id="network") net_doc = nml.NeuroMLDocument(id=net.id) net_doc.networks.append(net) net_doc.iaf_ref_cells.append(iaF_GrC) net.populations.append(GrCPop) net.populations.append(mossySpikersPopON) net.populations.append(mossySpikersPopOFF) #net_doc.includes.append(nml.IncludeType(href=iaf_nml2_file_name)) # Add locations for GCs for grc in range(N_grc): inst = nml.Instance(id=grc) GrCPop.instances.append(inst) inst.location = nml.Location(x=grc_pos[grc, 0], y=grc_pos[grc, 1], z=grc_pos[grc, 2]) # ON MFs: locations and connectivity ONprojectionAMPA = nml.Projection( id="ONProjAMPA", presynaptic_population=mossySpikersPopON.id, postsynaptic_population=GrCPop.id, synapse=rothmanMFToGrCAMPA) ONprojectionNMDA = nml.Projection( id="ONProjNMDA", presynaptic_population=mossySpikersPopON.id, postsynaptic_population=GrCPop.id, synapse=rothmanMFToGrCNMDA) net.projections.append(ONprojectionAMPA) net.projections.append(ONprojectionNMDA) ix = 0 for mf_ix_ON in range(N_mf_ON): mf_ix = mf_indices_ON[mf_ix_ON] inst = nml.Instance(id=mf_ix_ON) mossySpikersPopON.instances.append(inst) inst.location = nml.Location(x=glom_pos[mf_ix, 0], y=glom_pos[mf_ix, 1], z=glom_pos[mf_ix, 2]) # find which granule cells are neighbors innervated_grcs = np.where(conn_mat[mf_ix, :] == 1)[0] for grc_ix in innervated_grcs: for synapse in [rothmanMFToGrCAMPA, rothmanMFToGrCNMDA]: connection = nml.Connection( id=ix, pre_cell_id='../{}/{}/{}'.format(mossySpikersPopON.id, mf_ix_ON, spike_generator_on.id), post_cell_id='../{}/{}/{}'.format(GrCPop.id, grc_ix, iaF_GrC.id)) ONprojectionAMPA.connections.append(connection) ONprojectionNMDA.connections.append(connection) ix = ix + 1 # OFF MFs: locations and connectivity OFFprojectionAMPA = nml.Projection( id="OFFProjAMPA", presynaptic_population=mossySpikersPopOFF.id, postsynaptic_population=GrCPop.id, synapse=rothmanMFToGrCAMPA) OFFprojectionNMDA = nml.Projection( id="OFFProjNMDA", presynaptic_population=mossySpikersPopOFF.id, postsynaptic_population=GrCPop.id, synapse=rothmanMFToGrCNMDA) net.projections.append(OFFprojectionAMPA) net.projections.append(OFFprojectionNMDA) ix = 0 for mf_ix_OFF in range(N_mf_OFF): mf_ix = mf_indices_OFF[mf_ix_OFF] inst = nml.Instance(id=mf_ix_OFF) mossySpikersPopOFF.instances.append(inst) inst.location = nml.Location(x=glom_pos[mf_ix, 0], y=glom_pos[mf_ix, 1], z=glom_pos[mf_ix, 2]) # find which granule cells are neighbors innervated_grcs = np.where(conn_mat[mf_ix, :] == 1)[0] for grc_ix in innervated_grcs: for synapse in [rothmanMFToGrCAMPA, rothmanMFToGrCNMDA]: connection = nml.Connection( id=ix, pre_cell_id='../{}/{}/{}'.format(mossySpikersPopOFF.id, mf_ix_OFF, spike_generator_on.id), post_cell_id='../{}/{}/{}'.format(GrCPop.id, grc_ix, iaF_GrC.id)) OFFprojectionAMPA.connections.append(connection) OFFprojectionNMDA.connections.append(connection) ix = ix + 1 # Write network to file net_file_name = 'OSBnet.nml' pynml.write_neuroml2_file(net_doc, net_file_name) # Write LEMS instances to file lems_instances_file_name = 'instances.xml' pynml.write_lems_file(lems_instances_doc, lems_instances_file_name, validate=False) # Create a LEMSSimulation to manage creation of LEMS file ls = LEMSSimulation( 'sim', duration, dt, simulation_seed=123) # int(np.round(1000*random.random()))) # Point to network as target of simulation ls.assign_simulation_target(net.id) # Include generated/existing NeuroML2 files ###ls.include_lems_file(spike_generator_file_name, include_included=False) ls.include_lems_file(lems_instances_file_name) ls.include_lems_file(ampa_syn_filename, include_included=False) ls.include_lems_file(nmda_syn_filename, include_included=False) ls.include_neuroml2_file(net_file_name) # Specify Displays and Output Files basedir = '' eof0 = 'Volts_file' ls.create_event_output_file(eof0, basedir + "MF_spikes.dat") for i in range(mossySpikersPopON.size): ls.add_selection_to_event_output_file( eof0, mf_indices_ON[i], '{}/{}/{}'.format(mossySpikersPopON.id, i, spike_generator_on.id), 'spike') for i in range(mossySpikersPopOFF.size): ls.add_selection_to_event_output_file( eof0, mf_indices_OFF[i], '{}/{}/{}'.format(mossySpikersPopOFF.id, i, spike_generator_on.id), 'spike') eof1 = 'GrCspike_file' ls.create_event_output_file(eof1, basedir + "GrC_spikes.dat") for i in range(GrCPop.size): ls.add_selection_to_event_output_file( eof1, i, '{}/{}/{}'.format(GrCPop.id, i, iaF_GrC.id), 'spike') lems_file_name = ls.save_to_file() if run: print('Running the generated LEMS file: %s for simulation of %sms' % (lems_file_name, duration)) results = pynml.run_lems_with_jneuroml(lems_file_name, max_memory="8G", nogui=True, load_saved_data=False, plot=False) return results
def create_GoC_network( duration, dt, seed, runid, run=False): ### ---------- Load Params noPar = True pfile = Path('params_file.pkl') if pfile.exists(): print('Reading parameters from file:') file = open('params_file.pkl','rb') params_list = pkl.load(file) if len(params_list)>runid: p = params_list[runid] file.close() if noPar: p = inp.get_simulation_params( runid ) ### ---------- Component types goc_filename = 'GoC.cell.nml' # Golgi cell with channels goc_file = pynml.read_neuroml2_file( goc_filename ) goc_type = goc_file.cells[0] goc_ref = nml.IncludeType( href=goc_filename ) MFSyn_filename = 'MF_GoC_Syn.nml' # small conductance synapse for background inputs mfsyn_file = pynml.read_neuroml2_file( MFSyn_filename ) MFSyn_type = mfsyn_file.exp_three_synapses[0] mfsyn_ref = nml.IncludeType( href=MFSyn_filename ) MF20Syn_filename = 'MF_GoC_SynMult.nml' # multi-syn conductance for strong/coincident transient input mf20syn_file = pynml.read_neuroml2_file( MF20Syn_filename ) MF20Syn_type = mf20syn_file.exp_three_synapses[0] mf20syn_ref = nml.IncludeType( href=MF20Syn_filename ) mf_type2 = 'spikeGeneratorPoisson' # Spike source for background inputs mf_poisson = nml.SpikeGeneratorPoisson( id = "MF_Poisson", average_rate="5 Hz" ) # Not tuned to any data - qqq ! mf_bursttype = 'transientPoissonFiringSynapse' # Burst of MF input (as explicit input) mf_burst = nml.TransientPoissonFiringSynapse( id="MF_Burst", average_rate="100 Hz", delay="2000 ms", duration="500 ms", synapse=MF20Syn_type.id, spike_target='./{}'.format(MF20Syn_type.id) ) gj = nml.GapJunction( id="GJ_0", conductance="426pS" ) # GoC synapse ### --------- Populations # Build network to specify cells and connectivity net = nml.Network( id="gocNetwork", type="networkWithTemperature" , temperature="23 degC" ) # Create GoC population goc_pop = nml.Population( id=goc_type.id+"Pop", component = goc_type.id, type="populationList", size=p["nGoC"] ) for goc in range( p["nGoC"] ): inst = nml.Instance( id=goc ) goc_pop.instances.append( inst ) inst.location = nml.Location( x=p["GoC_pos"][goc,0], y=p["GoC_pos"][goc,1], z=p["GoC_pos"][goc,2] ) net.populations.append( goc_pop ) ### MF population MF_Poisson_pop = nml.Population(id=mf_poisson.id+"_pop", component=mf_poisson.id, type="populationList", size=p["nMF"]) for mf in range( p["nMF"] ): inst = nml.Instance(id=mf) MF_Poisson_pop.instances.append( inst ) inst.location = nml.Location( x=p["MF_pos"][mf,0], y=p["MF_pos"][mf,1], z=p["MF_pos"][mf,2] ) net.populations.append( MF_Poisson_pop ) # Create NML document for network specification net_doc = nml.NeuroMLDocument( id=net.id ) net_doc.networks.append( net ) net_doc.includes.append( goc_ref ) net_doc.includes.append( mfsyn_ref ) net_doc.includes.append( mf20syn_ref ) net_doc.spike_generator_poissons.append( mf_poisson ) net_doc.transient_poisson_firing_synapses.append( mf_burst ) net_doc.gap_junctions.append(gj) ### ------------ Connectivity ### 1. Background excitatory inputs: MF to GoC populations MFProjection = nml.Projection(id="MFtoGoC", presynaptic_population=MF_Poisson_pop.id, postsynaptic_population=goc_pop.id, synapse=MFSyn_type.id) net.projections.append(MFProjection) # MF_> GoC synapses (with syn_count equivalent to integer scaling of Mf synapse strength) nMFSyn = p["MF_GoC_pairs"].shape[1] ctr=0 for syn in range( nMFSyn ): mf, goc = p["MF_GoC_pairs"][:, syn] for syn_count in range(p["MF_GoC_wt"][ctr]): conn2 = nml.Connection(id=ctr, pre_cell_id='../{}/{}/{}'.format(MF_Poisson_pop.id, mf, mf_poisson.id), post_cell_id='../{}/{}/{}'.format(goc_pop.id, goc, goc_type.id), post_segment_id='0', post_fraction_along="0.5") #on soma MFProjection.connections.append(conn2) ctr+=1 ### 2. Perturbation as High Freq MF Inputs ctr=0 for goc in p["Burst_GoC"]: for jj in range( p["nBurst"] ): # Each Perturbed GoC gets nBurst random Burst sources inst = nml.ExplicitInput( id=ctr, target='../{}/{}/{}'.format(goc_pop.id, goc, goc_type.id), input=mf_burst.id, synapse=MF20Syn_type.id, spikeTarget='./{}'.format(MF20Syn_type.id)) net.explicit_inputs.append( inst ) ctr += 1 ### 3. Electrical coupling between GoCs GoCCoupling = nml.ElectricalProjection( id="gocGJ", presynaptic_population=goc_pop.id, postsynaptic_population=goc_pop.id ) net.electrical_projections.append( GoCCoupling ) dend_id = [1,2,5] for jj in range( p["GJ_pairs"].shape[0] ): conn = nml.ElectricalConnectionInstanceW( id=jj, pre_cell='../{}/{}/{}'.format(goc_pop.id, p["GJ_pairs"][jj,0], goc_type.id), pre_segment=dend_id[p["GJ_loc"][jj,0]], pre_fraction_along='0.5', post_cell='../{}/{}/{}'.format(goc_pop.id, p["GJ_pairs"][jj,1], goc_type.id), post_segment=dend_id[p["GJ_loc"][jj,1]], post_fraction_along='0.5', synapse=gj.id, weight=p["GJ_wt"][jj] ) GoCCoupling.electrical_connection_instance_ws.append( conn ) ### -------------- Write files net_filename = 'gocNetwork.nml' pynml.write_neuroml2_file( net_doc, net_filename ) simid = 'sim_gocnet_'+goc_type.id+'_run_{}'.format(runid) ls = LEMSSimulation( simid, duration=duration, dt=dt, simulation_seed=seed ) ls.assign_simulation_target( net.id ) ls.include_neuroml2_file( net_filename) ls.include_neuroml2_file( goc_filename) ls.include_neuroml2_file( MFSyn_filename) ls.include_neuroml2_file( MF20Syn_filename) # Specify outputs eof0 = 'Events_file' ls.create_event_output_file(eof0, "%s.v.spikes"%simid,format='ID_TIME') for jj in range( goc_pop.size): ls.add_selection_to_event_output_file( eof0, jj, '{}/{}/{}'.format( goc_pop.id, jj, goc_type.id), 'spike' ) of0 = 'Volts_file' ls.create_output_file(of0, "%s.v.dat"%simid) for jj in range( goc_pop.size ): ls.add_column_to_output_file(of0, jj, '{}/{}/{}/v'.format( goc_pop.id, jj, goc_type.id)) #Create Lems file to run lems_simfile = ls.save_to_file() if run: res = pynml.run_lems_with_jneuroml_neuron( lems_simfile, max_memory="2G", nogui=True, plot=False) else: res = pynml.run_lems_with_jneuroml_neuron( lems_simfile, max_memory="2G", only_generate_scripts = True, compile_mods = False, nogui=True, plot=False) return res
def create_GoC_network(duration, dt, seed, runid, run=False): ### ---------- Load Params noPar = True pfile = Path('params_file.pkl') if pfile.exists(): print('Reading parameters from file:') file = open('params_file.pkl', 'rb') params_list = pkl.load(file) if len(params_list) > runid: p = params_list[runid] file.close() if noPar: p = inp.get_simulation_params(runid) ### ---------- Component types goc_filename = 'GoC.cell.nml' # Golgi cell with channels goc_file = pynml.read_neuroml2_file(goc_filename) goc_type = goc_file.cells[0] goc_ref = nml.IncludeType(href=goc_filename) gj = nml.GapJunction(id="GJ_0", conductance="426pS") # GoC synapse ### --------- Populations # Build network to specify cells and connectivity net = nml.Network(id="gocNetwork", type="networkWithTemperature", temperature="23 degC") # Create GoC population goc_pop = nml.Population(id=goc_type.id + "Pop", component=goc_type.id, type="populationList", size=p["nGoC"]) for goc in range(p["nGoC"]): inst = nml.Instance(id=goc) goc_pop.instances.append(inst) inst.location = nml.Location(x=p["GoC_pos"][goc, 0], y=p["GoC_pos"][goc, 1], z=p["GoC_pos"][goc, 2]) net.populations.append(goc_pop) # Create NML document for network specification net_doc = nml.NeuroMLDocument(id=net.id) net_doc.networks.append(net) net_doc.includes.append(goc_ref) net_doc.gap_junctions.append(gj) ### ------------ Connectivity ### 1. Input Current to one cell ctr = 0 for goc in p["Test_GoC"]: for jj in range(p["nSteps"]): input_id = 'stim_{}'.format(ctr) istep = nml.PulseGenerator( id=input_id, delay='{} ms'.format(p["iDuration"] * jj + p["iRest"] * (jj + 1)), duration='{} ms'.format(p["iDuration"]), amplitude='{} pA'.format(p["iAmp"][jj])) net_doc.pulse_generators.append(istep) input_list = nml.InputList(id='ilist_{}'.format(ctr), component=istep.id, populations=goc_pop.id) curr_inj = nml.Input('0', target="../%s[%i]" % (goc_pop.id, goc), destination="synapses") input_list.input.append(curr_inj) net.input_lists.append(input_list) ctr += 1 ### 2. Electrical coupling between GoCs GoCCoupling = nml.ElectricalProjection(id="gocGJ", presynaptic_population=goc_pop.id, postsynaptic_population=goc_pop.id) net.electrical_projections.append(GoCCoupling) dend_id = [1, 2, 5] for jj in range(p["GJ_pairs"].shape[0]): conn = nml.ElectricalConnectionInstanceW( id=jj, pre_cell='../{}/{}/{}'.format(goc_pop.id, p["GJ_pairs"][jj, 0], goc_type.id), pre_segment=dend_id[p["GJ_loc"][jj, 0]], pre_fraction_along='0.5', post_cell='../{}/{}/{}'.format(goc_pop.id, p["GJ_pairs"][jj, 1], goc_type.id), post_segment=dend_id[p["GJ_loc"][jj, 1]], post_fraction_along='0.5', synapse=gj.id, weight=p["GJ_wt"][jj]) GoCCoupling.electrical_connection_instance_ws.append(conn) ### -------------- Write files net_filename = 'gocNetwork.nml' pynml.write_neuroml2_file(net_doc, net_filename) simid = 'sim_gocnet_' + goc_type.id + '_run_{}'.format(runid) ls = LEMSSimulation(simid, duration=duration, dt=dt, simulation_seed=seed) ls.assign_simulation_target(net.id) ls.include_neuroml2_file(net_filename) ls.include_neuroml2_file(goc_filename) # Specify outputs eof0 = 'Events_file' ls.create_event_output_file(eof0, "%s.v.spikes" % simid, format='ID_TIME') for jj in range(goc_pop.size): ls.add_selection_to_event_output_file( eof0, jj, '{}/{}/{}'.format(goc_pop.id, jj, goc_type.id), 'spike') of0 = 'Volts_file' ls.create_output_file(of0, "%s.v.dat" % simid) ctr = 0 for jj in p["Test_GoC"]: ls.add_column_to_output_file( of0, jj, '{}/{}/{}/v'.format(goc_pop.id, ctr, goc_type.id)) ctr += 1 #Create Lems file to run lems_simfile = ls.save_to_file() if run: res = pynml.run_lems_with_jneuroml_neuron(lems_simfile, max_memory="2G", nogui=True, plot=False) else: res = pynml.run_lems_with_jneuroml_neuron(lems_simfile, max_memory="2G", only_generate_scripts=True, compile_mods=False, nogui=True, plot=False) return res
def create_GoC_network(duration=2000, dt=0.025, seed=123, runid=0, run=False, minI=-75, maxI=200, iStep=25, iDur=400, iRest=500): file = open('useParams_SpontFreq_7_pm_2.pkl', 'rb') use_params = pkl.load(file)["useParams"] file.close() runid = use_params[0][runid] print('Using parameter set = ', runid) ### ---------- Component types gocID = 'GoC_' + format(runid, '05d') goc_filename = '{}.cell.nml'.format(gocID) goc_type = pynml.read_neuroml2_file(goc_filename).cells[0] ### --------- Populations # Build network to specify cells and connectivity net = nml.Network(id='GoCNet_' + format(runid, '05d'), type="networkWithTemperature", temperature="23 degC") # Create GoC population goc_pop = nml.Population(id=goc_type.id + "Pop", component=goc_type.id, type="populationList", size=1) inst = nml.Instance(id=0) goc_pop.instances.append(inst) inst.location = nml.Location(x=0, y=0, z=0) net.populations.append(goc_pop) # Create NML document for network specification net_doc = nml.NeuroMLDocument(id=net.id) net_doc.networks.append(net) net_doc.includes.append(nml.IncludeType(href=goc_filename)) # Add Current Injection ctr = 0 goc = 0 p = { "iAmp": np.arange(minI, maxI + iStep / 2, iStep), "iDuration": iDur, "iRest": iRest } p["nSteps"] = p["iAmp"].shape[0] for jj in range(p["nSteps"]): input_id = 'stim_{}'.format(ctr) istep = nml.PulseGenerator(id=input_id, delay='{} ms'.format(p["iDuration"] * jj + p["iRest"] * (jj + 1)), duration='{} ms'.format(p["iDuration"]), amplitude='{} pA'.format(p["iAmp"][jj])) net_doc.pulse_generators.append(istep) input_list = nml.InputList(id='ilist_{}'.format(ctr), component=istep.id, populations=goc_pop.id) curr_inj = nml.Input('0', target="../%s[%i]" % (goc_pop.id, goc), destination="synapses") input_list.input.append(curr_inj) net.input_lists.append(input_list) ctr += 1 ### -------------- Write files net_filename = 'GoCNet_istep_' + format(runid, '05d') + '.nml' pynml.write_neuroml2_file(net_doc, net_filename) simid = 'sim_gocnet_istep_' + goc_type.id ls = LEMSSimulation(simid, duration=duration, dt=dt, simulation_seed=seed) ls.assign_simulation_target(net.id) ls.include_neuroml2_file(net_filename) ls.include_neuroml2_file(goc_filename) # Specify outputs eof0 = 'Events_file' ls.create_event_output_file(eof0, "%s.v.spikes" % simid, format='ID_TIME') for jj in range(goc_pop.size): ls.add_selection_to_event_output_file( eof0, jj, '{}/{}/{}'.format(goc_pop.id, jj, goc_type.id), 'spike') of0 = 'Volts_file' ls.create_output_file(of0, "%s.v.dat" % simid) for jj in range(goc_pop.size): ls.add_column_to_output_file( of0, jj, '{}/{}/{}/v'.format(goc_pop.id, jj, goc_type.id)) #Create Lems file to run lems_simfile = ls.save_to_file() if run: res = pynml.run_lems_with_jneuroml_neuron(lems_simfile, max_memory="2G", nogui=True, plot=False) else: res = pynml.run_lems_with_jneuroml_neuron(lems_simfile, max_memory="2G", only_generate_scripts=True, compile_mods=False, nogui=True, plot=False) return res
pref_duration_ms, pref_dt_ms, # used in Allen Neuron runs "LEMS_%s.xml"%model_id, nml2_cell_dir, copy_neuroml = False, lems_file_generate_seed=1234) net_doc.includes.append(neuroml.IncludeType(nml_cell_file)) pop = neuroml.Population(id="Pop_%s"%model_id, component=cell.id, type="populationList") net.populations.append(pop) inst = neuroml.Instance(id="0") pop.instances.append(inst) width = 7 X = count%width Z = (count -X) / width inst.location = neuroml.Location(x=300*X, y=0, z=300*Z) count+=1 net_file = '%s/%s.net.nml'%(nml2_cell_dir,net_ref) neuroml.writers.NeuroMLWriter.write(net_doc, net_file) print("Written network with %i cells in network to: %s"%(count,net_file)) pynml.nml2_to_svg(net_file)
def create_GoC_network(duration=2000, dt=0.025, seed=123, runid=0, run=False): keepFile = open('useParams_FI_14_25.pkl', 'rb') runid = pkl.load(keepFile)[runid] keepFile.close() ### ---------- Component types gocID = 'Golgi_040408_C1_' + format(runid, '05d') goc_filename = '{}.cell.nml'.format(gocID) goc_type = pynml.read_neuroml2_file(goc_filename).cells[0] ### --------- Populations # Build network to specify cells and connectivity net = nml.Network(id='MorphoNet_' + format(runid, '05d'), type="networkWithTemperature", temperature="23 degC") # Create GoC population goc_pop = nml.Population(id=goc_type.id + "Pop", component=goc_type.id, type="populationList", size=1) inst = nml.Instance(id=0) goc_pop.instances.append(inst) inst.location = nml.Location(x=0, y=0, z=0) net.populations.append(goc_pop) # Create NML document for network specification net_doc = nml.NeuroMLDocument(id=net.id) net_doc.networks.append(net) net_doc.includes.append(nml.IncludeType(href=goc_filename)) ### -------------- Write files net_filename = 'Morpho1_' + format(runid, '05d') + '.nml' pynml.write_neuroml2_file(net_doc, net_filename) simid = 'sim_morpho1_' + goc_type.id ls = LEMSSimulation(simid, duration=duration, dt=dt, simulation_seed=seed) ls.assign_simulation_target(net.id) ls.include_neuroml2_file(net_filename) ls.include_neuroml2_file(goc_filename) # Specify outputs eof0 = 'Events_file' ls.create_event_output_file(eof0, "%s.v.spikes" % simid, format='ID_TIME') for jj in range(goc_pop.size): ls.add_selection_to_event_output_file( eof0, jj, '{}/{}/{}'.format(goc_pop.id, jj, goc_type.id), 'spike') of0 = 'Volts_file' ls.create_output_file(of0, "%s.v.dat" % simid) for jj in range(goc_pop.size): ls.add_column_to_output_file( of0, jj, '{}/{}/{}/v'.format(goc_pop.id, jj, goc_type.id)) #Create Lems file to run lems_simfile = ls.save_to_file() if run: res = pynml.run_lems_with_jneuroml_neuron(lems_simfile, max_memory="2G", nogui=True, plot=False) else: res = pynml.run_lems_with_jneuroml_neuron(lems_simfile, max_memory="2G", only_generate_scripts=True, compile_mods=False, nogui=True, plot=False) return res
def create_populations(net, cell_types, nrn_runname, randomSeed): ''' Reads original data files (mainly position.dat) and creates population of cells :param net: neuroml.Network() - to which the populations will be added :param cell_types: list - (just to avoid multiple declaration of cell_types) :param nrn_runname: string - name of the directory where the saved data files are stored (celltype.dat, position.dat) :param randoSeed: int - seed for random color generation :return dCellIDs: dictionary - key: cellID, value: [cell_type, ID in pop_cell_type] (for creating synapses) :return dNumCells: dictonary with the number of cells in a given population (for creating output files -> just for "real cells") ''' # read in cell gids: fCellIDs = "../../results/%s/celltype.dat" % nrn_runname dCellIDs = {} with open(fCellIDs) as file: next( file ) # skip header: "celltype, techtype, typeIndex, rangeStart, rangeEnd" for line in file: if line.split()[0] not in ["ca3cell", "eccell"]: cell_type = line.split()[1][:-4] else: cell_type = line.split()[0][:-4] rangeStart = int(line.split()[3]) rangeEnd = int(line.split()[4]) if rangeStart == rangeEnd: dCellIDs[rangeStart] = [cell_type, 0] elif rangeStart < rangeEnd: for ind, i in enumerate(range(rangeStart, rangeEnd + 1)): dCellIDs[i] = [cell_type, ind] else: raise AssertionError( "rangeEnd:%g is lower than rangeStart:%g!" % (rangeEnd, rangeStart)) file.close() # read in cell positions fPositions = "../../results/%s/position.dat" % nrn_runname dCellPops = {} with open(fPositions) as file: next(file) # skip header: "cell, x, y, z, host" for line in file: cellID = int(line.split()[0]) if cellID in dCellIDs: cell_type = dCellIDs[cellID][0] pos = [ float(line.split()[1]), float(line.split()[2]), float(line.split()[3]) ] if cell_type not in dCellPops: dCellPops[cell_type] = [] dCellPops[cell_type].append(pos) else: dCellPops[cell_type].append(pos) file.close() ##### add populations to nml file ##### dNumCells = { } # for creating displays and output files (see later in the code) j = 0 # for increasing random seed in random colour generation for cell_type, pop_list in dCellPops.iteritems(): if cell_type in cell_types: dNumCells[cell_type] = 0 component = "%scell" % cell_type else: component = "spikeGenPoisson" # TODO: implement other stimulations ... popID = "pop_%s" % cell_type pop = neuroml.Population(id=popID, component=component, type="populationList", size=len(pop_list)) pop.properties.append( neuroml.Property("color", helper_getnextcolor(randomSeed + j))) net.populations.append(pop) j += 1 for i, sublist in enumerate(pop_list): x_pos = sublist[0] y_pos = sublist[1] z_pos = sublist[2] inst = neuroml.Instance(id=i) pop.instances.append(inst) inst.location = neuroml.Location(x=x_pos, y=y_pos, z=z_pos) if cell_type in cell_types: dNumCells[cell_type] += 1 return dCellIDs, dNumCells
def create_GoC_network(duration, dt, seed, N_goc=0, N_mf=15, run=False, prob_type='Boltzmann', GJw_type='Vervaeke2010'): ### ---------- Component types goc_filename = 'GoC.cell.nml' # Golgi cell with channels goc_file = pynml.read_neuroml2_file(goc_filename) goc_type = goc_file.cells[0] goc_ref = nml.IncludeType(href=goc_filename) MFSyn_filename = 'MF_GoC_Syn.nml' # small conductance synapse for background inputs mfsyn_file = pynml.read_neuroml2_file(MFSyn_filename) MFSyn_type = mfsyn_file.exp_three_synapses[0] mfsyn_ref = nml.IncludeType(href=MFSyn_filename) MF20Syn_filename = 'MF_GoC_SynMult.nml' # multi-syn conductance for strong/coincident transient input mf20syn_file = pynml.read_neuroml2_file(MF20Syn_filename) MF20Syn_type = mf20syn_file.exp_three_synapses[0] mf20syn_ref = nml.IncludeType(href=MF20Syn_filename) mf_type2 = 'spikeGeneratorPoisson' # Spike source for background inputs mf_poisson = nml.SpikeGeneratorPoisson( id="MF_Poisson", average_rate="5 Hz") # Not tuned to any data - qqq ! mf_bursttype = 'transientPoissonFiringSynapse' # Burst of MF input (as explicit input) mf_burst = nml.TransientPoissonFiringSynapse(id="MF_Burst", average_rate="100 Hz", delay="2000 ms", duration="500 ms", synapse=MF20Syn_type.id, spike_target='./{}'.format( MF20Syn_type.id)) gj = nml.GapJunction(id="GJ_0", conductance="426pS") # GoC synapse ### --------- Populations # Build network to specify cells and connectivity net = nml.Network(id="gocNetwork", type="networkWithTemperature", temperature="23 degC") ### Golgi cells if N_goc > 0: GoC_pos = nu.GoC_locate(N_goc) else: GoC_pos = nu.GoC_density_locate() N_goc = GoC_pos.shape[0] # Create GoC population goc_pop = nml.Population(id=goc_type.id + "Pop", component=goc_type.id, type="populationList", size=N_goc) for goc in range(N_goc): inst = nml.Instance(id=goc) goc_pop.instances.append(inst) inst.location = nml.Location(x=GoC_pos[goc, 0], y=GoC_pos[goc, 1], z=GoC_pos[goc, 2]) net.populations.append(goc_pop) ### MF population MF_Poisson_pop = nml.Population(id=mf_poisson.id + "_pop", component=mf_poisson.id, type="populationList", size=N_mf) MF_pos = nu.GoC_locate(N_mf) for mf in range(N_mf): inst = nml.Instance(id=mf) MF_Poisson_pop.instances.append(inst) inst.location = nml.Location(x=MF_pos[mf, 0], y=MF_pos[mf, 1], z=MF_pos[mf, 2]) net.populations.append(MF_Poisson_pop) # Create NML document for network specification net_doc = nml.NeuroMLDocument(id=net.id) net_doc.networks.append(net) net_doc.includes.append(goc_ref) net_doc.includes.append(mfsyn_ref) net_doc.includes.append(mf20syn_ref) net_doc.spike_generator_poissons.append(mf_poisson) net_doc.transient_poisson_firing_synapses.append(mf_burst) net_doc.gap_junctions.append(gj) ### ------------ Connectivity ### background excitatory inputs: MF to GoC populations MFProjection = nml.Projection(id="MFtoGoC", presynaptic_population=MF_Poisson_pop.id, postsynaptic_population=goc_pop.id, synapse=MFSyn_type.id) net.projections.append(MFProjection) #Get list of MF->GoC synapse mf_synlist = nu.randdist_MF_syn(N_mf, N_goc, pConn=0.3) # Not tuned to any data - qqq! nMFSyn = mf_synlist.shape[1] for syn in range(nMFSyn): mf, goc = mf_synlist[:, syn] conn2 = nml.Connection( id=syn, pre_cell_id='../{}/{}/{}'.format(MF_Poisson_pop.id, mf, mf_poisson.id), post_cell_id='../{}/{}/{}'.format(goc_pop.id, goc, goc_type.id), post_segment_id='0', post_fraction_along="0.5") #on soma MFProjection.connections.append(conn2) ### Add few burst inputs n_bursts = 4 gocPerm = np.random.permutation( N_goc) # change to central neurons later -qqq !!! ctr = 0 for gg in range(4): goc = gocPerm[gg] for jj in range(n_bursts): inst = nml.ExplicitInput( id=ctr, target='../{}/{}/{}'.format(goc_pop.id, goc, goc_type.id), input=mf_burst.id, synapse=MF20Syn_type.id, spikeTarget='./{}'.format(MF20Syn_type.id)) net.explicit_inputs.append(inst) ctr += 1 ### Electrical coupling between GoCs # get GJ connectivity GJ_pairs, GJWt = nu.GJ_conn(GoC_pos, prob_type, GJw_type) #tmp1, tmp2 = valnet.gapJuncAnalysis( GJ_pairs, GJWt ) #print("Number of gap junctions per cell: ", tmp1) #print("Net GJ conductance per cell:", tmp2) # Add electrical synapses GoCCoupling = nml.ElectricalProjection(id="gocGJ", presynaptic_population=goc_pop.id, postsynaptic_population=goc_pop.id) nGJ = GJ_pairs.shape[0] for jj in range(nGJ): conn = nml.ElectricalConnectionInstanceW( id=jj, pre_cell='../{}/{}/{}'.format(goc_pop.id, GJ_pairs[jj, 0], goc_type.id), pre_segment='1', pre_fraction_along='0.5', post_cell='../{}/{}/{}'.format(goc_pop.id, GJ_pairs[jj, 1], goc_type.id), post_segment='1', post_fraction_along='0.5', synapse=gj.id, weight=GJWt[jj]) GoCCoupling.electrical_connection_instance_ws.append(conn) net.electrical_projections.append(GoCCoupling) ### -------------- Write files net_filename = 'gocNetwork.nml' pynml.write_neuroml2_file(net_doc, net_filename) #lems_filename = 'instances.xml' #pynml.write_lems_file( lems_inst_doc, lems_filename, validate=False ) simid = 'sim_gocnet' + goc_type.id ls = LEMSSimulation(simid, duration=duration, dt=dt, simulation_seed=seed) ls.assign_simulation_target(net.id) ls.include_neuroml2_file(net_filename) ls.include_neuroml2_file(goc_filename) ls.include_neuroml2_file(MFSyn_filename) ls.include_neuroml2_file(MF20Syn_filename) #ls.include_lems_file( lems_filename, include_included=False) # Specify outputs eof0 = 'Events_file' ls.create_event_output_file(eof0, "%s.v.spikes" % simid, format='ID_TIME') for jj in range(goc_pop.size): ls.add_selection_to_event_output_file( eof0, jj, '{}/{}/{}'.format(goc_pop.id, jj, goc_type.id), 'spike') of0 = 'Volts_file' ls.create_output_file(of0, "%s.v.dat" % simid) for jj in range(goc_pop.size): ls.add_column_to_output_file( of0, jj, '{}/{}/{}/v'.format(goc_pop.id, jj, goc_type.id)) #Create Lems file to run lems_simfile = ls.save_to_file() if run: res = pynml.run_lems_with_jneuroml_neuron(lems_simfile, max_memory="2G", nogui=True, plot=False) else: res = pynml.run_lems_with_jneuroml_neuron(lems_simfile, max_memory="2G", only_generate_scripts=True, compile_mods=False, nogui=True, plot=False) return res
net_ref = "BC_StimNet" net_doc = neuroml.NeuroMLDocument(id=net_ref) net = neuroml.Network(id=net_ref) net_doc.networks.append(net) cell_id = 'BC2_na_k' net_doc.includes.append(neuroml.IncludeType(cell_id + '.cell.nml')) pop = neuroml.Population(id="BC", component=cell_id, type="populationList") inst = neuroml.Instance(id="0") pop.instances.append(inst) inst.location = neuroml.Location(x=0, y=0, z=0) net.populations.append(pop) stim = neuroml.PulseGenerator(id='stim0', delay='50ms', duration='200ms', amplitude='0.5nA') net_doc.pulse_generators.append(stim) input_list = neuroml.InputList(id="%s_input" % stim.id, component=stim.id, populations=pop.id) syn_input = neuroml.Input(id=0, target="../%s/0/%s" % (pop.id, pop.component),
def generate_WB_network(cell_id, synapse_id, numCells_bc, connection_probability, I_mean, I_sigma, generate_LEMS_simulation, duration, x_size=100, y_size=100, z_size=100, network_id=ref + 'Network', color='0 0 1', connection=True, temperature='37 degC', validate=True, dt=0.01): nml_doc = neuroml.NeuroMLDocument(id=network_id) nml_doc.includes.append(neuroml.IncludeType(href='WangBuzsaki.cell.nml')) nml_doc.includes.append(neuroml.IncludeType(href='WangBuzsakiSynapse.xml')) # Create network net = neuroml.Network(id=network_id, type='networkWithTemperature', temperature=temperature) net.notes = 'Network generated using libNeuroML v%s' % __version__ nml_doc.networks.append(net) # Create population pop = neuroml.Population(id=ref + 'pop', component=cell_id, type='populationList', size=numCells_bc) if color is not None: pop.properties.append(neuroml.Property('color', color)) net.populations.append(pop) for i in range(0, numCells_bc): inst = neuroml.Instance(id=i) pop.instances.append(inst) inst.location = neuroml.Location(x=str(x_size * rnd.random()), y=str(y_size * rnd.random()), z=str(z_size * rnd.random())) # Add connections proj = neuroml.ContinuousProjection(id=ref + 'proj', presynaptic_population=pop.id, postsynaptic_population=pop.id) conn_count = 0 for i in range(0, numCells_bc): for j in range(0, numCells_bc): if i != j and rnd.random() < connection_probability: connection = neuroml.ContinuousConnectionInstance( id=conn_count, pre_cell='../%s/%i/%s' % (pop.id, i, cell_id), pre_component='silent', post_cell='../%s/%i/%s' % (pop.id, j, cell_id), post_component=synapse_id) proj.continuous_connection_instances.append(connection) conn_count += 1 net.continuous_projections.append(proj) # make cell pop inhomogenouos (different V_init-s with voltage-clamp) vc_dur = 2 # ms for i in range(0, numCells_bc): tmp = -75 + (rnd.random() * 15) vc = neuroml.VoltageClamp(id='VClamp%i' % i, delay='0ms', duration='%ims' % vc_dur, simple_series_resistance='1e6ohm', target_voltage='%imV' % tmp) nml_doc.voltage_clamps.append(vc) input_list = neuroml.InputList(id='input_%i' % i, component='VClamp%i' % i, populations=pop.id) input = neuroml.Input(id=i, target='../%s/%i/%s' % (pop.id, i, cell_id), destination='synapses') input_list.input.append(input) net.input_lists.append(input_list) # Add outer input (IClamp) tmp = rnd.normal(I_mean, I_sigma**2, numCells_bc) # random numbers from Gaussian distribution for i in range(0, numCells_bc): pg = neuroml.PulseGenerator(id='IClamp%i' % i, delay='%ims' % vc_dur, duration='%ims' % (duration - vc_dur), amplitude='%fpA' % (tmp[i])) nml_doc.pulse_generators.append(pg) input_list = neuroml.InputList(id='input%i' % i, component='IClamp%i' % i, populations=pop.id) input = neuroml.Input(id=i, target='../%s/%i/%s' % (pop.id, i, cell_id), destination='synapses') input_list.input.append(input) net.input_lists.append(input_list) # Write to file nml_file = '%s100Cells.net.nml' % ref print 'Writing network file to:', nml_file, '...' neuroml.writers.NeuroMLWriter.write(nml_doc, nml_file) if validate: # Validate the NeuroML from neuroml.utils import validate_neuroml2 validate_neuroml2(nml_file) if generate_LEMS_simulation: # Vreate a LEMSSimulation to manage creation of LEMS file ls = LEMSSimulation(sim_id='%sNetSim' % ref, duration=duration, dt=dt) # Point to network as target of simulation ls.assign_simulation_target(net.id) # Incude generated/existing NeuroML2 files ls.include_neuroml2_file('WangBuzsaki.cell.nml', include_included=False) ls.include_neuroml2_file('WangBuzsakiSynapse.xml', include_included=False) ls.include_neuroml2_file(nml_file, include_included=False) # Specify Display and output files disp_bc = 'display_bc' ls.create_display(disp_bc, 'Basket Cell Voltage trace', '-80', '40') of_bc = 'volts_file_bc' ls.create_output_file(of_bc, 'wangbuzsaki_network.dat') of_spikes_bc = 'spikes_bc' ls.create_event_output_file(of_spikes_bc, 'wangbuzsaki_network_spikes.dat') max_traces = 9 # the 10th color in NEURON is white ... for i in range(numCells_bc): quantity = '%s/%i/%s/v' % (pop.id, i, cell_id) if i < max_traces: ls.add_line_to_display(disp_bc, 'BC %i: Vm' % i, quantity, '1mV', pynml.get_next_hex_color()) ls.add_column_to_output_file(of_bc, 'v_%i' % i, quantity) ls.add_selection_to_event_output_file(of_spikes_bc, i, select='%s/%i/%s' % (pop.id, i, cell_id), event_port='spike') # Save to LEMS file print 'Writing LEMS file...' lems_file_name = ls.save_to_file() else: ls = None lems_file_name = '' return ls, lems_file_name