def writeConnections(): net_id = "MuscleConnections" nml_network_doc = NeuroMLDocument(id=net_id) # Create a NeuroML Network data structure to hold on to all the neuron- # muscle connection info. net = Network(id=net_id) nml_network_doc.networks.append(net) pop0 = Population(id=muscles[0].name, component=muscles[0].name, size=1) inst = Instance(id="0") inst.location = Location(x="0.0", y="0.0", z="0.0") pop0.instances.append(inst) # put that Population into the Network data structure from above net.populations.append(pop0) for (pre_cell, post_cell, close_pairs) in connect_list: # take information about each connection and package it into a # NeuroML Projection data structure proj_id = "NCXLS_%s_%s" % (pre_cell, post_cell) proj0 = Projection(id=proj_id, presynaptic_population=pre_cell, postsynaptic_population=post_cell) #synapse=conn.synclass) for conn0 in close_pairs: proj0.connections.append(conn0) net.projections.append(proj0) nml_file = 'Output/' + net_id + '.nml' writers.NeuroMLWriter.write(nml_network_doc, nml_file)
def generate(net_id, params, cells = None, cells_to_plot=None, cells_to_stimulate=None, duration=500, dt=0.01, vmin=-75, vmax=20): nml_doc = NeuroMLDocument(id=net_id) nml_doc.iaf_cells.append(params.generic_cell) net = Network(id=net_id) nml_doc.networks.append(net) nml_doc.pulse_generators.append(params.offset_current) # Use the spreadsheet reader to give a list of all cells and a list of all connections # This could be replaced with a call to "DatabaseReader" or "OpenWormNeuroLexReader" in future... cell_names, conns = SpreadsheetDataReader.readDataFromSpreadsheet("../../../") cell_names.sort() # To hold all Cell NeuroML objects vs. names all_cells = {} # lems_file = "" lems_info = {"reference": net_id, "duration": duration, "dt": dt, "vmin": vmin, "vmax": vmax, "cell_component": params.generic_cell.id} lems_info["plots"] = [] lems_info["cells"] = [] for cell in cell_names: if cells is None or cell in cells: # build a Population data structure out of the cell name pop0 = Population(id=cell, component=params.generic_cell.id, type="populationList") inst = Instance(id="0") pop0.instances.append(inst) # put that Population into the Network data structure from above net.populations.append(pop0) # also use the cell name to grab the morphology file, as a NeuroML data structure # into the 'all_cells' dict cell_file = '../../generatedNeuroML2/%s.nml'%cell doc = loaders.NeuroMLLoader.load(cell_file) all_cells[cell] = doc.cells[0] location = doc.cells[0].morphology.segments[0].proximal print("Loaded morphology file from: %s, with id: %s, location: (%s, %s, %s)"%(cell_file, all_cells[cell].id, location.x, location.y, location.z)) inst.location = Location(float(location.x), float(location.y), float(location.z)) exp_input = ExplicitInput(target="%s/0/%s"%(pop0.id, params.generic_cell.id), input=params.offset_current.id) if cells_to_stimulate is None or cell in cells_to_stimulate: net.explicit_inputs.append(exp_input) if cells_to_plot is None or cell in cells_to_plot: plot = {} plot["cell"] = cell plot["colour"] = get_random_colour_hex() lems_info["plots"].append(plot) lems_info["cells"].append(cell) for conn in conns: if conn.pre_cell in lems_info["cells"] and conn.post_cell in lems_info["cells"]: # take information about each connection and package it into a # NeuroML Projection data structure proj_id = get_projection_id(conn.pre_cell, conn.post_cell, conn.synclass, conn.syntype) syn0 = params.exc_syn if 'GABA' in conn.synclass: syn0 = params.inh_syn syn_new = create_n_connection_synapse(syn0, conn.number, nml_doc) proj0 = Projection(id=proj_id, \ presynaptic_population=conn.pre_cell, postsynaptic_population=conn.post_cell, synapse=syn_new.id) # Get the corresponding Cell for each # pre_cell = all_cells[conn.pre_cell] # post_cell = all_cells[conn.post_cell] net.projections.append(proj0) # Add a Connection with the closest locations conn0 = Connection(id="0", \ pre_cell_id="../%s/0/%s"%(conn.pre_cell, params.generic_cell.id), post_cell_id="../%s/0/%s"%(conn.post_cell, params.generic_cell.id)) proj0.connections.append(conn0) write_to_file(nml_doc, lems_info, net_id)
def create_network(cell, tauSyn, syn_ex, syn_ih, inputs): g = 5.0 # ratio inhibitory weight/excitatory weight eta = 2.0 # external rate relative to threshold rate epsilon = 0.1 # connection probability order = 10 NE = 4*order # number of excitatory neurons NI = 1*order # number of inhibitory neurons N_neurons = NE+NI # number of neurons in total CE = int(epsilon*NE) # number of excitatory synapses per neuron CI = int(epsilon*NI) # number of inhibitory synapses per neuron C_tot = int(CI+CE) # total number of synapses per neuron net = Network(id="net") nodes_ex = Population(id="nodes_ex", component=cell.id, size=NE) nodes_inh = Population(id="nodes_inh", component=cell.id, size=NI) noise = Population(id="noise", component=inputs.id, size=1) net.populations.append(nodes_ex) net.populations.append(nodes_inh) net.populations.append(noise) g = 5.0 # ratio inhibitory weight/excitatory weight J = 0.1 # postsynaptic amplitude in mV J_unit = computePSPnorm(cell.tauMem, cell.CMem, tauSyn) J_ex = J / J_unit # amplitude of excitatory postsynaptic current J_in = -g * J_ex # amplitude of inhibitory postsynaptic current ex_ibase = str(J_ex) + 'nA' in_ibase = str(J_in) + 'nA' delay = "1.5 ms" proj = Projection(id="Proj0", synapse=syn_ex.id, presynaptic_population=noise.id, postsynaptic_population=nodes_ex.id) net.projections.append(proj) proj.connection_wds.extend( all_to_all(noise, nodes_ex, syn_ex, 1, delay)) #net.synaptic_current_weight_delays.extend( # all_to_all(noise, nodes_inh, synapse, in_weight, delay)) ''' random.seed(1234) sources_ex = random.random_integers(1, NE, (N_neurons, CE)) sources_in = random.random_integers(NE+1, N_neurons, (N_neurons, CI)) ex_ex = sources_ex[:NE] - 1 ex_in = sources_ex[NE:] - 1 in_ex = sources_in[:NE] - NE - 1 in_in = sources_in[NE:] - NE - 1 net.synaptic_current_weight_delays.extend( connect_from_list(ex_ex, 'nodes_ex', 'nodes_ex', synapse, 1, delay)) net.synaptic_current_weight_delays.extend( connect_from_list(ex_in, 'nodes_ex', 'nodes_inh', synapse, 1, delay)) net.synaptic_current_weight_delays.extend( connect_from_list(in_ex, 'nodes_inh', 'nodes_ex', synapse, 1, delay)) net.synaptic_current_weight_delays.extend( connect_from_list(in_in, 'nodes_inh', 'nodes_inh', synapse, 1, delay))''' return net, ex_ibase, in_ibase
def generate_example_network(network_id, numCells_exc, numCells_inh, x_size = 1000, y_size = 100, z_size = 1000, exc_group_component = "SimpleIaF", inh_group_component = "SimpleIaF_inh", validate = True, random_seed = 1234, generate_lems_simulation = False, connections = True, connection_probability_exc_exc = 0.4, connection_probability_inh_exc = 0.4, connection_probability_exc_inh = 0.4, connection_probability_inh_inh = 0.4, inputs = False, input_firing_rate = 50, # Hz input_offset_min = 0, # nA input_offset_max = 0, # nA num_inputs_per_exc = 4, duration = 500, # ms dt = 0.05, temperature="32.0 degC"): seed(random_seed) nml_doc = NeuroMLDocument(id=network_id) net = Network(id = network_id, type = "networkWithTemperature", temperature = temperature) net.notes = "Network generated using libNeuroML v%s"%__version__ nml_doc.networks.append(net) for cell_comp in set([exc_group_component, inh_group_component]): # removes duplicates nml_doc.includes.append(IncludeType(href='%s.cell.nml'%cell_comp)) # The names of the Exc & Inh groups/populations exc_group = "Exc" inh_group = "Inh" # The names of the network connections net_conn_exc_inh = "NetConn_Exc_Inh" net_conn_inh_exc = "NetConn_Inh_Exc" net_conn_exc_exc = "NetConn_Exc_Exc" net_conn_inh_inh = "NetConn_Inh_Inh" # The names of the synapse types (should match names at Cell Mechanism/Network tabs in neuroConstruct) exc_inh_syn = "AMPAR" inh_exc_syn = "GABAA" exc_exc_syn = "AMPAR" inh_inh_syn = "GABAA" for syn in [exc_inh_syn, inh_exc_syn]: nml_doc.includes.append(IncludeType(href='%s.synapse.nml'%syn)) # Generate excitatory cells exc_pop = Population(id=exc_group, component=exc_group_component, type="populationList", size=numCells_exc) net.populations.append(exc_pop) for i in range(0, numCells_exc) : index = i inst = Instance(id=index) exc_pop.instances.append(inst) inst.location = Location(x=str(x_size*random()), y=str(y_size*random()), z=str(z_size*random())) # Generate inhibitory cells inh_pop = Population(id=inh_group, component=inh_group_component, type="populationList", size=numCells_inh) net.populations.append(inh_pop) for i in range(0, numCells_inh) : index = i inst = Instance(id=index) inh_pop.instances.append(inst) inst.location = Location(x=str(x_size*random()), y=str(y_size*random()), z=str(z_size*random())) if connections: proj_exc_exc = Projection(id=net_conn_exc_exc, presynaptic_population=exc_group, postsynaptic_population=exc_group, synapse=exc_exc_syn) net.projections.append(proj_exc_exc) proj_exc_inh = Projection(id=net_conn_exc_inh, presynaptic_population=exc_group, postsynaptic_population=inh_group, synapse=exc_inh_syn) net.projections.append(proj_exc_inh) proj_inh_exc = Projection(id=net_conn_inh_exc, presynaptic_population=inh_group, postsynaptic_population=exc_group, synapse=inh_exc_syn) net.projections.append(proj_inh_exc) proj_inh_inh = Projection(id=net_conn_inh_inh, presynaptic_population=inh_group, postsynaptic_population=inh_group, synapse=inh_inh_syn) net.projections.append(proj_inh_inh) count_exc_inh = 0 count_inh_exc = 0 count_exc_exc = 0 count_inh_inh = 0 for i in range(0, numCells_exc): for j in range(0, numCells_inh): if i != j: if random()<connection_probability_exc_inh: add_connection(proj_exc_inh, count_exc_inh, exc_group, exc_group_component, i, 0, inh_group, inh_group_component, j, 0) count_exc_inh+=1 if random()<connection_probability_inh_exc: add_connection(proj_inh_exc, count_inh_exc, inh_group, inh_group_component, j, 0, exc_group, exc_group_component, i, 0) count_inh_exc+=1 for i in range(0, numCells_exc): for j in range(0, numCells_exc): if i != j: if random()<connection_probability_exc_exc: add_connection(proj_exc_exc, count_exc_exc, exc_group, exc_group_component, i, 0, exc_group, exc_group_component, j, 0) count_exc_exc+=1 for i in range(0, numCells_inh): for j in range(0, numCells_inh): if i != j: if random()<connection_probability_inh_inh: add_connection(proj_inh_inh, count_inh_inh, inh_group, inh_group_component, j, 0, inh_group, inh_group_component, i, 0) count_inh_inh+=1 if inputs: if input_firing_rate>0: mf_input_syn = "AMPAR" if mf_input_syn!=exc_inh_syn and mf_input_syn!=inh_exc_syn: nml_doc.includes.append(IncludeType(href='%s.synapse.nml'%mf_input_syn)) rand_spiker_id = "input_%sHz"%input_firing_rate pfs = PoissonFiringSynapse(id=rand_spiker_id, average_rate="%s per_s"%input_firing_rate, synapse=mf_input_syn, spike_target="./%s"%mf_input_syn) nml_doc.poisson_firing_synapses.append(pfs) input_list = InputList(id="Input_0", component=rand_spiker_id, populations=exc_group) count = 0 for i in range(0, numCells_exc): for j in range(num_inputs_per_exc): input = Input(id=count, target="../%s/%i/%s"%(exc_group, i, exc_group_component), destination="synapses") input_list.input.append(input) count += 1 net.input_lists.append(input_list) if input_offset_max != 0 or input_offset_min != 0: for i in range(0, numCells_exc): pg = PulseGenerator(id="PulseGenerator_%i"%i, delay="0ms", duration="%sms"%duration, amplitude="%fnA"%(input_offset_min+(input_offset_max-input_offset_min)*random())) nml_doc.pulse_generators.append(pg) input_list = InputList(id="Input_Pulse_List_%i"%i, component=pg.id, populations=exc_group) input = Input(id=0, target="../%s/%i/%s"%(exc_group, i, exc_group_component), destination="synapses") input_list.input.append(input) net.input_lists.append(input_list) ####### Write to file ###### print("Saving to file...") nml_file = network_id+'.net.nml' writers.NeuroMLWriter.write(nml_doc, nml_file) print("Written network file to: "+nml_file) if validate: ###### Validate the NeuroML ###### from neuroml.utils import validate_neuroml2 validate_neuroml2(nml_file) if generate_lems_simulation: # Create a LEMSSimulation to manage creation of LEMS file ls = LEMSSimulation("Sim_%s"%network_id, duration, dt) # Point to network as target of simulation ls.assign_simulation_target(net.id) # Include generated/existing NeuroML2 files ls.include_neuroml2_file('%s.cell.nml'%exc_group_component) ls.include_neuroml2_file('%s.cell.nml'%inh_group_component) ls.include_neuroml2_file(nml_file) # Specify Displays and Output Files disp_exc = "display_exc" ls.create_display(disp_exc, "Voltages Exc cells", "-80", "50") of_exc = 'Volts_file_exc' ls.create_output_file(of_exc, "v_exc.dat") disp_inh = "display_inh" ls.create_display(disp_inh, "Voltages Inh cells", "-80", "50") of_inh = 'Volts_file_inh' ls.create_output_file(of_inh, "v_inh.dat") for i in range(numCells_exc): quantity = "%s/%i/%s/v"%(exc_group, i, exc_group_component) ls.add_line_to_display(disp_exc, "Exc %i: Vm"%i, quantity, "1mV", pynml.get_next_hex_color()) ls.add_column_to_output_file(of_exc, "v_%i"%i, quantity) for i in range(numCells_inh): quantity = "%s/%i/%s/v"%(inh_group, i, inh_group_component) ls.add_line_to_display(disp_inh, "Inh %i: Vm"%i, quantity, "1mV", pynml.get_next_hex_color()) ls.add_column_to_output_file(of_inh, "v_%i"%i, quantity) # Save to LEMS XML file lems_file_name = ls.save_to_file() print "-----------------------------------"
def generate(net_id, params, cells=None, cells_to_plot=None, cells_to_stimulate=None, include_muscles=False, conn_number_override=None, conn_number_scaling=None, duration=500, dt=0.01, vmin=None, vmax=None, seed=1234, validate=True, test=False, verbose=True, target_directory='./'): root_dir = os.path.dirname(os.path.abspath(__file__)) params.create_models() if vmin == None: if params.level == 'A': vmin = -72 elif params.level == 'B': vmin = -52 elif params.level == 'C': vmin = -60 else: vmin = -52 if vmax == None: if params.level == 'A': vmax = -48 elif params.level == 'B': vmax = -28 elif params.level == 'C': vmax = 25 else: vmax = -28 random.seed(seed) info = "\n\nParameters and setting used to generate this network:\n\n"+\ " Cells: %s\n" % (cells if cells is not None else "All cells")+\ " Cell stimulated: %s\n" % (cells_to_stimulate if cells_to_stimulate is not None else "All cells")+\ " Connection numbers overridden: %s\n" % (conn_number_override if conn_number_override is not None else "None")+\ " Connection numbers scaled: %s\n" % (conn_number_scaling if conn_number_scaling is not None else "None")+\ " Include muscles: %s\n" % include_muscles print_(info) info += "\n%s\n" % (params.bioparameter_info(" ")) nml_doc = NeuroMLDocument(id=net_id, notes=info) if params.level == "A" or params.level == "B" or params.level == "BC1": nml_doc.iaf_cells.append(params.generic_muscle_cell) nml_doc.iaf_cells.append(params.generic_neuron_cell) elif params.level == "C": nml_doc.cells.append(params.generic_muscle_cell) nml_doc.cells.append(params.generic_neuron_cell) net = Network(id=net_id) nml_doc.networks.append(net) nml_doc.pulse_generators.append(params.offset_current) if params.level == "C" or params.level == "C1": nml_doc.fixed_factor_concentration_models.append( params.concentration_model) cell_names, conns = get_cell_names_and_connection() # To hold all Cell NeuroML objects vs. names all_cells = {} # lems_file = "" lems_info = { "comment": info, "reference": net_id, "duration": duration, "dt": dt, "vmin": vmin, "vmax": vmax, "cell_component": params.generic_neuron_cell.id } lems_info["plots"] = [] lems_info["activity_plots"] = [] lems_info["muscle_plots"] = [] lems_info["muscle_activity_plots"] = [] lems_info["to_save"] = [] lems_info["activity_to_save"] = [] lems_info["muscles_to_save"] = [] lems_info["muscles_activity_to_save"] = [] lems_info["cells"] = [] lems_info["muscles"] = [] lems_info["includes"] = [] if params.custom_component_types_definitions: lems_info["includes"].append(params.custom_component_types_definitions) if target_directory != './': def_file = "%s/%s" % (os.path.dirname(os.path.abspath(__file__)), params.custom_component_types_definitions) shutil.copy(def_file, target_directory) nml_doc.includes.append( IncludeType(href=params.custom_component_types_definitions)) backers_dir = root_dir + "/../../../../OpenWormBackers/" if test else root_dir + "/../../../OpenWormBackers/" sys.path.append(backers_dir) import backers cells_vs_name = backers.get_adopted_cell_names(backers_dir) populations_without_location = False # isinstance(params.elec_syn, GapJunction) count = 0 for cell in cell_names: if cells is None or cell in cells: inst = Instance(id="0") if not populations_without_location: # build a Population data structure out of the cell name pop0 = Population(id=cell, component=params.generic_neuron_cell.id, type="populationList") pop0.instances.append(inst) else: # build a Population data structure out of the cell name pop0 = Population(id=cell, component=params.generic_neuron_cell.id, size="1") # put that Population into the Network data structure from above net.populations.append(pop0) if cells_vs_name.has_key(cell): p = Property(tag="OpenWormBackerAssignedName", value=cells_vs_name[cell]) pop0.properties.append(p) # also use the cell name to grab the morphology file, as a NeuroML data structure # into the 'all_cells' dict cell_file_path = root_dir + "/../../../" if test else root_dir + "/../../" #if running test cell_file = cell_file_path + 'generatedNeuroML2/%s.cell.nml' % cell doc = loaders.NeuroMLLoader.load(cell_file) all_cells[cell] = doc.cells[0] location = doc.cells[0].morphology.segments[0].proximal if verbose: print_( "Loaded morphology: %s; id: %s; location: (%s, %s, %s)" % (os.path.realpath(cell_file), all_cells[cell].id, location.x, location.y, location.z)) inst.location = Location(float(location.x), float(location.y), float(location.z)) target = "../%s/0/%s" % (pop0.id, params.generic_neuron_cell.id) if populations_without_location: target = "../%s[0]" % (cell) if cells_to_stimulate is None or cell in cells_to_stimulate: input_list = InputList(id="Input_%s_%s" % (cell, params.offset_current.id), component=params.offset_current.id, populations='%s' % cell) input_list.input.append( Input(id=0, target=target, destination="synapses")) net.input_lists.append(input_list) if cells_to_plot is None or cell in cells_to_plot: plot = {} plot["cell"] = cell plot["colour"] = get_random_colour_hex() plot["quantity"] = "%s/0/%s/v" % ( cell, params.generic_neuron_cell.id) if populations_without_location: plot["quantity"] = "%s[0]/v" % (cell) lems_info["plots"].append(plot) if params.generic_neuron_cell.__class__.__name__ == 'IafActivityCell': plot = {} plot["cell"] = cell plot["colour"] = get_random_colour_hex() plot["quantity"] = "%s/0/%s/activity" % ( cell, params.generic_neuron_cell.id) if populations_without_location: plot["quantity"] = "%s[0]/activity" % (cell) lems_info["activity_plots"].append(plot) if params.generic_neuron_cell.__class__.__name__ == 'Cell': plot = {} plot["cell"] = cell plot["colour"] = get_random_colour_hex() plot["quantity"] = "%s/0/%s/caConc" % ( cell, params.generic_neuron_cell.id) if populations_without_location: plot["quantity"] = "%s[0]/caConc" % (cell) lems_info["activity_plots"].append(plot) save = {} save["cell"] = cell save["quantity"] = "%s/0/%s/v" % (cell, params.generic_neuron_cell.id) if populations_without_location: save["quantity"] = "%s[0]/v" % (cell) lems_info["to_save"].append(save) if params.generic_neuron_cell.__class__.__name__ == 'IafActivityCell': save = {} save["cell"] = cell save["quantity"] = "%s/0/%s/activity" % ( cell, params.generic_neuron_cell.id) if populations_without_location: save["quantity"] = "%s[0]/activity" % (cell) lems_info["activity_to_save"].append(save) if params.generic_neuron_cell.__class__.__name__ == 'Cell': save = {} save["cell"] = cell save["quantity"] = "%s/0/%s/caConc" % ( cell, params.generic_neuron_cell.id) if populations_without_location: save["quantity"] = "%s[0]/caConc" % (cell) lems_info["activity_to_save"].append(save) lems_info["cells"].append(cell) count += 1 if verbose: print_("Finished loading %i cells" % count) mneurons, all_muscles, muscle_conns = get_cell_muscle_names_and_connection( ) muscles = get_muscle_names() if include_muscles: muscle_count = 0 for muscle in muscles: inst = Instance(id="0") if not populations_without_location: # build a Population data structure out of the cell name pop0 = Population(id=muscle, component=params.generic_muscle_cell.id, type="populationList") pop0.instances.append(inst) else: # build a Population data structure out of the cell name pop0 = Population(id=muscle, component=params.generic_muscle_cell.id, size="1") # put that Population into the Network data structure from above net.populations.append(pop0) if cells_vs_name.has_key(muscle): # No muscles adopted yet, but just in case they are in future... p = Property(tag="OpenWormBackerAssignedName", value=cells_vs_name[muscle]) pop0.properties.append(p) x = 80 * (-1 if muscle[1] == 'V' else 1) z = 80 * (-1 if muscle[2] == 'L' else 1) y = -300 + 30 * int(muscle[3:5]) print_('Positioning muscle: %s at (%s,%s,%s)' % (muscle, x, y, z)) inst.location = Location(x, y, z) target = "%s/0/%s" % (pop0.id, params.generic_muscle_cell.id) if populations_without_location: target = "%s[0]" % (muscle) plot = {} plot["cell"] = muscle plot["colour"] = get_random_colour_hex() plot["quantity"] = "%s/0/%s/v" % (muscle, params.generic_muscle_cell.id) if populations_without_location: plot["quantity"] = "%s[0]/v" % (muscle) lems_info["muscle_plots"].append(plot) if params.generic_muscle_cell.__class__.__name__ == 'IafActivityCell': plot = {} plot["cell"] = muscle plot["colour"] = get_random_colour_hex() plot["quantity"] = "%s/0/%s/activity" % ( muscle, params.generic_muscle_cell.id) if populations_without_location: plot["quantity"] = "%s[0]/activity" % (muscle) lems_info["muscle_activity_plots"].append(plot) if params.generic_muscle_cell.__class__.__name__ == 'Cell': plot = {} plot["cell"] = muscle plot["colour"] = get_random_colour_hex() plot["quantity"] = "%s/0/%s/caConc" % ( muscle, params.generic_muscle_cell.id) if populations_without_location: plot["quantity"] = "%s[0]/caConc" % (muscle) lems_info["muscle_activity_plots"].append(plot) save = {} save["cell"] = muscle save["quantity"] = "%s/0/%s/v" % (muscle, params.generic_muscle_cell.id) if populations_without_location: save["quantity"] = "%s[0]/v" % (muscle) lems_info["muscles_to_save"].append(save) if params.generic_muscle_cell.__class__.__name__ == 'IafActivityCell': save = {} save["cell"] = muscle save["quantity"] = "%s/0/%s/activity" % ( muscle, params.generic_muscle_cell.id) if populations_without_location: save["quantity"] = "%s[0]/activity" % (muscle) lems_info["muscles_activity_to_save"].append(save) if params.generic_muscle_cell.__class__.__name__ == 'Cell': save = {} save["cell"] = muscle save["quantity"] = "%s/0/%s/caConc" % ( muscle, params.generic_muscle_cell.id) if populations_without_location: save["quantity"] = "%s[0]/caConc" % (muscle) lems_info["muscles_activity_to_save"].append(save) lems_info["muscles"].append(muscle) muscle_count += 1 if verbose: print_("Finished creating %i muscles" % muscle_count) existing_synapses = {} for conn in conns: if conn.pre_cell in lems_info["cells"] and conn.post_cell in lems_info[ "cells"]: # take information about each connection and package it into a # NeuroML Projection data structure proj_id = get_projection_id(conn.pre_cell, conn.post_cell, conn.synclass, conn.syntype) elect_conn = False analog_conn = False syn0 = params.neuron_to_neuron_exc_syn if 'GABA' in conn.synclass: syn0 = params.neuron_to_neuron_inh_syn if '_GJ' in conn.synclass: syn0 = params.neuron_to_neuron_elec_syn elect_conn = isinstance(params.neuron_to_neuron_elec_syn, GapJunction) if isinstance(syn0, GradedSynapse): analog_conn = True if len(nml_doc.silent_synapses) == 0: silent = SilentSynapse(id="silent") nml_doc.silent_synapses.append(silent) number_syns = conn.number conn_shorthand = "%s-%s" % (conn.pre_cell, conn.post_cell) if conn_number_override is not None and ( conn_number_override.has_key(conn_shorthand)): number_syns = conn_number_override[conn_shorthand] elif conn_number_scaling is not None and ( conn_number_scaling.has_key(conn_shorthand)): number_syns = conn.number * conn_number_scaling[conn_shorthand] ''' else: print conn_shorthand print conn_number_override print conn_number_scaling''' if number_syns != conn.number: magnitude, unit = bioparameters.split_neuroml_quantity( syn0.gbase) cond0 = "%s%s" % (magnitude * conn.number, unit) cond1 = "%s%s" % (magnitude * number_syns, unit) if verbose: print_(">> Changing number of effective synapses connection %s -> %s: was: %s (total cond: %s), becomes %s (total cond: %s)" % \ (conn.pre_cell, conn.post_cell, conn.number, cond0, number_syns, cond1)) syn_new = create_n_connection_synapse(syn0, number_syns, nml_doc, existing_synapses) if elect_conn: if populations_without_location: proj0 = ElectricalProjection(id=proj_id, \ presynaptic_population=conn.pre_cell, postsynaptic_population=conn.post_cell) net.electrical_projections.append(proj0) # Add a Connection with the closest locations conn0 = ElectricalConnection(id="0", \ pre_cell="0", post_cell="0", synapse=syn_new.id) proj0.electrical_connections.append(conn0) else: proj0 = ElectricalProjection(id=proj_id, \ presynaptic_population=conn.pre_cell, postsynaptic_population=conn.post_cell) net.electrical_projections.append(proj0) pre_cell_id = "../%s/0/%s" % ( conn.pre_cell, params.generic_neuron_cell.id) post_cell_id = "../%s/0/%s" % ( conn.post_cell, params.generic_neuron_cell.id) #print_("Conn %s -> %s"%(pre_cell_id,post_cell_id)) # Add a Connection with the closest locations conn0 = ElectricalConnectionInstance(id="0", \ pre_cell=pre_cell_id, post_cell=post_cell_id, synapse=syn_new.id) proj0.electrical_connection_instances.append(conn0) elif analog_conn: proj0 = ContinuousProjection(id=proj_id, \ presynaptic_population=conn.pre_cell, postsynaptic_population=conn.post_cell) net.continuous_projections.append(proj0) pre_cell_id = "../%s/0/%s" % (conn.pre_cell, params.generic_neuron_cell.id) post_cell_id = "../%s/0/%s" % (conn.post_cell, params.generic_neuron_cell.id) conn0 = ContinuousConnectionInstance(id="0", \ pre_cell=pre_cell_id, post_cell=post_cell_id, pre_component="silent", post_component=syn_new.id) proj0.continuous_connection_instances.append(conn0) else: if not populations_without_location: proj0 = Projection(id=proj_id, \ presynaptic_population=conn.pre_cell, postsynaptic_population=conn.post_cell, synapse=syn_new.id) net.projections.append(proj0) pre_cell_id = "../%s/0/%s" % ( conn.pre_cell, params.generic_neuron_cell.id) post_cell_id = "../%s/0/%s" % ( conn.post_cell, params.generic_neuron_cell.id) conn0 = ConnectionWD(id="0", \ pre_cell_id=pre_cell_id, post_cell_id=post_cell_id, weight = number_syns, delay = '0ms') proj0.connection_wds.append(conn0) if populations_without_location: raise NotImplementedError ''' # <synapticConnection from="hh1pop[0]" to="hh2pop[0]" synapse="syn1exp" destination="synapses"/> pre_cell_id="%s[0]"%(conn.pre_cell) post_cell_id="%s[0]"%(conn.post_cell) conn0 = SynapticConnection(from_=pre_cell_id, to=post_cell_id, synapse=syn_new.id, destination="synapses") net.synaptic_connections.append(conn0)''' if include_muscles: for conn in muscle_conns: if conn.pre_cell in lems_info[ "cells"] and conn.post_cell in muscles: # take information about each connection and package it into a # NeuroML Projection data structure proj_id = get_projection_id(conn.pre_cell, conn.post_cell, conn.synclass, conn.syntype) elect_conn = False analog_conn = False syn0 = params.neuron_to_muscle_exc_syn if 'GABA' in conn.synclass: syn0 = params.neuron_to_muscle_inh_syn if '_GJ' in conn.synclass: syn0 = params.neuron_to_muscle_elec_syn elect_conn = isinstance(params.neuron_to_muscle_elec_syn, GapJunction) if isinstance(syn0, GradedSynapse): analog_conn = True if len(nml_doc.silent_synapses) == 0: silent = SilentSynapse(id="silent") nml_doc.silent_synapses.append(silent) number_syns = conn.number conn_shorthand = "%s-%s" % (conn.pre_cell, conn.post_cell) if conn_number_override is not None and ( conn_number_override.has_key(conn_shorthand)): number_syns = conn_number_override[conn_shorthand] elif conn_number_scaling is not None and ( conn_number_scaling.has_key(conn_shorthand)): number_syns = conn.number * conn_number_scaling[ conn_shorthand] ''' else: print conn_shorthand print conn_number_override print conn_number_scaling''' if number_syns != conn.number: magnitude, unit = bioparameters.split_neuroml_quantity( syn0.gbase) cond0 = "%s%s" % (magnitude * conn.number, unit) cond1 = "%s%s" % (magnitude * number_syns, unit) if verbose: print_(">> Changing number of effective synapses connection %s -> %s: was: %s (total cond: %s), becomes %s (total cond: %s)" % \ (conn.pre_cell, conn.post_cell, conn.number, cond0, number_syns, cond1)) syn_new = create_n_connection_synapse(syn0, number_syns, nml_doc, existing_synapses) if elect_conn: if populations_without_location: proj0 = ElectricalProjection(id=proj_id, \ presynaptic_population=conn.pre_cell, postsynaptic_population=conn.post_cell) net.electrical_projections.append(proj0) # Add a Connection with the closest locations conn0 = ElectricalConnection(id="0", \ pre_cell="0", post_cell="0", synapse=syn_new.id) proj0.electrical_connections.append(conn0) else: proj0 = ElectricalProjection(id=proj_id, \ presynaptic_population=conn.pre_cell, postsynaptic_population=conn.post_cell) net.electrical_projections.append(proj0) pre_cell_id = "../%s/0/%s" % ( conn.pre_cell, params.generic_neuron_cell.id) post_cell_id = "../%s/0/%s" % ( conn.post_cell, params.generic_muscle_cell.id) #print_("Conn %s -> %s"%(pre_cell_id,post_cell_id)) # Add a Connection with the closest locations conn0 = ElectricalConnectionInstance(id="0", \ pre_cell=pre_cell_id, post_cell=post_cell_id, synapse=syn_new.id) proj0.electrical_connection_instances.append(conn0) elif analog_conn: proj0 = ContinuousProjection(id=proj_id, \ presynaptic_population=conn.pre_cell, postsynaptic_population=conn.post_cell) net.continuous_projections.append(proj0) pre_cell_id = "../%s/0/%s" % ( conn.pre_cell, params.generic_neuron_cell.id) post_cell_id = "../%s/0/%s" % ( conn.post_cell, params.generic_muscle_cell.id) conn0 = ContinuousConnectionInstance(id="0", \ pre_cell=pre_cell_id, post_cell=post_cell_id, pre_component="silent", post_component=syn_new.id) proj0.continuous_connection_instances.append(conn0) else: if not populations_without_location: proj0 = Projection(id=proj_id, \ presynaptic_population=conn.pre_cell, postsynaptic_population=conn.post_cell, synapse=syn_new.id) net.projections.append(proj0) # Add a Connection with the closest locations pre_cell_id = "../%s/0/%s" % ( conn.pre_cell, params.generic_neuron_cell.id) post_cell_id = "../%s/0/%s" % ( conn.post_cell, params.generic_muscle_cell.id) conn0 = Connection(id="0", \ pre_cell_id=pre_cell_id, post_cell_id=post_cell_id) proj0.connections.append(conn0) if populations_without_location: # <synapticConnection from="hh1pop[0]" to="hh2pop[0]" synapse="syn1exp" destination="synapses"/> pre_cell_id = "%s[0]" % (conn.pre_cell) post_cell_id = "%s[0]" % (conn.post_cell) conn0 = SynapticConnection(from_=pre_cell_id, to=post_cell_id, synapse=syn_new.id, destination="synapses") net.synaptic_connections.append(conn0) # import pprint # pprint.pprint(lems_info) template_path = root_dir + '/../' if test else root_dir + '/' # if running test write_to_file(nml_doc, lems_info, net_id, template_path, validate=validate, verbose=verbose, target_directory=target_directory) return nml_doc
def generate(net_id, params, cells = None, cells_to_plot = None, cells_to_stimulate = None, include_muscles=False, conn_number_override = None, conn_number_scaling = None, duration = 500, dt = 0.01, vmin = -75, vmax = 20, seed = 1234, validate=True, test=False): random.seed(seed) info = "\n\nParameters and setting used to generate this network:\n\n"+\ " Cells: %s\n" % (cells if cells is not None else "All cells")+\ " Cell stimulated: %s\n" % (cells_to_stimulate if cells_to_stimulate is not None else "All cells")+\ " Connection numbers overridden: %s\n" % (conn_number_override if conn_number_override is not None else "None")+\ " Connection numbers scaled: %s\n" % (conn_number_scaling if conn_number_scaling is not None else "None")+\ " Include muscles: %s\n" % include_muscles info += "\n%s\n"%(bioparameter_info(" ")) nml_doc = NeuroMLDocument(id=net_id, notes=info) nml_doc.iaf_cells.append(params.generic_cell) net = Network(id=net_id) nml_doc.networks.append(net) nml_doc.pulse_generators.append(params.offset_current) # Use the spreadsheet reader to give a list of all cells and a list of all connections # This could be replaced with a call to "DatabaseReader" or "OpenWormNeuroLexReader" in future... # If called from unittest folder ammend path to "../../../../" spreadsheet_location = "../../../../" if test else "../../../" cell_names, conns = SpreadsheetDataReader.readDataFromSpreadsheet(spreadsheet_location, include_nonconnected_cells=True) cell_names.sort() # To hold all Cell NeuroML objects vs. names all_cells = {} # lems_file = "" lems_info = {"comment": info, "reference": net_id, "duration": duration, "dt": dt, "vmin": vmin, "vmax": vmax, "cell_component": params.generic_cell.id} lems_info["plots"] = [] lems_info["activity_plots"] = [] lems_info["muscle_plots"] = [] lems_info["muscle_activity_plots"] = [] lems_info["to_save"] = [] lems_info["activity_to_save"] = [] lems_info["muscles_to_save"] = [] lems_info["muscles_activity_to_save"] = [] lems_info["cells"] = [] lems_info["muscles"] = [] lems_info["includes"] = [] if hasattr(params.generic_cell, 'custom_component_type_definition'): lems_info["includes"].append(params.generic_cell.custom_component_type_definition) backers_dir = "../../../../OpenWormBackers/" if test else "../../../OpenWormBackers/" sys.path.append(backers_dir) import backers cells_vs_name = backers.get_adopted_cell_names(backers_dir) populations_without_location = isinstance(params.elec_syn, GapJunction) count = 0 for cell in cell_names: if cells is None or cell in cells: inst = Instance(id="0") if not populations_without_location: # build a Population data structure out of the cell name pop0 = Population(id=cell, component=params.generic_cell.id, type="populationList") pop0.instances.append(inst) else: # build a Population data structure out of the cell name pop0 = Population(id=cell, component=params.generic_cell.id, size="1") # put that Population into the Network data structure from above net.populations.append(pop0) if cells_vs_name.has_key(cell): p = Property(tag="OpenWormBackerAssignedName", value=cells_vs_name[cell]) pop0.properties.append(p) # also use the cell name to grab the morphology file, as a NeuroML data structure # into the 'all_cells' dict cell_file_path = "../../../" if test else "../../" #if running test cell_file = cell_file_path+'generatedNeuroML2/%s.nml'%cell doc = loaders.NeuroMLLoader.load(cell_file) all_cells[cell] = doc.cells[0] location = doc.cells[0].morphology.segments[0].proximal print("Loaded morphology file from: %s, with id: %s, location: (%s, %s, %s)"%(cell_file, all_cells[cell].id, location.x, location.y, location.z)) inst.location = Location(float(location.x), float(location.y), float(location.z)) target = "%s/0/%s"%(pop0.id, params.generic_cell.id) if populations_without_location: target = "%s[0]" % (cell) exp_input = ExplicitInput(target=target, input=params.offset_current.id) if cells_to_stimulate is None or cell in cells_to_stimulate: net.explicit_inputs.append(exp_input) if cells_to_plot is None or cell in cells_to_plot: plot = {} plot["cell"] = cell plot["colour"] = get_random_colour_hex() plot["quantity"] = "%s/0/%s/v" % (cell, params.generic_cell.id) if populations_without_location: plot["quantity"] = "%s[0]/v" % (cell) lems_info["plots"].append(plot) if hasattr(params.generic_cell, 'custom_component_type_definition'): plot = {} plot["cell"] = cell plot["colour"] = get_random_colour_hex() plot["quantity"] = "%s/0/%s/activity" % (cell, params.generic_cell.id) if populations_without_location: plot["quantity"] = "%s[0]/activity" % (cell) lems_info["activity_plots"].append(plot) save = {} save["cell"] = cell save["quantity"] = "%s/0/%s/v" % (cell, params.generic_cell.id) if populations_without_location: save["quantity"] = "%s[0]/v" % (cell) lems_info["to_save"].append(save) if hasattr(params.generic_cell, 'custom_component_type_definition'): save = {} save["cell"] = cell save["quantity"] = "%s/0/%s/activity" % (cell, params.generic_cell.id) if populations_without_location: save["quantity"] = "%s[0]/activity" % (cell) lems_info["activity_to_save"].append(save) lems_info["cells"].append(cell) count+=1 print("Finished loading %i cells"%count) mneurons, all_muscles, muscle_conns = SpreadsheetDataReader.readMuscleDataFromSpreadsheet(spreadsheet_location) muscles = get_muscle_names() if include_muscles: muscle_count = 0 for muscle in muscles: inst = Instance(id="0") if not populations_without_location: # build a Population data structure out of the cell name pop0 = Population(id=muscle, component=params.generic_cell.id, type="populationList") pop0.instances.append(inst) else: # build a Population data structure out of the cell name pop0 = Population(id=muscle, component=params.generic_cell.id, size="1") # put that Population into the Network data structure from above net.populations.append(pop0) if cells_vs_name.has_key(muscle): # No muscles adopted yet, but just in case they are in future... p = Property(tag="OpenWormBackerAssignedName", value=cells_vs_name[muscle]) pop0.properties.append(p) inst.location = Location(100, 10*muscle_count, 100) target = "%s/0/%s"%(pop0.id, params.generic_cell.id) if populations_without_location: target = "%s[0]" % (muscle) plot = {} plot["cell"] = muscle plot["colour"] = get_random_colour_hex() plot["quantity"] = "%s/0/%s/v" % (muscle, params.generic_cell.id) if populations_without_location: plot["quantity"] = "%s[0]/v" % (muscle) lems_info["muscle_plots"].append(plot) if hasattr(params.generic_cell, 'custom_component_type_definition'): plot = {} plot["cell"] = muscle plot["colour"] = get_random_colour_hex() plot["quantity"] = "%s/0/%s/activity" % (muscle, params.generic_cell.id) if populations_without_location: plot["quantity"] = "%s[0]/activity" % (muscle) lems_info["muscle_activity_plots"].append(plot) save = {} save["cell"] = muscle save["quantity"] = "%s/0/%s/v" % (muscle, params.generic_cell.id) if populations_without_location: save["quantity"] = "%s[0]/v" % (muscle) lems_info["muscles_to_save"].append(save) if hasattr(params.generic_cell, 'custom_component_type_definition'): save = {} save["cell"] = muscle save["quantity"] = "%s/0/%s/activity" % (muscle, params.generic_cell.id) if populations_without_location: save["quantity"] = "%s[0]/activity" % (muscle) lems_info["muscles_activity_to_save"].append(save) lems_info["muscles"].append(muscle) muscle_count+=1 print("Finished creating %i muscles"%muscle_count) for conn in conns: if conn.pre_cell in lems_info["cells"] and conn.post_cell in lems_info["cells"]: # take information about each connection and package it into a # NeuroML Projection data structure proj_id = get_projection_id(conn.pre_cell, conn.post_cell, conn.synclass, conn.syntype) elect_conn = False syn0 = params.exc_syn if 'GABA' in conn.synclass: syn0 = params.inh_syn if '_GJ' in conn.synclass: syn0 = params.elec_syn elect_conn = isinstance(params.elec_syn, GapJunction) number_syns = conn.number conn_shorthand = "%s-%s"%(conn.pre_cell, conn.post_cell) if conn_number_override is not None and (conn_number_override.has_key(conn_shorthand)): number_syns = conn_number_override[conn_shorthand] elif conn_number_scaling is not None and (conn_number_scaling.has_key(conn_shorthand)): number_syns = conn.number*conn_number_scaling[conn_shorthand] ''' else: print conn_shorthand print conn_number_override print conn_number_scaling''' if number_syns != conn.number: magnitude, unit = split_neuroml_quantity(syn0.gbase) cond0 = "%s%s"%(magnitude*conn.number, unit) cond1 = "%s%s"%(magnitude*number_syns, unit) print(">> Changing number of effective synapses connection %s -> %s: was: %s (total cond: %s), becomes %s (total cond: %s)" % \ (conn.pre_cell, conn.post_cell, conn.number, cond0, number_syns, cond1)) syn_new = create_n_connection_synapse(syn0, number_syns, nml_doc) if not elect_conn: if not populations_without_location: proj0 = Projection(id=proj_id, \ presynaptic_population=conn.pre_cell, postsynaptic_population=conn.post_cell, synapse=syn_new.id) net.projections.append(proj0) # Add a Connection with the closest locations pre_cell_id="../%s/0/%s"%(conn.pre_cell, params.generic_cell.id) post_cell_id="../%s/0/%s"%(conn.post_cell, params.generic_cell.id) conn0 = Connection(id="0", \ pre_cell_id=pre_cell_id, post_cell_id=post_cell_id) proj0.connections.append(conn0) if populations_without_location: # <synapticConnection from="hh1pop[0]" to="hh2pop[0]" synapse="syn1exp" destination="synapses"/> pre_cell_id="%s[0]"%(conn.pre_cell) post_cell_id="%s[0]"%(conn.post_cell) conn0 = SynapticConnection(from_=pre_cell_id, to=post_cell_id, synapse=syn_new.id, destination="synapses") net.synaptic_connections.append(conn0) else: proj0 = ElectricalProjection(id=proj_id, \ presynaptic_population=conn.pre_cell, postsynaptic_population=conn.post_cell) net.electrical_projections.append(proj0) # Add a Connection with the closest locations conn0 = ElectricalConnection(id="0", \ pre_cell="0", post_cell="0", synapse=syn_new.id) proj0.electrical_connections.append(conn0) if include_muscles: for conn in muscle_conns: if conn.pre_cell in lems_info["cells"] and conn.post_cell in muscles: # take information about each connection and package it into a # NeuroML Projection data structure proj_id = get_projection_id(conn.pre_cell, conn.post_cell, conn.synclass, conn.syntype) elect_conn = False syn0 = params.exc_syn if 'GABA' in conn.synclass: syn0 = params.inh_syn if '_GJ' in conn.synclass: syn0 = params.elec_syn elect_conn = isinstance(params.elec_syn, GapJunction) number_syns = conn.number conn_shorthand = "%s-%s"%(conn.pre_cell, conn.post_cell) if conn_number_override is not None and (conn_number_override.has_key(conn_shorthand)): number_syns = conn_number_override[conn_shorthand] elif conn_number_scaling is not None and (conn_number_scaling.has_key(conn_shorthand)): number_syns = conn.number*conn_number_scaling[conn_shorthand] ''' else: print conn_shorthand print conn_number_override print conn_number_scaling''' if number_syns != conn.number: magnitude, unit = split_neuroml_quantity(syn0.gbase) cond0 = "%s%s"%(magnitude*conn.number, unit) cond1 = "%s%s"%(magnitude*number_syns, unit) print(">> Changing number of effective synapses connection %s -> %s: was: %s (total cond: %s), becomes %s (total cond: %s)" % \ (conn.pre_cell, conn.post_cell, conn.number, cond0, number_syns, cond1)) syn_new = create_n_connection_synapse(syn0, number_syns, nml_doc) if not elect_conn: if not populations_without_location: proj0 = Projection(id=proj_id, \ presynaptic_population=conn.pre_cell, postsynaptic_population=conn.post_cell, synapse=syn_new.id) net.projections.append(proj0) # Add a Connection with the closest locations pre_cell_id="../%s/0/%s"%(conn.pre_cell, params.generic_cell.id) post_cell_id="../%s/0/%s"%(conn.post_cell, params.generic_cell.id) conn0 = Connection(id="0", \ pre_cell_id=pre_cell_id, post_cell_id=post_cell_id) proj0.connections.append(conn0) if populations_without_location: # <synapticConnection from="hh1pop[0]" to="hh2pop[0]" synapse="syn1exp" destination="synapses"/> pre_cell_id="%s[0]"%(conn.pre_cell) post_cell_id="%s[0]"%(conn.post_cell) conn0 = SynapticConnection(from_=pre_cell_id, to=post_cell_id, synapse=syn_new.id, destination="synapses") net.synaptic_connections.append(conn0) else: proj0 = ElectricalProjection(id=proj_id, \ presynaptic_population=conn.pre_cell, postsynaptic_population=conn.post_cell) net.electrical_projections.append(proj0) # Add a Connection with the closest locations conn0 = ElectricalConnection(id="0", \ pre_cell="0", post_cell="0", synapse=syn_new.id) proj0.electrical_connections.append(conn0) # import pprint # pprint.pprint(lems_info) template_path = '../' if test else '' # if running test write_to_file(nml_doc, lems_info, net_id, template_path, validate=validate) return nml_doc
# also use the cell name to grab the morphology file, as a NeuroML data structure # into the 'all_cells' dict cell_file = '../generatedNeuroML2/%s.cell.nml'%cell doc = loaders.NeuroMLLoader.load(cell_file) all_cells[cell] = doc.cells[0] print("Loaded morphology file from: %s, with id: %s"%(cell_file, all_cells[cell].id)) dists = [] start_time = time.time() for conn in conns: # take information about each connection and package it into a # NeuroML Projection data structure proj_id = get_projection_id(conn.pre_cell, conn.post_cell, conn.syntype) proj0 = Projection(id=proj_id, \ presynaptic_population=conn.pre_cell, postsynaptic_population=conn.post_cell, synapse=conn.synclass) # Get the corresponding Cell for each pre_cell = all_cells[conn.pre_cell] post_cell = all_cells[conn.post_cell] # Get lists of the valid segment ids pre_segs = getSegmentIds(pre_cell) post_segs = getSegmentIds(post_cell) debug = False #if "VC5" in conn.pre_cell: debug = True debug = True if debug: print "Projection between %s and %s has %i conns"%(conn.pre_cell,conn.post_cell,conn.number)
for i in range(cell_num): inst = Instance(id=i) pop.instances.append(inst) inst.location = Location(x=str(x_size * random.random()), y=str(y_size * random.random()), z=str(z_size * random.random())) prob_connection = 0.5 proj_count = 0 from_pop = pop.id to_pop = pop.id projection = Projection(id="Proj", presynaptic_population=from_pop, postsynaptic_population=to_pop, synapse=syn0.id) electricalProjection = ElectricalProjection(id="ElectProj", presynaptic_population=from_pop, postsynaptic_population=to_pop) electricalProjectionW = ElectricalProjection(id="ElectProjW", presynaptic_population=from_pop, postsynaptic_population=to_pop) net.projections.append(projection) net.electrical_projections.append(electricalProjection) net.electrical_projections.append(electricalProjectionW) input_list = InputList(id='il', component=pfs.id, populations=from_pop) net.input_lists.append(input_list)
def run(): cell_num = 10 x_size = 500 y_size = 500 z_size = 500 nml_doc = NeuroMLDocument(id="Net3DExample") syn0 = ExpOneSynapse(id="syn0", gbase="65nS", erev="0mV", tau_decay="3ms") nml_doc.exp_one_synapses.append(syn0) net = Network(id="Net3D") nml_doc.networks.append(net) proj_count = 0 #conn_count = 0 for cell_id in range(0, cell_num): cell = Cell(id="Cell_%i" % cell_id) cell.morphology = generateRandomMorphology() nml_doc.cells.append(cell) pop = Population(id="Pop_%i" % cell_id, component=cell.id, type="populationList") net.populations.append(pop) pop.properties.append(Property(tag="color", value="1 0 0")) inst = Instance(id="0") pop.instances.append(inst) inst.location = Location(x=str(x_size * random()), y=str(y_size * random()), z=str(z_size * random())) prob_connection = 0.5 for post in range(0, cell_num): if post is not cell_id and random() <= prob_connection: from_pop = "Pop_%i" % cell_id to_pop = "Pop_%i" % post pre_seg_id = 0 post_seg_id = 1 projection = Projection(id="Proj_%i" % proj_count, presynaptic_population=from_pop, postsynaptic_population=to_pop, synapse=syn0.id) net.projections.append(projection) connection = Connection(id=proj_count, \ pre_cell_id="%s[%i]"%(from_pop,0), \ pre_segment_id=pre_seg_id, \ pre_fraction_along=random(), post_cell_id="%s[%i]"%(to_pop,0), \ post_segment_id=post_seg_id, post_fraction_along=random()) projection.connections.append(connection) proj_count += 1 #net.synaptic_connections.append(SynapticConnection(from_="%s[%i]"%(from_pop,0), to="%s[%i]"%(to_pop,0))) ####### Write to file ###### nml_file = 'tmp/net3d.nml' writers.NeuroMLWriter.write(nml_doc, nml_file) print("Written network file to: " + nml_file) ###### Validate the NeuroML ###### from neuroml.utils import validate_neuroml2 validate_neuroml2(nml_file)
for i in range(cell_num): inst = Instance(id=i) pop.instances.append(inst) inst.location = Location(x=str(x_size * random()), y=str(y_size * random()), z=str(z_size * random())) prob_connection = 0.5 proj_count = 0 from_pop = "Pop_x" to_pop = "Pop_x" projection = Projection(id="Proj", presynaptic_population=from_pop, postsynaptic_population=to_pop, synapse=syn0.id) net.projections.append(projection) input_list = InputList(id='il', component=pfs.id, populations=from_pop) net.input_lists.append(input_list) for pre_index in range(0, cell_num): for post_index in range(0, cell_num): if pre_index != post_index and random() <= prob_connection: pre_seg_id = 0 post_seg_id = 0
def createModel(self): # File names of all components pyr_file_name = "../ACnet2_NML2/Cells/pyr_4_sym.cell.nml" bask_file_name = "../ACnet2_NML2/Cells/bask.cell.nml" exc_exc_syn_names = '../ACnet2_NML2/Synapses/AMPA_syn.synapse.nml' exc_inh_syn_names = '../ACnet2_NML2/Synapses/AMPA_syn_inh.synapse.nml' inh_exc_syn_names = '../ACnet2_NML2/Synapses/GABA_syn.synapse.nml' inh_inh_syn_names = '../ACnet2_NML2/Synapses/GABA_syn_inh.synapse.nml' bg_exc_syn_names = '../ACnet2_NML2/Synapses/bg_AMPA_syn.synapse.nml' nml_doc = NeuroMLDocument(id=self.filename + '_doc') net = Network(id=self.filename + '_net') nml_doc.networks.append(net) nml_doc.includes.append(IncludeType(pyr_file_name)) nml_doc.includes.append(IncludeType(bask_file_name)) nml_doc.includes.append(IncludeType(exc_exc_syn_names)) nml_doc.includes.append(IncludeType(exc_inh_syn_names)) nml_doc.includes.append(IncludeType(inh_exc_syn_names)) nml_doc.includes.append(IncludeType(inh_inh_syn_names)) nml_doc.includes.append(IncludeType(bg_exc_syn_names)) # Create a LEMSSimulation to manage creation of LEMS file ls = LEMSSimulation(self.filename, self.sim_time, self.dt) # Point to network as target of simulation ls.assign_simulation_target(net.id) # The names of the cell type/component used in the Exc & Inh populations exc_group_component = "pyr_4_sym" inh_group_component = "bask" # The names of the Exc & Inh groups/populations exc_group = "pyramidals" #"pyramidals48x48" inh_group = "baskets" #"baskets24x24" # The names of the network connections net_conn_exc_exc = "pyr_pyr" net_conn_exc_inh = "pyr_bask" net_conn_inh_exc = "bask_pyr" net_conn_inh_inh = "bask_bask" # The names of the synapse types exc_exc_syn = "AMPA_syn" exc_exc_syn_seg_id = 3 # Middle apical dendrite exc_inh_syn = "AMPA_syn_inh" exc_inh_syn_seg_id = 1 # Dendrite inh_exc_syn = "GABA_syn" inh_exc_syn_seg_id = 6 # Basal dendrite inh_inh_syn = "GABA_syn_inh" inh_inh_syn_seg_id = 0 # Soma aff_exc_syn = "AMPA_aff_syn" aff_exc_syn_seg_id = 5 # proximal apical dendrite bg_exc_syn = "bg_AMPA_syn" bg_exc_syn_seg_id = 7 # Basal dendrite # Excitatory Parameters XSCALE_ex = 24 #48 ZSCALE_ex = 24 #48 xSpacing_ex = 40 # 10^-6m zSpacing_ex = 40 # 10^-6m # Inhibitory Parameters XSCALE_inh = 12 #24 ZSCALE_inh = 12 #24 xSpacing_inh = 80 # 10^-6m zSpacing_inh = 80 # 10^-6m numCells_ex = XSCALE_ex * ZSCALE_ex numCells_inh = XSCALE_inh * ZSCALE_inh # Connection probabilities (initial value) connection_probability_ex_ex = 0.15 connection_probability_ex_inh = 0.45 connection_probability_inh_ex = 0.6 connection_probability_inh_inh = 0.6 # Generate excitatory cells exc_pop = Population(id=exc_group, component=exc_group_component, type="populationList", size=XSCALE_ex * ZSCALE_ex) net.populations.append(exc_pop) exc_pos = np.zeros((XSCALE_ex * ZSCALE_ex, 2)) for i in range(0, XSCALE_ex): for j in range(0, ZSCALE_ex): # create cells x = i * xSpacing_ex z = j * zSpacing_ex index = i * ZSCALE_ex + j inst = Instance(id=index) exc_pop.instances.append(inst) inst.location = Location(x=x, y=0, z=z) exc_pos[index, 0] = x exc_pos[index, 1] = z # Generate inhibitory cells inh_pop = Population(id=inh_group, component=inh_group_component, type="populationList", size=XSCALE_inh * ZSCALE_inh) net.populations.append(inh_pop) inh_pos = np.zeros((XSCALE_inh * ZSCALE_inh, 2)) for i in range(0, XSCALE_inh): for j in range(0, ZSCALE_inh): # create cells x = i * xSpacing_inh z = j * zSpacing_inh index = i * ZSCALE_inh + j inst = Instance(id=index) inh_pop.instances.append(inst) inst.location = Location(x=x, y=0, z=z) inh_pos[index, 0] = x inh_pos[index, 1] = z proj_exc_exc = Projection(id=net_conn_exc_exc, presynaptic_population=exc_group, postsynaptic_population=exc_group, synapse=exc_exc_syn) net.projections.append(proj_exc_exc) proj_exc_inh = Projection(id=net_conn_exc_inh, presynaptic_population=exc_group, postsynaptic_population=inh_group, synapse=exc_inh_syn) net.projections.append(proj_exc_inh) proj_inh_exc = Projection(id=net_conn_inh_exc, presynaptic_population=inh_group, postsynaptic_population=exc_group, synapse=inh_exc_syn) net.projections.append(proj_inh_exc) proj_inh_inh = Projection(id=net_conn_inh_inh, presynaptic_population=inh_group, postsynaptic_population=inh_group, synapse=inh_inh_syn) net.projections.append(proj_inh_inh) # Generate exc -> * connections exc_exc_conn = np.zeros((numCells_ex, numCells_ex)) exc_inh_conn = np.zeros((numCells_ex, numCells_inh)) count_exc_exc = 0 count_exc_inh = 0 for i in range(0, XSCALE_ex): for j in range(0, ZSCALE_ex): x = i * xSpacing_ex y = j * zSpacing_ex index = i * ZSCALE_ex + j #print("Looking at connections for exc cell at (%i, %i)"%(i,j)) # exc -> exc connections conn_type = net_conn_exc_exc for k in range(0, XSCALE_ex): for l in range(0, ZSCALE_ex): # calculate distance from pre- to post-synaptic neuron xk = k * xSpacing_ex yk = l * zSpacing_ex distance = math.sqrt((x - xk)**2 + (y - yk)**2) connection_probability = connection_probability_ex_ex * math.exp( -(distance / (10.0 * xSpacing_ex))**2) # create a random number between 0 and 1, if it is <= connection_probability # accept connection otherwise refuse a = random.random() if 0 < a <= connection_probability: index2 = k * ZSCALE_ex + l count_exc_exc += 1 add_connection(proj_exc_exc, count_exc_exc, exc_group, exc_group_component, index, 0, exc_group, exc_group_component, index2, exc_exc_syn_seg_id) exc_exc_conn[index, index2] = 1 # exc -> inh connections conn_type = net_conn_exc_inh for k in range(0, XSCALE_inh): for l in range(0, ZSCALE_inh): # calculate distance from pre- to post-synaptic neuron xk = k * xSpacing_inh yk = l * zSpacing_inh distance = math.sqrt((x - xk)**2 + (y - yk)**2) connection_probability = connection_probability_ex_inh * math.exp( -(distance / (10.0 * xSpacing_ex))**2) # create a random number between 0 and 1, if it is <= connection_probability # accept connection otherwise refuse a = random.random() if 0 < a <= connection_probability: index2 = k * ZSCALE_inh + l count_exc_inh += 1 add_connection(proj_exc_inh, count_exc_inh, exc_group, exc_group_component, index, 0, inh_group, inh_group_component, index2, exc_inh_syn_seg_id) exc_inh_conn[index, index2] = 1 inh_exc_conn = np.zeros((numCells_inh, numCells_ex)) inh_inh_conn = np.zeros((numCells_inh, numCells_inh)) count_inh_exc = 0 count_inh_inh = 0 for i in range(0, XSCALE_inh): for j in range(0, ZSCALE_inh): x = i * xSpacing_inh y = j * zSpacing_inh index = i * ZSCALE_inh + j #print("Looking at connections for inh cell at (%i, %i)"%(i,j)) # inh -> exc connections conn_type = net_conn_inh_exc for k in range(0, XSCALE_ex): for l in range(0, ZSCALE_ex): # calculate distance from pre- to post-synaptic neuron xk = k * xSpacing_ex yk = l * zSpacing_ex distance = math.sqrt((x - xk)**2 + (y - yk)**2) connection_probability = connection_probability_inh_ex * math.exp( -(distance / (10.0 * xSpacing_ex))**2) # create a random number between 0 and 1, if it is <= connection_probability # accept connection otherwise refuse a = random.random() if 0 < a <= connection_probability: index2 = k * ZSCALE_ex + l count_inh_exc += 1 add_connection(proj_inh_exc, count_inh_exc, inh_group, inh_group_component, index, 0, exc_group, exc_group_component, index2, inh_exc_syn_seg_id) inh_exc_conn[index, index2] = 1 # inh -> inh connections conn_type = net_conn_inh_inh for k in range(0, XSCALE_inh): for l in range(0, ZSCALE_inh): # calculate distance from pre- to post-synaptic neuron xk = k * xSpacing_inh yk = l * zSpacing_inh distance = math.sqrt((x - xk)**2 + (y - yk)**2) connection_probability = connection_probability_inh_inh * math.exp( -(distance / (10.0 * xSpacing_ex))**2) # create a random number between 0 and 1, if it is <= connection_probability # accept connection otherwise refuse a = random.random() if 0 < a <= connection_probability: index2 = k * ZSCALE_inh + l count_inh_inh += 1 add_connection(proj_inh_inh, count_inh_inh, inh_group, inh_group_component, index, 0, inh_group, inh_group_component, index2, inh_inh_syn_seg_id) inh_inh_conn[index, index2] = 1 print( "Generated network with %i exc_exc, %i exc_inh, %i inh_exc, %i inh_inh connections" % (count_exc_exc, count_exc_inh, count_inh_exc, count_inh_inh)) ####### Create Input ###### # Create a sine generator sgE = SineGenerator(id="sineGen_0", phase="0", delay="0ms", duration=str(self.sim_time) + "ms", amplitude=str(self.Edrive_weight) + "nA", period=str(self.Drive_period) + "ms") sgI = SineGenerator(id="sineGen_1", phase="0", delay="0ms", duration=str(self.sim_time) + "ms", amplitude=str(self.Idrive_weight) + "nA", period=str(self.Drive_period) + "ms") nml_doc.sine_generators.append(sgE) nml_doc.sine_generators.append(sgI) # Create an input object for each excitatory cell for i in range(0, XSCALE_ex): exp_input = ExplicitInput(target="%s[%i]" % (exc_pop.id, i), input=sgE.id) net.explicit_inputs.append(exp_input) # Create an input object for a percentage of inhibitory cells input_probability = 0.65 for i in range(0, XSCALE_inh): ran = random.random() if 0 < ran <= input_probability: inh_input = ExplicitInput(target="%s[%i]" % (inh_pop.id, i), input=sgI.id) net.explicit_inputs.append(inh_input) # Define Poisson noise input # Ex #nml_doc.includes.append(IncludeType('Synapses/bg_AMPA_syn.synapse.nml')) pfs1 = PoissonFiringSynapse(id="poissonFiringSyn1", average_rate=str(self.bg_noise_frequency) + "Hz", synapse=bg_exc_syn, spike_target="./%s" % bg_exc_syn) nml_doc.poisson_firing_synapses.append(pfs1) pfs_input_list1 = InputList(id="pfsInput1", component=pfs1.id, populations=exc_pop.id) net.input_lists.append(pfs_input_list1) for i in range(0, numCells_ex): pfs_input_list1.input.append( Input(id=i, target='../%s/%i/%s' % (exc_pop.id, i, exc_group_component), segment_id=bg_exc_syn_seg_id, destination="synapses")) ####### Write to file ###### print("Saving to file...") nml_file = '../ACnet2_NML2/' + self.filename + '_doc' + '.net.nml' writers.NeuroMLWriter.write(nml_doc, nml_file) print("Written network file to: " + nml_file) ###### Validate the NeuroML ###### from neuroml.utils import validate_neuroml2 validate_neuroml2(nml_file) print "-----------------------------------" ###### Output ####### # Output membrane potential # Ex population Ex_potentials = 'V_Ex' ls.create_output_file(Ex_potentials, "../ACnet2_NML2/Results/v_exc.dat") for j in range(numCells_ex): quantity = "%s[%i]/v" % (exc_pop.id, j) v = 'v' + str(j) ls.add_column_to_output_file(Ex_potentials, v, quantity) # Inh population #Inh_potentials = 'V_Inh' #ls.create_output_file(Inh_potentials, "../ACnet2_NML2/Results/v_inh.dat") #for j in range(numCells_inh): # quantity = "%s[%i]/v"%(inh_pop.id, j) # v = 'v'+str(j) # ls.add_column_to_output_file(Inh_potentials,v, quantity) # include generated network ls.include_neuroml2_file(nml_file) # Save to LEMS XML file lems_file_name = ls.save_to_file(file_name='../ACnet2_NML2/LEMS_' + self.filename + '.xml')
def generate(net_id, params, data_reader = "SpreadsheetDataReader", cells = None, cells_to_plot = None, cells_to_stimulate = None, muscles_to_include=[], conns_to_include=[], conn_number_override = None, conn_number_scaling = None, conn_polarity_override = None, duration = 500, dt = 0.01, vmin = None, vmax = None, seed = 1234, test=False, verbose=True, param_overrides={}, target_directory='./'): validate = not (params.is_level_B() or params.is_level_C0()) root_dir = os.path.dirname(os.path.abspath(__file__)) for k in param_overrides.keys(): v = param_overrides[k] print_("Setting parameter %s = %s"%(k,v)) params.set_bioparameter(k, v, "Set with param_overrides", 0) params.create_models() if vmin==None: if params.is_level_A(): vmin=-72 elif params.is_level_B(): vmin=-52 elif params.is_level_C(): vmin=-60 elif params.is_level_D(): vmin=-60 else: vmin=-52 if vmax==None: if params.is_level_A(): vmax=-48 elif params.is_level_B(): vmax=-28 elif params.is_level_C(): vmax=25 elif params.is_level_D(): vmax=25 else: vmax=-28 random.seed(seed) info = "\n\nParameters and setting used to generate this network:\n\n"+\ " Data reader: %s\n" % data_reader+\ " Cells: %s\n" % (cells if cells is not None else "All cells")+\ " Cell stimulated: %s\n" % (cells_to_stimulate if cells_to_stimulate is not None else "All neurons")+\ " Connection: %s\n" % (conns_to_include if conns_to_include is not None else "All connections") + \ " Connection numbers overridden: %s\n" % (conn_number_override if conn_number_override is not None else "None")+\ " Connection numbers scaled: %s\n" % (conn_number_scaling if conn_number_scaling is not None else "None")+ \ " Connection polarities override: %s\n" % conn_polarity_override + \ " Muscles: %s\n" % (muscles_to_include if muscles_to_include is not None else "All muscles") if verbose: print_(info) info += "\n%s\n"%(params.bioparameter_info(" ")) nml_doc = NeuroMLDocument(id=net_id, notes=info) if params.is_level_A() or params.is_level_B() or params.level == "BC1": nml_doc.iaf_cells.append(params.generic_muscle_cell) nml_doc.iaf_cells.append(params.generic_neuron_cell) elif params.is_level_C(): nml_doc.cells.append(params.generic_muscle_cell) nml_doc.cells.append(params.generic_neuron_cell) elif params.is_level_D(): nml_doc.cells.append(params.generic_muscle_cell) net = Network(id=net_id) nml_doc.networks.append(net) nml_doc.pulse_generators.append(params.offset_current) if is_cond_based_cell(params): nml_doc.fixed_factor_concentration_models.append(params.concentration_model) cell_names, conns = get_cell_names_and_connection(data_reader) # To hold all Cell NeuroML objects vs. names all_cells = {} # lems_file = "" lems_info = {"comment": info, "reference": net_id, "duration": duration, "dt": dt, "vmin": vmin, "vmax": vmax} lems_info["plots"] = [] lems_info["activity_plots"] = [] lems_info["muscle_plots"] = [] lems_info["muscle_activity_plots"] = [] lems_info["to_save"] = [] lems_info["activity_to_save"] = [] lems_info["muscles_to_save"] = [] lems_info["muscles_activity_to_save"] = [] lems_info["cells"] = [] lems_info["muscles"] = [] lems_info["includes"] = [] if params.custom_component_types_definitions: if isinstance(params.custom_component_types_definitions, str): params.custom_component_types_definitions = [params.custom_component_types_definitions] for ctd in params.custom_component_types_definitions: lems_info["includes"].append(ctd) if target_directory != './': def_file = "%s/%s"%(os.path.dirname(os.path.abspath(__file__)), ctd) shutil.copy(def_file, target_directory) nml_doc.includes.append(IncludeType(href=ctd)) backers_dir = root_dir+"/../../../../OpenWormBackers/" if test else root_dir+"/../../../OpenWormBackers/" sys.path.append(backers_dir) import backers cells_vs_name = backers.get_adopted_cell_names(backers_dir) count = 0 for cell in cell_names: if cells is None or cell in cells: inst = Instance(id="0") if not params.is_level_D(): # build a Population data structure out of the cell name pop0 = Population(id=cell, component=params.generic_neuron_cell.id, type="populationList") cell_id = params.generic_neuron_cell.id else: # build a Population data structure out of the cell name pop0 = Population(id=cell, component=cell, type="populationList") cell_id = cell pop0.instances.append(inst) # put that Population into the Network data structure from above net.populations.append(pop0) if cells_vs_name.has_key(cell): p = Property(tag="OpenWormBackerAssignedName", value=cells_vs_name[cell]) pop0.properties.append(p) # also use the cell name to grab the morphology file, as a NeuroML data structure # into the 'all_cells' dict cell_file_path = root_dir+"/../../../" if test else root_dir+"/../../" #if running test cell_file = cell_file_path+'generatedNeuroML2/%s.cell.nml'%cell doc = loaders.NeuroMLLoader.load(cell_file) all_cells[cell] = doc.cells[0] if params.is_level_D(): new_cell = params.create_neuron_cell(cell, doc.cells[0].morphology) nml_cell_doc = NeuroMLDocument(id=cell) nml_cell_doc.cells.append(new_cell) new_cell_file = 'cells/'+cell+'_D.cell.nml' nml_file = target_directory+'/'+new_cell_file print_("Writing new cell to: %s"%os.path.realpath(nml_file)) writers.NeuroMLWriter.write(nml_cell_doc, nml_file) nml_doc.includes.append(IncludeType(href=new_cell_file)) lems_info["includes"].append(new_cell_file) inst.location = Location(0,0,0) else: location = doc.cells[0].morphology.segments[0].proximal inst.location = Location(float(location.x), float(location.y), float(location.z)) if verbose: print_("Loaded morphology: %s; id: %s; placing at location: (%s, %s, %s)"%(os.path.realpath(cell_file), all_cells[cell].id, inst.location.x, inst.location.y, inst.location.z)) if cells_to_stimulate is None or cell in cells_to_stimulate: target = "../%s/0/%s"%(pop0.id, cell_id) if params.is_level_D(): target+="/0" input_list = InputList(id="Input_%s_%s"%(cell,params.offset_current.id), component=params.offset_current.id, populations='%s'%cell) input_list.input.append(Input(id=0, target=target, destination="synapses")) net.input_lists.append(input_list) if cells_to_plot is None or cell in cells_to_plot: plot = {} plot["cell"] = cell plot["colour"] = get_random_colour_hex() plot["quantity"] = "%s/0/%s/v" % (cell, cell_id) lems_info["plots"].append(plot) if params.is_level_B(): plot = {} plot["cell"] = cell plot["colour"] = get_random_colour_hex() plot["quantity"] = "%s/0/%s/activity" % (cell, cell_id) lems_info["activity_plots"].append(plot) if is_cond_based_cell(params): plot = {} plot["cell"] = cell plot["colour"] = get_random_colour_hex() plot["quantity"] = "%s/0/%s/caConc" % (cell, cell_id) lems_info["activity_plots"].append(plot) save = {} save["cell"] = cell save["quantity"] = "%s/0/%s/v" % (cell, cell_id) lems_info["to_save"].append(save) if params.is_level_B(): save = {} save["cell"] = cell save["quantity"] = "%s/0/%s/activity" % (cell, cell_id) lems_info["activity_to_save"].append(save) if is_cond_based_cell(params): save = {} save["cell"] = cell save["quantity"] = "%s/0/%s/caConc" % (cell, cell_id) lems_info["activity_to_save"].append(save) lems_info["cells"].append(cell) count+=1 if verbose: print_("Finished loading %i cells"%count) mneurons, all_muscles, muscle_conns = get_cell_muscle_names_and_connection(data_reader) #if data_reader == "SpreadsheetDataReader": # all_muscles = get_muscle_names() if muscles_to_include == None or muscles_to_include == True: muscles_to_include = all_muscles elif muscles_to_include == False: muscles_to_include = [] for m in muscles_to_include: assert m in all_muscles if len(muscles_to_include)>0: muscle_count = 0 for muscle in muscles_to_include: inst = Instance(id="0") # build a Population data structure out of the cell name pop0 = Population(id=muscle, component=params.generic_muscle_cell.id, type="populationList") pop0.instances.append(inst) # put that Population into the Network data structure from above net.populations.append(pop0) if cells_vs_name.has_key(muscle): # No muscles adopted yet, but just in case they are in future... p = Property(tag="OpenWormBackerAssignedName", value=cells_vs_name[muscle]) pop0.properties.append(p) x, y, z = get_muscle_position(muscle, data_reader) print_('Positioning muscle: %s at (%s,%s,%s)'%(muscle,x,y,z)) inst.location = Location(x,y,z) #target = "%s/0/%s"%(pop0.id, params.generic_muscle_cell.id) # unused plot = {} plot["cell"] = muscle plot["colour"] = get_random_colour_hex() plot["quantity"] = "%s/0/%s/v" % (muscle, params.generic_muscle_cell.id) lems_info["muscle_plots"].append(plot) if params.generic_muscle_cell.__class__.__name__ == 'IafActivityCell': plot = {} plot["cell"] = muscle plot["colour"] = get_random_colour_hex() plot["quantity"] = "%s/0/%s/activity" % (muscle, params.generic_muscle_cell.id) lems_info["muscle_activity_plots"].append(plot) if params.generic_muscle_cell.__class__.__name__ == 'Cell': plot = {} plot["cell"] = muscle plot["colour"] = get_random_colour_hex() plot["quantity"] = "%s/0/%s/caConc" % (muscle, params.generic_muscle_cell.id) lems_info["muscle_activity_plots"].append(plot) save = {} save["cell"] = muscle save["quantity"] = "%s/0/%s/v" % (muscle, params.generic_muscle_cell.id) lems_info["muscles_to_save"].append(save) if params.generic_muscle_cell.__class__.__name__ == 'IafActivityCell': save = {} save["cell"] = muscle save["quantity"] = "%s/0/%s/activity" % (muscle, params.generic_muscle_cell.id) lems_info["muscles_activity_to_save"].append(save) if params.generic_muscle_cell.__class__.__name__ == 'Cell': save = {} save["cell"] = muscle save["quantity"] = "%s/0/%s/caConc" % (muscle, params.generic_muscle_cell.id) lems_info["muscles_activity_to_save"].append(save) lems_info["muscles"].append(muscle) muscle_count+=1 if muscle in cells_to_stimulate: target = "../%s/0/%s"%(pop0.id, params.generic_muscle_cell.id) if params.is_level_D(): target+="/0" input_list = InputList(id="Input_%s_%s"%(muscle,params.offset_current.id), component=params.offset_current.id, populations='%s'%pop0.id) input_list.input.append(Input(id=0, target=target, destination="synapses")) net.input_lists.append(input_list) if verbose: print_("Finished creating %i muscles"%muscle_count) existing_synapses = {} for conn in conns: if conn.pre_cell in lems_info["cells"] and conn.post_cell in lems_info["cells"]: # take information about each connection and package it into a # NeuroML Projection data structure proj_id = get_projection_id(conn.pre_cell, conn.post_cell, conn.synclass, conn.syntype) conn_shorthand = "%s-%s" % (conn.pre_cell, conn.post_cell) elect_conn = False analog_conn = False syn0 = params.neuron_to_neuron_exc_syn orig_pol = "exc" if 'GABA' in conn.synclass: syn0 = params.neuron_to_neuron_inh_syn orig_pol = "inh" if '_GJ' in conn.synclass: syn0 = params.neuron_to_neuron_elec_syn elect_conn = isinstance(params.neuron_to_neuron_elec_syn, GapJunction) conn_shorthand = "%s-%s_GJ" % (conn.pre_cell, conn.post_cell) if conns_to_include and conn_shorthand not in conns_to_include: continue print conn_shorthand + " " + str(conn.number) + " " + orig_pol + " " + conn.synclass polarity = None if conn_polarity_override and conn_polarity_override.has_key(conn_shorthand): polarity = conn_polarity_override[conn_shorthand] if polarity and not elect_conn: if polarity == 'inh': syn0 = params.neuron_to_neuron_inh_syn else: syn0 = params.neuron_to_neuron_exc_syn if verbose and polarity != orig_pol: print_(">> Changing polarity of connection %s -> %s: was: %s, becomes %s " % \ (conn.pre_cell, conn.post_cell, orig_pol, polarity)) if isinstance(syn0, GradedSynapse) or isinstance(syn0, GradedSynapse2): analog_conn = True if len(nml_doc.silent_synapses)==0: silent = SilentSynapse(id="silent") nml_doc.silent_synapses.append(silent) number_syns = conn.number if conn_number_override is not None and (conn_number_override.has_key(conn_shorthand)): number_syns = conn_number_override[conn_shorthand] elif conn_number_scaling is not None and (conn_number_scaling.has_key(conn_shorthand)): number_syns = conn.number*conn_number_scaling[conn_shorthand] ''' else: print conn_shorthand print conn_number_override print conn_number_scaling''' """if polarity: print "%s %s num:%s" % (conn_shorthand, polarity, number_syns) elif elect_conn: print "%s num:%s" % (conn_shorthand, number_syns) else: print "%s %s num:%s" % (conn_shorthand, orig_pol, number_syns)""" if number_syns != conn.number: if analog_conn or elect_conn: magnitude, unit = bioparameters.split_neuroml_quantity(syn0.conductance) else: magnitude, unit = bioparameters.split_neuroml_quantity(syn0.gbase) cond0 = "%s%s"%(magnitude*conn.number, unit) cond1 = "%s%s" % (get_str_from_expnotation(magnitude * number_syns), unit) gj = "" if not elect_conn else " GapJunction" if verbose: print_(">> Changing number of effective synapses connection %s -> %s%s: was: %s (total cond: %s), becomes %s (total cond: %s)" % \ (conn.pre_cell, conn.post_cell, gj, conn.number, cond0, number_syns, cond1)) #print "######## %s-%s %s %s" % (conn.pre_cell, conn.post_cell, conn.synclass, number_syns) #known_motor_prefixes = ["VA"] #if conn.pre_cell.startswith(tuple(known_motor_prefixes)) or conn.post_cell.startswith(tuple(known_motor_prefixes)): # print "######### %s-%s %s %s" % (conn.pre_cell, conn.post_cell, number_syns, conn.synclass) syn_new = create_n_connection_synapse(syn0, number_syns, nml_doc, existing_synapses) if elect_conn: proj0 = ElectricalProjection(id=proj_id, \ presynaptic_population=conn.pre_cell, postsynaptic_population=conn.post_cell) net.electrical_projections.append(proj0) pre_cell_id=get_cell_id_string(conn.pre_cell, params) post_cell_id= get_cell_id_string(conn.post_cell, params) #print_("Conn %s -> %s"%(pre_cell_id,post_cell_id)) # Add a Connection with the closest locations conn0 = ElectricalConnectionInstance(id="0", \ pre_cell=pre_cell_id, post_cell=post_cell_id, synapse=syn_new.id) proj0.electrical_connection_instances.append(conn0) elif analog_conn: proj0 = ContinuousProjection(id=proj_id, \ presynaptic_population=conn.pre_cell, postsynaptic_population=conn.post_cell) net.continuous_projections.append(proj0) pre_cell_id= get_cell_id_string(conn.pre_cell, params) post_cell_id= get_cell_id_string(conn.post_cell, params) conn0 = ContinuousConnectionInstance(id="0", \ pre_cell=pre_cell_id, post_cell=post_cell_id, pre_component="silent", post_component=syn_new.id) proj0.continuous_connection_instances.append(conn0) else: proj0 = Projection(id=proj_id, \ presynaptic_population=conn.pre_cell, postsynaptic_population=conn.post_cell, synapse=syn_new.id) net.projections.append(proj0) pre_cell_id= get_cell_id_string(conn.pre_cell, params) post_cell_id= get_cell_id_string(conn.post_cell, params) conn0 = ConnectionWD(id="0", \ pre_cell_id=pre_cell_id, post_cell_id=post_cell_id, weight = number_syns, delay = '0ms') proj0.connection_wds.append(conn0) if len(muscles_to_include)>0: for conn in muscle_conns: if not conn.post_cell in muscles_to_include: continue if not conn.pre_cell in lems_info["cells"] and not conn.pre_cell in muscles_to_include: continue # take information about each connection and package it into a # NeuroML Projection data structure proj_id = get_projection_id(conn.pre_cell, conn.post_cell, conn.synclass, conn.syntype) conn_shorthand = "%s-%s" % (conn.pre_cell, conn.post_cell) elect_conn = False analog_conn = False syn0 = params.neuron_to_muscle_exc_syn orig_pol = "exc" if 'GABA' in conn.synclass: syn0 = params.neuron_to_muscle_inh_syn orig_pol = "inh" if '_GJ' in conn.synclass : elect_conn = isinstance(params.neuron_to_muscle_elec_syn, GapJunction) conn_shorthand = "%s-%s_GJ" % (conn.pre_cell, conn.post_cell) if conn.pre_cell in lems_info["cells"]: syn0 = params.neuron_to_muscle_elec_syn elif conn.pre_cell in muscles_to_include: try: syn0 = params.muscle_to_muscle_elec_syn except: syn0 = params.neuron_to_muscle_elec_syn if conns_to_include and conn_shorthand not in conns_to_include: continue print conn_shorthand + " " + str(conn.number) + " " + orig_pol + " " + conn.synclass polarity = None if conn_polarity_override and conn_polarity_override.has_key(conn_shorthand): polarity = conn_polarity_override[conn_shorthand] if polarity and not elect_conn: if polarity == 'inh': syn0 = params.neuron_to_neuron_inh_syn else: syn0 = params.neuron_to_neuron_exc_syn if verbose and polarity != orig_pol: print_(">> Changing polarity of connection %s -> %s: was: %s, becomes %s " % \ (conn.pre_cell, conn.post_cell, orig_pol, polarity)) if isinstance(syn0, GradedSynapse) or isinstance(syn0, GradedSynapse2): analog_conn = True if len(nml_doc.silent_synapses)==0: silent = SilentSynapse(id="silent") nml_doc.silent_synapses.append(silent) number_syns = conn.number if conn_number_override is not None and (conn_number_override.has_key(conn_shorthand)): number_syns = conn_number_override[conn_shorthand] elif conn_number_scaling is not None and (conn_number_scaling.has_key(conn_shorthand)): number_syns = conn.number*conn_number_scaling[conn_shorthand] ''' else: print conn_shorthand print conn_number_override print conn_number_scaling''' """if polarity: print "%s %s num:%s" % (conn_shorthand, polarity, number_syns) elif elect_conn: print "%s num:%s" % (conn_shorthand, number_syns) else: print "%s %s num:%s" % (conn_shorthand, orig_pol, number_syns)""" if number_syns != conn.number: if analog_conn or elect_conn: magnitude, unit = bioparameters.split_neuroml_quantity(syn0.conductance) else: magnitude, unit = bioparameters.split_neuroml_quantity(syn0.gbase) cond0 = "%s%s"%(magnitude*conn.number, unit) cond1 = "%s%s" % (get_str_from_expnotation(magnitude * number_syns), unit) gj = "" if not elect_conn else " GapJunction" if verbose: print_(">> Changing number of effective synapses connection %s -> %s%s: was: %s (total cond: %s), becomes %s (total cond: %s)" % \ (conn.pre_cell, conn.post_cell, gj, conn.number, cond0, number_syns, cond1)) syn_new = create_n_connection_synapse(syn0, number_syns, nml_doc, existing_synapses) if elect_conn: proj0 = ElectricalProjection(id=proj_id, \ presynaptic_population=conn.pre_cell, postsynaptic_population=conn.post_cell) net.electrical_projections.append(proj0) pre_cell_id= get_cell_id_string(conn.pre_cell, params) post_cell_id= get_cell_id_string(conn.post_cell, params, muscle=True) #print_("Conn %s -> %s"%(pre_cell_id,post_cell_id)) # Add a Connection with the closest locations conn0 = ElectricalConnectionInstance(id="0", \ pre_cell=pre_cell_id, post_cell=post_cell_id, synapse=syn_new.id) proj0.electrical_connection_instances.append(conn0) elif analog_conn: proj0 = ContinuousProjection(id=proj_id, \ presynaptic_population=conn.pre_cell, postsynaptic_population=conn.post_cell) net.continuous_projections.append(proj0) pre_cell_id= get_cell_id_string(conn.pre_cell, params) post_cell_id= get_cell_id_string(conn.post_cell, params, muscle=True) conn0 = ContinuousConnectionInstance(id="0", \ pre_cell=pre_cell_id, post_cell=post_cell_id, pre_component="silent", post_component=syn_new.id) proj0.continuous_connection_instances.append(conn0) else: proj0 = Projection(id=proj_id, \ presynaptic_population=conn.pre_cell, postsynaptic_population=conn.post_cell, synapse=syn_new.id) net.projections.append(proj0) # Add a Connection with the closest locations pre_cell_id= get_cell_id_string(conn.pre_cell, params) post_cell_id= get_cell_id_string(conn.post_cell, params, muscle=True) conn0 = Connection(id="0", \ pre_cell_id=pre_cell_id, post_cell_id=post_cell_id) proj0.connections.append(conn0) # import pprint # pprint.pprint(lems_info) template_path = root_dir+'/../' if test else root_dir+'/' # if running test write_to_file(nml_doc, lems_info, net_id, template_path, validate=validate, verbose=verbose, target_directory=target_directory) return nml_doc
net = Network(id="IzNet") nml_doc.networks.append(net) size0 = 5 pop0 = Population(id="IzPop0", component=iz0.id, size=size0) # Set optional color property. Note: used later when generating graphs etc. pop0.properties.append(Property(tag='color', value='0 0 .8')) net.populations.append(pop0) size1 = 5 pop1 = Population(id="IzPop1", component=iz0.id, size=size1) pop1.properties.append(Property(tag='color', value='.8 0 0')) net.populations.append(pop1) proj = Projection(id='proj', presynaptic_population=pop0.id, postsynaptic_population=pop1.id, synapse=syn0.id) net.projections.append(proj) random.seed(123) prob_connection = 0.8 count = 0 for pre in range(0, size0): pg = PulseGenerator(id="pg_%i" % pre, delay="0ms", duration="10000ms", amplitude="%f nA" % (0.1 + 0.1 * random.random())) nml_doc.pulse_generators.append(pg) exp_input = ExplicitInput(target="%s[%i]" % (pop0.id, pre), input=pg.id) net.explicit_inputs.append(exp_input)
for i in range(0, XSCALE_inh) : for j in range(0, ZSCALE_inh): # create cells x = i*xSpacing_inh z = j*zSpacing_inh index = i*ZSCALE_inh + j inst = Instance(id=index) inh_pop.instances.append(inst) inst.location = Location(x=x, y=0, z=z) proj_exc_exc = Projection(id=net_conn_exc_exc, presynaptic_population=exc_group, postsynaptic_population=exc_group, synapse=exc_exc_syn) net.projections.append(proj_exc_exc) proj_exc_inh = Projection(id=net_conn_exc_inh, presynaptic_population=exc_group, postsynaptic_population=inh_group, synapse=exc_inh_syn) net.projections.append(proj_exc_inh) proj_inh_exc = Projection(id=net_conn_inh_exc, presynaptic_population=inh_group, postsynaptic_population=exc_group, synapse=inh_exc_syn) net.projections.append(proj_inh_exc) proj_inh_inh = Projection(id=net_conn_inh_inh, presynaptic_population=inh_group, postsynaptic_population=inh_group, synapse=inh_inh_syn) net.projections.append(proj_inh_inh) # Generate exc -> * connections exc_exc_conn_number = [[0 for x in xrange(ZSCALE_ex)] for x in xrange(XSCALE_ex)] exc_inh_conn_number = [[0 for x in xrange(ZSCALE_ex)] for x in xrange(XSCALE_ex)] count_exc_exc = 0 count_exc_inh = 0