def __getitem__(self, index): id_index = self._get_index_or_add('id', -1) if id_index > 0: id = int(self.array[index][id_index]) assert (self.array[index][0] == index) else: id = index pre_cell_id = int(self.array[index][self._get_index_or_add( 'pre_cell_id', 1)]) post_cell_id = int(self.array[index][self._get_index_or_add( 'post_cell_id', 2)]) pre_segment_id = int(self._get_value(index, 'pre_segment_id', 0)) post_segment_id = int(self._get_value(index, 'post_segment_id', 0)) pre_fraction_along = float( self._get_value(index, 'pre_fraction_along', 0.5)) post_fraction_along = float( self._get_value(index, 'post_fraction_along', 0.5)) input = neuroml.Connection( id=id, pre_cell_id="../%s/%i/%s" % (self.presynaptic_population, pre_cell_id, "???"), post_cell_id="../%s/%i/%s" % (self.postsynaptic_population, post_cell_id, "???"), pre_segment_id=pre_segment_id, post_segment_id=post_segment_id, pre_fraction_along=pre_fraction_along, post_fraction_along=post_fraction_along) return input
def handleConnection(self, proj_id, conn_id, prePop, postPop, synapseType, \ preCellId, \ postCellId, \ preSegId = 0, \ preFract = 0.5, \ postSegId = 0, \ postFract = 0.5, \ delay=0, weight=1): #self.printConnectionInformation(proj_id, conn_id, prePop, postPop, synapseType, preCellId, postCellId, weight) if not self.weightDelays[proj_id] and delay == 0 and weight == 1: connection = neuroml.Connection(id=conn_id, \ pre_cell_id="../%s/%i/%s"%(prePop,preCellId,self.populations[prePop].component), \ pre_segment_id=preSegId, \ pre_fraction_along=preFract, post_cell_id="../%s/%i/%s"%(postPop,postCellId,self.populations[postPop].component), \ post_segment_id=postSegId, post_fraction_along=postFract) self.projections[proj_id].connections.append(connection) else: connection = neuroml.ConnectionWD(id=conn_id, \ pre_cell_id="../%s/%i/%s"%(prePop,preCellId,self.populations[prePop].component), \ pre_segment_id=preSegId, \ pre_fraction_along=preFract, post_cell_id="../%s/%i/%s"%(postPop,postCellId,self.populations[postPop].component), \ post_segment_id=postSegId, post_fraction_along=postFract, weight=weight, delay='%sms'%(delay*1000.0)) self.projections[proj_id].connection_wds.append(connection)
def create_GoC_network( duration, dt, seed, runid, run=False): ### ---------- Load Params noPar = True pfile = Path('params_file.pkl') if pfile.exists(): print('Reading parameters from file:') file = open('params_file.pkl','rb') params_list = pkl.load(file) if len(params_list)>runid: p = params_list[runid] file.close() if noPar: p = inp.get_simulation_params( runid ) ### ---------- Component types goc_filename = 'GoC.cell.nml' # Golgi cell with channels goc_file = pynml.read_neuroml2_file( goc_filename ) goc_type = goc_file.cells[0] goc_ref = nml.IncludeType( href=goc_filename ) MFSyn_filename = 'MF_GoC_Syn.nml' # small conductance synapse for background inputs mfsyn_file = pynml.read_neuroml2_file( MFSyn_filename ) MFSyn_type = mfsyn_file.exp_three_synapses[0] mfsyn_ref = nml.IncludeType( href=MFSyn_filename ) MF20Syn_filename = 'MF_GoC_SynMult.nml' # multi-syn conductance for strong/coincident transient input mf20syn_file = pynml.read_neuroml2_file( MF20Syn_filename ) MF20Syn_type = mf20syn_file.exp_three_synapses[0] mf20syn_ref = nml.IncludeType( href=MF20Syn_filename ) mf_type2 = 'spikeGeneratorPoisson' # Spike source for background inputs mf_poisson = nml.SpikeGeneratorPoisson( id = "MF_Poisson", average_rate="5 Hz" ) # Not tuned to any data - qqq ! mf_bursttype = 'transientPoissonFiringSynapse' # Burst of MF input (as explicit input) mf_burst = nml.TransientPoissonFiringSynapse( id="MF_Burst", average_rate="100 Hz", delay="2000 ms", duration="500 ms", synapse=MF20Syn_type.id, spike_target='./{}'.format(MF20Syn_type.id) ) gj = nml.GapJunction( id="GJ_0", conductance="426pS" ) # GoC synapse ### --------- Populations # Build network to specify cells and connectivity net = nml.Network( id="gocNetwork", type="networkWithTemperature" , temperature="23 degC" ) # Create GoC population goc_pop = nml.Population( id=goc_type.id+"Pop", component = goc_type.id, type="populationList", size=p["nGoC"] ) for goc in range( p["nGoC"] ): inst = nml.Instance( id=goc ) goc_pop.instances.append( inst ) inst.location = nml.Location( x=p["GoC_pos"][goc,0], y=p["GoC_pos"][goc,1], z=p["GoC_pos"][goc,2] ) net.populations.append( goc_pop ) ### MF population MF_Poisson_pop = nml.Population(id=mf_poisson.id+"_pop", component=mf_poisson.id, type="populationList", size=p["nMF"]) for mf in range( p["nMF"] ): inst = nml.Instance(id=mf) MF_Poisson_pop.instances.append( inst ) inst.location = nml.Location( x=p["MF_pos"][mf,0], y=p["MF_pos"][mf,1], z=p["MF_pos"][mf,2] ) net.populations.append( MF_Poisson_pop ) # Create NML document for network specification net_doc = nml.NeuroMLDocument( id=net.id ) net_doc.networks.append( net ) net_doc.includes.append( goc_ref ) net_doc.includes.append( mfsyn_ref ) net_doc.includes.append( mf20syn_ref ) net_doc.spike_generator_poissons.append( mf_poisson ) net_doc.transient_poisson_firing_synapses.append( mf_burst ) net_doc.gap_junctions.append(gj) ### ------------ Connectivity ### 1. Background excitatory inputs: MF to GoC populations MFProjection = nml.Projection(id="MFtoGoC", presynaptic_population=MF_Poisson_pop.id, postsynaptic_population=goc_pop.id, synapse=MFSyn_type.id) net.projections.append(MFProjection) # MF_> GoC synapses (with syn_count equivalent to integer scaling of Mf synapse strength) nMFSyn = p["MF_GoC_pairs"].shape[1] ctr=0 for syn in range( nMFSyn ): mf, goc = p["MF_GoC_pairs"][:, syn] for syn_count in range(p["MF_GoC_wt"][ctr]): conn2 = nml.Connection(id=ctr, pre_cell_id='../{}/{}/{}'.format(MF_Poisson_pop.id, mf, mf_poisson.id), post_cell_id='../{}/{}/{}'.format(goc_pop.id, goc, goc_type.id), post_segment_id='0', post_fraction_along="0.5") #on soma MFProjection.connections.append(conn2) ctr+=1 ### 2. Perturbation as High Freq MF Inputs ctr=0 for goc in p["Burst_GoC"]: for jj in range( p["nBurst"] ): # Each Perturbed GoC gets nBurst random Burst sources inst = nml.ExplicitInput( id=ctr, target='../{}/{}/{}'.format(goc_pop.id, goc, goc_type.id), input=mf_burst.id, synapse=MF20Syn_type.id, spikeTarget='./{}'.format(MF20Syn_type.id)) net.explicit_inputs.append( inst ) ctr += 1 ### 3. Electrical coupling between GoCs GoCCoupling = nml.ElectricalProjection( id="gocGJ", presynaptic_population=goc_pop.id, postsynaptic_population=goc_pop.id ) net.electrical_projections.append( GoCCoupling ) dend_id = [1,2,5] for jj in range( p["GJ_pairs"].shape[0] ): conn = nml.ElectricalConnectionInstanceW( id=jj, pre_cell='../{}/{}/{}'.format(goc_pop.id, p["GJ_pairs"][jj,0], goc_type.id), pre_segment=dend_id[p["GJ_loc"][jj,0]], pre_fraction_along='0.5', post_cell='../{}/{}/{}'.format(goc_pop.id, p["GJ_pairs"][jj,1], goc_type.id), post_segment=dend_id[p["GJ_loc"][jj,1]], post_fraction_along='0.5', synapse=gj.id, weight=p["GJ_wt"][jj] ) GoCCoupling.electrical_connection_instance_ws.append( conn ) ### -------------- Write files net_filename = 'gocNetwork.nml' pynml.write_neuroml2_file( net_doc, net_filename ) simid = 'sim_gocnet_'+goc_type.id+'_run_{}'.format(runid) ls = LEMSSimulation( simid, duration=duration, dt=dt, simulation_seed=seed ) ls.assign_simulation_target( net.id ) ls.include_neuroml2_file( net_filename) ls.include_neuroml2_file( goc_filename) ls.include_neuroml2_file( MFSyn_filename) ls.include_neuroml2_file( MF20Syn_filename) # Specify outputs eof0 = 'Events_file' ls.create_event_output_file(eof0, "%s.v.spikes"%simid,format='ID_TIME') for jj in range( goc_pop.size): ls.add_selection_to_event_output_file( eof0, jj, '{}/{}/{}'.format( goc_pop.id, jj, goc_type.id), 'spike' ) of0 = 'Volts_file' ls.create_output_file(of0, "%s.v.dat"%simid) for jj in range( goc_pop.size ): ls.add_column_to_output_file(of0, jj, '{}/{}/{}/v'.format( goc_pop.id, jj, goc_type.id)) #Create Lems file to run lems_simfile = ls.save_to_file() if run: res = pynml.run_lems_with_jneuroml_neuron( lems_simfile, max_memory="2G", nogui=True, plot=False) else: res = pynml.run_lems_with_jneuroml_neuron( lems_simfile, max_memory="2G", only_generate_scripts = True, compile_mods = False, nogui=True, plot=False) return res
input_list = neuroml.InputList(id="il%i" % pre, component=pg.id, populations=pop0.id) input = neuroml.Input(id=pre, target="../%s[%i]" % (pop0.id, pre), destination="synapses") input_list.input.append(input) net.input_lists.append(input_list) # Connect cells with defined probability prob_connection = 0.5 for post in range(0, size1): if random.random() <= prob_connection: conn = \ neuroml.Connection(id=conn_count, \ pre_cell_id="../%s[%i]" % (pop0.id, pre), post_cell_id="../%s[%i]" % (pop1.id, post)) proj1.connections.append(conn) conn_count += 1 ######################################################### import neuroml.writers as writers nml_file = 'simplenet.nml' writers.NeuroMLWriter.write(nml_doc, nml_file) print("Written network file to: " + nml_file) ###### Validate the NeuroML ###### from neuroml.utils import validate_neuroml2
def create_GoC_network(duration, dt, seed, N_goc=0, N_mf=15, run=False, prob_type='Boltzmann', GJw_type='Vervaeke2010'): ### ---------- Component types goc_filename = 'GoC.cell.nml' # Golgi cell with channels goc_file = pynml.read_neuroml2_file(goc_filename) goc_type = goc_file.cells[0] goc_ref = nml.IncludeType(href=goc_filename) MFSyn_filename = 'MF_GoC_Syn.nml' # small conductance synapse for background inputs mfsyn_file = pynml.read_neuroml2_file(MFSyn_filename) MFSyn_type = mfsyn_file.exp_three_synapses[0] mfsyn_ref = nml.IncludeType(href=MFSyn_filename) MF20Syn_filename = 'MF_GoC_SynMult.nml' # multi-syn conductance for strong/coincident transient input mf20syn_file = pynml.read_neuroml2_file(MF20Syn_filename) MF20Syn_type = mf20syn_file.exp_three_synapses[0] mf20syn_ref = nml.IncludeType(href=MF20Syn_filename) mf_type2 = 'spikeGeneratorPoisson' # Spike source for background inputs mf_poisson = nml.SpikeGeneratorPoisson( id="MF_Poisson", average_rate="5 Hz") # Not tuned to any data - qqq ! mf_bursttype = 'transientPoissonFiringSynapse' # Burst of MF input (as explicit input) mf_burst = nml.TransientPoissonFiringSynapse(id="MF_Burst", average_rate="100 Hz", delay="2000 ms", duration="500 ms", synapse=MF20Syn_type.id, spike_target='./{}'.format( MF20Syn_type.id)) gj = nml.GapJunction(id="GJ_0", conductance="426pS") # GoC synapse ### --------- Populations # Build network to specify cells and connectivity net = nml.Network(id="gocNetwork", type="networkWithTemperature", temperature="23 degC") ### Golgi cells if N_goc > 0: GoC_pos = nu.GoC_locate(N_goc) else: GoC_pos = nu.GoC_density_locate() N_goc = GoC_pos.shape[0] # Create GoC population goc_pop = nml.Population(id=goc_type.id + "Pop", component=goc_type.id, type="populationList", size=N_goc) for goc in range(N_goc): inst = nml.Instance(id=goc) goc_pop.instances.append(inst) inst.location = nml.Location(x=GoC_pos[goc, 0], y=GoC_pos[goc, 1], z=GoC_pos[goc, 2]) net.populations.append(goc_pop) ### MF population MF_Poisson_pop = nml.Population(id=mf_poisson.id + "_pop", component=mf_poisson.id, type="populationList", size=N_mf) MF_pos = nu.GoC_locate(N_mf) for mf in range(N_mf): inst = nml.Instance(id=mf) MF_Poisson_pop.instances.append(inst) inst.location = nml.Location(x=MF_pos[mf, 0], y=MF_pos[mf, 1], z=MF_pos[mf, 2]) net.populations.append(MF_Poisson_pop) # Create NML document for network specification net_doc = nml.NeuroMLDocument(id=net.id) net_doc.networks.append(net) net_doc.includes.append(goc_ref) net_doc.includes.append(mfsyn_ref) net_doc.includes.append(mf20syn_ref) net_doc.spike_generator_poissons.append(mf_poisson) net_doc.transient_poisson_firing_synapses.append(mf_burst) net_doc.gap_junctions.append(gj) ### ------------ Connectivity ### background excitatory inputs: MF to GoC populations MFProjection = nml.Projection(id="MFtoGoC", presynaptic_population=MF_Poisson_pop.id, postsynaptic_population=goc_pop.id, synapse=MFSyn_type.id) net.projections.append(MFProjection) #Get list of MF->GoC synapse mf_synlist = nu.randdist_MF_syn(N_mf, N_goc, pConn=0.3) # Not tuned to any data - qqq! nMFSyn = mf_synlist.shape[1] for syn in range(nMFSyn): mf, goc = mf_synlist[:, syn] conn2 = nml.Connection( id=syn, pre_cell_id='../{}/{}/{}'.format(MF_Poisson_pop.id, mf, mf_poisson.id), post_cell_id='../{}/{}/{}'.format(goc_pop.id, goc, goc_type.id), post_segment_id='0', post_fraction_along="0.5") #on soma MFProjection.connections.append(conn2) ### Add few burst inputs n_bursts = 4 gocPerm = np.random.permutation( N_goc) # change to central neurons later -qqq !!! ctr = 0 for gg in range(4): goc = gocPerm[gg] for jj in range(n_bursts): inst = nml.ExplicitInput( id=ctr, target='../{}/{}/{}'.format(goc_pop.id, goc, goc_type.id), input=mf_burst.id, synapse=MF20Syn_type.id, spikeTarget='./{}'.format(MF20Syn_type.id)) net.explicit_inputs.append(inst) ctr += 1 ### Electrical coupling between GoCs # get GJ connectivity GJ_pairs, GJWt = nu.GJ_conn(GoC_pos, prob_type, GJw_type) #tmp1, tmp2 = valnet.gapJuncAnalysis( GJ_pairs, GJWt ) #print("Number of gap junctions per cell: ", tmp1) #print("Net GJ conductance per cell:", tmp2) # Add electrical synapses GoCCoupling = nml.ElectricalProjection(id="gocGJ", presynaptic_population=goc_pop.id, postsynaptic_population=goc_pop.id) nGJ = GJ_pairs.shape[0] for jj in range(nGJ): conn = nml.ElectricalConnectionInstanceW( id=jj, pre_cell='../{}/{}/{}'.format(goc_pop.id, GJ_pairs[jj, 0], goc_type.id), pre_segment='1', pre_fraction_along='0.5', post_cell='../{}/{}/{}'.format(goc_pop.id, GJ_pairs[jj, 1], goc_type.id), post_segment='1', post_fraction_along='0.5', synapse=gj.id, weight=GJWt[jj]) GoCCoupling.electrical_connection_instance_ws.append(conn) net.electrical_projections.append(GoCCoupling) ### -------------- Write files net_filename = 'gocNetwork.nml' pynml.write_neuroml2_file(net_doc, net_filename) #lems_filename = 'instances.xml' #pynml.write_lems_file( lems_inst_doc, lems_filename, validate=False ) simid = 'sim_gocnet' + goc_type.id ls = LEMSSimulation(simid, duration=duration, dt=dt, simulation_seed=seed) ls.assign_simulation_target(net.id) ls.include_neuroml2_file(net_filename) ls.include_neuroml2_file(goc_filename) ls.include_neuroml2_file(MFSyn_filename) ls.include_neuroml2_file(MF20Syn_filename) #ls.include_lems_file( lems_filename, include_included=False) # Specify outputs eof0 = 'Events_file' ls.create_event_output_file(eof0, "%s.v.spikes" % simid, format='ID_TIME') for jj in range(goc_pop.size): ls.add_selection_to_event_output_file( eof0, jj, '{}/{}/{}'.format(goc_pop.id, jj, goc_type.id), 'spike') of0 = 'Volts_file' ls.create_output_file(of0, "%s.v.dat" % simid) for jj in range(goc_pop.size): ls.add_column_to_output_file( of0, jj, '{}/{}/{}/v'.format(goc_pop.id, jj, goc_type.id)) #Create Lems file to run lems_simfile = ls.save_to_file() if run: res = pynml.run_lems_with_jneuroml_neuron(lems_simfile, max_memory="2G", nogui=True, plot=False) else: res = pynml.run_lems_with_jneuroml_neuron(lems_simfile, max_memory="2G", only_generate_scripts=True, compile_mods=False, nogui=True, plot=False) return res
def handle_connection(self, proj_id, conn_id, prePop, postPop, synapseType, \ preCellId, \ postCellId, \ preSegId = 0, \ preFract = 0.5, \ postSegId = 0, \ postFract = 0.5, \ delay=0, weight=1): #self.printConnectionInformation(proj_id, conn_id, prePop, postPop, synapseType, preCellId, postCellId, weight) pre_cell_path = "../%s/%i/%s" % (prePop, preCellId, self.populations[prePop].component) if self.populations[prePop].type == None: pre_cell_path = "../%s[%i]" % (prePop, preCellId) post_cell_path = "../%s/%i/%s" % (postPop, postCellId, self.populations[postPop].component) if self.populations[postPop].type == None: post_cell_path = "../%s[%i]" % (postPop, postCellId) if isinstance(self.projections[proj_id], neuroml.ElectricalProjection): instances = False if len(self.populations[prePop].instances) > 0 or len( self.populations[postPop].instances) > 0: instances = True if not instances: conn = neuroml.ElectricalConnection(id=conn_id, \ pre_cell="%s"%(preCellId), \ pre_segment=preSegId, \ pre_fraction_along=preFract, post_cell="%s"%(postCellId), \ post_segment=postSegId, post_fraction_along=postFract, synapse=self.projection_syns[proj_id]) self.projections[proj_id].electrical_connections.append(conn) else: if weight == 1: conn = neuroml.ElectricalConnectionInstance(id=conn_id, \ pre_cell=pre_cell_path, \ pre_segment=preSegId, \ pre_fraction_along=preFract, post_cell=post_cell_path, \ post_segment=postSegId, post_fraction_along=postFract, synapse=self.projection_syns[proj_id]) self.projections[ proj_id].electrical_connection_instances.append(conn) else: conn = neuroml.ElectricalConnectionInstanceW(id=conn_id, \ pre_cell=pre_cell_path, \ pre_segment=preSegId, \ pre_fraction_along=preFract, post_cell=post_cell_path, \ post_segment=postSegId, post_fraction_along=postFract, synapse=self.projection_syns[proj_id], weight=weight) self.projections[ proj_id].electrical_connection_instance_ws.append(conn) elif isinstance(self.projections[proj_id], neuroml.ContinuousProjection): instances = False if len(self.populations[prePop].instances) > 0 or len( self.populations[postPop].instances) > 0: instances = True if not instances: if weight != 1: raise Exception( "Case not (yet) supported: weight!=1 when not an instance based population..." ) conn = neuroml.ContinuousConnection(id=conn_id, \ pre_cell="%s"%(preCellId), \ pre_segment=preSegId, \ pre_fraction_along=preFract, post_cell="%s"%(postCellId), \ post_segment=postSegId, post_fraction_along=postFract, pre_component=self.projection_syns_pre[proj_id], post_component=self.projection_syns[proj_id]) self.projections[proj_id].continuous_connections.append(conn) else: if weight == 1: conn = neuroml.ContinuousConnectionInstance(id=conn_id, \ pre_cell=pre_cell_path, \ pre_segment=preSegId, \ pre_fraction_along=preFract, post_cell=post_cell_path, \ post_segment=postSegId, post_fraction_along=postFract, pre_component=self.projection_syns_pre[proj_id], post_component=self.projection_syns[proj_id]) self.projections[ proj_id].continuous_connection_instances.append(conn) else: conn = neuroml.ContinuousConnectionInstanceW(id=conn_id, \ pre_cell=pre_cell_path, \ pre_segment=preSegId, \ pre_fraction_along=preFract, post_cell=post_cell_path, \ post_segment=postSegId, post_fraction_along=postFract, pre_component=self.projection_syns_pre[proj_id], post_component=self.projection_syns[proj_id], weight=weight) self.projections[ proj_id].continuous_connection_instance_ws.append(conn) else: if not self.weightDelays[proj_id] and delay == 0 and weight == 1: connection = neuroml.Connection(id=conn_id, \ pre_cell_id=pre_cell_path, \ pre_segment_id=preSegId, \ pre_fraction_along=preFract, post_cell_id=post_cell_path, \ post_segment_id=postSegId, post_fraction_along=postFract) self.projections[proj_id].connections.append(connection) else: connection = neuroml.ConnectionWD(id=conn_id, \ pre_cell_id=pre_cell_path, \ pre_segment_id=preSegId, \ pre_fraction_along=preFract, post_cell_id=post_cell_path, \ post_segment_id=postSegId, post_fraction_along=postFract, weight=weight, delay='%sms'%(delay)) self.projections[proj_id].connection_wds.append(connection)
def XF_input_models_3D_region_specific_import(popID, cellType, cellNML2Type, input_group_parameters, cell_positions, seed_number, sim_params): random.seed(seed_number) parentDir = None simID = sim_params['simID'] expID = sim_params['experimentID'] libID = sim_params['libraryID'] saveCellID = sim_params['saveCellID'] lib_params = sim_params['libraryParams'] input_receiving_cells = [] if 'currentDir' in sim_params: currDir = sim_params['currentDir'] if 'parentDir' in sim_params: parentDir = sim_params['parentDir'] if parentDir != None: cellTypeFile = parentDir + "/NeuroML2" + "/" + cellType else: cellTypeFile = cellType fraction_to_target_per_pop = input_group_parameters['fractionToTarget'] dim_array = np.shape(cell_positions) region_specific_targets_per_cell_group = [] for region in range(0, len(input_group_parameters['regionList'])): for cell in range(0, dim_array[0]): if input_group_parameters['regionList'][region]['xVector'][0] < cell_positions[cell,0] \ and cell_positions[cell,0] < input_group_parameters['regionList'][region]['xVector'][1]: if input_group_parameters['regionList'][region]['yVector'][0] < cell_positions[cell,1] \ and cell_positions[cell,1] < input_group_parameters['regionList'][region]['yVector'][1] : if input_group_parameters['regionList'][region]['zVector'][0] < cell_positions[cell,2] \ and cell_positions[cell,2] < input_group_parameters['regionList'][region]['zVector'][1]: region_specific_targets_per_cell_group.append(cell) target_cells = random.sample( region_specific_targets_per_cell_group, int( round(fraction_to_target_per_pop * len(region_specific_targets_per_cell_group)))) synapse_list = input_group_parameters['synapseList'] label = input_group_parameters['inputLabel'] input_pop_array = [] spike_arrays = [] proj_arrays = [] synapse_name_array = [] if input_group_parameters['colocalizeSynapses']: print("will add block for localizing synapses") if input_group_parameters[ 'targetingModel'] == "segments and subsegments": segment_target_array = extract_morphology_information( [cellTypeFile], {cellTypeFile: cellNML2Type}, ["segments", input_group_parameters['segmentList']]) if input_group_parameters[ 'targetingModel'] == "segment groups and segments": segment_target_array = extract_morphology_information( [cellTypeFile], {cellTypeFile: cellNML2Type}, ["segment groups", input_group_parameters['segmentGroupList']]) cell_counter = 0 for target_cell in target_cells: if saveCellID: input_receiving_cells.append(target_cell) if input_group_parameters[ 'numberModel'] == "constant number of inputs per cell": no_of_inputs = input_group_parameters['noInputs'] if input_group_parameters[ 'numberModel'] == "variable number of inputs per cell": if input_group_parameters['distribution'] == "binomial": no_of_inputs=np.random.binomial(input_group_parameters['maxNoInputs'],\ input_group_parameters['averageNoInputs']/input_group_parameters['maxNoInputs']) ### other options can be added if input_group_parameters[ 'targetingModel'] == "segment groups and segments": target_points=get_unique_target_points(segment_target_array,"segment groups and segments",\ [input_group_parameters['segmentGroupList'],input_group_parameters['segmentGroupProbabilities']],no_of_inputs) if input_group_parameters[ 'targetingModel'] == "segments and subsegments": target_points=get_unique_target_points(segment_target_array,"segments and subsegments",\ [input_group_parameters['segmentList'],input_group_parameters['segmentProbabilities'],\ input_group_parameters['fractionAlongANDsubsegProbabilities']],no_of_inputs) target_point_counter = 0 for target_point in range(0, len(target_points)): train_libID = cell_counter + target_point_counter if libID == 'newlyGenerated': file_string = currDir + "/simulations/%s/sim%d/%s_%s_syn0_PoissonTrain_%d.dat" % ( expID, simID, label, popID, train_libID) else: file_string = currDir + "/simulations/%s/sim%d/%s_PoissonTrain_%d.dat" % ( libID, simID, input_group_parameters['inputIdLibrary'], train_libID) if os.path.getsize(file_string) > 0: target_point_counter += 1 spike_times = np.loadtxt(file_string) spike_times = np.transpose(spike_times) spike_times = spike_times[1] spike_array = neuroml.SpikeArray( id="%s_%s_cell%d_%d" % (label, popID, target_cell, target_point)) if 'units' in input_group_parameters: units = input_group_parameters['units'] else: units = "ms" for spike in range(0, len(spike_times)): spike_object = neuroml.Spike( id="%d" % spike, time="%f%s" % (spike_times[spike], units)) spike_array.spikes.append(spike_object) spike_arrays.append(spike_array) Input_pop = neuroml.Population( id="InputPop_%s_%s_cell%d_%d" % (label, popID, target_cell, target_point), size=1, component=spike_array.id) input_pop_array.append(Input_pop) for synapse_index in range(0, len(synapse_list)): synapse_array = synapse_list[synapse_index] synapse_name = synapse_array['synapseType'] synapse_name_array.append(synapse_name) proj = neuroml.Projection(id="InputProj_%s_%s_cell%d_syn%d_%d"%(label,popID,target_cell,synapse_index,target_point),presynaptic_population=Input_pop.id,\ postsynaptic_population=popID,synapse=synapse_name) conn = neuroml.Connection(id="0", \ pre_cell_id="../%s[0]"%(Input_pop.id), \ pre_segment_id=0, \ pre_fraction_along=0.5,\ post_cell_id="../%s/%i/%s"%(popID,target_cell,cellType), \ post_segment_id="%d"%target_points[target_point,0], post_fraction_along="%f"%target_points[target_point,1]) proj.connections.append(conn) proj_arrays.append(proj) cell_counter += 1 else: for synapse_index in range(0, len(synapse_list)): synapse_array = synapse_list[synapse_index] synapse_name = synapse_array['synapseType'] synapse_name_array.append(synapse_name) if synapse_array['targetingModel'] == "segments and subsegments": segment_target_array = extract_morphology_information( [cellTypeFile], {cellTypeFile: cellNML2Type}, ["segments", synapse_array['segmentList']]) if synapse_array[ 'targetingModel'] == "segment groups and segments": segment_target_array = extract_morphology_information( [cellTypeFile], {cellTypeFile: cellNML2Type}, ["segment groups", synapse_array['segmentGroupList']]) cell_counter = 0 for target_cell in target_cells: if saveCellID: input_receiving_cells.append(target_cell) if synapse_array[ 'numberModel'] == "constant number of inputs per cell": no_of_inputs = synapse_array['noInputs'] if synapse_array[ 'numberModel'] == "variable number of inputs per cell": if synapse_array['distribution'] == "binomial": no_of_inputs=np.random.binomial(synapse_array['maxNoInputs'],\ synapse_array['averageNoInputs']/synapse_array['maxNoInputs']) ### other options can be added if synapse_array[ 'targetingModel'] == "segment groups and segments": target_points=get_unique_target_points(segment_target_array,"segment groups and segments",\ [synapse_array['segmentGroupList'],synapse_array['segmentGroupProbabilities']],no_of_inputs) if synapse_array[ 'targetingModel'] == "segments and subsegments": target_points=get_unique_target_points(segment_target_array,"segments and subsegments",\ [synapse_array['segmentList'],synapse_array['segmentProbabilities'],\ synapse_array['fractionAlongANDsubsegProbabilities']],no_of_inputs) target_point_counter = 0 for target_point in range(0, len(target_points)): train_libID = cell_counter + target_point_counter if libID == 'newlyGenerated': file_string = currDir + "/simulations/%s/sim%d/%s_%s_syn%d_PoissonTrain_%d.dat" % ( expID, simID, label, popID, synapse_index, train_libID) else: file_string = currDir + "/simulations/%s/sim%d/%s_PoissonTrain_%d.dat" % ( libID, simID, synapse_array['inputIdLibrary'], train_libID) if os.path.getsize(file_string) > 0: target_point_counter += 1 spike_times = np.loadtxt(file_string) spike_times = np.transpose(spike_times) spike_times = spike_times[1] spike_array = neuroml.SpikeArray( id="%s_%s_cell%d_syn%d_%d" % (label, popID, target_cell, synapse_index, target_point)) if 'units' in input_group_parameters: units = synapse_array['units'] else: units = "ms" for spike in range(0, len(spike_times)): spike_object = neuroml.Spike( id="%d" % spike, time="%f%s" % (spike_times[spike], units)) spike_array.spikes.append(spike_object) spike_arrays.append(spike_array) Input_pop = neuroml.Population( id="InputPop_%s_%s_syn%d_%d" % (label, popID, synapse_index, target_point), size=1, component=spike_array.id) input_pop_array.append(Input_pop) proj = neuroml.Projection(id="InputProj_%s_%s_syn%d_%d"%(label,popID,synapse_index,target_point),presynaptic_population=Input_pop.id,\ postsynaptic_population=popID,synapse=synapse_name) conn = neuroml.Connection(id="0", \ pre_cell_id="../%s[0]"%(Input_pop.id), \ pre_segment_id=0, \ pre_fraction_along=0.5,\ post_cell_id="../%s/%i/%s"%(popID,target_cell,cellType), \ post_segment_id="%d"%target_points[target_point,0], post_fraction_along="%f"%target_points[target_point,1]) proj.connections.append(conn) proj_arrays.append(proj) cell_counter += 1 return input_pop_array, spike_arrays, proj_arrays, synapse_name_array, input_receiving_cells
def chemical_connection_model(pair_id,projection_id,prePop,prePop_listIndex,prePopSize,preCellType,preNML2Type,pre_cell_positions,\ postPop,postPop_listIndex,postPopSize,postCellType,postNML2Type,post_cell_positions,\ connectivity_parameters,seed_number,parentDir=None): random.seed(seed_number) if parentDir != None: preCellTypeFile=parentDir+"/NeuroML2"+"/"+preCellType postCellTypeFile=parentDir+"/NeuroML2"+"/"+postCellType else: preCellTypeFile=preCellType postCellTypeFile=postCellType nonempty_projection=False gapJ_object_array=[] gap_counter=0 ####### one_population=False if prePop==postPop: one_population=True if connectivity_parameters['targetingModelprePop']['model']=="segment groups and segments": pre_pop_target_segment_array=extract_morphology_information([preCellTypeFile],{preCellTypeFile:preNML2Type},\ ["segment groups", \ connectivity_parameters['targetingModelprePop']['segmentGroupList']]) if connectivity_parameters['targetingModelprePop']['model']=="segments and subsegments": pre_pop_target_segment_array=extract_morphology_information([preCellTypeFile],{preCellTypeFile:preNML2Type},\ ["segments",connectivity_parameters['targetingModelprePop']['segmentList']]) if connectivity_parameters['targetingModelpostPop']['model']=="segment groups and segments": post_pop_target_segment_array=extract_morphology_information([postCellTypeFile],{postCellTypeFile:postNML2Type},\ ["segment groups",connectivity_parameters['targetingModelpostPop']['segmentGroupList'] ] ) if connectivity_parameters['targetingModelpostPop']['model']=="segments and subsegments": post_pop_target_segment_array=extract_morphology_information([postCellTypeFile],{postCellTypeFile:postNML2Type},\ ["segments",connectivity_parameters['targetingModelpostPop']['segmentGroupList']]) proj = neuroml.Projection(id="proj%d"%projection_id,presynaptic_population=prePop,postsynaptic_population=postPop,synapse=connectivity_parameters['synapse']) synapse_name=connectivity_parameters['synapse'] conn_count = 0 #### for now, no_of_Synapses_Onto_TargetCell is fixed for each presynaptic cell of a given population no_of_Synapses_Onto_TargetCell=connectivity_parameters['number_of_PostCellSynapses_per_PreCell'] ######## connect pre and post populations according to a given probability and a number of synapses made by a single presynaptic cell onto a single postsynaptic cell if connectivity_parameters['chemicalConnModel']=="explicit_connection_probabilities": connection_probability=connectivity_parameters['connProb_from_PreCell_to_PostCell'] for Pre_cell in range(0,prePopSize): if one_population: post_index_array=range(0,postPopSize) post_index_array.remove(Pre_cell) else: post_index_array=range(0,postPopSize) if connectivity_parameters['targetingModelprePop']['model']=="segment groups and segments": pre_target_points=get_unique_target_points(pre_pop_target_segment_array,"segment groups and segments",\ [connectivity_parameters['targetingModelprePop']['segmentGroupList'],\ connectivity_parameters['targetingModelprePop']['segmentGroupProbabilities']],no_of_Synapses_Onto_TargetCell) if connectivity_parameters['targetingModelprePop']['model']=="segments and subsegments": pre_target_points=get_unique_target_points(pre_pop_target_segment_array,"segments and subsegments",\ [connectivity_parameters['targetingModelprePop']['segmentList'],\ connectivity_parameters['targetingModelprePop']['segmentProbabilities'],connectivity_parameters['targetingModelprePop']['fractionAlongANDsubsegProbabilities']],\ no_of_Synapses_Onto_TargetCell) for Post_cell in post_index_array: if random.random() < connection_probability: if connectivity_parameters['targetingModelpostPop']['model']=="segment groups and segments": post_targeting_mode="segment groups and segments" post_targeting_parameters=[connectivity_parameters['targetingModelpostPop']['segmentGroupList'],\ connectivity_parameters['targetingModelpostPop']['segmentGroupProbabilities']] if connectivity_parameters['targetingModelpostPop']['model']=="segments and subsegments": post_targeting_mode="segments and subsegments" post_targeting_parameters=[connectivity_parameters['targetingModelpostPop']['segmentList'],\ connectivity_parameters['targetingModelpostPop']['segmentProbabilities'],connectivity_parameters['targetingModelpostPop']['fractionAlongANDsubsegProbabilities']] for pre_target_point in range(0,no_of_Synapses_Onto_TargetCell): if 'maximalConnDistance' in connectivity_parameters: x=0 while x==0: post_target_points=get_unique_target_points(post_pop_target_segment_array,post_targeting_mode,post_targeting_parameters,1) if get_3D_connection_length(preCellTypeFile,postCellTypeFile,preNML2Type,postNML2Type,pre_cell_positions,post_cell_positions,Pre_cell,\ Post_cell,pre_target_points[pre_target_point,0],post_target_point[0,0],\ pre_target_points[pre_target_point,1],post_target_point[0,1]) <=connectivity_parameters['maximalConnDistance']: x=1 else: post_target_point=get_unique_target_points(post_pop_target_segment_array,post_targeting_mode,\ post_targeting_parameters,1) Pre_segment_id=pre_target_points[pre_target_point,0] Post_segment_id=post_target_point[0,0] Pre_fraction=pre_target_points[pre_target_point,1] Post_fraction=post_target_point[0,1] conn =neuroml.Connection(id=conn_count,pre_cell="../%s/%d/%s"%(prePop,Pre_cell,preCellType),\ post_cell="../%s/%d/%s"%(postPop,Post_cell,postCellType),\ pre_segment="%d"%Pre_segment_id,post_segment="%d"%Post_segment_id,\ pre_fraction_along="%f"%Pre_fraction,post_fraction_along="%f"%Post_fraction) nonempty_projection=True proj.connections.append(conn) conn_count+=1 ##### projection in which each presynaptic cell contacts a fixed number of postsynaptic cells if connectivity_parameters['chemicalConnModel']=="fixedNo_of_PostTargetCells": for Pre_cell in range(0,prePopSize): if one_population: post_index_array=range(0,postPopSize) post_index_array.remove(Pre_cell) else: post_index_array=range(0,postPopSize) if connectivity_parameters['chooseTargetMode']=='random': randomly_selected_target_cells=random.sample(range(post_index_array),int(round(connectivity_parameters['number_of_PostTargetCells_per_PreCell']))) ###### other chooseTargetModes can be added in the future if connectivity_parameters['targetingModelprePop']['model']=="segment groups and segments": pre_target_points=get_unique_target_points(pre_pop_target_segment_array,"segment groups and segments",\ [connectivity_parameters['targetingModelprePop']['segmentGroupList'],\ connectivity_parameters['targetingModelprePop']['segmentGroupProbabilities']],no_of_Synapses_Onto_TargetCell) if connectivity_parameters['targetingModelprePop']['model']=="segments and subsegments": pre_target_points=get_unique_target_points(pre_pop_target_segment_array,"segments and subsegments",\ [connectivity_parameters['targetingModelprePop']['segmentList'],\ connectivity_parameters['targetingModelprePop']['segmentProbabilities'],connectivity_parameters['targetingModelprePop']['fractionAlongANDsubsegProbabilities']],\ no_of_Synapses_Onto_TargetCell) for Post_cell in randomly_selected_target_cells: if connectivity_parameters['targetingModelpostPop']['model']=="segment groups and segments": post_targeting_mode="segment groups and segments" post_targeting_parameters=[connectivity_parameters['targetingModelpostPop']['segmentGroupList'],\ connectivity_parameters['targetingModelpostPop']['segmentGroupProbabilities']] if connectivity_parameters['targetingModelpostPop']['model']=="segments and subsegments": post_targeting_mode="segments and subsegments" post_targeting_parameters=[connectivity_parameters['targetingModelpostPop']['segmentList'],\ connectivity_parameters['targetingModelpostPop']['segmentProbabilities'],connectivity_parameters['targetingModelpostPop']['fractionAlongANDsubsegProbabilities']] for pre_target_point in range(0,no_of_Synapses_Onto_TargetCell): if 'maximalConnDistance' in connectivity_parameters: x=0 while x==0: post_target_points=get_unique_target_points(post_pop_target_segment_array,post_targeting_mode,post_targeting_parameters,1) if get_3D_connection_length(preCellTypeFile,postCellTypeFile,preNML2Type,postNML2Type,pre_cell_positions,post_cell_positions,Pre_cell,\ Post_cell,pre_target_points[pre_target_point,0],post_target_point[0,0],\ pre_target_points[pre_target_point,1],post_target_point[0,1]) <=connectivity_parameters['maximalConnDistance']: x=1 else: post_target_point=get_unique_target_points(post_pop_target_segment_array,post_targeting_mode,\ post_targeting_parameters,1) Pre_segment_id=pre_target_points[pre_target_point,0] Post_segment_id=post_target_point[0,0] Pre_fraction=pre_target_points[pre_target_point,1] Post_fraction=post_target_point[0,1] conn =neuroml.Connection(id=conn_count,pre_cell="../%s/%d/%s"%(prePop,Pre_cell,preCellType),\ post_cell="../%s/%d/%s"%(postPop,Post_cell,postCellType),\ pre_segment="%d"%Pre_segment_id,post_segment="%d"%Post_segment_id,\ pre_fraction_along="%f"%Pre_fraction,post_fraction_along="%f"%Post_fraction) nonempty_projection=True proj.connections.append(conn) conn_count+=1 ############ projection in which each presynaptic cell of a given presynaptic population has a variable number of postsynaptic targets according to a given statistical distribution if connectivity_parameters['chemicalConnModel']=="variableNo_of_PostTargetCells": for Pre_cell in range(0,prePopSize): if one_population: post_index_array=range(0,postPopSize) post_index_array.remove(Pre_cell) else: post_index_array=range(0,postPopSize) if connectivity_parameters['targetNoModel']['modelType']=='binomial': no_of_targets=np.random.binomial(connectivity_parameters['targetNoModel']['maxTargetNo'],\ connectivity_parameters['targetNoModel']['average']/connectivity_parameters['targetNoModel']['maxTargetNo']) ####### other distributions can be added in the future if connectivity_parameters['chooseTargetMode']=='random': randomly_selected_target_cells=random.sample(post_index_array,int(round(no_of_targets))) ###### other chooseTargetModes can be added in the future if connectivity_parameters['targetingModelprePop']['model']=="segment groups and segments": pre_target_points=get_unique_target_points(pre_pop_target_segment_array,"segment groups and segments",\ [connectivity_parameters['targetingModelprePop']['segmentGroupList'],\ connectivity_parameters['targetingModelprePop']['segmentGroupProbabilities']],no_of_Synapses_Onto_TargetCell) if connectivity_parameters['targetingModelprePop']['model']=="segments and subsegments": pre_target_points=get_unique_target_points(pre_pop_target_segment_array,"segments and subsegments",\ [connectivity_parameters['targetingModelprePop']['segmentList'],\ connectivity_parameters['targetingModelprePop']['segmentProbabilities'],connectivity_parameters['targetingModelprePop']['fractionAlongANDsubsegProbabilities']],\ no_of_Synapses_Onto_TargetCell) for Post_cell in randomly_selected_target_cells: if connectivity_parameters['targetingModelpostPop']['model']=="segment groups and segments": post_targeting_mode="segment groups and segments" post_targeting_parameters=[connectivity_parameters['targetingModelpostPop']['segmentGroupList'],\ connectivity_parameters['targetingModelpostPop']['segmentGroupProbabilities']] if connectivity_parameters['targetingModelpostPop']['model']=="segments and subsegments": post_targeting_mode="segments and subsegments" post_targeting_parameters=[connectivity_parameters['targetingModelpostPop']['segmentList'],\ connectivity_parameters['targetingModelpostPop']['segmentProbabilities'],connectivity_parameters['targetingModelpostPop']['fractionAlongANDsubsegProbabilities']] for pre_target_point in range(0,no_of_Synapses_Onto_TargetCell): if 'maximalConnDistance' in connectivity_parameters: x=0 while x==0: post_target_points=get_unique_target_points(post_pop_target_segment_array,post_targeting_mode,post_targeting_parameters,1) if get_3D_connection_length(preCellTypeFile,postCellTypeFile,preNML2Type,postNML2Type,pre_cell_positions,post_cell_positions,Pre_cell,\ Post_cell,pre_target_points[pre_target_point,0],post_target_point[0,0],\ pre_target_points[pre_target_point,1],post_target_point[0,1]) <=connectivity_parameters['maximalConnDistance']: x=1 else: post_target_point=get_unique_target_points(post_pop_target_segment_array,post_targeting_mode,\ post_targeting_parameters,1) Pre_segment_id=pre_target_points[pre_target_point,0] Post_segment_id=post_target_point[0,0] Pre_fraction=pre_target_points[pre_target_point,1] Post_fraction=post_target_point[0,1] conn =neuroml.Connection(id=conn_count,pre_cell="../%s/%d/%s"%(prePop,Pre_cell,preCellType),\ post_cell="../%s/%d/%s"%(postPop,Post_cell,postCellType),\ pre_segment="%d"%Pre_segment_id,post_segment="%d"%Post_segment_id,\ pre_fraction_along="%f"%Pre_fraction,post_fraction_along="%f"%Post_fraction) nonempty_projection=True proj.connections.append(conn) conn_count+=1 return proj, nonempty_projection,gapJ_object_array,synapse_name
def create_GoC_network( duration, dt, seed, N_goc=0, run=False, prob_type='Boltzmann', GJw_type='Vervaeke2010' ): goc_filename = 'GoC.cell.nml' goc_file = pynml.read_neuroml2_file( goc_filename ) goc_type = goc_file.cells[0] GJ_filename = 'GapJuncCML.nml' GJ_file = pynml.read_neuroml2_file( GJ_filename ) GJ_type = GJ_file.gap_junctions[0] MFSyn_filename = 'MF_GoC_Syn.nml' mfsyn_file = pynml.read_neuroml2_file( MFSyn_filename ) MFSyn_type = mfsyn_file.exp_three_synapses[0] MF20Syn_filename = 'MF_GoC_SynMult.nml' mf20syn_file = pynml.read_neuroml2_file( MF20Syn_filename ) MF20Syn_type = mf20syn_file.exp_three_synapses[0] # Distribute cells in 3D if N_goc>0: GoC_pos = nu.GoC_locate(N_goc) else: GoC_pos = nu.GoC_density_locate() N_goc = GoC_pos.shape[0] # get GJ connectivity GJ_pairs, GJWt = nu.GJ_conn( GoC_pos, prob_type, GJw_type ) tmp1, tmp2 = valnet.gapJuncAnalysis( GJ_pairs, GJWt ) print("Number of gap junctions per cell: ", tmp1) print("Net GJ conductance per cell:", tmp2) # Create pop List goc_pop = nml.Population( id=goc_type.id+"Pop", component = goc_type.id, type="populationList", size=N_goc ) # Create NML document for network specification net = nml.Network( id="gocNetwork", type="networkWithTemperature" , temperature="23 degC" ) net_doc = nml.NeuroMLDocument( id=net.id ) net_doc.networks.append( net ) net_doc.includes.append( goc_type ) net.populations.append( goc_pop ) #Add locations for GoC instances in the population: for goc in range(N_goc): inst = nml.Instance( id=goc ) goc_pop.instances.append( inst ) inst.location = nml.Location( x=GoC_pos[goc,0], y=GoC_pos[goc,1], z=GoC_pos[goc,2] ) # Define input spiketrains input_type = 'spikeGenerator'#'spikeGeneratorPoisson' lems_inst_doc = lems.Model() mf_inputs = lems.Component( "MF_Input", input_type) mf_inputs.set_parameter("period", "2000 ms" ) #mf_inputs.set_parameter("averageRate", "50 Hz") lems_inst_doc.add( mf_inputs ) #synapse_type = 'alphaCurrentSynapse' #alpha_syn = lems.Component( "AlphaSyn", synapse_type) #alpha_syn.set_parameter("tau", "30 ms" ) #alpha_syn.set_parameter("ibase", "200 pA") #lems_inst_doc.add( alpha_syn ) # Define MF input population N_mf = 15 #MF_pop = nml.Population(id=mf_inputs.id+"_pop", component=mf_inputs.id, type="populationList", size=N_mf) #net.populations.append( MF_pop ) mf_type2 = 'spikeGeneratorPoisson' #mf_poisson = lems.Component( "MF_Poisson", mf_type2) #mf_poisson.set_parameter("averageRate", "5 Hz") #lems_inst_doc.add( mf_poisson ) # adding in neuroml document instead of mf_poisson mf_poisson = nml.SpikeGeneratorPoisson( id = "MF_Poisson", average_rate="5 Hz" ) net_doc.spike_generator_poissons.append( mf_poisson ) net_doc.includes.append( goc_type ) MF_Poisson_pop = nml.Population(id=mf_poisson.id+"_pop", component=mf_poisson.id, type="populationList", size=N_mf) net.populations.append( MF_Poisson_pop ) MF_pos = nu.GoC_locate( N_mf ) for mf in range( N_mf ): inst = nml.Instance(id=mf) MF_Poisson_pop.instances.append( inst ) inst.location = nml.Location( x=MF_pos[mf,0], y=MF_pos[mf,1], z=MF_pos[mf,2] ) # Setup Mf->GoC synapses #MFprojection = nml.Projection(id="MFtoGoC", presynaptic_population=MF_pop.id, postsynaptic_population=goc_pop.id, synapse=alpha_syn.id) #net.projections.append(MFprojection) MF2projection = nml.Projection(id="MF2toGoC", presynaptic_population=MF_Poisson_pop.id, postsynaptic_population=goc_pop.id, synapse=MFSyn_type.id)#alpha_syn.id net.projections.append(MF2projection) #Get list of MF->GoC synapse mf_synlist = nu.randdist_MF_syn( N_mf, N_goc, pConn=0.3) nMFSyn = mf_synlist.shape[1] for syn in range( nMFSyn ): mf, goc = mf_synlist[:, syn] conn2 = nml.Connection(id=syn, pre_cell_id='../{}/{}/{}'.format(MF_Poisson_pop.id, mf, mf_poisson.id), post_cell_id='../{}/{}/{}'.format(goc_pop.id, goc, goc_type.id), post_segment_id='0', post_fraction_along="0.5") MF2projection.connections.append(conn2) # Burst of MF input (as explicit input) mf_bursttype = 'transientPoissonFiringSynapse' mf_burst = lems.Component( "MF_Burst", mf_bursttype) mf_burst.set_parameter( "averageRate", "100 Hz" ) mf_burst.set_parameter( "delay", "2000 ms" ) mf_burst.set_parameter( "duration", "500 ms" ) mf_burst.set_parameter( "synapse", MF20Syn_type.id ) mf_burst.set_parameter( "spikeTarget", './{}'.format(MF20Syn_type.id) ) lems_inst_doc.add( mf_burst ) # Add few burst inputs n_bursts = 4 gocPerm = np.random.permutation( N_goc ) ctr = 0 for gg in range(4): goc = gocPerm[gg] for jj in range( n_bursts ): inst = nml.ExplicitInput( id=ctr, target='../{}/{}/{}'.format(goc_pop.id, goc, goc_type.id), input=mf_burst.id, synapse=MF20Syn_type.id, spikeTarget='./{}'.format(MF20Syn_type.id)) net.explicit_inputs.append( inst ) ctr += 1 ''' one-to-one pairing of MF and GoC -> no shared inputs for goc in range(N_mf): #inst = nml.Instance(id=goc) #MF_pop.instances.append( inst ) #inst.location = nml.Location( x=GoC_pos[goc,0], y=GoC_pos[goc,1], z=GoC_pos[goc,2]+100 ) #conn = nml.Connection(id=goc, pre_cell_id='../{}/{}/{}'.format(MF_pop.id, goc, mf_inputs.id), post_cell_id='../{}/{}/{}'.format(goc_pop.id, goc, goc_type.id), post_segment_id='0', post_fraction_along="0.5") #MFprojection.connections.append(conn) goc2 = N_goc-goc-1 inst2 = nml.Instance(id=goc) MF_Poisson_pop.instances.append( inst2 ) inst2.location = nml.Location( x=GoC_pos[goc2,0], y=GoC_pos[goc2,1], z=GoC_pos[goc2,2]+100 ) conn2 = nml.Connection(id=goc, pre_cell_id='../{}/{}/{}'.format(MF_Poisson_pop.id, goc, mf_poisson.id), post_cell_id='../{}/{}/{}'.format(goc_pop.id, goc2, goc_type.id), post_segment_id='0', post_fraction_along="0.5") MF2projection.connections.append(conn2) ''' # Add electrical synapses GoCCoupling = nml.ElectricalProjection( id="gocGJ", presynaptic_population=goc_pop.id, postsynaptic_population=goc_pop.id ) #print(GJ_pairs) gj = nml.GapJunction( id="GJ_0", conductance="426pS" ) net_doc.gap_junctions.append(gj) nGJ = GJ_pairs.shape[0] for jj in range( nGJ ): #gj.append( lems.Component( "GJ_%d"%jj, 'gapJunction') ) #gj[jj].set_parameter( "conductance", "%fnS"%(GJWt[jj]) ) #gj = nml.GapJunction(id="GJ_%d"%jj, conductance="%fnS"%(GJWt[jj])) #net_doc.gap_junctions.append(gj) #lems_inst_doc.add( gj[jj] ) #print("%fnS"%(GJWt[jj]*0.426)) conn = nml.ElectricalConnectionInstanceW( id=jj, pre_cell='../{}/{}/{}'.format(goc_pop.id, GJ_pairs[jj,0], goc_type.id), pre_segment='1', pre_fraction_along='0.5', post_cell='../{}/{}/{}'.format(goc_pop.id, GJ_pairs[jj,1], goc_type.id), post_segment='1', post_fraction_along='0.5', synapse=gj.id, weight=GJWt[jj] )#synapse="GapJuncCML" synapse=gj.id , conductance="100E-9mS" # ------------ need to create GJ component GoCCoupling.electrical_connection_instance_ws.append( conn ) net.electrical_projections.append( GoCCoupling ) net_filename = 'gocNetwork.nml' pynml.write_neuroml2_file( net_doc, net_filename ) lems_filename = 'instances.xml' pynml.write_lems_file( lems_inst_doc, lems_filename, validate=False ) simid = 'sim_gocnet'+goc_type.id ls = LEMSSimulation( simid, duration=duration, dt=dt, simulation_seed=seed ) ls.assign_simulation_target( net.id ) #ls.include_lems_file( 'Synapses.xml', include_included=False) #ls.include_lems_file( 'Inputs.xml', include_included=False) ls.include_neuroml2_file( net_filename) ls.include_neuroml2_file( goc_filename) ls.include_neuroml2_file( GJ_filename) ls.include_neuroml2_file( MFSyn_filename) ls.include_neuroml2_file( MF20Syn_filename) ls.include_lems_file( lems_filename, include_included=False) # Specify outputs eof0 = 'Events_file' ls.create_event_output_file(eof0, "%s.v.spikes"%simid,format='ID_TIME') for jj in range( goc_pop.size): ls.add_selection_to_event_output_file( eof0, jj, '{}/{}/{}'.format( goc_pop.id, jj, goc_type.id), 'spike' ) of0 = 'Volts_file' ls.create_output_file(of0, "%s.v.dat"%simid) for jj in range( goc_pop.size ): ls.add_column_to_output_file(of0, jj, '{}/{}/{}/v'.format( goc_pop.id, jj, goc_type.id)) #Create Lems file to run lems_simfile = ls.save_to_file() #res = pynml.run_lems_with_jneuroml( lems_simfile, max_memory="1G",nogui=True, plot=False) #res = pynml.run_lems_with_jneuroml_neuron( lems_simfile, max_memory="2G", only_generate_scripts = True, compile_mods = False, nogui=True, plot=False) res = pynml.run_lems_with_jneuroml_neuron( lems_simfile, max_memory="2G", compile_mods = False,nogui=True, plot=False) #res=True return res
target='../%s/2/%s' % (pyr_cells_pop3.id, cell_id), segment_id="4", destination="synapses")) net.input_lists.append(tsi_input_list) # Create a projection proj_sa = neuroml.Projection(id="Proj_sa", synapse=syn1.id, presynaptic_population=sa_pop.id, postsynaptic_population=pyr_cells_pop1.id) net.projections.append(proj_sa) proj_sa.connections.append(neuroml.Connection(id=0, \ pre_cell_id="../%s[0]"%(sa_pop.id), post_cell_id="../%s/%i/%s"%(pyr_cells_pop1.id,0,cell_id))) proj_sa.connections.append(neuroml.Connection(id=1, \ pre_cell_id="../%s[0]"%(sa_pop.id), post_cell_id="../%s/%i/%s"%(pyr_cells_pop1.id,1,cell_id), post_segment_id = "2",)) proj_sa.connections.append(neuroml.Connection(id=2, \ pre_cell_id="../%s[0]"%(sa_pop.id), post_cell_id="../%s/%i/%s"%(pyr_cells_pop1.id,2,cell_id), post_segment_id = "4",)) proj_sgp = neuroml.Projection(id="Proj_sgp", synapse=syn0.id, presynaptic_population=sgp_pop.id,
def generate_grc_layer_network( p_mf_ON, duration, dt, minimumISI, # ms ONRate, # Hz OFFRate, # Hz run=False): # Load connectivity matrix file = open('GCLconnectivity.pkl') p = pkl.load(file) conn_mat = p['conn_mat'] N_mf, N_grc = conn_mat.shape assert (np.all(conn_mat.sum( axis=0) == 4)), 'Connectivity matrix is incorrect.' # Load GrC and MF rosette positions grc_pos = p['grc_pos'] glom_pos = p['glom_pos'] # Choose which mossy fibers are on, which are off N_mf_ON = int(N_mf * p_mf_ON) mf_indices_ON = random.sample(range(N_mf), N_mf_ON) mf_indices_ON.sort() N_mf_OFF = N_mf - N_mf_ON mf_indices_OFF = [x for x in range(N_mf) if x not in mf_indices_ON] mf_indices_OFF.sort() # load NeuroML components, LEMS components and LEMS componentTypes from external files ##spikeGeneratorRefPoisson is now a standard nml type... ##spike_generator_doc = pynml.read_lems_file(spike_generator_file_name) iaF_GrC = nml.IafRefCell(id="iaF_GrC", refract="2ms", C="3.22pF", thresh="-40mV", reset="-63mV", leak_conductance="1.498nS", leak_reversal="-79.67mV") ampa_syn_filename = "RothmanMFToGrCAMPA.xml" nmda_syn_filename = "RothmanMFToGrCNMDA.xml" rothmanMFToGrCAMPA_doc = pynml.read_lems_file(ampa_syn_filename) rothmanMFToGrCNMDA_doc = pynml.read_lems_file(nmda_syn_filename) # define some components from the componentTypes we just loaded ##spike_generator_ref_poisson_type = spike_generator_doc.component_types['spikeGeneratorRefPoisson'] lems_instances_doc = lems.Model() spike_generator_ref_poisson_type_name = 'spikeGeneratorRefPoisson' spike_generator_on = lems.Component("mossySpikerON", spike_generator_ref_poisson_type_name) spike_generator_on.set_parameter("minimumISI", "%s ms" % minimumISI) spike_generator_on.set_parameter("averageRate", "%s Hz" % ONRate) lems_instances_doc.add(spike_generator_on) spike_generator_off = lems.Component( "mossySpikerOFF", spike_generator_ref_poisson_type_name) spike_generator_off.set_parameter("minimumISI", "%s ms" % minimumISI) spike_generator_off.set_parameter("averageRate", "%s Hz" % OFFRate) lems_instances_doc.add(spike_generator_off) rothmanMFToGrCAMPA = rothmanMFToGrCAMPA_doc.components[ 'RothmanMFToGrCAMPA'].id rothmanMFToGrCNMDA = rothmanMFToGrCNMDA_doc.components[ 'RothmanMFToGrCNMDA'].id # create populations GrCPop = nml.Population(id=iaF_GrC.id + "Pop", component=iaF_GrC.id, type="populationList", size=N_grc) GrCPop.properties.append(nml.Property(tag='color', value='0 0 0.8')) GrCPop.properties.append(nml.Property(tag='radius', value=2)) mossySpikersPopON = nml.Population(id=spike_generator_on.id + "Pop", component=spike_generator_on.id, type="populationList", size=N_mf_ON) mossySpikersPopON.properties.append( nml.Property(tag='color', value='0.8 0 0')) mossySpikersPopON.properties.append(nml.Property(tag='radius', value=2)) mossySpikersPopOFF = nml.Population(id=spike_generator_off.id + "Pop", component=spike_generator_off.id, size=N_mf_OFF) mossySpikersPopOFF.properties.append( nml.Property(tag='color', value='0 0.8 0')) mossySpikersPopOFF.properties.append(nml.Property(tag='radius', value=2)) # create network and add populations net = nml.Network(id="network") net_doc = nml.NeuroMLDocument(id=net.id) net_doc.networks.append(net) net_doc.iaf_ref_cells.append(iaF_GrC) net.populations.append(GrCPop) net.populations.append(mossySpikersPopON) net.populations.append(mossySpikersPopOFF) #net_doc.includes.append(nml.IncludeType(href=iaf_nml2_file_name)) # Add locations for GCs for grc in range(N_grc): inst = nml.Instance(id=grc) GrCPop.instances.append(inst) inst.location = nml.Location(x=grc_pos[grc, 0], y=grc_pos[grc, 1], z=grc_pos[grc, 2]) # ON MFs: locations and connectivity ONprojectionAMPA = nml.Projection( id="ONProjAMPA", presynaptic_population=mossySpikersPopON.id, postsynaptic_population=GrCPop.id, synapse=rothmanMFToGrCAMPA) ONprojectionNMDA = nml.Projection( id="ONProjNMDA", presynaptic_population=mossySpikersPopON.id, postsynaptic_population=GrCPop.id, synapse=rothmanMFToGrCNMDA) net.projections.append(ONprojectionAMPA) net.projections.append(ONprojectionNMDA) ix = 0 for mf_ix_ON in range(N_mf_ON): mf_ix = mf_indices_ON[mf_ix_ON] inst = nml.Instance(id=mf_ix_ON) mossySpikersPopON.instances.append(inst) inst.location = nml.Location(x=glom_pos[mf_ix, 0], y=glom_pos[mf_ix, 1], z=glom_pos[mf_ix, 2]) # find which granule cells are neighbors innervated_grcs = np.where(conn_mat[mf_ix, :] == 1)[0] for grc_ix in innervated_grcs: for synapse in [rothmanMFToGrCAMPA, rothmanMFToGrCNMDA]: connection = nml.Connection( id=ix, pre_cell_id='../{}/{}/{}'.format(mossySpikersPopON.id, mf_ix_ON, spike_generator_on.id), post_cell_id='../{}/{}/{}'.format(GrCPop.id, grc_ix, iaF_GrC.id)) ONprojectionAMPA.connections.append(connection) ONprojectionNMDA.connections.append(connection) ix = ix + 1 # OFF MFs: locations and connectivity OFFprojectionAMPA = nml.Projection( id="OFFProjAMPA", presynaptic_population=mossySpikersPopOFF.id, postsynaptic_population=GrCPop.id, synapse=rothmanMFToGrCAMPA) OFFprojectionNMDA = nml.Projection( id="OFFProjNMDA", presynaptic_population=mossySpikersPopOFF.id, postsynaptic_population=GrCPop.id, synapse=rothmanMFToGrCNMDA) net.projections.append(OFFprojectionAMPA) net.projections.append(OFFprojectionNMDA) ix = 0 for mf_ix_OFF in range(N_mf_OFF): mf_ix = mf_indices_OFF[mf_ix_OFF] inst = nml.Instance(id=mf_ix_OFF) mossySpikersPopOFF.instances.append(inst) inst.location = nml.Location(x=glom_pos[mf_ix, 0], y=glom_pos[mf_ix, 1], z=glom_pos[mf_ix, 2]) # find which granule cells are neighbors innervated_grcs = np.where(conn_mat[mf_ix, :] == 1)[0] for grc_ix in innervated_grcs: for synapse in [rothmanMFToGrCAMPA, rothmanMFToGrCNMDA]: connection = nml.Connection( id=ix, pre_cell_id='../{}/{}/{}'.format(mossySpikersPopOFF.id, mf_ix_OFF, spike_generator_on.id), post_cell_id='../{}/{}/{}'.format(GrCPop.id, grc_ix, iaF_GrC.id)) OFFprojectionAMPA.connections.append(connection) OFFprojectionNMDA.connections.append(connection) ix = ix + 1 # Write network to file net_file_name = 'OSBnet.nml' pynml.write_neuroml2_file(net_doc, net_file_name) # Write LEMS instances to file lems_instances_file_name = 'instances.xml' pynml.write_lems_file(lems_instances_doc, lems_instances_file_name, validate=False) # Create a LEMSSimulation to manage creation of LEMS file ls = LEMSSimulation( 'sim', duration, dt, simulation_seed=123) # int(np.round(1000*random.random()))) # Point to network as target of simulation ls.assign_simulation_target(net.id) # Include generated/existing NeuroML2 files ###ls.include_lems_file(spike_generator_file_name, include_included=False) ls.include_lems_file(lems_instances_file_name) ls.include_lems_file(ampa_syn_filename, include_included=False) ls.include_lems_file(nmda_syn_filename, include_included=False) ls.include_neuroml2_file(net_file_name) # Specify Displays and Output Files basedir = '' eof0 = 'Volts_file' ls.create_event_output_file(eof0, basedir + "MF_spikes.dat") for i in range(mossySpikersPopON.size): ls.add_selection_to_event_output_file( eof0, mf_indices_ON[i], '{}/{}/{}'.format(mossySpikersPopON.id, i, spike_generator_on.id), 'spike') for i in range(mossySpikersPopOFF.size): ls.add_selection_to_event_output_file( eof0, mf_indices_OFF[i], '{}/{}/{}'.format(mossySpikersPopOFF.id, i, spike_generator_on.id), 'spike') eof1 = 'GrCspike_file' ls.create_event_output_file(eof1, basedir + "GrC_spikes.dat") for i in range(GrCPop.size): ls.add_selection_to_event_output_file( eof1, i, '{}/{}/{}'.format(GrCPop.id, i, iaF_GrC.id), 'spike') lems_file_name = ls.save_to_file() if run: print('Running the generated LEMS file: %s for simulation of %sms' % (lems_file_name, duration)) results = pynml.run_lems_with_jneuroml(lems_file_name, max_memory="8G", nogui=True, load_saved_data=False, plot=False) return results
nc.populations.append(pc) instance = neuroml.Instance(0) instance.location = neuroml.Location(100, 100, 33.333) pc.instances.append(instance) instance = neuroml.Instance(1) instance.location = neuroml.Location(200, 200, 66.66) pc.instances.append(instance) prc = ProjectionContainer(id="proj", presynaptic_population=pc0.id, postsynaptic_population=pc.id, synapse="ampa") conn = neuroml.Connection(id=0, pre_cell_id="../%s/%i/%s"%(pc0.id,0,pc0.component), \ pre_segment_id=2, \ pre_fraction_along=0.1, post_cell_id="../%s/%i/%s"%(pc.id,2,pc.id)) prc.connections.append(conn) nc.projections.append(prc) ilc = InputListContainer(id="iii", component="CCC", populations=pc.id) nc.input_lists.append(ilc) ilc.input.append( neuroml.Input(id=0, target="../pyramidals_48/37/pyr_4_sym", destination="synapses", segment_id="2", fraction_along="0.3")) nc2 = NetworkContainer(id="testnet2")