def add_input_source(self, input_source, network): input_params = input_source.parameters if input_source.parameters else {} for ip in input_params: input_params[ip] = evaluate(input_params[ip], network.parameters) ''' This is a quick hack to support noisyCurrentSource before that type is integrated into the core of NeuroML... TODO: remove when integrated! ''' if input_source.lems_source_file and 'noisyCurrentSource' in input_source.id: pynn_input_params = {} for p in input_params: if p=='delay': pynn_input_params['start'] = convert_to_units(input_params[p],'ms') elif p=='duration': pynn_input_params['stop'] = convert_to_units(input_params[p],'ms') + convert_to_units(input_params['delay'],'ms') elif p=='mean': pynn_input_params['mean'] = convert_to_units(input_params[p],'nA') elif p=='stdev': pynn_input_params['stdev'] = convert_to_units(input_params[p],'nA') elif p=='noiseDt': pynn_input_params['dt'] = convert_to_units(input_params[p],'ms') else: raise Exception('Parameter %s=%s is not appropriate for inout %s'%(p,input_params[p],input_source.id)) exec('self.input_sources["%s"] = self.sim.NoisyCurrentSource(**pynn_input_params)'%(input_source.id)) else: exec('self.input_sources["%s"] = self.sim.%s(**input_params)'%(input_source.id,input_source.pynn_input))
def _eval_at_all(self, expr, parameters, traces): tr_present = [] for t in traces: if t != "t" and t in expr: tr_present.append(t) ret_val = [] num_vals = len(traces[tr_present[0]]) print_( "Evaluating %s with traces: %s (%i values) and params: %s" % (expr, tr_present, num_vals, parameters.keys()), self.verbose, ) for i in range(num_vals): noo = expr for t in tr_present: noo = noo.replace(t, str(traces[tr_present[0]][i])) # print_v('%i: %s -> %s'%(i, expr, noo)) r = evaluate(noo, parameters) ret_val.append(float(r)) print_( "Generated: %s->%s (#%s)" % (ret_val[0], ret_val[-1], len(ret_val)), self.verbose, ) return ret_val
def handle_projection(self, projName, prePop, postPop, synapse, hasWeights=False, hasDelays=False, type="projection", synapse_obj=None, pre_synapse_obj=None): shape = self.EXC_CONN_ARROW_SHAPE line = 'solid' # Could be used in a network with no explicit connections, but weight # between populations set at high level projection element in NeuroMLlite projection_weight = 1.0 self.proj_pre_pops[projName] = prePop self.proj_post_pops[projName] = postPop self.proj_types[projName] = type if prePop in self.pop_types: if 'I' in self.pop_types[prePop]: shape = self.INH_CONN_ARROW_SHAPE if type=='electricalProjection': shape = self.GAP_CONN_ARROW_SHAPE line = 'dashed' if type=='continuousProjection': shape = self.CONT_CONN_ARROW_SHAPE line = 'solid' if synapse_obj: self.proj_syn_objs[projName] = synapse_obj erev = self.get_reversal_potential_mV(synapse_obj) if erev!=None and erev < self.CUTOFF_INH_SYN_MV: shape = self.INH_CONN_ARROW_SHAPE if self.nl_network: syn = self.nl_network.get_child(synapse,'synapses') if syn: if syn.parameters: if 'e_rev' in syn.parameters and syn.parameters['e_rev']<self.CUTOFF_INH_SYN_MV: shape = self.INH_CONN_ARROW_SHAPE proj = self.nl_network.get_child(projName,'projections') if proj: if proj.weight: proj_weight = evaluate(proj.weight, self.nl_network.parameters) if proj_weight<0: shape = self.INH_CONN_ARROW_SHAPE projection_weight = abs(proj_weight) self.proj_weights[projName] = projection_weight self.proj_shapes[projName] = shape self.proj_lines[projName] = line self.proj_conns[projName] = 0 self.proj_tot_weight[projName] = 0 if self.is_cell_level(): pre_size = self.pop_sizes[prePop] post_size = self.pop_sizes[postPop] self.proj_individual_weights[projName] = np.zeros((pre_size, post_size)) self.proj_individual_conn_numbers[projName] = np.zeros((pre_size, post_size)) self.proj_individual_scaled_weights[projName] = np.zeros((pre_size, post_size))
def add_input_source(self, input_source, network): input_params = input_source.parameters if input_source.parameters else {} for ip in input_params: input_params[ip] = evaluate(input_params[ip], network.parameters) exec('self.input_sources["%s"] = self.sim.%s(**input_params)' % (input_source.id, input_source.pynn_input))
def _convert_value(self, val): funcs = ['exp'] for f in funcs: if '%s(' % f in val: val = val.replace('%s(' % f, 'math.%s(' % f) val = evaluate(val) # catch if it's an int etc. return val
def handle_projection(self, projName, prePop, postPop, synapse, hasWeights=False, hasDelays=False, type="projection", synapse_obj=None, pre_synapse_obj=None): weight = 1.0 self.proj_pre_pops[projName] = prePop self.proj_post_pops[projName] = postPop proj_type = 'excitatory' if prePop in self.pop_types: if 'I' in self.pop_types[prePop]: proj_type = 'inhibitory' if type=='electricalProjection': proj_type = 'gap_junction' if synapse_obj: self.proj_syn_objs[projName] = synapse_obj erev = self.get_reversal_potential_mV(synapse_obj) if erev!=None and erev < self.CUTOFF_INH_SYN_MV: proj_type = 'inhibitory' if self.nl_network: syn = self.nl_network.get_child(synapse,'synapses') if syn: if syn.parameters: if 'e_rev' in syn.parameters and syn.parameters['e_rev']<self.CUTOFF_INH_SYN_MV: proj_type = 'inhibitory' proj = self.nl_network.get_child(projName,'projections') if proj: if proj.weight: proj_weight = evaluate(proj.weight, self.nl_network.parameters, self.rng) if proj_weight<0: proj_type = 'inhibitory' weight = float(abs(proj_weight)) if type=='continuousProjection': proj_type += 'continuous' self.proj_weights[projName] = float(weight) self.proj_types[projName] = proj_type self.proj_conns[projName] = 0 self.proj_tot_weight[projName] = 0 if self.is_cell_level(): pre_size = self.pop_sizes[prePop] post_size = self.pop_sizes[postPop] self.proj_individual_weights[projName] = np.zeros((pre_size, post_size)) self.proj_individual_conn_numbers[projName] = np.zeros((pre_size, post_size)) self.proj_individual_scaled_weights[projName] = np.zeros((pre_size, post_size)) self.proj_delays[projName] = np.zeros((pre_size, post_size)) print_v("New projection: %s, %s->%s, weights? %s, type: %s"%(projName, prePop, postPop, weight, proj_type))
def create_arbor_cell(cell, nl_network, gid): if cell.arbor_cell=='cable_cell': default_tree = arbor.segment_tree() radius = evaluate(cell.parameters['radius'], nl_network.parameters) if 'radius' in cell.parameters else 3 default_tree.append(arbor.mnpos, arbor.mpoint(-1*radius, 0, 0, radius), arbor.mpoint(radius, 0, 0, radius), tag=1) labels = arbor.label_dict({'soma': '(tag 1)', 'center': '(location 0 0.5)'}) labels['root'] = '(root)' decor = arbor.decor() v_init = evaluate(cell.parameters['v_init'], nl_network.parameters) if 'v_init' in cell.parameters else -70 decor.set_property(Vm=v_init) decor.paint('"soma"', cell.parameters['mechanism']) if gid==0: ic = arbor.iclamp( nl_network.parameters['input_del'], nl_network.parameters['input_dur'], nl_network.parameters['input_amp']) print_v("Stim: %s"%ic) decor.place('"center"', ic) decor.place('"center"', arbor.spike_detector(-10)) # (2) Mark location for synapse at the midpoint of branch 1 (the first dendrite). labels['synapse_site'] = '(location 0 0.5)' # (4) Attach a single synapse. decor.place('"synapse_site"', 'expsyn') default_cell = arbor.cable_cell(default_tree, labels, decor) print_v("Created a new cell for gid %i: %s"%(gid,cell)) print_v("%s"%(default_cell)) return default_cell
def add_input_source(self, input_source, network): input_params = input_source.parameters if input_source.parameters else {} for ip in input_params: input_params[ip] = evaluate(input_params[ip], network.parameters) """ This is a quick hack to support noisyCurrentSource before that type is integrated into the core of NeuroML... TODO: remove when integrated! """ if input_source.lems_source_file and "noisyCurrentSource" in input_source.id: pynn_input_params = {} for p in input_params: if p == "delay": pynn_input_params["start"] = convert_to_units( input_params[p], "ms") elif p == "duration": pynn_input_params["stop"] = convert_to_units( input_params[p], "ms") + convert_to_units( input_params["delay"], "ms") elif p == "mean": pynn_input_params["mean"] = convert_to_units( input_params[p], "nA") elif p == "stdev": pynn_input_params["stdev"] = convert_to_units( input_params[p], "nA") elif p == "noiseDt": pynn_input_params["dt"] = convert_to_units( input_params[p], "ms") else: raise Exception( "Parameter %s=%s is not appropriate for inout %s" % (p, input_params[p], input_source.id)) exec( 'self.input_sources["%s"] = self.sim.NoisyCurrentSource(**pynn_input_params)' % (input_source.id)) else: exec('self.input_sources["%s"] = self.sim.%s(**input_params)' % (input_source.id, input_source.pynn_input))
def handle_population(self, population_id, component, size=-1, component_obj=None, properties={}): sizeInfo = " as yet unspecified size" if size>=0: sizeInfo = ", size: "+ str(size)+ " cells" if component_obj: compInfo = " (%s)"%component_obj.__class__.__name__ else: compInfo="" print_v("Population: "+population_id+", component: "+component+compInfo+sizeInfo) if size>=0: for i in range(size): node_id = '%s_%i'%(population_id, i) node = {} node['type'] = {} node['name'] = node_id #node['type']['NeuroML'] = component comp = self.nl_network.get_child(component, 'cells') base_dir = './' # for now... fname = locate_file(comp.lems_source_file, base_dir) model = lems.Model() model.import_from_file(fname) lems_comp = model.components.get(component) print('Cell: [%s] comes from %s and in Lems is: %s'%(comp,fname, lems_comp)) comp_type = lems_comp.type type = "The type of %s"%comp_type function = "The function of %s"%comp_type if comp_type == 'pnlLinearFunctionTM': function = 'Linear' type = "TransferMechanism" elif comp_type == 'inputNode': function = 'Linear' type = "TransferMechanism" elif comp_type == 'pnlLogisticFunctionTM': function = 'Logistic' type = "TransferMechanism" elif comp_type == 'pnlExponentialFunctionTM': function = 'Exponential' type = "TransferMechanism" elif comp_type == 'pnlSimpleIntegratorMechanism': function = 'SimpleIntegrator' type = "IntegratorMechanism" node['type']["PNL"] = type node['type']["generic"] = None node['parameters'] = {} node['parameters']['PNL'] = {} node['functions'] = [] func_info = {} func_info['type']={} func_info['type']['generic']=function func_info['name']='Function_%s'%function func_info['args']={} for p in lems_comp.parameters: func_info['args'][p] = {} func_info['args'][p]['type'] = 'float' func_info['args'][p]['source'] = '%s.input_ports.%s'%(node_id,p) if comp.parameters is not None and p in comp.parameters: func_info['args'][p]['value'] = evaluate(comp.parameters[p], self.nl_network.parameters) else: func_info['args'][p]['value'] = evaluate(lems_comp.parameters[p]) # evaluate to ensure strings -> ints/floats etc node['functions'].append(func_info) self.bids_mdf_graph['nodes'][node_id] = node pop_node_id = '%s'%(population_id) pop_node = {} pop_node['type'] = {} pop_node['name'] = pop_node_id pop_node['type']['NeuroML'] = component pop_node['parameters'] = {} pop_node['parameters']['size'] = size pop_node['functions'] = {} self.bids_mdf_graph_hl['nodes'][pop_node_id] = pop_node
def _get_pop_size(self, pop_id): pop = self.network.get_child(pop_id, 'populations') return evaluate(pop.size, self.network.parameters)
def create_arbor_cell(self, cell, gid, pop_id, index): if cell.arbor_cell == "cable_cell": default_tree = arbor.segment_tree() radius = (evaluate(cell.parameters["radius"], self.nl_network.parameters) if "radius" in cell.parameters else 3) default_tree.append( arbor.mnpos, arbor.mpoint(-1 * radius, 0, 0, radius), arbor.mpoint(radius, 0, 0, radius), tag=1, ) labels = arbor.label_dict({ "soma": "(tag 1)", "center": "(location 0 0.5)" }) labels["root"] = "(root)" decor = arbor.decor() v_init = (evaluate(cell.parameters["v_init"], self.nl_network.parameters) if "v_init" in cell.parameters else -70) decor.set_property(Vm=v_init) decor.paint('"soma"', arbor.density(cell.parameters["mechanism"])) decor.place('"center"', arbor.spike_detector(0), "detector") for ip in self.input_info: if self.input_info[ip][0] == pop_id: print_v("Stim: %s (%s) being placed on %s" % (ip, self.input_info[ip], pop_id)) for il in self.input_lists[ip]: cellId, segId, fract, weight = il if cellId == index: if self.input_info[ip][ 1] == 'i_clamp': # TODO: remove hardcoding of this... ic = arbor.iclamp( self.nl_network.parameters["input_del"], self.nl_network.parameters["input_dur"], self.nl_network.parameters["input_amp"], ) print_v("Stim: %s on %s" % (ic, gid)) decor.place('"center"', ic, "iclamp") # (2) Mark location for synapse at the midpoint of branch 1 (the first dendrite). labels["synapse_site"] = "(location 0 0.5)" # (4) Attach a single synapse. decor.place('"synapse_site"', arbor.synapse("expsyn"), "syn") default_cell = arbor.cable_cell(default_tree, labels, decor) print_v("Created a new cell for gid %i: %s" % (gid, cell)) print_v("%s" % (default_cell)) return default_cell
def generate_neuroml2_from_network(nl_model, nml_file_name=None, print_summary=True, seed=1234, format='xml', base_dir=None, copy_included_elements=False, target_dir=None, validate=False): """ Generate and save NeuroML2 file (in either XML or HDF5 format) from the NeuroMLlite description """ print_v("Generating NeuroML2 for %s%s..." % (nl_model.id, ' (base dir: %s; target dir: %s)' % (base_dir, target_dir) if base_dir or target_dir else '')) import neuroml from neuroml.hdf5.NetworkBuilder import NetworkBuilder neuroml_handler = NetworkBuilder() generate_network(nl_model, neuroml_handler, seed=seed, base_dir=base_dir) nml_doc = neuroml_handler.get_nml_doc() for i in nl_model.input_sources: if nml_doc.get_by_id(i.id) == None: if i.neuroml2_source_file: incl = neuroml.IncludeType( _locate_file(i.neuroml2_source_file, base_dir)) if not incl in nml_doc.includes: nml_doc.includes.append(incl) if i.neuroml2_input: input_params = i.parameters if i.parameters else {} # TODO make more generic... if i.neuroml2_input.lower() == 'pulsegenerator': input = neuroml.PulseGenerator(id=i.id) nml_doc.pulse_generators.append(input) elif i.neuroml2_input.lower() == 'pulsegeneratordl': input = neuroml.PulseGeneratorDL(id=i.id) nml_doc.pulse_generator_dls.append(input) elif i.neuroml2_input.lower() == 'poissonfiringsynapse': input = neuroml.PoissonFiringSynapse(id=i.id) nml_doc.poisson_firing_synapses.append(input) for p in input_params: exec('input.%s = "%s"' % (p, evaluate(input_params[p], nl_model.parameters))) for c in nl_model.cells: if c.neuroml2_source_file: incl = neuroml.IncludeType( _locate_file(c.neuroml2_source_file, base_dir)) found_cell = False for cell in nml_doc.cells: if cell.id == c.id: nml_doc.cells.remove( cell ) # Better to use imported cell file; will have channels, etc. nml_doc.includes.append(incl) found_cell = True if not found_cell: for p in nl_model.populations: if p.component == c.id: pass if not incl in nml_doc.includes: nml_doc.includes.append(incl) ''' Needed??? if c.lems_source_file: incl = neuroml.IncludeType(_locate_file(c.lems_source_file, base_dir)) if not incl in nml_doc.includes: nml_doc.includes.append(incl)''' if c.neuroml2_cell: cell_params = c.parameters if c.parameters else {} # TODO make more generic... if c.neuroml2_cell.lower() == 'spikegenerator': cell = neuroml.SpikeGenerator(id=c.id) nml_doc.spike_generators.append(cell) elif c.neuroml2_cell.lower() == 'spikegeneratorpoisson': cell = neuroml.SpikeGeneratorPoisson(id=c.id) nml_doc.spike_generator_poissons.append(cell) elif c.neuroml2_cell.lower() == 'spikegeneratorrefpoisson': cell = neuroml.SpikeGeneratorRefPoisson(id=c.id) nml_doc.spike_generator_ref_poissons.append(cell) else: raise Exception( 'The neuroml2_cell: %s is not yet supported...' % c.neuroml2_cell) for p in cell_params: exec('cell.%s = "%s"' % (p, evaluate(cell_params[p], nl_model.parameters))) for s in nl_model.synapses: if nml_doc.get_by_id(s.id) == None: if s.neuroml2_source_file: incl = neuroml.IncludeType( _locate_file(s.neuroml2_source_file, base_dir)) if not incl in nml_doc.includes: nml_doc.includes.append(incl) # Look for and add the PyNN based elements to the NeuroMLDocument _extract_pynn_components_to_neuroml(nl_model, nml_doc) if print_summary: # Print info print_v(nml_doc.summary()) # Save to file if target_dir == None: target_dir = base_dir if format == 'xml': if not nml_file_name: nml_file_name = _locate_file('%s.net.nml' % nml_doc.id, target_dir) from neuroml.writers import NeuroMLWriter NeuroMLWriter.write(nml_doc, nml_file_name) if format == 'hdf5': if not nml_file_name: nml_file_name = _locate_file('%s.net.nml.h5' % nml_doc.id, target_dir) from neuroml.writers import NeuroMLHdf5Writer NeuroMLHdf5Writer.write(nml_doc, nml_file_name) print_v("Written NeuroML to %s" % nml_file_name) if validate and format == 'xml': from pyneuroml import pynml success = pynml.validate_neuroml2(nml_file_name, verbose_validate=False) if success: print_v('Generated file is valid NeuroML2!') else: print_v('Generated file is NOT valid NeuroML2!') return nml_file_name, nml_doc
def handle_projection( self, projName, prePop, postPop, synapse, hasWeights=False, hasDelays=False, type="projection", synapse_obj=None, pre_synapse_obj=None, ): shape = self.EXC_CONN_ARROW_SHAPE line = "solid" # Could be used in a network with no explicit connections, but weight # between populations set at high level projection element in NeuroMLlite projection_weight = 1.0 if not (prePop in self.pop_sizes and postPop in self.pop_sizes): print_v("Ignoring projection, as one of pops empty...") return self.proj_pre_pops[projName] = prePop self.proj_post_pops[projName] = postPop self.proj_types[projName] = type if prePop in self.pop_types: if "I" in self.pop_types[prePop]: shape = self.INH_CONN_ARROW_SHAPE if type == "electricalProjection": shape = self.GAP_CONN_ARROW_SHAPE line = "dashed" if type == "continuousProjection": shape = self.CONT_CONN_ARROW_SHAPE line = "solid" if synapse_obj: self.proj_syn_objs[projName] = synapse_obj erev = self.get_reversal_potential_mV(synapse_obj) if erev != None and erev < self.CUTOFF_INH_SYN_MV: shape = self.INH_CONN_ARROW_SHAPE if self.nl_network: syn = self.nl_network.get_child(synapse, "synapses") if syn: if syn.parameters: if ("e_rev" in syn.parameters and syn.parameters["e_rev"] < self.CUTOFF_INH_SYN_MV): shape = self.INH_CONN_ARROW_SHAPE proj = self.nl_network.get_child(projName, "projections") if proj: if proj.weight: proj_weight = evaluate(proj.weight, self.nl_network.parameters, self.rng) if proj_weight < 0: shape = self.INH_CONN_ARROW_SHAPE projection_weight = abs(proj_weight) self.proj_weights[projName] = projection_weight self.proj_shapes[projName] = shape self.proj_lines[projName] = line self.proj_conns[projName] = 0 self.proj_tot_weight[projName] = 0 if self.is_cell_level(): pre_size = self.pop_sizes[prePop] post_size = self.pop_sizes[postPop] self.proj_individual_weights[projName] = np.zeros( (pre_size, post_size)) self.proj_individual_conn_numbers[projName] = np.zeros( (pre_size, post_size)) self.proj_individual_scaled_weights[projName] = np.zeros( (pre_size, post_size)) self.proj_delays[projName] = np.zeros((pre_size, post_size))
def generate(ref="Example6_PyNN", add_inputs=True): ################################################################################ ### Build new network net = Network(id=ref, notes="Another network for PyNN - work in progress...") net.parameters = { "N_scaling": 0.005, "layer_height": 400, "width": 100, "depth": 100, "input_weight": 0.1, } cell = Cell(id="CorticalCell", pynn_cell="IF_curr_exp") cell.parameters = { "cm": 0.25, # nF "i_offset": 0.0, # nA "tau_m": 10.0, # ms "tau_refrac": 2.0, # ms "v_reset": -65.0, # mV "v_rest": -65.0, # mV "v_thresh": -50.0, # mV } net.cells.append(cell) if add_inputs: input_cell = Cell(id="InputCell", pynn_cell="SpikeSourcePoisson") input_cell.parameters = {"start": 0, "duration": 10000000000, "rate": 150} net.cells.append(input_cell) e_syn = Synapse( id="ampa", pynn_receptor_type="excitatory", pynn_synapse_type="curr_exp", parameters={"tau_syn": 0.5}, ) net.synapses.append(e_syn) i_syn = Synapse( id="gaba", pynn_receptor_type="inhibitory", pynn_synapse_type="curr_exp", parameters={"tau_syn": 0.5}, ) net.synapses.append(i_syn) N_full = { "L23": {"E": 20683, "I": 5834}, "L4": {"E": 21915, "I": 5479}, "L5": {"E": 4850, "I": 1065}, "L6": {"E": 14395, "I": 2948}, } scale = 0.1 pops = [] input_pops = [] pop_dict = {} layers = ["L23"] layers = ["L23", "L4", "L5", "L6"] for l in layers: i = 3 - layers.index(l) r = RectangularRegion( id=l, x=0, y=i * net.parameters["layer_height"], z=0, width=net.parameters["width"], height=net.parameters["layer_height"], depth=net.parameters["depth"], ) net.regions.append(r) for t in ["E", "I"]: try: import opencortex.utils.color as occ if l == "L23": if t == "E": color = occ.L23_PRINCIPAL_CELL if t == "I": color = occ.L23_INTERNEURON if l == "L4": if t == "E": color = occ.L4_PRINCIPAL_CELL if t == "I": color = occ.L4_INTERNEURON if l == "L5": if t == "E": color = occ.L5_PRINCIPAL_CELL if t == "I": color = occ.L5_INTERNEURON if l == "L6": if t == "E": color = occ.L6_PRINCIPAL_CELL if t == "I": color = occ.L6_INTERNEURON except: color = ".8 0 0" if t == "E" else "0 0 1" pop_id = "%s_%s" % (l, t) pops.append(pop_id) ref = "l%s%s" % (l[1:], t.lower()) exec( ref + " = Population(id=pop_id, size='int(%s*N_scaling)'%N_full[l][t], component=cell.id, properties={'color':color, 'type':t})" ) exec("%s.random_layout = RandomLayout(region = r.id)" % ref) exec("net.populations.append(%s)" % ref) exec("pop_dict['%s'] = %s" % (pop_id, ref)) if add_inputs: color = ".8 .8 .8" input_id = "%s_%s_input" % (l, t) input_pops.append(input_id) input_ref = "l%s%s_i" % (l[1:], t.lower()) exec( input_ref + " = Population(id=input_id, size='int(%s*N_scaling)'%N_full[l][t], component=input_cell.id, properties={'color':color})" ) exec("%s.random_layout = RandomLayout(region = r.id)" % input_ref) exec("net.populations.append(%s)" % input_ref) # l23i = Population(id='L23_I', size=int(100*scale), component=cell.id, properties={'color':}) # l23ei = Population(id='L23_E_input', size=int(100*scale), component=input_cell.id) # l23ii = Population(id='L23_I_input', size=int(100*scale), component=input_cell.id) # net.populations.append(l23e) # net.populations.append(l23ei) # net.populations.append(l23i) # net.populations.append(l23ii) conn_probs = [ [0.1009, 0.1689, 0.0437, 0.0818, 0.0323, 0.0, 0.0076, 0.0], [0.1346, 0.1371, 0.0316, 0.0515, 0.0755, 0.0, 0.0042, 0.0], [0.0077, 0.0059, 0.0497, 0.135, 0.0067, 0.0003, 0.0453, 0.0], [0.0691, 0.0029, 0.0794, 0.1597, 0.0033, 0.0, 0.1057, 0.0], [0.1004, 0.0622, 0.0505, 0.0057, 0.0831, 0.3726, 0.0204, 0.0], [0.0548, 0.0269, 0.0257, 0.0022, 0.06, 0.3158, 0.0086, 0.0], [0.0156, 0.0066, 0.0211, 0.0166, 0.0572, 0.0197, 0.0396, 0.2252], [0.0364, 0.001, 0.0034, 0.0005, 0.0277, 0.008, 0.0658, 0.1443], ] if add_inputs: for p in pops: proj = Projection( id="proj_input_%s" % p, presynaptic="%s_input" % p, postsynaptic=p, synapse=e_syn.id, delay=2, weight="input_weight", ) proj.one_to_one_connector = OneToOneConnector() net.projections.append(proj) for pre_i in range(len(pops)): for post_i in range(len(pops)): pre = pops[pre_i] post = pops[post_i] prob = conn_probs[post_i][pre_i] ####### TODO: check!!!! weight = 1 syn = e_syn if prob > 0: if "I" in pre: weight = -1 syn = i_syn proj = Projection( id="proj_%s_%s" % (pre, post), presynaptic=pre, postsynaptic=post, synapse=syn.id, delay=1, weight=weight, ) proj.random_connectivity = RandomConnectivity(probability=prob) net.projections.append(proj) print(net.to_json()) new_file = net.to_json_file("%s.json" % net.id) ################################################################################ ### Build Simulation object & save as JSON record_traces = {} record_spikes = {} from neuromllite.utils import evaluate for p in pops: forecast_size = evaluate(pop_dict[p].size, net.parameters) record_traces[p] = list(range(min(2, forecast_size))) record_spikes[p] = "*" for ip in input_pops: record_spikes[ip] = "*" sim = Simulation( id="Sim%s" % net.id, network=new_file, duration="100", dt="0.025", seed=1234, record_traces=record_traces, record_spikes=record_spikes, ) sim.to_json_file() return sim, net
def handle_population(self, population_id, component, size=-1, component_obj=None, properties={}): sizeInfo = " as yet unspecified size" if size >= 0: sizeInfo = ", size: " + str(size) + " cells" if component_obj: compInfo = " (%s)" % component_obj.__class__.__name__ else: compInfo = "" print_v("Population: " + population_id + ", component: " + component + compInfo + sizeInfo) if size >= 0: for i in range(size): node_id = '%s_%i' % (population_id, i) node = {} #node['type'] = {} #node['name'] = node_id #node['type']['NeuroML'] = component comp = self.nl_network.get_child(component, 'cells') base_dir = './' # for now... node['parameters'] = {} node['input_ports'] = {} node['output_ports'] = {} if comp is not None and comp.lems_source_file: fname = locate_file(comp.lems_source_file, base_dir) model = MDFHandler._load_lems_file_with_neuroml2_types( fname) #print('All comp types: %s'%model.component_types.keys()) #print('All comps: %s'%model.components.keys()) lems_comp = model.components.get(component) comp_type_name = lems_comp.type lems_comp_type = model.component_types.get(comp_type_name) notes = 'Cell: [%s] is defined in %s and in Lems is: %s' % ( comp, fname, lems_comp) node['notes'] = notes for p in lems_comp.parameters: node['parameters'][p] = { 'value': get_value_in_si(evaluate(lems_comp.parameters[p])) } for c in lems_comp_type.constants: node['parameters'][c.name] = { 'value': get_value_in_si(c.value) } for dv in lems_comp_type.dynamics.derived_variables: if dv.name == 'INPUT': node['input_ports'][dv.name] = {} else: if dv.exposure: #<DerivedVariable name="OUTPUT" dimension="none" exposure="OUTPUT" value="variable"/> node['output_ports'][dv.exposure] = { 'value': self._convert_value(dv.value) } for sv in lems_comp_type.dynamics.state_variables: node['parameters'][sv.name] = {} print(dir(lems_comp_type.dynamics)) for os in lems_comp_type.dynamics.event_handlers: if type(os) == lems.OnStart: for a in os.actions: if type(a) == lems.StateAssignment: node['parameters'][a.variable][ 'default_initial_value'] = a.value for td in lems_comp_type.dynamics.time_derivatives: node['parameters'][td.variable][ 'time_derivative'] = self._convert_value(td.value) if self.pnl_additions: node['type']["PNL"] = type node['type']["generic"] = None #node['parameters']['PNL'] = {} ''' node['functions'] = [] func_info = {} if self.pnl_additions: func_info['type']={} func_info['type']['generic']=function func_info['name']='Function_%s'%function func_info['args']={} for p in lems_comp.parameters: func_info['args'][p] = {} func_info['args'][p]['type'] = 'float' func_info['args'][p]['source'] = '%s.input_ports.%s'%(node_id,p) if comp.parameters is not None and p in comp.parameters: func_info['args'][p]['value'] = evaluate(comp.parameters[p], self.nl_network.parameters) else: func_info['args'][p]['value'] = evaluate(lems_comp.parameters[p]) # evaluate to ensure strings -> ints/floats etc node['functions'].append(func_info)''' self.mdf_graph['nodes'][node_id] = node '''
def generate_network(nl_model, handler, seed=1234, always_include_props=False, include_connections=True, include_inputs=True, base_dir=None): """ Generate the network model as described in NeuroMLlite in a specific handler, e.g. NeuroMLHandler, PyNNHandler, etc. """ pop_locations = {} cell_objects = {} synapse_objects = {} print_v("Starting net generation for %s%s..." % (nl_model.id, ' (base dir: %s)' % base_dir if base_dir else '')) rng = random.Random(seed) if nl_model.network_reader: exec('from neuromllite.%s import %s' % (nl_model.network_reader.type, nl_model.network_reader.type)) exec('network_reader = %s()' % (nl_model.network_reader.type)) network_reader.parameters = nl_model.network_reader.parameters network_reader.parse(handler) pop_locations = network_reader.get_locations() else: from neuromllite import __version__ as nmlv notes = "Generated by NeuroMLlite v%s" % nmlv notes += "\n Generated network: %s" % nl_model.id notes += "\n Generation seed: %i" % (seed) if nl_model.parameters: notes += "\n NeuroMLlite parameters: " for p in sorted(nl_model.parameters.keys()): notes += "\n %s = %s" % (p, nl_model.parameters[p]) handler.handle_document_start(nl_model.id, notes) temperature = '%sdegC' % nl_model.temperature if nl_model.temperature else None handler.handle_network(nl_model.id, nl_model.notes, temperature=temperature) nml2_doc_temp = _extract_pynn_components_to_neuroml(nl_model) for c in nl_model.cells: if c.neuroml2_source_file: from pyneuroml import pynml nml2_doc = pynml.read_neuroml2_file(_locate_file( c.neuroml2_source_file, base_dir), include_includes=True) cell_objects[c.id] = nml2_doc.get_by_id(c.id) if c.pynn_cell: cell_objects[c.id] = nml2_doc_temp.get_by_id(c.id) for s in nl_model.synapses: if s.neuroml2_source_file: from pyneuroml import pynml nml2_doc = pynml.read_neuroml2_file(_locate_file( s.neuroml2_source_file, base_dir), include_includes=True) synapse_objects[s.id] = nml2_doc.get_by_id(s.id) if s.pynn_synapse: synapse_objects[s.id] = nml2_doc_temp.get_by_id(s.id) for p in nl_model.populations: size = evaluate(p.size, nl_model.parameters) properties = p.properties if p.properties else {} if p.random_layout: properties['region'] = p.random_layout.region if p.relative_layout: properties['region'] = p.relative_layout.region if not p.random_layout and not p.single_location and not p.relative_layout and not always_include_props: # If there are no positions (abstract network), and <property> # is added to <population>, jLems doesn't like it... (it has difficulty # interpreting pop0[0]/v, etc.) # So better not to give properties... properties = {} if p.notes: handler.handle_population(p.id, p.component, size, cell_objects[p.component] if p.component in cell_objects else None, properties=properties, notes=p.notes) else: handler.handle_population(p.id, p.component, size, cell_objects[p.component] if p.component in cell_objects else None, properties=properties) pop_locations[p.id] = np.zeros((size, 3)) for i in range(size): if p.random_layout: region = nl_model.get_child(p.random_layout.region, 'regions') x = region.x + rng.random() * region.width y = region.y + rng.random() * region.height z = region.z + rng.random() * region.depth pop_locations[p.id][i] = (x, y, z) handler.handle_location(i, p.id, p.component, x, y, z) if p.single_location: loc = p.single_location.location x = loc.x y = loc.y z = loc.z pop_locations[p.id][i] = (x, y, z) handler.handle_location(i, p.id, p.component, x, y, z) if p.relative_layout: print_v("Generating population with layout: %s" % p.relative_layout) region = nl_model.get_child(p.relative_layout.region, 'regions') x = p.relative_layout.x + region.x y = p.relative_layout.y + region.y z = p.relative_layout.z + region.z pop_locations[p.id][i] = (x, y, z) handler.handle_location(i, p.id, p.component, x, y, z) if hasattr(handler, 'finalise_population'): handler.finalise_population(p.id) if include_connections: for p in nl_model.projections: type = p.type if p.type else 'projection' delay = evaluate(p.delay, nl_model.parameters) if p.delay else 0 weight = evaluate(p.weight, nl_model.parameters) if p.weight else 1 if weight != 0: handler.handle_projection( p.id, p.presynaptic, p.postsynaptic, p.synapse, synapse_obj=synapse_objects[p.synapse] if p.synapse in synapse_objects else None, pre_synapse_obj=synapse_objects[p.pre_synapse] if p.pre_synapse in synapse_objects else None, type=type) conn_count = 0 if p.random_connectivity: for pre_i in range(len(pop_locations[p.presynaptic])): for post_i in range(len( pop_locations[p.postsynaptic])): flip = rng.random() #print("Is cell %i conn to %i, prob %s - %s"%(pre_i, post_i, flip, p.random_connectivity.probability)) if flip < p.random_connectivity.probability: #print_v("Adding connection %i with weight: %s, delay: %s"%(conn_count, weight, delay)) handler.handle_connection(p.id, conn_count, p.presynaptic, p.postsynaptic, p.synapse, \ pre_i, \ post_i, \ preSegId=0, \ preFract=0.5, \ postSegId=0, \ postFract=0.5, \ delay=delay, \ weight=weight) conn_count += 1 if p.convergent_connectivity: for post_i in range(len(pop_locations[p.postsynaptic])): for count in range( int(p.convergent_connectivity.num_per_post)): found = False while not found: pre_i = int(rng.random() * len(pop_locations[p.presynaptic])) if p.presynaptic == p.postsynaptic and pre_i == post_i: found = False else: found = True print_v( "Adding connection %i (%i->%i; %i to %s of post) with weight: %s, delay: %s" % (conn_count, pre_i, post_i, count, p.convergent_connectivity.num_per_post, weight, delay)) handler.handle_connection(p.id, conn_count, p.presynaptic, p.postsynaptic, p.synapse, \ pre_i, \ post_i, \ preSegId=0, \ preFract=0.5, \ postSegId=0, \ postFract=0.5, \ delay=delay, \ weight=weight) conn_count += 1 elif p.one_to_one_connector: for i in range( min(len(pop_locations[p.presynaptic]), len(pop_locations[p.postsynaptic]))): #print_v("Adding connection %i with weight: %s, delay: %s"%(conn_count, weight, delay)) handler.handle_connection(p.id, conn_count, p.presynaptic, p.postsynaptic, p.synapse, \ i, \ i, \ preSegId=0, \ preFract=0.5, \ postSegId=0, \ postFract=0.5, \ delay=delay, \ weight=weight) conn_count += 1 handler.finalise_projection(p.id, p.presynaptic, p.postsynaptic, p.synapse) if include_inputs: for input in nl_model.inputs: handler.handle_input_list(input.id, input.population, input.input_source, size=0, input_comp_obj=None) input_count = 0 for i in range(len(pop_locations[input.population])): flip = rng.random() weight = input.weight if input.weight else 1 if flip * 100. < input.percentage: number_per_cell = evaluate( input.number_per_cell, nl_model.parameters) if input.number_per_cell else 1 for j in range(number_per_cell): handler.handle_single_input(input.id, input_count, i, weight=evaluate( weight, nl_model.parameters)) input_count += 1 handler.finalise_input_source(input.id) if hasattr(handler, 'finalise_document'): handler.finalise_document()
def _extract_pynn_components_to_neuroml(nl_model, nml_doc=None): """ Parse the NeuroMLlite description for cell, synapses and inputs described as PyNN elements (e.g. IF_cond_alpha, DCSource) and parameters, and convert these to the equivalent elements in a NeuroMLDocument """ if nml_doc == None: from neuroml import NeuroMLDocument nml_doc = NeuroMLDocument(id="temp") for c in nl_model.cells: if c.pynn_cell: if nml_doc.get_by_id(c.id) == None: import pyNN.neuroml cell_params = c.parameters if c.parameters else {} #print('------- %s: %s' % (c, cell_params)) for p in cell_params: cell_params[p] = evaluate(cell_params[p], nl_model.parameters) #print('====== %s: %s' % (c, cell_params)) for proj in nl_model.projections: synapse = nl_model.get_child(proj.synapse, 'synapses') post_pop = nl_model.get_child(proj.postsynaptic, 'populations') if post_pop.component == c.id: #print("--------- Cell %s in post pop %s of %s uses %s"%(c.id,post_pop.id, proj.id, synapse)) if synapse.pynn_receptor_type == 'excitatory': post = '_E' elif synapse.pynn_receptor_type == 'inhibitory': post = '_I' for p in synapse.parameters: cell_params['%s%s' % (p, post)] = synapse.parameters[p] temp_cell = eval('pyNN.neuroml.%s(**cell_params)' % c.pynn_cell) if c.pynn_cell != 'SpikeSourcePoisson': temp_cell.default_initial_values[ 'v'] = temp_cell.parameter_space['v_rest'].base_value cell_id = temp_cell.add_to_nml_doc(nml_doc, None) cell = nml_doc.get_by_id(cell_id) cell.id = c.id for s in nl_model.synapses: if nml_doc.get_by_id(s.id) == None: if s.pynn_synapse_type and s.pynn_receptor_type: import neuroml if s.pynn_synapse_type == 'cond_exp': syn = neuroml.ExpCondSynapse( id=s.id, tau_syn=s.parameters['tau_syn'], e_rev=s.parameters['e_rev']) nml_doc.exp_cond_synapses.append(syn) elif s.pynn_synapse_type == 'cond_alpha': syn = neuroml.AlphaCondSynapse( id=s.id, tau_syn=s.parameters['tau_syn'], e_rev=s.parameters['e_rev']) nml_doc.alpha_cond_synapses.append(syn) elif s.pynn_synapse_type == 'curr_exp': syn = neuroml.ExpCurrSynapse( id=s.id, tau_syn=s.parameters['tau_syn']) nml_doc.exp_curr_synapses.append(syn) elif s.pynn_synapse_type == 'curr_alpha': syn = neuroml.AlphaCurrSynapse( id=s.id, tau_syn=s.parameters['tau_syn']) nml_doc.alpha_curr_synapses.append(syn) for i in nl_model.input_sources: #if nml_doc.get_by_id(i.id) == None: if i.pynn_input: import pyNN.neuroml input_params = i.parameters if i.parameters else {} exec('input__%s = pyNN.neuroml.%s(**input_params)' % (i.id, i.pynn_input)) exec('temp_input = input__%s' % i.id) pg_id = temp_input.add_to_nml_doc(nml_doc, None) #for pp in nml_doc.pulse_generators: # print('PG: %s: %s'%(pp,pp.id)) pg = nml_doc.get_by_id(pg_id) pg.id = i.id return nml_doc
def generate(ref='Example6_PyNN', add_inputs=True): ################################################################################ ### Build new network net = Network(id=ref, notes='Another network for PyNN - work in progress...') net.parameters = { 'N_scaling': 0.005, 'layer_height': 400, 'width': 100, 'depth': 100, 'input_weight': 0.1 } cell = Cell(id='CorticalCell', pynn_cell='IF_curr_exp') cell.parameters = { 'cm': 0.25, # nF 'i_offset': 0.0, # nA 'tau_m': 10.0, # ms 'tau_refrac': 2.0, # ms 'v_reset': -65.0, # mV 'v_rest': -65.0, # mV 'v_thresh': -50.0 # mV } net.cells.append(cell) if add_inputs: input_cell = Cell(id='InputCell', pynn_cell='SpikeSourcePoisson') input_cell.parameters = { 'start': 0, 'duration': 10000000000, 'rate': 150 } net.cells.append(input_cell) e_syn = Synapse(id='ampa', pynn_receptor_type='excitatory', pynn_synapse_type='curr_exp', parameters={'tau_syn': 0.5}) net.synapses.append(e_syn) i_syn = Synapse(id='gaba', pynn_receptor_type='inhibitory', pynn_synapse_type='curr_exp', parameters={'tau_syn': 0.5}) net.synapses.append(i_syn) N_full = { 'L23': { 'E': 20683, 'I': 5834 }, 'L4': { 'E': 21915, 'I': 5479 }, 'L5': { 'E': 4850, 'I': 1065 }, 'L6': { 'E': 14395, 'I': 2948 } } scale = 0.1 pops = [] input_pops = [] pop_dict = {} layers = ['L23'] layers = ['L23', 'L4', 'L5', 'L6'] for l in layers: i = 3 - layers.index(l) r = RectangularRegion(id=l, x=0, y=i * net.parameters['layer_height'], z=0, width=net.parameters['width'], height=net.parameters['layer_height'], depth=net.parameters['depth']) net.regions.append(r) for t in ['E', 'I']: try: import opencortex.utils.color as occ if l == 'L23': if t == 'E': color = occ.L23_PRINCIPAL_CELL if t == 'I': color = occ.L23_INTERNEURON if l == 'L4': if t == 'E': color = occ.L4_PRINCIPAL_CELL if t == 'I': color = occ.L4_INTERNEURON if l == 'L5': if t == 'E': color = occ.L5_PRINCIPAL_CELL if t == 'I': color = occ.L5_INTERNEURON if l == 'L6': if t == 'E': color = occ.L6_PRINCIPAL_CELL if t == 'I': color = occ.L6_INTERNEURON except: color = '.8 0 0' if t == 'E' else '0 0 1' pop_id = '%s_%s' % (l, t) pops.append(pop_id) ref = 'l%s%s' % (l[1:], t.lower()) exec( ref + " = Population(id=pop_id, size='int(%s*N_scaling)'%N_full[l][t], component=cell.id, properties={'color':color, 'type':t})" ) exec("%s.random_layout = RandomLayout(region = r.id)" % ref) exec("net.populations.append(%s)" % ref) exec("pop_dict['%s'] = %s" % (pop_id, ref)) if add_inputs: color = '.8 .8 .8' input_id = '%s_%s_input' % (l, t) input_pops.append(input_id) input_ref = 'l%s%s_i' % (l[1:], t.lower()) exec( input_ref + " = Population(id=input_id, size='int(%s*N_scaling)'%N_full[l][t], component=input_cell.id, properties={'color':color})" ) exec("%s.random_layout = RandomLayout(region = r.id)" % input_ref) exec("net.populations.append(%s)" % input_ref) #l23i = Population(id='L23_I', size=int(100*scale), component=cell.id, properties={'color':}) #l23ei = Population(id='L23_E_input', size=int(100*scale), component=input_cell.id) #l23ii = Population(id='L23_I_input', size=int(100*scale), component=input_cell.id) #net.populations.append(l23e) #net.populations.append(l23ei) #net.populations.append(l23i) #net.populations.append(l23ii) conn_probs = [ [0.1009, 0.1689, 0.0437, 0.0818, 0.0323, 0., 0.0076, 0.], [0.1346, 0.1371, 0.0316, 0.0515, 0.0755, 0., 0.0042, 0.], [0.0077, 0.0059, 0.0497, 0.135, 0.0067, 0.0003, 0.0453, 0.], [0.0691, 0.0029, 0.0794, 0.1597, 0.0033, 0., 0.1057, 0.], [0.1004, 0.0622, 0.0505, 0.0057, 0.0831, 0.3726, 0.0204, 0.], [0.0548, 0.0269, 0.0257, 0.0022, 0.06, 0.3158, 0.0086, 0.], [0.0156, 0.0066, 0.0211, 0.0166, 0.0572, 0.0197, 0.0396, 0.2252], [0.0364, 0.001, 0.0034, 0.0005, 0.0277, 0.008, 0.0658, 0.1443] ] if add_inputs: for p in pops: proj = Projection(id='proj_input_%s' % p, presynaptic='%s_input' % p, postsynaptic=p, synapse=e_syn.id, delay=2, weight='input_weight') proj.one_to_one_connector = OneToOneConnector() net.projections.append(proj) for pre_i in range(len(pops)): for post_i in range(len(pops)): pre = pops[pre_i] post = pops[post_i] prob = conn_probs[post_i][pre_i] ####### TODO: check!!!! weight = 1 syn = e_syn if prob > 0: if 'I' in pre: weight = -1 syn = i_syn proj = Projection(id='proj_%s_%s' % (pre, post), presynaptic=pre, postsynaptic=post, synapse=syn.id, delay=1, weight=weight) proj.random_connectivity = RandomConnectivity(probability=prob) net.projections.append(proj) print(net.to_json()) new_file = net.to_json_file('%s.json' % net.id) ################################################################################ ### Build Simulation object & save as JSON recordTraces = {} recordSpikes = {} from neuromllite.utils import evaluate for p in pops: forecast_size = evaluate(pop_dict[p].size, net.parameters) recordTraces[p] = list(range(min(2, forecast_size))) recordSpikes[p] = '*' for ip in input_pops: recordSpikes[ip] = '*' sim = Simulation(id='Sim%s' % net.id, network=new_file, duration='100', dt='0.025', seed=1234, recordTraces=recordTraces, recordSpikes=recordSpikes) sim.to_json_file() return sim, net
def generate_and_run(simulation, simulator, network=None, return_results=False, base_dir=None, target_dir=None, num_processors=1): """ Generates the network in the specified simulator and runs, if appropriate """ if network == None: network = load_network_json(simulation.network) print_v("Generating network %s and running in simulator: %s..." % (network.id, simulator)) if simulator == 'NEURON': _generate_neuron_files_from_neuroml(network, dir_for_mod_files=target_dir) from neuromllite.NeuronHandler import NeuronHandler nrn_handler = NeuronHandler() for c in network.cells: if c.neuroml2_source_file: src_dir = os.path.dirname( os.path.abspath(c.neuroml2_source_file)) nrn_handler.executeHoc('load_file("%s/%s.hoc")' % (src_dir, c.id)) generate_network(network, nrn_handler, generate_network, base_dir) if return_results: raise NotImplementedError( "Reloading results not supported in Neuron yet...") elif simulator.lower() == 'sonata': # Will not "run" obviously... from neuromllite.SonataHandler import SonataHandler sonata_handler = SonataHandler() generate_network(network, sonata_handler, always_include_props=True, base_dir=base_dir) print_v("Done with Sonata...") elif simulator.lower().startswith('graph'): # Will not "run" obviously... from neuromllite.GraphVizHandler import GraphVizHandler, engines try: if simulator[-1].isalpha(): engine = engines[simulator[-1]] level = int(simulator[5:-1]) else: engine = 'dot' level = int(simulator[5:]) except Exception as e: print_v("Error parsing: %s: %s" % (simulator, e)) print_v( "Graphs of the network structure can be generated at many levels of detail (1-6, required) and laid out using GraphViz engines (d - dot (default); c - circo; n - neato; f - fdp), so use: -graph3c, -graph2, -graph4f etc." ) return handler = GraphVizHandler(level, engine=engine, nl_network=network) generate_network(network, handler, always_include_props=True, base_dir=base_dir) print_v("Done with GraphViz...") elif simulator.lower().startswith('matrix'): # Will not "run" obviously... from neuromllite.MatrixHandler import MatrixHandler try: level = int(simulator[6:]) except: print_v("Error parsing: %s" % simulator) print_v( "Matrices of the network structure can be generated at many levels of detail (1-n, required), so use: -matrix1, -matrix2, etc." ) return handler = MatrixHandler(level, nl_network=network) generate_network(network, handler, always_include_props=True, base_dir=base_dir) print_v("Done with MatrixHandler...") elif simulator.startswith('PyNN'): #_generate_neuron_files_from_neuroml(network) simulator_name = simulator.split('_')[1].lower() from neuromllite.PyNNHandler import PyNNHandler pynn_handler = PyNNHandler(simulator_name, simulation.dt, network.id) syn_cell_params = {} for proj in network.projections: synapse = network.get_child(proj.synapse, 'synapses') post_pop = network.get_child(proj.postsynaptic, 'populations') if not post_pop.component in syn_cell_params: syn_cell_params[post_pop.component] = {} for p in synapse.parameters: post = '' if synapse.pynn_receptor_type == "excitatory": post = '_E' elif synapse.pynn_receptor_type == "inhibitory": post = '_I' syn_cell_params[post_pop.component][ '%s%s' % (p, post)] = synapse.parameters[p] cells = {} for c in network.cells: if c.pynn_cell: cell_params = {} if c.parameters: for p in c.parameters: cell_params[p] = evaluate(c.parameters[p], network.parameters) dont_set_here = [ 'tau_syn_E', 'e_rev_E', 'tau_syn_I', 'e_rev_I' ] for d in dont_set_here: if d in c.parameters: raise Exception( 'Synaptic parameters like %s should be set ' + 'in individual synapses, not in the list of parameters associated with the cell' % d) if c.id in syn_cell_params: cell_params.update(syn_cell_params[c.id]) print_v("Creating cell with params: %s" % cell_params) exec('cells["%s"] = pynn_handler.sim.%s(**cell_params)' % (c.id, c.pynn_cell)) if c.pynn_cell != 'SpikeSourcePoisson': exec( "cells['%s'].default_initial_values['v'] = cells['%s'].parameter_space['v_rest'].base_value" % (c.id, c.id)) pynn_handler.set_cells(cells) receptor_types = {} for s in network.synapses: if s.pynn_receptor_type: receptor_types[s.id] = s.pynn_receptor_type pynn_handler.set_receptor_types(receptor_types) for input_source in network.input_sources: if input_source.pynn_input: pynn_handler.add_input_source(input_source) generate_network(network, pynn_handler, always_include_props=True, base_dir=base_dir) for pid in pynn_handler.populations: pop = pynn_handler.populations[pid] if 'all' in simulation.recordTraces or pop.label in simulation.recordTraces: if pop.can_record('v'): pop.record('v') pynn_handler.sim.run(simulation.duration) pynn_handler.sim.end() traces = {} events = {} if not 'NeuroML' in simulator: from neo.io import PyNNTextIO for pid in pynn_handler.populations: pop = pynn_handler.populations[pid] if 'all' in simulation.recordTraces or pop.label in simulation.recordTraces: filename = "%s.%s.v.dat" % (simulation.id, pop.label) all_columns = [] print_v("Writing data for %s to %s" % (pop.label, filename)) for i in range(len(pop)): if pop.can_record('v'): ref = '%s[%i]' % (pop.label, i) traces[ref] = [] data = pop.get_data('v', gather=False) for segment in data.segments: vm = segment.analogsignals[0].transpose()[i] if len(all_columns) == 0: tt = np.array([ t * simulation.dt / 1000. for t in range(len(vm)) ]) all_columns.append(tt) vm_si = [float(v / 1000.) for v in vm] traces[ref] = vm_si all_columns.append(vm_si) times_vm = np.array(all_columns).transpose() np.savetxt(filename, times_vm, delimiter='\t', fmt='%s') if return_results: _print_result_info(traces, events) return traces, events elif simulator == 'NetPyNE': if target_dir == None: target_dir = './' _generate_neuron_files_from_neuroml(network, dir_for_mod_files=target_dir) from netpyne import specs from netpyne import sim # Note NetPyNE from this branch is required: https://github.com/Neurosim-lab/netpyne/tree/neuroml_updates from netpyne.conversion.neuromlFormat import NetPyNEBuilder import pprint pp = pprint.PrettyPrinter(depth=6) netParams = specs.NetParams() simConfig = specs.SimConfig() netpyne_handler = NetPyNEBuilder(netParams, simConfig=simConfig, verbose=True) generate_network(network, netpyne_handler, base_dir=base_dir) netpyne_handler.finalise() simConfig = specs.SimConfig() simConfig.tstop = simulation.duration simConfig.duration = simulation.duration simConfig.dt = simulation.dt simConfig.seed = simulation.seed simConfig.recordStep = simulation.dt simConfig.recordCells = ['all'] simConfig.recordTraces = {} for pop in netpyne_handler.popParams.values(): if 'all' in simulation.recordTraces or pop.id in simulation.recordTraces: for i in pop['cellsList']: id = pop['pop'] index = i['cellLabel'] simConfig.recordTraces['v_%s_%s' % (id, index)] = { 'sec': 'soma', 'loc': 0.5, 'var': 'v', 'conds': { 'pop': id, 'cellLabel': index } } simConfig.saveDat = True print_v("NetPyNE netParams: ") pp.pprint(netParams.todict()) #print_v("NetPyNE simConfig: ") #pp.pprint(simConfig.todict()) sim.initialize( netParams, simConfig) # create network object and set cfg and net params sim.net.createPops() cells = sim.net.createCells( ) # instantiate network cells based on defined populations for proj_id in netpyne_handler.projection_infos.keys(): projName, prePop, postPop, synapse, ptype = netpyne_handler.projection_infos[ proj_id] print_v("Creating connections for %s (%s): %s->%s via %s" % (projName, ptype, prePop, postPop, synapse)) preComp = netpyne_handler.pop_ids_vs_components[prePop] for conn in netpyne_handler.connections[projName]: pre_id, pre_seg, pre_fract, post_id, post_seg, post_fract, delay, weight = conn #connParam = {'delay':delay,'weight':weight,'synsPerConn':1, 'sec':post_seg, 'loc':post_fract, 'threshold':threshold} connParam = { 'delay': delay, 'weight': weight, 'synsPerConn': 1, 'sec': post_seg, 'loc': post_fract } if ptype == 'electricalProjection': if weight != 1: raise Exception( 'Cannot yet support inputs where weight !=1!') connParam = { 'synsPerConn': 1, 'sec': post_seg, 'loc': post_fract, 'gapJunction': True, 'weight': weight } else: connParam = { 'delay': delay, 'weight': weight, 'synsPerConn': 1, 'sec': post_seg, 'loc': post_fract } #'threshold': threshold} connParam['synMech'] = synapse if post_id in sim.net.gid2lid: # check if postsyn is in this node's list of gids sim.net._addCellConn(connParam, pre_id, post_id) stims = sim.net.addStims( ) # add external stimulation to cells (IClamps etc) simData = sim.setupRecording( ) # setup variables to record for each cell (spikes, V traces, etc) sim.runSim() # run parallel Neuron simulation sim.gatherData() # gather spiking data and cell info from each node sim.saveData( ) # save params, cell info and sim output to file (pickle,mat,txt,etc) if return_results: raise NotImplementedError( "Reloading results not supported in NetPyNE yet...") elif simulator == 'jNeuroML' or simulator == 'jNeuroML_NEURON' or simulator == 'jNeuroML_NetPyNE': from pyneuroml.lems import generate_lems_file_for_neuroml from pyneuroml import pynml lems_file_name = 'LEMS_%s.xml' % simulation.id nml_file_name, nml_doc = generate_neuroml2_from_network( network, base_dir=base_dir, target_dir=target_dir) included_files = ['PyNN.xml'] for c in network.cells: if c.lems_source_file: included_files.append(c.lems_source_file) ''' if network.cells: for c in network.cells: included_files.append(c.neuroml2_source_file) ''' if network.synapses: for s in network.synapses: if s.lems_source_file: included_files.append(s.lems_source_file) print_v("Generating LEMS file prior to running in %s" % simulator) pops_plot_save = [] pops_spike_save = [] gen_plots_for_quantities = {} gen_saves_for_quantities = {} for p in network.populations: if simulation.recordTraces and ('all' in simulation.recordTraces or p.id in simulation.recordTraces): pops_plot_save.append(p.id) if simulation.recordSpikes and ('all' in simulation.recordSpikes or p.id in simulation.recordSpikes): pops_spike_save.append(p.id) if simulation.recordRates and ('all' in simulation.recordRates or p.id in simulation.recordRates): size = evaluate(p.size, network.parameters) for i in range(size): quantity = '%s/%i/%s/r' % (p.id, i, p.component) gen_plots_for_quantities['%s_%i_r' % (p.id, i)] = [quantity] gen_saves_for_quantities['%s_%i.r.dat' % (p.id, i)] = [quantity] if simulation.recordVariables: for var in simulation.recordVariables: to_rec = simulation.recordVariables[var] if ('all' in to_rec or p.id in to_rec): size = evaluate(p.size, network.parameters) for i in range(size): quantity = '%s/%i/%s/%s' % (p.id, i, p.component, var) gen_plots_for_quantities['%s_%i_%s' % (p.id, i, var)] = [ quantity ] gen_saves_for_quantities['%s_%i.%s.dat' % (p.id, i, var)] = [ quantity ] generate_lems_file_for_neuroml( simulation.id, nml_file_name, network.id, simulation.duration, simulation.dt, lems_file_name, target_dir=target_dir if target_dir else '.', nml_doc= nml_doc, # Use this if the nml doc has already been loaded (to avoid delay in reload) include_extra_files=included_files, gen_plots_for_all_v=False, plot_all_segments=False, gen_plots_for_quantities= gen_plots_for_quantities, # Dict with displays vs lists of quantity paths gen_plots_for_only_populations= pops_plot_save, # List of populations, all pops if = [] gen_saves_for_all_v=False, save_all_segments=False, gen_saves_for_only_populations= pops_plot_save, # List of populations, all pops if = [] gen_saves_for_quantities= gen_saves_for_quantities, # Dict with file names vs lists of quantity paths gen_spike_saves_for_all_somas=False, gen_spike_saves_for_only_populations= pops_spike_save, # List of populations, all pops if = [] gen_spike_saves_for_cells= {}, # Dict with file names vs lists of quantity paths spike_time_format='ID_TIME', copy_neuroml=True, lems_file_generate_seed=12345, report_file_name='report.%s.txt' % simulation.id, simulation_seed=simulation.seed if simulation.seed else 12345, verbose=True) lems_file_name = _locate_file(lems_file_name, target_dir) if simulator == 'jNeuroML': results = pynml.run_lems_with_jneuroml( lems_file_name, nogui=True, load_saved_data=return_results, reload_events=return_results) elif simulator == 'jNeuroML_NEURON': results = pynml.run_lems_with_jneuroml_neuron( lems_file_name, nogui=True, load_saved_data=return_results, reload_events=return_results) elif simulator == 'jNeuroML_NetPyNE': results = pynml.run_lems_with_jneuroml_netpyne( lems_file_name, nogui=True, verbose=True, load_saved_data=return_results, reload_events=return_results, num_processors=num_processors) print_v("Finished running LEMS file %s in %s (returning results: %s)" % (lems_file_name, simulator, return_results)) if return_results: traces, events = results _print_result_info(traces, events) return results # traces, events =
def handle_population(self, population_id, component, size=-1, component_obj=None, properties={}): sizeInfo = " as yet unspecified size" if size >= 0: sizeInfo = ", size: " + str(size) + " cells" if component_obj: compInfo = " (%s)" % component_obj.__class__.__name__ else: compInfo = "" print_v("Population: " + population_id + ", component: " + component + compInfo + sizeInfo) if size >= 0: for i in range(size): node_id = "%s_%i" % (population_id, i) node = {} node["type"] = {} node["name"] = node_id # node['type']['NeuroML'] = component comp = self.nl_network.get_child(component, "cells") base_dir = "./" # for now... fname = locate_file(comp.lems_source_file, base_dir) model = lems.Model() model.import_from_file(fname) lems_comp = model.components.get(component) print("Cell: [%s] comes from %s and in Lems is: %s" % (comp, fname, lems_comp)) comp_type = lems_comp.type type = "The type of %s" % comp_type function = "The function of %s" % comp_type if comp_type == "pnlLinearFunctionTM": function = "Linear" type = "TransferMechanism" elif comp_type == "inputNode": function = "Linear" type = "TransferMechanism" elif comp_type == "pnlLogisticFunctionTM": function = "Logistic" type = "TransferMechanism" elif comp_type == "pnlExponentialFunctionTM": function = "Exponential" type = "TransferMechanism" elif comp_type == "pnlSimpleIntegratorMechanism": function = "SimpleIntegrator" type = "IntegratorMechanism" elif comp_type == "fnCell": function = "FitzHughNagumoIntegrator" type = "IntegratorMechanism" node["type"]["PNL"] = type node["type"]["generic"] = None node["parameters"] = {} node["parameters"]["PNL"] = {} node["functions"] = [] func_info = {} func_info["type"] = {} func_info["type"]["generic"] = function func_info["name"] = "Function_%s" % function func_info["args"] = {} for p in lems_comp.parameters: func_info["args"][p] = {} func_info["args"][p]["type"] = "float" func_info["args"][p]["source"] = "%s.input_ports.%s" % ( node_id, p) if comp.parameters is not None and p in comp.parameters: func_info["args"][p]["value"] = evaluate( comp.parameters[p], self.nl_network.parameters) else: func_info["args"][p]["value"] = evaluate( lems_comp.parameters[p] ) # evaluate to ensure strings -> ints/floats etc node["functions"].append(func_info) self.bids_mdf_graph["nodes"][node_id] = node pop_node_id = "%s" % (population_id) pop_node = {} pop_node["type"] = {} pop_node["name"] = pop_node_id pop_node["type"]["NeuroML"] = component pop_node["parameters"] = {} pop_node["parameters"]["size"] = size pop_node["functions"] = {} self.bids_mdf_graph_hl["nodes"][pop_node_id] = pop_node