def handle_single_input(self, inputListId, id, cellId, segId=0, fract=0.5, weight=1.0): input_list = self.input_lists[inputListId] target_path = "../%s/%i/%s" % ( input_list.populations, cellId, self.populations[input_list.populations].component) if self.populations[input_list.populations].type == None: target_path = "../%s[%i]" % (input_list.populations, cellId) if weight == 1: input = neuroml.Input(id=id, target=target_path, destination="synapses") if segId != 0: input.segment_id = "%s" % (segId) if fract != 0.5: input.fraction_along = "%s" % (fract) input_list.input.append(input) else: input_w = neuroml.InputW(id=id, target=target_path, destination="synapses") if segId != 0: input_w.segment_id = "%s" % (segId) if fract != 0.5: input_w.fraction_along = "%s" % (fract) input_w.weight = weight input_list.input_ws.append(input_w)
def init_voltage(nml_doc, net, dClamps, dNumCells): """ Initialise the voltage of cells with voltageClamps (-> no need to create new cell_type.cell.nml files...) :param nml_doc: neuroml.NeuroMLDocument() - to which the voltage clamps will be added :param net: neuroml.Network() - to which the inputs will be added :param dClamps: dictionary which contains the initial voltages (this in hard coded...) :param dNumCells: - dictionary created by create_populations, which specifies how many inputs will be added """ vcDur = 1 # ms for cell_type, numCells in dNumCells.iteritems(): clamp = dClamps[cell_type] vc = neuroml.VoltageClamp(id="vc_%s" % cell_type, delay="0ms", duration="%gms" % vcDur, simple_series_resistance="5e4ohm", target_voltage="%gmV" % clamp) nml_doc.voltage_clamps.append(vc) input_list = neuroml.InputList(id="input_vc_%s" % cell_type, populations="pop_%s" % cell_type, component="vc_%s" % cell_type) for i in range(0, numCells): inp = neuroml.Input(id=i, target="../pop_%s/%g/%scell" % (cell_type, i, cell_type), destination="synapses") input_list.input.append(inp) net.input_lists.append(input_list)
def handleSingleInput(self, inputListId, id, cellId, segId=0, fract=0.5): input_list = self.input_lists[inputListId] input = neuroml.Input( id=id, target="../%s/%i/%s" % (input_list.populations, cellId, self.populations[input_list.populations].component), destination="synapses") if segId != 0: input.segment_id = "%s" % (segId) if fract != 0.5: input.fraction_along = "%s" % (fract) input_list.input.append(input)
def variable_basal_firing_rate(popID, popSize, cellType, input_group_parameters, simulation_duration, seed_number): random.seed(seed_number) label = input_group_parameters['inputLabel'] offset_units = input_group_parameters['offsetUnits'] units = input_group_parameters['ampUnits'] input_list_array = [] pulse_generator_array = [] for cell in range(0, popSize): if "gaussian" == input_group_parameters["amplitudeDistribution"]: amp = random.gauss(input_group_parameters['averageAmp'], input_group_parameters['stDevAmp']) if "uniform" == input_group_parameters["amplitudeDistribution"]: amp = random.uniform(input_group_parameters['leftAmpBound'], input_group_parameters['rightAmpBound']) if "constant" == input_group_parameters["amplitudeDistribution"]: amp = input_group_parameters['valueAmp'] if "gaussian" == input_group_parameters["offsetDistribution"]: offset = random.gauss(input_group_parameters['averageOffset'], input_group_parameters['stDevOffset']) if "uniform" == input_group_parameters["offsetDistribution"]: offset = random.uniform(input_group_parameters['leftOffBound'], input_group_parameters['rightOffBound']) if "constant" == input_group_parameters["offsetDistribution"]: offset = input_group_parameters["valueOffset"] Pulse_generator_variable=neuroml.PulseGenerator(id="Pulse_%s_%s_%d"%(label,popID,cell),delay="%f%s"%(offset,offset_units),\ duration="%f%s"%((simulation_duration-offset),offset_units),amplitude="%f%s"%(amp,units)) pulse_generator_array.append(Pulse_generator_variable) Input_list = neuroml.InputList(id="%s_%s_%d" % (label, popID, cell), component="Pulse_%s_%s_%d" % (label, popID, cell), populations="%s" % popID) Inp = neuroml.Input(target="../%s/%d/%s" % (popID, cell, cellType), id="%d" % cell, destination="synapses") Input_list.input.append(Inp) input_list_array.append(Input_list) return input_list_array, pulse_generator_array
def inject_into(self, cells): __doc__ = StandardCurrentSource.inject_into.__doc__ logger.debug("%s injecting into: %s"%(self.__class__.__name__, cells)) self.nml_doc = _get_nml_doc() id = self.add_to_nml_doc(self.nml_doc, cells) for cell in cells: pop_id = cell.parent.label index = cell.parent.id_to_index(cell) celltype = cell.parent.celltype.__class__.__name__ logger.debug("Injecting: %s to %s (%s[%s])"%(id, cell, pop_id, index)) input_list = self._get_input_list(id, pop_id) input = neuroml.Input(id=len(input_list.input), target="../%s/%i/%s_%s"%(pop_id, index, celltype, pop_id), destination="synapses") input_list.input.append(input)
def __getitem__(self, index): #print(' Getting instance %s'%(index)) #print self.array id = self.array[index][self._get_index_or_add('id', 0)] assert (id == index) target_cell_id = int(self.array[index][self._get_index_or_add( 'target_cell_id', 1)]) segment_id = int(self.array[index][self._get_index_or_add( 'segment_id', 1)]) fraction_along = float(self.array[index][self._get_index_or_add( 'fraction_along', 1)]) input = neuroml.Input(id=index, target="../%s/%i/%s" % (self.target_population, target_cell_id, "???"), destination="synapses", segment_id=segment_id, fraction_along=fraction_along) return input
def testing(popID, popSize, cellType, input_group_parameters, seed_number, saveCellID): random.seed(seed_number) input_receiving_cells = [] amp_units = input_group_parameters['ampUnits'] time_units = input_group_parameters['timeUnits'] label = input_group_parameters['inputLabel'] randomly_select_target_cells = random.sample( range(popSize), int(round(popSize * input_group_parameters['cellFractionToTarget']))) pulseGenerator_array = [] input_list_array = [] for pulse_x in range(0, len(input_group_parameters['pulseParameters'])): Pulse_generator_x=neuroml.PulseGenerator(id="Pulse_%s_%s_%d"%(label,popID,pulse_x),\ delay="%f%s"%(input_group_parameters['pulseParameters'][pulse_x]['delay'],time_units),\ duration="%f%s"%(input_group_parameters['pulseParameters'][pulse_x]['duration'],time_units),\ amplitude="%f%s"%(input_group_parameters['pulseParameters'][pulse_x]['amplitude'],amp_units)) pulseGenerator_array.append(Pulse_generator_x) Input_list = neuroml.InputList(id="%s_%s_%d" % (label, popID, pulse_x), component="Pulse_%s_%s_%d" % (label, popID, pulse_x), populations="%s" % popID) for i in randomly_select_target_cells: if saveCellID: input_receiving_cells.append(i) Inp = neuroml.Input(target="../%s/%d/%s" % (popID, i, cellType), id="%d" % i, destination="synapses") Input_list.input.append(Inp) input_list_array.append(Input_list) return input_list_array, pulseGenerator_array, input_receiving_cells
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, 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 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
def add_targeted_inputs_to_population(net, id, population, input_comp_id, segment_group, number_per_cell=1, all_cells=False, only_cells=None): """ Add current input to the specified population. Attributes: `net` reference to the network object previously created `id` id of the <inputList> to be created `population` the <population> to be targeted `input_comp_id` id of the component to be used for the input (e.g. added with add_pulse_generator()) `segment_group` which segment group on the target cells to limit input locations to `number_per_cell` How many inputs to apply to each cell of the population. Default 1 `all_cells` whether to target all cells. Default False `only_cells` which specific cells to target. List of ids. Default None """ if all_cells and only_cells is not None: error = "Error! Method opencortex.build.%s() called with both arguments all_cells and only_cells set!" % sys._getframe( ).f_code.co_name opencortex.print_comment_v(error) raise Exception(error) cell_ids = [] target_cell = oc_build.cell_ids_vs_nml_docs[ population.component].get_by_id(population.component) target_segs = oc_build.extract_seg_ids(target_cell, [segment_group], "segGroups") seg_target_dict = oc_build.make_target_dict(target_cell, target_segs) subset_dict = {segment_group: number_per_cell} if all_cells: cell_ids = range(population.size) if only_cells is not None: if only_cells == []: return cell_ids = only_cells input_list = neuroml.InputList(id=id, component=input_comp_id, populations=population.id) count = 0 for cell_id in cell_ids: target_seg_array, target_fractions = oc_build.get_target_segments( seg_target_dict, subset_dict) for i in range(number_per_cell): input = neuroml.Input( id=count, target="../%s/%i/%s" % (population.id, cell_id, population.component), segment_id=target_seg_array[i], fraction_along=target_fractions[i], destination="synapses") input_list.input.append(input) count += 1 if count > 0: net.input_lists.append(input_list) return input_list
def XF_input_models_3D_region_specific(popID, cellType, cellNML2Type, input_group_parameters, cell_positions, seed_number, saveCellID, parentDir=None): random.seed(seed_number) input_receiving_cells = [] if parentDir != None: cellTypeFile = parentDir + "/NeuroML2" + "/" + cellType else: cellTypeFile = cellType fraction_to_target_per_pop = input_group_parameters['fractionToTarget'] dim_array = np.shape(cell_positions) region_specific_targets_per_cell_group = [] for region in range(0, len(input_group_parameters['regionList'])): for cell in range(0, dim_array[0]): if ( input_group_parameters['regionList'][region]['xVector'][0] < cell_positions[cell, 0] ) and (cell_positions[cell, 0] < input_group_parameters['regionList'][region]['xVector'][1]): if (input_group_parameters['regionList'][region]['yVector'][0] < cell_positions[cell, 1]) and ( cell_positions[cell, 1] < input_group_parameters['regionList'][region] ['yVector'][1]): if (input_group_parameters['regionList'][region]['zVector'] [0] < cell_positions[cell, 2]) and ( cell_positions[cell, 2] < input_group_parameters['regionList'][region] ['zVector'][1]): region_specific_targets_per_cell_group.append(cell) target_cells = random.sample( region_specific_targets_per_cell_group, int( round(fraction_to_target_per_pop * len(region_specific_targets_per_cell_group)))) label = input_group_parameters['inputLabel'] synapse_list = input_group_parameters['synapseList'] synapse_name_array = [] poisson_synapse_array = [] input_list_array = [] for synapse_index in range(0, len(synapse_list)): synapse_name = synapse_list[synapse_index]['synapseType'] synapse_name_array.append(synapse_name) synapse_dict = {} if synapse_list[synapse_index][ 'targetingModel'] == "segments and subsegments": segment_target_array=extract_morphology_information([cellTypeFile],{cellTypeFile:cellNML2Type},\ ["segments",synapse_list[synapse_index]['segmentList']]) if synapse_list[synapse_index][ 'targetingModel'] == "segment groups and segments": segment_target_array =extract_morphology_information([cellTypeFile],{cellTypeFile:cellNML2Type},\ ["segment groups",synapse_list[synapse_index]['segmentGroupList']]) if synapse_list[synapse_index]['synapseMode'] == "persistent": poisson_syn=neuroml.PoissonFiringSynapse(id="%s_%s_%s_syn%d"%(label,synapse_name,popID,synapse_index),\ average_rate="%f per_s"%synapse_list[synapse_index]['averageRate'],\ synapse=synapse_list[synapse_index]['synapseType'],\ spike_target="./%s"%synapse_list[synapse_index]['synapseType']) synapse_dict['synapseMode'] = "persistent" if synapse_list[synapse_index]['synapseMode'] == "transient": poisson_syn=neuroml.TransientPoissonFiringSynapse(id="%s_%s_%s_syn%d"%(label,synapse_name,popID,synapse_index),\ average_rate="%f per_s"%synapse_list[synapse_index]['averageRate'],\ synapse=synapse_list[synapse_index]['synapseType'] ,\ spike_target="./%s"%synapse_list[synapse_index]['synapseType'],\ delay="%f%s"%(synapse_list[synapse_index]['delay'],synapse_list[synapse_index]['units']),\ duration="%f%s"%(synapse_list[synapse_index]['duration'],synapse_list[synapse_index]['units'] ) ) synapse_dict['synapseMode'] = "transient" synapse_dict['synapse_object'] = poisson_syn poisson_synapse_array.append(synapse_dict) input_list = neuroml.InputList( id="List_%s_%s_%s_syn%d" % (label, synapse_name, popID, synapse_index), component=poisson_syn.id, populations="%s" % popID) count = 0 for target_cell in target_cells: if saveCellID: input_receiving_cells.append(target_cell) if synapse_list[synapse_index][ 'numberModel'] == "constant number of inputs per cell": no_of_inputs = synapse_list[synapse_index]['noInputs'] if synapse_list[synapse_index][ 'numberModel'] == "variable number of inputs per cell": if synapse_list[synapse_index]['distribution'] == "binomial": no_of_inputs=np.random.binomial(synapse_list[synapse_index]['maxNoInputs'],\ synapse_list[synapse_index]['averageNoInputs']/synapse_list[synapse_index]['maxNoInputs']) ### other options can be added if synapse_list[synapse_index][ 'targetingModel'] == "segment groups and segments": target_points=get_unique_target_points(segment_target_array,"segment groups and segments",\ [synapse_list[synapse_index]['segmentGroupList'],synapse_list[synapse_index]['segmentGroupProbabilities']],no_of_inputs) if synapse_list[synapse_index][ 'targetingModel'] == "segments and subsegments": target_points=get_unique_target_points(segment_target_array,"segments and subsegments",\ [synapse_list[synapse_index]['segmentList'],synapse_list[synapse_index]['segmentProbabilities'],\ synapse_list[synapse_index]['fractionAlongANDsubsegProbabilities']],no_of_inputs) for target_point in range(0, len(target_points)): syn_input = neuroml.Input(id="%d"%(count),target="../%s/%i/%s"%(popID,target_cell,cellType),\ destination="synapses",segment_id="%d"%target_points[target_point,0],fraction_along="%f"%target_points[target_point,1]) input_list.input.append(syn_input) count = count + 1 input_list_array.append(input_list) return input_list_array, poisson_synapse_array, synapse_name_array, input_receiving_cells
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_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
conn_count = 0 for pre in range(0, size0): # Create a number of random amplitude current pulses pg = neuroml.PulseGenerator(id="input%i" % pre, delay="0ms", duration="500ms", amplitude="%fnA" % (0.5 + random.random())) nml_doc.pulse_generators.append(pg) # Add these to cells input_list = neuroml.InputList(id="il%i" % pre, component=pg.id, populations=pop0.id) input = neuroml.Input(id=pre, target="../%s[%i]" % (pop0.id, pre), destination="synapses") input_list.input.append(input) net.input_lists.append(input_list) # Connect cells with defined probability prob_connection = 0.5 for post in range(0, size1): if random.random() <= prob_connection: conn = \ neuroml.Connection(id=conn_count, \ pre_cell_id="../%s[%i]" % (pop0.id, pre), post_cell_id="../%s[%i]" % (pop1.id, post)) proj1.connections.append(conn) conn_count += 1
net.populations.append(pop) pg = neuroml.PulseGenerator(id="pulseGen0", delay="100ms", duration="800ms", amplitude="28 pA") nml_doc.pulse_generators.append(pg) input_list = neuroml.InputList(id='il', component=pg.id, populations=pop.id) input = neuroml.Input( id=0, target="../%s/%i/%s" % (pop.id, 0, cell_comp), segment_id=3, # dend tip... destination="synapses") input_list.input.append(input) net.input_lists.append(input_list) nml_file = '%s/%s.net.nml' % (root_dir, reference) writers.NeuroMLWriter.write(nml_doc, nml_file) print("Written network file to: " + nml_file) ############################################ # Create the LEMS file with helper method sim_id = 'Sim%s' % reference target = net.id
sgp_pop = neuroml.Population(id="SpikeGeneratorPoissons", size=1, component=sgp.id) net.populations.append(sgp_pop) # Add inputs pfs_input_list = neuroml.InputList(id="pfsInput", component=pfs.id, populations=pyr_cells_pop0.id) net.input_lists.append(pfs_input_list) pfs_input_list.input.append( neuroml.Input(id=0, target='../%s/0/%s' % (pyr_cells_pop0.id, cell_id), destination="synapses")) pfs_input_list.input.append( neuroml.Input(id=1, target='../%s/1/%s' % (pyr_cells_pop0.id, cell_id), segment_id="2", destination="synapses")) pfs_input_list.input.append( neuroml.Input(id=2, target='../%s/2/%s' % (pyr_cells_pop0.id, cell_id), segment_id="4", destination="synapses")) tsi_input_list = neuroml.InputList(id="tsiInput", component=tsi.id, populations=pyr_cells_pop3.id)
new_net.populations[0].id = pop_id new_net.populations[0].component = pop_comp stim_ref = "stim" stim = neuroml.PulseGenerator(id=stim_ref, delay="1020ms", duration="1000ms", amplitude="%spA"%get_test_current(model_id)) new_net_doc.pulse_generators.append(stim) input_list = neuroml.InputList(id="%s_input"%stim_ref, component=stim_ref, populations=pop_id) input = neuroml.Input(id=0, target="../%s/0/%s"%(pop_id, pop_comp), destination="synapses") input_list.input.append(input) new_net.input_lists.append(input_list) pynml.write_neuroml2_file(new_net_doc, new_net_loc) generate_lems_file_for_neuroml(model_id, new_net_loc, "network", pref_duration_ms, pref_dt_ms, # used in Allen Neuron runs "LEMS_%s.xml"%model_id, nml2_cell_dir, copy_neuroml = False,
def generate_current_vs_frequency_curve(nml2_file, cell_id, start_amp_nA, end_amp_nA, step_nA, analysis_duration, analysis_delay, dt=0.05, temperature="32degC", spike_threshold_mV=0., plot_voltage_traces=False, plot_if=True, plot_iv=False, xlim_if=None, ylim_if=None, xlim_iv=None, ylim_iv=None, show_plot_already=True, save_if_figure_to=None, save_iv_figure_to=None, simulator="jNeuroML", include_included=True): from pyelectro.analysis import max_min from pyelectro.analysis import mean_spike_frequency import numpy as np print_comment_v( "Generating FI curve for cell %s in %s using %s (%snA->%snA; %snA steps)" % (cell_id, nml2_file, simulator, start_amp_nA, end_amp_nA, step_nA)) sim_id = 'iv_%s' % cell_id duration = analysis_duration + analysis_delay ls = LEMSSimulation(sim_id, duration, dt) ls.include_neuroml2_file(nml2_file, include_included=include_included) stims = [] amp = start_amp_nA while amp <= end_amp_nA: stims.append(amp) amp += step_nA number_cells = len(stims) pop = nml.Population(id="population_of_%s" % cell_id, component=cell_id, size=number_cells) # create network and add populations net_id = "network_of_%s" % cell_id net = nml.Network(id=net_id, type="networkWithTemperature", temperature=temperature) ls.assign_simulation_target(net_id) net_doc = nml.NeuroMLDocument(id=net.id) net_doc.networks.append(net) net_doc.includes.append(nml.IncludeType(nml2_file)) net.populations.append(pop) for i in range(number_cells): stim_amp = "%snA" % stims[i] input_id = ("input_%s" % stim_amp).replace('.', '_').replace('-', 'min') pg = nml.PulseGenerator(id=input_id, delay="0ms", duration="%sms" % duration, amplitude=stim_amp) net_doc.pulse_generators.append(pg) # Add these to cells input_list = nml.InputList(id=input_id, component=pg.id, populations=pop.id) input = nml.Input(id='0', target="../%s[%i]" % (pop.id, i), destination="synapses") input_list.input.append(input) net.input_lists.append(input_list) net_file_name = '%s.net.nml' % sim_id pynml.write_neuroml2_file(net_doc, net_file_name) ls.include_neuroml2_file(net_file_name) disp0 = 'Voltage_display' ls.create_display(disp0, "Voltages", "-90", "50") of0 = 'Volts_file' ls.create_output_file(of0, "%s.v.dat" % sim_id) for i in range(number_cells): ref = "v_cell%i" % i quantity = "%s[%i]/v" % (pop.id, i) ls.add_line_to_display(disp0, ref, quantity, "1mV", pynml.get_next_hex_color()) ls.add_column_to_output_file(of0, ref, quantity) 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) #print(results.keys()) if_results = {} iv_results = {} for i in range(number_cells): t = np.array(results['t']) * 1000 v = np.array(results["%s[%i]/v" % (pop.id, i)]) * 1000 mm = max_min(v, t, delta=0, peak_threshold=spike_threshold_mV) spike_times = mm['maxima_times'] freq = 0 if len(spike_times) > 2: count = 0 for s in spike_times: if s >= analysis_delay and s < (analysis_duration + analysis_delay): count += 1 freq = 1000 * count / float(analysis_duration) mean_freq = mean_spike_frequency(spike_times) # print("--- %s nA, spike times: %s, mean_spike_frequency: %f, freq (%fms -> %fms): %f"%(stims[i],spike_times, mean_freq, analysis_delay, analysis_duration+analysis_delay, freq)) if_results[stims[i]] = freq if freq == 0: iv_results[stims[i]] = v[-1] if plot_if: stims = sorted(if_results.keys()) stims_pA = [ii * 1000 for ii in stims] freqs = [if_results[s] for s in stims] pynml.generate_plot([stims_pA], [freqs], "Frequency versus injected current for: %s" % nml2_file, colors=['k'], linestyles=['-'], markers=['o'], xaxis='Input current (pA)', yaxis='Firing frequency (Hz)', xlim=xlim_if, ylim=ylim_if, grid=True, show_plot_already=False, save_figure_to=save_if_figure_to) if plot_iv: stims = sorted(iv_results.keys()) stims_pA = [ii * 1000 for ii in sorted(iv_results.keys())] vs = [iv_results[s] for s in stims] pynml.generate_plot( [stims_pA], [vs], "Final membrane potential versus injected current for: %s" % nml2_file, colors=['k'], linestyles=['-'], markers=['o'], xaxis='Input current (pA)', yaxis='Membrane potential (mV)', xlim=xlim_iv, ylim=ylim_iv, grid=True, show_plot_already=False, save_figure_to=save_iv_figure_to) if show_plot_already: from matplotlib import pyplot as plt plt.show() return if_results
def generate_current_vs_frequency_curve(nml2_file, cell_id, start_amp_nA=-0.1, end_amp_nA=0.1, step_nA=0.01, custom_amps_nA=[], analysis_duration=1000, analysis_delay=0, pre_zero_pulse=0, post_zero_pulse=0, dt=0.05, temperature="32degC", spike_threshold_mV=0., plot_voltage_traces=False, plot_if=True, plot_iv=False, xlim_if=None, ylim_if=None, xlim_iv=None, ylim_iv=None, label_xaxis=True, label_yaxis=True, show_volts_label=True, grid=True, font_size=12, if_iv_color='k', linewidth=1, bottom_left_spines_only=False, show_plot_already=True, save_voltage_traces_to=None, save_if_figure_to=None, save_iv_figure_to=None, save_if_data_to=None, save_iv_data_to=None, simulator="jNeuroML", num_processors=1, include_included=True, title_above_plot=False, return_axes=False, verbose=False): print_comment( "Running generate_current_vs_frequency_curve() on %s (%s)" % (nml2_file, os.path.abspath(nml2_file)), verbose) from pyelectro.analysis import max_min from pyelectro.analysis import mean_spike_frequency import numpy as np traces_ax = None if_ax = None iv_ax = None sim_id = 'iv_%s' % cell_id total_duration = pre_zero_pulse + analysis_duration + analysis_delay + post_zero_pulse pulse_duration = analysis_duration + analysis_delay end_stim = pre_zero_pulse + analysis_duration + analysis_delay ls = LEMSSimulation(sim_id, total_duration, dt) ls.include_neuroml2_file(nml2_file, include_included=include_included) stims = [] if len(custom_amps_nA) > 0: stims = [float(a) for a in custom_amps_nA] stim_info = ['%snA' % float(a) for a in custom_amps_nA] else: amp = start_amp_nA while amp <= end_amp_nA: stims.append(amp) amp += step_nA stim_info = '(%snA->%snA; %s steps of %snA; %sms)' % ( start_amp_nA, end_amp_nA, len(stims), step_nA, total_duration) print_comment_v("Generating an IF curve for cell %s in %s using %s %s" % (cell_id, nml2_file, simulator, stim_info)) number_cells = len(stims) pop = nml.Population(id="population_of_%s" % cell_id, component=cell_id, size=number_cells) # create network and add populations net_id = "network_of_%s" % cell_id net = nml.Network(id=net_id, type="networkWithTemperature", temperature=temperature) ls.assign_simulation_target(net_id) net_doc = nml.NeuroMLDocument(id=net.id) net_doc.networks.append(net) net_doc.includes.append(nml.IncludeType(nml2_file)) net.populations.append(pop) for i in range(number_cells): stim_amp = "%snA" % stims[i] input_id = ("input_%s" % stim_amp).replace('.', '_').replace('-', 'min') pg = nml.PulseGenerator(id=input_id, delay="%sms" % pre_zero_pulse, duration="%sms" % pulse_duration, amplitude=stim_amp) net_doc.pulse_generators.append(pg) # Add these to cells input_list = nml.InputList(id=input_id, component=pg.id, populations=pop.id) input = nml.Input(id='0', target="../%s[%i]" % (pop.id, i), destination="synapses") input_list.input.append(input) net.input_lists.append(input_list) net_file_name = '%s.net.nml' % sim_id pynml.write_neuroml2_file(net_doc, net_file_name) ls.include_neuroml2_file(net_file_name) disp0 = 'Voltage_display' ls.create_display(disp0, "Voltages", "-90", "50") of0 = 'Volts_file' ls.create_output_file(of0, "%s.v.dat" % sim_id) for i in range(number_cells): ref = "v_cell%i" % i quantity = "%s[%i]/v" % (pop.id, i) ls.add_line_to_display(disp0, ref, quantity, "1mV", pynml.get_next_hex_color()) ls.add_column_to_output_file(of0, ref, quantity) lems_file_name = ls.save_to_file() print_comment( "Written LEMS file %s (%s)" % (lems_file_name, os.path.abspath(lems_file_name)), verbose) if simulator == "jNeuroML": results = pynml.run_lems_with_jneuroml(lems_file_name, nogui=True, load_saved_data=True, plot=False, show_plot_already=False, verbose=verbose) elif simulator == "jNeuroML_NEURON": results = pynml.run_lems_with_jneuroml_neuron(lems_file_name, nogui=True, load_saved_data=True, plot=False, show_plot_already=False, verbose=verbose) elif simulator == "jNeuroML_NetPyNE": results = pynml.run_lems_with_jneuroml_netpyne( lems_file_name, nogui=True, load_saved_data=True, plot=False, show_plot_already=False, num_processors=num_processors, verbose=verbose) else: raise Exception( "Sorry, cannot yet run current vs frequency analysis using simulator %s" % simulator) print_comment( "Completed run in simulator %s (results: %s)" % (simulator, results.keys()), verbose) #print(results.keys()) times_results = [] volts_results = [] volts_labels = [] if_results = {} iv_results = {} for i in range(number_cells): t = np.array(results['t']) * 1000 v = np.array(results["%s[%i]/v" % (pop.id, i)]) * 1000 if plot_voltage_traces: times_results.append(t) volts_results.append(v) volts_labels.append("%s nA" % stims[i]) mm = max_min(v, t, delta=0, peak_threshold=spike_threshold_mV) spike_times = mm['maxima_times'] freq = 0 if len(spike_times) > 2: count = 0 for s in spike_times: if s >= pre_zero_pulse + analysis_delay and s < ( pre_zero_pulse + analysis_duration + analysis_delay): count += 1 freq = 1000 * count / float(analysis_duration) mean_freq = mean_spike_frequency(spike_times) #print("--- %s nA, spike times: %s, mean_spike_frequency: %f, freq (%fms -> %fms): %f"%(stims[i],spike_times, mean_freq, analysis_delay, analysis_duration+analysis_delay, freq)) if_results[stims[i]] = freq if freq == 0: if post_zero_pulse == 0: iv_results[stims[i]] = v[-1] else: v_end = None for j in range(len(t)): if v_end == None and t[j] >= end_stim: v_end = v[j] iv_results[stims[i]] = v_end if plot_voltage_traces: traces_ax = pynml.generate_plot( times_results, volts_results, "Membrane potential traces for: %s" % nml2_file, xaxis='Time (ms)' if label_xaxis else ' ', yaxis='Membrane potential (mV)' if label_yaxis else '', xlim=[total_duration * -0.05, total_duration * 1.05], show_xticklabels=label_xaxis, font_size=font_size, bottom_left_spines_only=bottom_left_spines_only, grid=False, labels=volts_labels if show_volts_label else [], show_plot_already=False, save_figure_to=save_voltage_traces_to, title_above_plot=title_above_plot, verbose=verbose) if plot_if: stims = sorted(if_results.keys()) stims_pA = [ii * 1000 for ii in stims] freqs = [if_results[s] for s in stims] if_ax = pynml.generate_plot( [stims_pA], [freqs], "Firing frequency versus injected current for: %s" % nml2_file, colors=[if_iv_color], linestyles=['-'], markers=['o'], linewidths=[linewidth], xaxis='Input current (pA)' if label_xaxis else ' ', yaxis='Firing frequency (Hz)' if label_yaxis else '', xlim=xlim_if, ylim=ylim_if, show_xticklabels=label_xaxis, show_yticklabels=label_yaxis, font_size=font_size, bottom_left_spines_only=bottom_left_spines_only, grid=grid, show_plot_already=False, save_figure_to=save_if_figure_to, title_above_plot=title_above_plot, verbose=verbose) if save_if_data_to: with open(save_if_data_to, 'w') as if_file: for i in range(len(stims_pA)): if_file.write("%s\t%s\n" % (stims_pA[i], freqs[i])) if plot_iv: stims = sorted(iv_results.keys()) stims_pA = [ii * 1000 for ii in sorted(iv_results.keys())] vs = [iv_results[s] for s in stims] xs = [] ys = [] xs.append([]) ys.append([]) for si in range(len(stims)): stim = stims[si] if len(custom_amps_nA) == 0 and si > 1 and ( stims[si] - stims[si - 1]) > step_nA * 1.01: xs.append([]) ys.append([]) xs[-1].append(stim * 1000) ys[-1].append(iv_results[stim]) iv_ax = pynml.generate_plot( xs, ys, "V at %sms versus I below threshold for: %s" % (end_stim, nml2_file), colors=[if_iv_color for s in xs], linestyles=['-' for s in xs], markers=['o' for s in xs], xaxis='Input current (pA)' if label_xaxis else '', yaxis='Membrane potential (mV)' if label_yaxis else '', xlim=xlim_iv, ylim=ylim_iv, show_xticklabels=label_xaxis, show_yticklabels=label_yaxis, font_size=font_size, linewidths=[linewidth for s in xs], bottom_left_spines_only=bottom_left_spines_only, grid=grid, show_plot_already=False, save_figure_to=save_iv_figure_to, title_above_plot=title_above_plot, verbose=verbose) if save_iv_data_to: with open(save_iv_data_to, 'w') as iv_file: for i in range(len(stims_pA)): iv_file.write("%s\t%s\n" % (stims_pA[i], vs[i])) if show_plot_already: from matplotlib import pyplot as plt plt.show() if return_axes: return traces_ax, if_ax, iv_ax return if_results
def add_inputs_to_population(net, id, population, input_comp_id, number_per_cell=1, all_cells=False, only_cells=None, segment_ids=[0], fraction_alongs=[0.5]): """ Add current input to the specified population. Attributes: `net` reference to the network object previously created `id` id of the <inputList> to be created `population` the <population> to be targeted `input_comp_id` id of the component to be used for the input (e.g. added with add_pulse_generator()) `number_per_cell` how many inputs to apply to each cell of the population. Default 1 `all_cells` Whether to target all cells. Default False `only_cells` Which specific cells to target. List of ids. Default None `segment_ids` List of segment ids to place inputs onto on each cell. Either list of 1 value or list of number_per_cell entries. Default [0] `fraction_alongs` List of fractions along the specified segments to place inputs onto on each cell. Either list of 1 value or list of number_per_cell entries. Default [0.5] """ if all_cells and only_cells is not None: error = "Error! Method opencortex.build.%s() called with both arguments all_cells and only_cells set!" % sys._getframe( ).f_code.co_name opencortex.print_comment_v(error) raise Exception(error) if len(segment_ids) != 1 or len(segment_ids) != number_per_cell: error = "Error! Attribute segment_ids in method opencortex.build.%s()"% sys._getframe().f_code.co_name+\ " should be a list of one integer (id of the segment all inputs to each cell go into) or a "+ \ "list of the same length as number_per_cell!" opencortex.print_comment_v(error) raise Exception(error) if len(fraction_alongs) != 1 or len(fraction_alongs) != number_per_cell: error = "Error! Attribute fraction_alongs in method opencortex.build.%s()"% sys._getframe().f_code.co_name+\ " should be a list of one float (fraction along the segment all inputs to each cell go into) or a "+ \ "list of the same length as number_per_cell!" opencortex.print_comment_v(error) raise Exception(error) cell_ids = [] if all_cells: cell_ids = range(population.size) if only_cells is not None: if only_cells == []: return cell_ids = only_cells input_list = neuroml.InputList(id=id, component=input_comp_id, populations=population.id) count = 0 for cell_id in cell_ids: for i in range(number_per_cell): segment_id = -1 if len(segment_ids) == 1: segment_id = segment_ids[0] else: segment_id = segment_ids[i] fraction_along = -1 if len(fraction_alongs) == 1: fraction_along = fraction_alongs[0] else: fraction_along = fraction_alongs[i] if fraction_along < 0 or fraction_along > 1: error = "Error! Attribute fraction_along should be >=0 and <=1" opencortex.print_comment_v(error) raise Exception(error) input = neuroml.Input( id=count, target="../%s/%i/%s" % (population.id, cell_id, population.component), segment_id=segment_id, fraction_along=fraction_along, destination="synapses") input_list.input.append(input) count += 1 if count > 0: net.input_lists.append(input_list) return input_list
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
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), destination="synapses") input_list.input.append(syn_input) net.input_lists.append(input_list) nml_file = net.id + '.net.nml' writers.NeuroMLWriter.write(net_doc, nml_file) print("Saved network file to: " + nml_file) ###### Validate the NeuroML ###### from neuroml.utils import validate_neuroml2
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)) prc.connections.append(conn) nc.projections.append(prc) ilc = InputListContainer(id="iii", component="CCC", populations=pc.id) nc.input_lists.append(ilc) ilc.input.append( neuroml.Input(id=0, target="../pyramidals_48/37/pyr_4_sym", destination="synapses", segment_id="2", fraction_along="0.3")) nc2 = NetworkContainer(id="testnet2") pc2 = PopulationContainer(id="fake2", component="iaf", size=4) nc2.populations.append(pc2) print(pc) nets = [nc, nc2, net0] nets = [nc] for n in nets: print('\n--------------------------------')